feat: wip python generator

Author: mjfaga

src/codegen/code-generators/python-generator.ts

@@ -0,0 +1,174 @@
+import {stripIndent} from 'common-tags'
+import camelCase from 'lodash.camelcase'
+
+import {ZodToPythonParameterClassMapper} from '../language-mappers/zod-to-python-parameter-class-mapper.js'
+import {ZodToTypescriptReturnValueMapper} from '../language-mappers/zod-to-typescript-return-value-mapper.js'
+import {PythonTyping} from '../types.js'
+import {BaseGenerator} from './base-generator.js'
+
+export class PythonGenerator extends BaseGenerator {
+  private _typings = new Set<PythonTyping>()
+
+  private DATACLASS_IMPORT = 'from dataclasses import dataclass'
+  private MUSTACHE_IMPORT = 'import pystache'
+  private PYDANTIC_IMPORT = 'from pydantic import BaseModel'
+
+  get filename(): string {
+    return 'prefab.py'
+  }
+
+  generate(): string {
+    // Need to genereate these before referencing _typings to ensure all required types are known
+    const parameterClassTemplates = this.generateParameterClasses()
+    const typings = this._typings.size > 0 ? [...this._typings].sort().join(', ') : null
+    const accessorMethods = this.generateAccessorMethods()
+
+    const additionalDependencies = new Set<string>()
+
+    if (parameterClassTemplates.length > 0) {
+      additionalDependencies.add(this.DATACLASS_IMPORT)
+    }
+
+    if (accessorMethods.length > 0) {
+      additionalDependencies.add(this.PYDANTIC_IMPORT)
+    }
+
+    if (this.configurations().some((c) => c.hasFunction)) {
+      additionalDependencies.add(this.MUSTACHE_IMPORT)
+    }
+
+    return stripIndent`
+    # AUTOGENERATED by prefab-cli's 'gen' command
+    import prefab_cloud_python
+    from prefab_cloud_python import ContextDictOrContext
+
+    ${[...additionalDependencies].join('\n    ') || '# No additional dependencies required'}
+
+    # Optional - need to make this dynamic
+    from datetime import timedelta # for Durations
+
+    ${typings ? `from typing import ${typings}` : '# No additional typings required'}
+
+    class PrefabTypedClient:
+        """Client for accessing Prefab configuration with type-safe methods"""
+        def __init__(self, client=None, use_global_client=False):
+            """
+            Initialize the typed client.
+
+            Args:
+                client: A Prefab client instance. If not provided and use_global_client is False,
+                          uses the global client at initialization time.
+                use_global_client: If True, dynamically calls prefab_cloud_python.get_client() for each request
+                                  instead of storing a reference. Useful in long-running applications where
+                                  the client might be reset or reconfigured.
+            """
+            self._prefab = prefab_cloud_python
+            self._use_global_client = use_global_client
+            self._client = None if use_global_client else (client or prefab_cloud_python.get_client())
+
+        @property
+        def client(self):
+            """
+            Returns the client to use for the current request.
+
+            If use_global_client is True, dynamically retrieves the current global client.
+            Otherwise, returns the stored client instance.
+            """
+            if self._use_global_client:
+                return self._prefab.get_client()
+            return self._client
+
+        ${parameterClassTemplates.join('\n\n        ') || '# No parameter classes generated'}
+
+        ${accessorMethods.join('\n\n              ') || '# No methods generated'}
+    `
+  }
+
+  private generateAccessorMethods(): string[] {
+    const uniqueMethods: Record<string, string> = {}
+    const schemaTypes = this.configurations().map((config) => {
+      let methodName = camelCase(config.key)
+
+      // If the method name starts with a digit, prefix it with an underscore to ensure method name is valid
+      if (/^\d/.test(methodName)) {
+        methodName = `_${methodName}`
+      }
+
+      if (uniqueMethods[methodName]) {
+        throw new Error(
+          `Method '${methodName}' is already registered. Prefab key ${config.key} conflicts with '${uniqueMethods[methodName]}'!`,
+        )
+      }
+
+      uniqueMethods[methodName] = config.key
+
+      if (config.configType === 'FEATURE_FLAG') {
+        return stripIndent`
+          get ${methodName}(): boolean {
+                  return this.prefab.isEnabled('${config.key}')
+                }
+          `
+      }
+
+      if (config.hasFunction) {
+        const returnValue = new ZodToTypescriptReturnValueMapper().resolveType(config.schema)
+
+        return stripIndent`
+          ${methodName}(): PrefabTypeGeneration.ReactHookConfigurationAccessor['${config.key}'] {
+                  const raw = this.get('${config.key}')
+                  return ${returnValue}
+                }
+          `
+      }
+
+      return stripIndent`
+        get ${methodName}(): PrefabTypeGeneration.ReactHookConfigurationAccessor['${config.key}'] {
+                return this.get('${config.key}')
+              }
+        `
+    })
+
+    return schemaTypes
+  }
+
+  private generateParameterClasses(): string[] {
+    const uniqueClasses: Record<string, string> = {}
+    const schemaTypes = this.configurations().map((config) => {
+      const mapper = new ZodToPythonParameterClassMapper({fieldName: config.key})
+      const result = mapper.renderClass(config.schema)
+
+      const className = ZodToPythonParameterClassMapper.parameterClassName(config.key)
+
+      if (uniqueClasses[className]) {
+        throw new Error(
+          `Class '${className}' is already registered. Prefab key ${config.key} conflicts with '${uniqueClasses[className]}'!`,
+        )
+      }
+
+      uniqueClasses[className] = config.key
+
+      if (mapper.hasAny) {
+        this._typings.add(PythonTyping.Any)
+      }
+      if (mapper.hasDict) {
+        this._typings.add(PythonTyping.Dict)
+      }
+      if (mapper.hasList) {
+        this._typings.add(PythonTyping.List)
+      }
+      if (mapper.hasOptional) {
+        this._typings.add(PythonTyping.Optional)
+      }
+      if (mapper.hasTuple) {
+        this._typings.add(PythonTyping.Tuple)
+      }
+      if (mapper.hasUnion) {
+        this._typings.add(PythonTyping.Union)
+      }
+
+      return result
+    })
+
+    return schemaTypes
+  }
+}

