feat: wip python generator

Author: mjfaga

package.json

@@ -15,6 +15,7 @@
     "fuzzy": "^0.1.3",
     "inquirer-autocomplete-standalone": "^0.8.1",
     "lodash.camelcase": "^4.3.0",
+    "lodash.snakecase": "^4.1.1",
     "mustache": "^4.2.0",
     "zod": "^3.22.4"
   },
@@ -25,6 +26,7 @@
     "@types/chai": "^4",
     "@types/common-tags": "^1.8.4",
     "@types/lodash.camelcase": "^4.3.9",
+    "@types/lodash.snakecase": "^4.1.9",
     "@types/mocha": "^10",
     "@types/mustache": "^4.2.5",
     "@types/node": "^18",

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

@@ -0,0 +1,159 @@
+import {stripIndent} from 'common-tags'
+import snakeCase from 'lodash.snakecase'
+
+import {ZodToPythonClassMapper} from '../language-mappers/zod-to-python-class-mapper.js'
+import {PythonTyping} from '../types.js'
+import {BaseGenerator} from './base-generator.js'
+
+export class PythonGenerator extends BaseGenerator {
+  private _hasEnum = false
+  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)
+    }
+
+    if (this._hasEnum) {
+      additionalDependencies.add(this.ENUM_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'}
+    ${typings ? `from typing import ${typings}` : '# No additional typings required'}
+
+    # TODO: Need to make this dynamic
+    from datetime import timedelta # for Durations
+    ${classTemplates.join('') || '# No parameter classes generated\n'}
+    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
+
+        ${accessorMethods.join('              ') || '# No methods generated'}
+    `
+  }
+
+  private generateAccessorMethods(): string[] {
+    const uniqueMethods: Record<string, string> = {}
+    const schemaTypes = this.configurations().map((config) => {
+      let methodName = snakeCase(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.hasFunction) {
+        // const returnValue = new ZodToTypescriptReturnValueMapper().resolveType(config.schema)
+
+        return `
+        def ${methodName}(self, context: Optional[ContextDictOrContext] = None) -> Any:
+            return self.client.get("${config.key}", context=context)
+        `
+      }
+
+      return `
+        def ${methodName}(self, context: Optional[ContextDictOrContext] = None) -> Any:
+            return self.client.get("${config.key}", context=context)
+      `
+    })
+
+    return schemaTypes
+  }
+
+  private generateClasses(): string[] {
+    const uniqueClasses: Record<string, string> = {}
+
+    this.configurations().forEach((config) => {
+      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)
+      }
+      if (mapper.hasEnum) {
+        this._hasEnum = true
+      }
+    })
+
+    return Object.values(uniqueClasses)
+  }
+}