feat: wip python generator

Author: mjfaga

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

@@ -0,0 +1,175 @@
+import {stripIndent} from 'common-tags'
+import camelCase from 'lodash.camelcase'
+
+import {ZodToPythonClassMapper} from '../language-mappers/zod-to-python-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 ENUM_IMPORT = 'from enum import StrEnum'
+  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 classTemplates = this.generateClasses()
+    const accessorMethods = this.generateAccessorMethods()
+
+    const additionalDependencies = new Set<string>()
+
+    const typings = this._typings.size > 0 ? [...this._typings].sort().join(', ') : null
+
+    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
+
+        ${classTemplates.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 generateClasses(): string[] {
+    const uniqueClasses: Record<string, string> = {}
+
+    const schemaTypes = this.configurations().flatMap((config) => {
+      if (config.key === 'use-mark-thing') {
+        console.log('config', config.schema)
+      }
+      const mapper = new ZodToPythonClassMapper({fieldName: config.key})
+      const results = mapper.renderClasses(config.schema)
+
+      results.forEach(([className, classDefinition]) => {
+        // If it's a duplicate definition and it's not identical, bomb out
+        if (uniqueClasses[className] && uniqueClasses[className] !== classDefinition) {
+          throw new Error(`Different class definition with identical name ${className}`)
+        }
+
+        uniqueClasses[className] = classDefinition
+      })
+
+      if (mapper.hasAny) {
+        this._typings.add(PythonTyping.Any)
+      }
+      if (mapper.hasTypedDict) {
+        this._typings.add(PythonTyping.TypedDict)
+      }
+      if (mapper.hasOptional) {
+        this._typings.add(PythonTyping.Optional)
+      }
+      if (mapper.hasTuple) {
+        this._typings.add(PythonTyping.Tuple)
+      }
+      if (mapper.hasUnion) {
+        this._typings.add(PythonTyping.Union)
+      }
+
+      // only return class definitions
+      return results.map(([, classDefinition]) => classDefinition)
+    })
+
+    return schemaTypes
+  }
+}