schemez 1.1.0__py3-none-any.whl → 1.2.0__py3-none-any.whl

schemez/helpers.py

@@ -4,19 +4,19 @@ 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 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
@@ -177,11 +177,48 @@ def resolve_type_string(type_string: str, safe: bool = True) -> type:
             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: str | None = None,
+    target_python_version: PythonVersion | None = None,
+    model_type: str = "pydantic.BaseModel",
 ) -> str:
     """Convert a BaseModel to Python code asynchronously.
 
@@ -190,6 +227,7 @@ async def model_to_python_code(
         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
@@ -198,67 +236,50 @@ async def model_to_python_code(
         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
+    working_prefix = await _detect_command("datamodel-codegen")
 
-    # 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
+    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:
-        json.dump(schema, 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)
 
-    try:
-        # Generate model using datamodel-codegen
+    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",
-            "--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,
+            *args,
             stdout=asyncio.subprocess.PIPE,
             stderr=asyncio.subprocess.PIPE,
         )
-        stdout, stderr = await proc.communicate()
+        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"
-            )
+            code = proc.returncode or -1
+            raise subprocess.CalledProcessError(code, "datamodel-codegen")
 
         return stdout.decode().strip()
 
-    finally:
-        # Cleanup temp file
+    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:"
@@ -260,7 +261,7 @@ class Schema(BaseModel):
         cls,
         *,
         class_name: str | None = None,
-        target_python_version: str | None = None,
+        target_python_version: PythonVersion | None = None,
     ) -> str:
         """Convert this model to Python code asynchronously.
 

schemez/schema_generators.py

