schemez 1.0.0__tar.gz → 1.1.0__tar.gz

{schemez-1.0.0 → schemez-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: schemez
-Version: 1.0.0
+Version: 1.1.0
 Summary: Pydantic shim for config stuff
 Keywords: 
 Author: Philipp Temminghoff

{schemez-1.0.0 → schemez-1.1.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "schemez"
-version = "1.0.0"
+version = "1.1.0"
 description = "Pydantic shim for config stuff"
 readme = "README.md"
 requires-python = ">=3.13"
@@ -48,6 +48,7 @@ dev = [
   "devtools",
   "pyreadline3",
   "pytest",
+  "pytest-asyncio>=1.2.0",
   "pytest-cov",
   # Only add below (Copier)
 ]

{schemez-1.0.0 → schemez-1.1.0}/src/schemez/helpers.py

@@ -2,8 +2,14 @@
 
 from __future__ import annotations
 
+import asyncio
 import importlib
+import json
 import os
+from pathlib import Path
+import subprocess
+import sys
+import tempfile
 from typing import TYPE_CHECKING, Any
 
 from pydantic import BaseModel
@@ -169,3 +175,90 @@ def resolve_type_string(type_string: str, safe: bool = True) -> type:
         except Exception as e:
             msg = f"Failed to resolve type {type_string} in unsafe mode"
             raise ValueError(msg) from e
+
+
+async def model_to_python_code(
+    model: type[BaseModel],
+    *,
+    class_name: str | None = None,
+    target_python_version: str | None = None,
+) -> str:
+    """Convert a BaseModel to Python code asynchronously.
+
+    Args:
+        model: The BaseModel class to convert
+        class_name: Optional custom class name for the generated code
+        target_python_version: Target Python version for code generation.
+            Defaults to current system Python version.
+
+    Returns:
+        Generated Python code as string
+
+    Raises:
+        RuntimeError: If datamodel-codegen is not available
+        subprocess.CalledProcessError: If code generation fails
+    """
+    try:
+        # Check if datamodel-codegen is available
+        proc = await asyncio.create_subprocess_exec(
+            "datamodel-codegen",
+            "--version",
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        await proc.communicate()
+        if proc.returncode != 0:
+            raise subprocess.CalledProcessError(
+                proc.returncode or -1, "datamodel-codegen"
+            )
+    except FileNotFoundError as e:
+        msg = "datamodel-codegen not available"
+        raise RuntimeError(msg) from e
+
+    # Get model schema
+    schema = model.model_json_schema()
+    name = class_name or model.__name__
+    python_version = (
+        target_python_version or f"{sys.version_info.major}.{sys.version_info.minor}"
+    )
+
+    # Create temporary file with schema
+    with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f:
+        json.dump(schema, f)
+        schema_file = Path(f.name)
+
+    try:
+        # Generate model using datamodel-codegen
+        proc = await asyncio.create_subprocess_exec(
+            "datamodel-codegen",
+            "--input",
+            str(schema_file),
+            "--input-file-type",
+            "jsonschema",
+            "--output-model-type",
+            "pydantic.BaseModel",
+            "--class-name",
+            name,
+            "--disable-timestamp",
+            "--use-union-operator",
+            "--use-schema-description",
+            "--enum-field-as-literal",
+            "all",
+            "--target-python-version",
+            python_version,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        stdout, stderr = await proc.communicate()
+
+        if proc.returncode != 0:
+            msg = f"datamodel-codegen failed: {stderr.decode()}"
+            raise subprocess.CalledProcessError(
+                proc.returncode or -1, "datamodel-codegen"
+            )
+
+        return stdout.decode().strip()
+
+    finally:
+        # Cleanup temp file
+        schema_file.unlink(missing_ok=True)

{schemez-1.0.0 → schemez-1.1.0}/src/schemez/schema.py

@@ -254,3 +254,27 @@ class Schema(BaseModel):
         except Exception as exc:
             msg = f"Failed to save configuration to {path}"
             raise ValueError(msg) from exc
+
+    @classmethod
+    async def to_python_code(
+        cls,
+        *,
+        class_name: str | None = None,
+        target_python_version: str | None = None,
+    ) -> str:
+        """Convert this model to Python code asynchronously.
+
+        Args:
+            class_name: Optional custom class name for the generated code
+            target_python_version: Target Python version for code generation
+
+        Returns:
+            Generated Python code as string
+        """
+        from schemez.helpers import model_to_python_code
+
+        return await model_to_python_code(
+            cls,
+            class_name=class_name,
+            target_python_version=target_python_version,
+        )

{schemez-1.0.0 → schemez-1.1.0}/src/schemez/schemadef/schemadef.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+from collections.abc import Callable
 from enum import Enum
 from typing import Annotated, Any, Literal
 
@@ -213,29 +214,22 @@ class InlineSchemaDef(BaseSchemaDef):
             # Handle enum type
             if field.type == "enum":
                 if not field.values:
-                    msg = f"Field '{name}' has type 'enum' but no values defined"
+                    msg = f"Field {name!r} has type 'enum' but no values defined"
                     raise ValueError(msg)
 
-                # Create dynamic Enum class
-                enum_name = f"{name.capitalize()}Enum"
-
-                # Create enum members dictionary
-                enum_members = {}
+                enum_name = f"{name.capitalize()}Enum"  # Create dynamic Enum class
+                enum_members = {}  # Create enum members dictionary
                 for i, value in enumerate(field.values):
                     if isinstance(value, str) and value.isidentifier():
-                        # If value is a valid Python identifier, use it as is
-                        key = value
+                        key = value  # If value is a valid Python identifier, use as is
                     else:
-                        # Otherwise, create a synthetic name
-                        key = f"VALUE_{i}"
+                        key = f"VALUE_{i}"  # Otherwise, create a synthetic name
                     enum_members[key] = value
 
-                # Create the enum class
-                enum_class = Enum(enum_name, enum_members)
+                enum_class = Enum(enum_name, enum_members)  # Create the enum class
                 python_type: Any = enum_class
 
-                # Handle enum default value specially
-                if field.default is not None:
+                if field.default is not None:  # Handle enum default value specially
                     # Store default value as the enum value string
                     # Pydantic v2 will convert it to the enum instance
                     if field.default in list(field.values):
@@ -252,18 +246,13 @@ class InlineSchemaDef(BaseSchemaDef):
                     msg = f"Unsupported field type: {field.type}"
                     raise ValueError(msg)
 
-            # Handle literal constraint if provided
-            if field.literal_value is not None:
-                from typing import Literal as LiteralType
-
-                python_type = LiteralType[field.literal_value]
+            if field.literal_value is not None:  # Handle literal constraint if provided
+                python_type = Literal[field.literal_value]
 
-            # Handle optional fields (allowing None)
-            if field.optional:
+            if field.optional:  # Handle optional fields (allowing None)
                 python_type = python_type | None  # type: ignore
 
-            # Add standard Pydantic constraints
-            # Collect all constraint values
+            # Add standard Pydantic constraints. Collect all constraint values
             for constraint in [
                 "default",
                 "title",
@@ -282,23 +271,19 @@ class InlineSchemaDef(BaseSchemaDef):
                 if value is not None:
                     field_constraints[constraint] = value
 
-            # Handle examples separately (Pydantic v2 way)
             if field.examples:
                 if field.json_schema_extra is None:
                     field.json_schema_extra = {}
                 field.json_schema_extra["examples"] = field.examples
 
-            # Add json_schema_extra if provided
             if field.json_schema_extra:
                 field_constraints["json_schema_extra"] = field.json_schema_extra
 
-            # Handle field dependencies
             if field.dependent_required or field.dependent_schema:
                 if field.json_schema_extra is None:
                     field_constraints["json_schema_extra"] = {}
 
                 json_extra = field_constraints.get("json_schema_extra", {})
-
                 if field.dependent_required:
                     if "dependentRequired" not in json_extra:
                         json_extra["dependentRequired"] = {}
@@ -311,9 +296,7 @@ class InlineSchemaDef(BaseSchemaDef):
 
                 field_constraints["json_schema_extra"] = json_extra
 
-            # Add any additional constraints
-            field_constraints.update(field.constraints)
-
+            field_constraints.update(field.constraints)  # Add any additional constraints
             field_info = Field(description=field.description, **field_constraints)
             fields[name] = (python_type, field_info)
 
@@ -321,25 +304,18 @@ class InlineSchemaDef(BaseSchemaDef):
             if field.dependent_required or field.dependent_schema:
                 if not model_dependencies:
                     model_dependencies = {"json_schema_extra": {}}
-
+                extra = model_dependencies["json_schema_extra"]
                 if field.dependent_required:
-                    if "dependentRequired" not in model_dependencies["json_schema_extra"]:
-                        model_dependencies["json_schema_extra"]["dependentRequired"] = {}
-                    model_dependencies["json_schema_extra"]["dependentRequired"].update(
-                        field.dependent_required
-                    )
-
+                    if "dependentRequired" not in extra:
+                        extra["dependentRequired"] = {}
+                    extra["dependentRequired"].update(field.dependent_required)
                 if field.dependent_schema:
-                    if "dependentSchemas" not in model_dependencies["json_schema_extra"]:
-                        model_dependencies["json_schema_extra"]["dependentSchemas"] = {}
-                    model_dependencies["json_schema_extra"]["dependentSchemas"].update(
-                        field.dependent_schema
-                    )
-
-        # Create the model class with field definitions
-        cls_name = self.description or "ResponseType"
-        model = create_model(
-            cls_name,
+                    if "dependentSchemas" not in extra:
+                        extra["dependentSchemas"] = {}
+                    extra["dependentSchemas"].update(field.dependent_schema)
+
+        model = create_model(  # Create the model class
+            self.description or "ResponseType",
             **fields,
             __base__=BaseModel,
             __doc__=self.description,
@@ -347,23 +323,22 @@ class InlineSchemaDef(BaseSchemaDef):
 
         # Add model-level JSON Schema extras for dependencies
         if model_dependencies:
-            if not hasattr(model, "model_config") or not model.model_config:
-                model.model_config = {}
-
-            if "json_schema_extra" not in model.model_config:
-                model.model_config["json_schema_extra"] = {}
-
-            schema_extra = model.model_config["json_schema_extra"]
-
-            if "dependentRequired" in model_dependencies["json_schema_extra"]:
-                schema_extra["dependentRequired"] = model_dependencies[
-                    "json_schema_extra"
-                ]["dependentRequired"]
-
-            if "dependentSchemas" in model_dependencies["json_schema_extra"]:
-                schema_extra["dependentSchemas"] = model_dependencies[
-                    "json_schema_extra"
-                ]["dependentSchemas"]
+            existing_extra = model.model_config.get("json_schema_extra")
+            deps_extra = model_dependencies["json_schema_extra"]
+
+            match existing_extra:
+                case None:
+                    model.model_config["json_schema_extra"] = deps_extra
+                case dict() as schema_extra:
+                    schema_extra.update(deps_extra)
+                case Callable() as callable_func:
+
+                    def wrapped_extra(*args: Any) -> None:
+                        callable_func(*args)
+                        schema = args[0]
+                        schema.update(deps_extra)
+
+                    model.model_config["json_schema_extra"] = wrapped_extra
 
         # Return the created model
         return model