src/codegen/language-mappers/zod-to-python-parameter-class-mapper.ts

@@ -0,0 +1,160 @@
+import {stripIndent} from 'common-tags'
+import {z} from 'zod'
+
+import pascalCase from '../../util/pascal-case.js'
+import {PythonTyping, ZodTypeSupported} from '../types.js'
+import {ZodBaseMapper} from './zod-base-mapper.js'
+
+export class ZodToPythonParameterClassMapper extends ZodBaseMapper {
+  private _fieldName: string | undefined
+  private _hasAny: boolean = false
+  private _hasDict: boolean = false
+  private _hasList: boolean = false
+  private _hasOptional: boolean = false
+  private _hasTuple: boolean = false
+  private _hasUnion: boolean = false
+
+  constructor({fieldName}: {fieldName?: string} = {}) {
+    super()
+    this._fieldName = fieldName
+  }
+
+  static parameterClassName(key: string) {
+    let keyPrefix = pascalCase(key)
+
+    // If the method name starts with a digit, prefix it with an underscore to ensure method name is valid
+    if (/^\d/.test(keyPrefix)) {
+      keyPrefix = `_${keyPrefix}`
+    }
+
+    return `${keyPrefix}Params`
+  }
+
+  get hasAny() {
+    return this._hasAny
+  }
+
+  get hasDict() {
+    return this._hasDict
+  }
+
+  get hasList() {
+    return this._hasList
+  }
+
+  get hasOptional() {
+    return this._hasOptional
+  }
+
+  get hasTuple() {
+    return this._hasTuple
+  }
+
+  get hasUnion() {
+    return this._hasUnion
+  }
+
+  any() {
+    this._hasAny = true
+
+    return PythonTyping.Any
+  }
+
+  array(wrappedType: string) {
+    this._hasList = true
+
+    return `${PythonTyping.List}[${wrappedType}]`
+  }
+
+  boolean() {
+    return 'bool'
+  }
+
+  enum(values: string[]) {
+    // TODO: figure out support for these
+    return values.map((v) => `'${v}'`).join(' | ')
+  }
+
+  function(args: string) {
+    // All we care about are the arguments
+    return args
+  }
+
+  functionArguments(value?: z.ZodTuple): string {
+    if (!value) {
+      return ''
+    }
+
+    const mapper = new ZodToPythonParameterClassMapper()
+    return mapper.resolveType(value)
+  }
+
+  functionReturns(): string {
+    // We don't care about return values when mapping parameter classes
+    return ''
+  }
+
+  null() {
+    return 'None'
+  }
+
+  number(isInteger: boolean) {
+    return isInteger ? 'int' : 'float'
+  }
+
+  object(properties: [string, z.ZodTypeAny][]) {
+    const nestedClasses: [string, string][] = properties.map(([fieldName, type]) => {
+      const mapper = new ZodToPythonParameterClassMapper({fieldName})
+      return [ZodToPythonParameterClassMapper.parameterClassName(fieldName), mapper.renderClass(type)]
+    })
+
+    // TODO: Fix this
+    return `{ ${nestedClasses.map(([className]) => className)} }`
+  }
+
+  optional(wrappedType: string) {
+    this._hasOptional = true
+
+    return `Optional[${wrappedType}]`
+  }
+
+  renderClass(type: ZodTypeSupported): string {
+    if (!this._fieldName) {
+      throw new Error('Field name must be set to render a class.')
+    }
+
+    const resolved = this.resolveType(type)
+
+    return stripIndent`
+    @dataclass
+            class ${ZodToPythonParameterClassMapper.parameterClassName(this._fieldName)}:
+                ${resolved}
+    `
+  }
+
+  string() {
+    return 'str'
+  }
+
+  tuple(wrappedTypes: string[]) {
+    this._hasTuple = true
+
+    return `Tuple[${wrappedTypes.join(', ')}]`
+  }
+
+  undefined() {
+    // There is no equivalent to `undefined` in Python, so we use `None`
+    return 'None'
+  }
+
+  union(wrappedTypes: string[]) {
+    this._hasUnion = true
+
+    return `Union[${wrappedTypes.join(', ')}]`
+  }
+
+  unknown() {
+    // There is no equivalent to `unknown` in Python, so we use `Any`
+    return PythonTyping.Any
+  }
+}

src/codegen/types.ts

@@ -1,8 +1,18 @@
 import {z} from 'zod'
 
 export enum SupportedLanguage {
+  Node = 'node',
+  Python = 'python',
   React = 'react',
-  TypeScript = 'typescript',
+}
+
+export enum PythonTyping {
+  Any = 'Any',
+  Dict = 'Dict',
+  List = 'List',
+  Optional = 'Optional',
+  Tuple = 'Tuple',
+  Union = 'Union',
 }
 
 export interface ConfigValue {