schemez 1.0.0__py3-none-any.whl → 1.1.1__py3-none-any.whl

schemez/helpers.py

@@ -2,15 +2,21 @@
 
 from __future__ import annotations
 
+import asyncio
 import importlib
 import os
-from typing import TYPE_CHECKING, Any
+from pathlib import Path
+import subprocess
+import sys
+import tempfile
+from typing import TYPE_CHECKING, Any, Literal
 
 from pydantic import BaseModel
+from pydantic_core import to_json
 
 
 StrPath = str | os.PathLike[str]
-
+PythonVersion = Literal["3.13", "3.14", "3.15"]
 
 if TYPE_CHECKING:
     from collections.abc import Callable
@@ -169,3 +175,111 @@ 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 _detect_command(command: str, *, test_flag: str = "--version") -> list[str]:
+    """Detect the correct command prefix for running a command.
+
+    Tries 'uv run' first, then falls back to direct execution.
+
+    Args:
+        command: The command to detect
+        test_flag: Flag to test command availability with
+
+    Returns:
+        Command prefix list (empty for direct execution)
+
+    Raises:
+        RuntimeError: If command is not available
+    """
+    cmd_prefixes = [["uv", "run"], []]
+
+    for prefix in cmd_prefixes:
+        try:
+            proc = await asyncio.create_subprocess_exec(
+                *prefix,
+                command,
+                test_flag,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+            )
+            await proc.communicate()
+            if proc.returncode == 0:
+                return prefix
+        except FileNotFoundError:
+            continue
+
+    msg = f"{command} not available (tried both 'uv run' and direct execution)"
+    raise RuntimeError(msg)
+
+
+async def model_to_python_code(
+    model: type[BaseModel],
+    *,
+    class_name: str | None = None,
+    target_python_version: PythonVersion | None = None,
+    model_type: str = "pydantic.BaseModel",
+) -> 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.
+        model_type: Type of the generated model. Defaults to "pydantic.BaseModel".
+
+    Returns:
+        Generated Python code as string
+
+    Raises:
+        RuntimeError: If datamodel-codegen is not available
+        subprocess.CalledProcessError: If code generation fails
+    """
+    working_prefix = await _detect_command("datamodel-codegen")
+
+    schema = model.model_json_schema()
+    name = class_name or model.__name__
+    py = target_python_version or f"{sys.version_info.major}.{sys.version_info.minor}"
+    with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f:
+        # Use pydantic_core.to_json for proper schema serialization
+        schema_json = to_json(schema, indent=2).decode()
+        f.write(schema_json)
+        schema_file = Path(f.name)
+
+    args = [
+        "--input",
+        str(schema_file),
+        "--input-file-type",
+        "jsonschema",
+        "--output-model-type",
+        model_type,
+        "--class-name",
+        name,
+        "--disable-timestamp",
+        "--use-union-operator",
+        "--use-schema-description",
+        "--enum-field-as-literal",
+        "all",
+        "--target-python-version",
+        py,
+    ]
+
+    try:  # Generate model using datamodel-codegen
+        proc = await asyncio.create_subprocess_exec(
+            *working_prefix,
+            "datamodel-codegen",
+            *args,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        stdout, _stderr = await proc.communicate()
+
+        if proc.returncode != 0:
+            code = proc.returncode or -1
+            raise subprocess.CalledProcessError(code, "datamodel-codegen")
+
+        return stdout.decode().strip()
+
+    finally:  # Cleanup temp file
+        schema_file.unlink(missing_ok=True)

schemez/schema.py

@@ -19,6 +19,7 @@ if TYPE_CHECKING:
 
 StrPath = str | os.PathLike[str]
 SourceType = Literal["pdf", "image"]
+PythonVersion = Literal["3.13", "3.14", "3.15"]
 
 DEFAULT_SYSTEM_PROMPT = "You are a schema extractor for {name} BaseModels."
 DEFAULT_USER_PROMPT = "Extract information from this document:"
@@ -254,3 +255,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: PythonVersion | 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/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

{schemez-1.0.0.dist-info → schemez-1.1.1.dist-info}/METADATA

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

{schemez-1.0.0.dist-info → schemez-1.1.1.dist-info}/RECORD

@@ -2,12 +2,12 @@ schemez/__init__.py,sha256=iDo1ZpV07BUOmRmISV6QDA8s3viJR5V1NnrBsdw6eVM,985
 schemez/code.py,sha256=usZLov9i5KpK1W2VJxngUzeetgrINtodiooG_AxN-y4,2072
 schemez/convert.py,sha256=b6Sz11lq0HvpXfMREOqnnw8rcVg2XzTKhjjPNc4YIoE,4403
 schemez/docstrings.py,sha256=kmd660wcomXzKac0SSNYxPRNbVCUovrpmE9jwnVRS6c,4115
-schemez/helpers.py,sha256=Ee3wvFbt65ljhWDFdb6ACVUJK4KLjJFVzl4Le75pOBQ,5159
+schemez/helpers.py,sha256=IVuoFbzPJs3eqJBrr0BA6SIHncoU6BFJGP41zTijzXM,8716
 schemez/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 schemez/pydantic_types.py,sha256=8vgSl8i2z9n0fB-8AJj-D3TBByEWE5IxItBxQ0XwXFI,1640
-schemez/schema.py,sha256=VeNSFec6aCR9GgqXLBE3t4TZeUoS9BDmIoofe9nbqVI,8804
+schemez/schema.py,sha256=u6SDhYDtfCjgy2Aa-_MDLLNcUfEXbeye4T-W6s3AED8,9558
 schemez/schemadef/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-schemez/schemadef/schemadef.py,sha256=m4m6f24xEgJgkp7jhp-6TpfLcwkVLL3WmKF9zDRhwAM,15091
-schemez-1.0.0.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
-schemez-1.0.0.dist-info/METADATA,sha256=8aIPUY5UbLeBZ_3vjIf8a692jMjeZF49wiUv8_Ywvxc,5359
-schemez-1.0.0.dist-info/RECORD,,
+schemez/schemadef/schemadef.py,sha256=FtD7TOnYxiuYOIfadRHKkkbZn98mWFb0_lKfPsPR-hI,14393
+schemez-1.1.1.dist-info/WHEEL,sha256=I8-bO5cg2sb8TH6ZM6EgCP87Y1cV_f9UGgWnfAhVOZI,78
+schemez-1.1.1.dist-info/METADATA,sha256=JwgerPl41Wss2TGr4FLUr3tic62ma4lUAN8rTqgJA9I,5359
+schemez-1.1.1.dist-info/RECORD,,

{schemez-1.0.0.dist-info → schemez-1.1.1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: uv 0.8.24
+Generator: uv 0.9.0
 Root-Is-Purelib: true
 Tag: py3-none-any