@@ -0,0 +1,215 @@
+from __future__ import annotations
+
+from collections.abc import Callable  # noqa: TC003
+import dataclasses
+import importlib
+import inspect
+import types
+from typing import Any, Literal, get_type_hints
+
+import pydantic
+
+from schemez.functionschema import (
+    FunctionSchema,
+    _resolve_type_annotation,
+    create_schema,
+)
+from schemez.typedefs import ToolParameters
+
+
+def create_schemas_from_callables(
+    callables: dict[str, Callable[..., Any]],
+    prefix: str | Literal[False] | None = None,
+    exclude_private: bool = True,
+) -> dict[str, FunctionSchema]:
+    """Generate OpenAI function schemas from a dictionary of callables.
+
+    Args:
+        callables: Dictionary mapping names to callable objects
+        prefix: Schema name prefix to prepend to function names.
+               If None, no prefix. If False, use raw name.
+               If string, uses that prefix.
+        exclude_private: Whether to exclude callables starting with underscore
+
+    Returns:
+        Dictionary mapping qualified names to FunctionSchema objects
+
+    Example:
+        >>> def foo(x: int) -> str: ...
+        >>> def bar(y: float) -> int: ...
+        >>> callables = {'foo': foo, 'bar': bar}
+        >>> schemas = create_schemas_from_callables(callables, prefix='math')
+        >>> print(schemas['math.foo'])
+    """
+    schemas = {}
+
+    for name, callable_obj in callables.items():
+        # Skip private members if requested
+        if exclude_private and name.startswith("_"):
+            continue
+
+        # Generate schema key based on prefix setting
+        key = name if prefix is False else f"{prefix}.{name}" if prefix else name
+        schemas[key] = create_schema(callable_obj)
+
+    return schemas
+
+
+def create_schemas_from_class(
+    cls: type,
+    prefix: str | Literal[False] | None = None,
+) -> dict[str, FunctionSchema]:
+    """Generate OpenAI function schemas for all public methods in a class.
+
+    Args:
+        cls: The class to generate schemas from
+        prefix: Schema name prefix. If None, uses class name.
+               If False, no prefix. If string, uses that prefix.
+
+    Returns:
+        Dictionary mapping qualified method names to FunctionSchema objects
+
+    Example:
+        >>> class MyClass:
+        ...     def my_method(self, x: int) -> str:
+        ...         return str(x)
+        >>> schemas = create_schemas_from_class(MyClass)
+        >>> print(schemas['MyClass.my_method'])
+    """
+    callables: dict[str, Callable[..., Any]] = {}
+
+    # Get all attributes of the class
+    for name, attr in inspect.getmembers(cls):
+        # Handle different method types
+        if inspect.isfunction(attr) or inspect.ismethod(attr):
+            callables[name] = attr
+        elif isinstance(attr, classmethod | staticmethod):
+            callables[name] = attr.__get__(None, cls)
+
+    # Use default prefix of class name if not specified
+    effective_prefix = cls.__name__ if prefix is None else prefix
+    return create_schemas_from_callables(callables, prefix=effective_prefix)
+
+
+def create_constructor_schema(cls: type) -> FunctionSchema:
+    """Create OpenAI function schema from class constructor.
+
+    Args:
+        cls: Class to create schema for
+
+    Returns:
+        OpenAI function schema for class constructor
+    """
+    if isinstance(cls, type) and issubclass(cls, pydantic.BaseModel):
+        properties = {}
+        required = []
+        for name, field in cls.model_fields.items():
+            param_type = field.annotation
+            properties[name] = _resolve_type_annotation(
+                param_type,
+                description=field.description,
+                default=field.default,
+            )
+            if field.is_required():
+                required.append(name)
+
+    # Handle dataclasses
+    elif dataclasses.is_dataclass(cls):
+        properties = {}
+        required = []
+        dc_fields = dataclasses.fields(cls)
+        hints = get_type_hints(cls)
+
+        for dc_field in dc_fields:
+            param_type = hints[dc_field.name]
+            properties[dc_field.name] = _resolve_type_annotation(
+                param_type, default=dc_field.default
+            )
+            if (
+                dc_field.default is dataclasses.MISSING
+                and dc_field.default_factory is dataclasses.MISSING
+            ):
+                required.append(dc_field.name)
+
+    # Handle regular classes
+    else:
+        sig = inspect.signature(cls.__init__)
+        hints = get_type_hints(cls.__init__)
+        properties = {}
+        required = []
+
+        for name, param in sig.parameters.items():
+            if name == "self":
+                continue
+
+            param_type = hints.get(name, Any)
+            properties[name] = _resolve_type_annotation(
+                param_type,
+                default=param.default,
+            )
+
+            if param.default is param.empty:
+                required.append(name)
+
+    name = f"create_{cls.__name__}"
+    description = inspect.getdoc(cls) or f"Create {cls.__name__} instance"
+
+    # Create parameters with required list included
+    params = ToolParameters({
+        "type": "object",
+        "properties": properties,
+        "required": required,
+    })
+
+    return FunctionSchema(
+        name=name, description=description, parameters=params, required=required
+    )
+
+
+def create_schemas_from_module(
+    module: types.ModuleType | str,
+    include_functions: list[str] | None = None,
+    prefix: str | Literal[False] | None = None,
+) -> dict[str, FunctionSchema]:
+    """Generate OpenAI function schemas from a Python module's functions.
+
+    Args:
+        module: Either a ModuleType object or string name of module to analyze
+        include_functions: Optional list of function names to specifically include
+        prefix: Schema name prefix. If None, uses module name.
+                If False, no prefix. If string, uses that prefix.
+
+    Returns:
+        Dictionary mapping function names to FunctionSchema objects
+
+    Raises:
+        ImportError: If module string name cannot be imported
+
+    Example:
+        >>> import math
+        >>> schemas = create_schemas_from_module(math, ['sin', 'cos'])
+        >>> print(schemas['math.sin'])
+    """
+    # Resolve module if string name provided
+    mod = (
+        module
+        if isinstance(module, types.ModuleType)
+        else importlib.import_module(module)
+    )
+
+    # Get all functions from module
+    callables: dict[str, Callable[..., Any]] = {
+        name: func
+        for name, func in inspect.getmembers(mod, predicate=inspect.isfunction)
+        if include_functions is None
+        or (name in include_functions and func.__module__.startswith(mod.__name__))
+    }
+
+    # Use default prefix of module name if not specified
+    effective_prefix = mod.__name__ if prefix is None else prefix
+    return create_schemas_from_callables(callables, prefix=effective_prefix)
+
+
+if __name__ == "__main__":
+    schemas = create_schemas_from_module(__name__)
+    print(schemas)

schemez/typedefs.py

@@ -0,0 +1,205 @@
+from __future__ import annotations
+
+import inspect
+from typing import Any, Literal, NotRequired, TypedDict
+
+
+class PropertyBase(TypedDict, total=False):
+    """Base schema property with common fields."""
+
+    type: str
+    description: str
+    format: str
+    default: Any
+    enum: NotRequired[list[Any]]
+
+
+class SimpleProperty(PropertyBase):
+    """Schema property for primitive types."""
+
+    type: Literal["string", "number", "integer", "boolean"]
+    enum: NotRequired[list[Any]]
+
+
+class ArrayProperty(PropertyBase):
+    """Schema property for array types."""
+
+    type: Literal["array"]
+    items: Property
+
+
+class ObjectProperty(PropertyBase):
+    """Schema property for nested object types."""
+
+    type: Literal["object"]
+    properties: NotRequired[dict[str, Property]]
+    required: NotRequired[list[str]]
+    additionalProperties: NotRequired[bool]
+
+
+Property = ArrayProperty | ObjectProperty | SimpleProperty
+
+
+class ToolParameters(TypedDict):
+    """Schema for function parameters."""
+
+    type: Literal["object"]
+    properties: dict[str, Property]
+    required: NotRequired[list[str]]
+
+
+class OpenAIFunctionDefinition(TypedDict):
+    """Schema for the function definition part of an OpenAI tool.
+
+    This represents the inner "function" object that contains the actual
+    function metadata and parameters.
+    """
+
+    name: str
+    description: str
+    parameters: ToolParameters
+
+
+class OpenAIFunctionTool(TypedDict):
+    """Complete OpenAI tool definition for function calling.
+
+    This represents the top-level tool object that wraps a function definition
+    and identifies it as a function tool type.
+    """
+
+    type: Literal["function"]
+    function: OpenAIFunctionDefinition
+
+
+def _create_simple_property(
+    type_str: Literal["string", "number", "integer", "boolean"],
+    description: str | None = None,
+    enum_values: list[Any] | None = None,
+    default: Any = None,
+    fmt: str | None = None,
+) -> SimpleProperty:
+    """Create a simple property."""
+    prop: SimpleProperty = {"type": type_str}
+    if description is not None:
+        prop["description"] = description
+    if enum_values is not None:
+        prop["enum"] = enum_values
+    if default is not inspect.Parameter.empty and default is not None:
+        prop["default"] = default
+    if fmt is not None:
+        prop["format"] = fmt
+    return prop
+
+
+def _create_array_property(
+    items: Property,
+    description: str | None = None,
+) -> ArrayProperty:
+    """Create an array property."""
+    prop: ArrayProperty = {
+        "type": "array",
+        "items": items,
+    }
+    if description is not None:
+        prop["description"] = description
+    return prop
+
+
+def _create_object_property(
+    description: str | None = None,
+    properties: dict[str, Property] | None = None,
+    required: list[str] | None = None,
+    additional_properties: bool | None = None,
+) -> ObjectProperty:
+    """Create an object property.
+
+    Args:
+        description: Optional property description
+        properties: Optional dict of property definitions
+        required: Optional list of required property names
+        additional_properties: Whether to allow additional properties
+
+    Returns:
+        Object property definition
+    """
+    prop: ObjectProperty = {"type": "object"}
+    if description is not None:
+        prop["description"] = description
+    if properties is not None:
+        prop["properties"] = properties
+    if required is not None:
+        prop["required"] = required
+    if additional_properties is not None:
+        prop["additionalProperties"] = additional_properties
+    return prop
+
+
+def _convert_complex_property(
+    prop: dict[str, Any],
+    description: str | None = None,
+) -> Property:
+    """Convert complex schema properties to simple OpenAI-compatible types.
+
+    Args:
+        prop: Complex property definition
+        description: Optional property description
+
+    Returns:
+        Simplified Property compatible with OpenAI
+    """
+    if "anyOf" in prop or "oneOf" in prop:
+        types = []
+        for subschema in prop.get("anyOf", prop.get("oneOf", [])):
+            if isinstance(subschema, dict):
+                types.append(subschema.get("type"))  # noqa: PERF401
+
+        # If null is allowed, treat as optional string
+        if "null" in types:
+            return _create_simple_property(
+                type_str="string",
+                description=description or prop.get("description"),
+                default=None,
+            )
+
+        # Get first non-null type or default to string
+        first_type = next((t for t in types if t != "null"), "string")
+        if first_type not in ("string", "number", "integer", "boolean"):
+            first_type = "string"
+
+        return _create_simple_property(
+            type_str=first_type,  # type: ignore # Valid since we checked above
+            description=description or prop.get("description"),
+            default=prop.get("default"),
+        )
+
+    if prop.get("type") == "array":
+        items = prop.get("items", {"type": "string"})
+        if isinstance(items, dict):
+            items = _convert_complex_property(items)
+        return _create_array_property(
+            items=items,
+            description=description or prop.get("description"),
+        )
+
+    if prop.get("type") == "object":
+        sub_props = prop.get("properties", {})
+        cleaned_props = {
+            name: _convert_complex_property(p) for name, p in sub_props.items()
+        }
+        return _create_object_property(
+            description=description or prop.get("description"),
+            properties=cleaned_props,
+            required=prop.get("required"),
+        )
+
+    type_str = prop.get("type", "string")
+    if type_str not in ("string", "number", "integer", "boolean"):
+        type_str = "string"
+
+    return _create_simple_property(
+        type_str=type_str,  # type: ignore # Valid since we checked above
+        description=description or prop.get("description"),
+        enum_values=prop.get("enum"),
+        default=prop.get("default"),
+        fmt=prop.get("format"),
+    )

{schemez-1.1.0.dist-info → schemez-1.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: schemez
-Version: 1.1.0
+Version: 1.2.0
 Summary: Pydantic shim for config stuff
 Keywords: 
 Author: Philipp Temminghoff
@@ -41,6 +41,7 @@ Classifier: Topic :: Documentation
 Classifier: Topic :: Software Development
 Classifier: Topic :: Utilities
 Classifier: Typing :: Typed
+Requires-Dist: docstring-parser>=0.17.0
 Requires-Dist: griffe>=1.7.3
 Requires-Dist: pydantic
 Requires-Dist: universal-pathlib>=0.2.6

schemez-1.2.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+schemez/__init__.py,sha256=KkwJF8pfbzw_4cBxwXuUyXIExqdxS8iumvyAL-JUED4,1669
+schemez/bind_kwargs.py,sha256=ChyArgNa5R8VdwSJmmrQItMH9Ld6hStWBISw-T1wyws,6228
+schemez/code.py,sha256=usZLov9i5KpK1W2VJxngUzeetgrINtodiooG_AxN-y4,2072
+schemez/convert.py,sha256=b6Sz11lq0HvpXfMREOqnnw8rcVg2XzTKhjjPNc4YIoE,4403
+schemez/create_type.py,sha256=wrdqdzXtfxZfsgp9IroldoYGTJs_Rdli8TiscqhV2bI,11647
+schemez/docstrings.py,sha256=kmd660wcomXzKac0SSNYxPRNbVCUovrpmE9jwnVRS6c,4115
+schemez/executable.py,sha256=YM4WcmRyJ9CpzKpNgS0A-Ri0Jd7mAzfHmoaXONI-mIs,7134
+schemez/functionschema.py,sha256=Z8kL1ckU6pEoRhOsFY6NziLhVudELHyylsFVXrCUcwU,26127
+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=u6SDhYDtfCjgy2Aa-_MDLLNcUfEXbeye4T-W6s3AED8,9558
+schemez/schema_generators.py,sha256=Gze7S7dQkTsl_1ckeHLXPxx4jQo7RB6hHQM-5fpAsrA,6973
+schemez/schemadef/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+schemez/schemadef/schemadef.py,sha256=FtD7TOnYxiuYOIfadRHKkkbZn98mWFb0_lKfPsPR-hI,14393
+schemez/typedefs.py,sha256=kxh-Vc5eKvCShdznJrg5N4_Fr8g1kYlkadEAdzgQ43w,6091
+schemez-1.2.0.dist-info/WHEEL,sha256=I8-bO5cg2sb8TH6ZM6EgCP87Y1cV_f9UGgWnfAhVOZI,78
+schemez-1.2.0.dist-info/METADATA,sha256=Nao7AGsQ0CGUiHDXT2nSE0AMOnwqlMybd8KTQSAaIB0,5399
+schemez-1.2.0.dist-info/RECORD,,

schemez-1.1.0.dist-info/RECORD

@@ -1,13 +0,0 @@
-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=TeYYb0_SghARkDwfXzlnrSErE4bhoGqzmDSCW63eOms,8016
-schemez/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-schemez/pydantic_types.py,sha256=8vgSl8i2z9n0fB-8AJj-D3TBByEWE5IxItBxQ0XwXFI,1640
-schemez/schema.py,sha256=tBrEuYuq_vqgjNZMebhdkbcFWXhVqRPTZCuCqL0boVk,9500
-schemez/schemadef/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-schemez/schemadef/schemadef.py,sha256=FtD7TOnYxiuYOIfadRHKkkbZn98mWFb0_lKfPsPR-hI,14393
-schemez-1.1.0.dist-info/WHEEL,sha256=I8-bO5cg2sb8TH6ZM6EgCP87Y1cV_f9UGgWnfAhVOZI,78
-schemez-1.1.0.dist-info/METADATA,sha256=BdB7YfOeV3zs62Z1CjDfLSL0qhDZXg-4-s9cXdItdqs,5359
-schemez-1.1.0.dist-info/RECORD,,