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

schemez/convert.py

@@ -64,7 +64,7 @@ def get_function_model(func: AnyCallable, *, name: str | None = None) -> type[Sc
 
     for param_name, param in sig.parameters.items():
         # Skip self/cls for methods
-        if param_name in ("self", "cls"):
+        if param_name in {"self", "cls"}:
             continue
 
         type_hint = hints.get(param_name, Any)

schemez/functionschema.py

@@ -37,7 +37,7 @@ if typing.TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 
-class FunctionType(str, enum.Enum):
+class FunctionType(enum.StrEnum):
     """Enum representing different function types."""
 
     SYNC = "sync"
@@ -119,6 +119,9 @@ class FunctionSchema(pydantic.BaseModel):
         required = self.parameters.get("required", self.required)
 
         for name, details in properties.items():
+            if name.startswith("_"):  # TODO: kwarg for renaming instead perhaps?
+                logger.debug("Skipping parameter %s due to leading underscore", name)
+                continue
             # Get base type
             if "enum" in details:
                 values = tuple(details["enum"])  # type: ignore
@@ -246,19 +249,14 @@ class FunctionSchema(pydantic.BaseModel):
             RuntimeError: If datamodel-codegen is not available
             subprocess.CalledProcessError: If code generation fails
         """
+        import shutil
         import subprocess
         import tempfile
 
-        try:
-            # Check if datamodel-codegen is available
-            subprocess.run(
-                ["datamodel-codegen", "--version"],
-                check=True,
-                capture_output=True,
-            )
-        except (subprocess.CalledProcessError, FileNotFoundError) as e:
+        # Check if datamodel-codegen is available
+        if not shutil.which("datamodel-codegen"):
             msg = "datamodel-codegen not available"
-            raise RuntimeError(msg) from e
+            raise RuntimeError(msg)
 
         name = class_name or f"{self.name.title()}Response"
 
@@ -393,7 +391,7 @@ def _is_optional_type(typ: type) -> TypeGuard[type]:
         True if the type is Optional, False otherwise
     """
     origin = typing.get_origin(typ)
-    if origin not in (typing.Union, types.UnionType):  # pyright: ignore
+    if origin not in {typing.Union, types.UnionType}:  # pyright: ignore
         return False
     args = typing.get_args(typ)
     # Check if any of the union members is None or NoneType
@@ -448,7 +446,7 @@ def _resolve_type_annotation(
     args = typing.get_args(typ)
 
     # Handle Union types (including Optional)
-    if origin in (typing.Union, types.UnionType):  # pyright: ignore
+    if origin in {typing.Union, types.UnionType}:  # pyright: ignore
         # For Optional (union with None), filter out None type
         non_none_types = [t for t in args if t is not type(None)]
         if non_none_types:
@@ -495,7 +493,7 @@ def _resolve_type_annotation(
             schema["required"] = required
     # Handle mappings - updated check
     elif (
-        origin in (dict, typing.Dict)  # noqa: UP006
+        origin in {dict, typing.Dict}  # noqa: UP006
         or (origin is not None and isinstance(origin, type) and issubclass(origin, dict))
     ):
         schema["type"] = "object"
@@ -503,14 +501,14 @@ def _resolve_type_annotation(
             schema["additionalProperties"] = True
 
     # Handle sequences
-    elif origin in (
+    elif origin in {
         list,
         set,
         tuple,
         frozenset,
         typing.List,  # noqa: UP006  # pyright: ignore
         typing.Set,  # noqa: UP006  # pyright: ignore
-    ) or (
+    } or (
         origin is not None
         and origin.__module__ == "collections.abc"
         and origin.__name__ in {"Sequence", "MutableSequence", "Collection"}
@@ -534,11 +532,11 @@ def _resolve_type_annotation(
             schema["enum"] = [e.value for e in typ]
 
         # Basic types
-        elif typ in (str, Path, UUID, re.Pattern):
+        elif typ in {str, Path, UUID, re.Pattern}:
             schema["type"] = "string"
         elif typ is int:
             schema["type"] = "integer"
-        elif typ in (float, decimal.Decimal):
+        elif typ in {float, decimal.Decimal}:
             schema["type"] = "number"
         elif typ is bool:
             schema["type"] = "boolean"
@@ -696,10 +694,10 @@ def create_schema(
         # Skip the first parameter for bound methods
         if skip_first and i == 0:
             continue
-        if param.kind in (
+        if param.kind in {
             inspect.Parameter.VAR_POSITIONAL,
             inspect.Parameter.VAR_KEYWORD,
-        ):
+        }:
             continue
 
         param_doc = next(
@@ -726,7 +724,7 @@ def create_schema(
     function_type = _determine_function_type(func)
     return_hint = hints.get("return", Any)
 
-    if function_type in (FunctionType.SYNC_GENERATOR, FunctionType.ASYNC_GENERATOR):
+    if function_type in {FunctionType.SYNC_GENERATOR, FunctionType.ASYNC_GENERATOR}:
         element_type = next(
             (t for t in typing.get_args(return_hint) if t is not type(None)),
             Any,

schemez/helpers.py

@@ -6,6 +6,7 @@ import asyncio
 import importlib
 import os
 from pathlib import Path
+import shutil
 import subprocess
 import sys
 import tempfile
@@ -177,53 +178,17 @@ 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],
+    model: type[BaseModel] | dict[str, Any],
     *,
     class_name: str | None = None,
     target_python_version: PythonVersion | None = None,
     model_type: str = "pydantic.BaseModel",
 ) -> str:
-    """Convert a BaseModel to Python code asynchronously.
+    """Convert a BaseModel or schema dict to Python code asynchronously.
 
     Args:
-        model: The BaseModel class to convert
+        model: The BaseModel class or schema dictionary 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.
@@ -236,10 +201,17 @@ async def model_to_python_code(
         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__
+    # Check if datamodel-codegen is available
+    if not shutil.which("datamodel-codegen"):
+        msg = "datamodel-codegen not available"
+        raise RuntimeError(msg)
+
+    if isinstance(model, dict):
+        schema = model
+        name = class_name or "GeneratedModel"
+    else:
+        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
@@ -267,7 +239,6 @@ async def model_to_python_code(
 
     try:  # Generate model using datamodel-codegen
         proc = await asyncio.create_subprocess_exec(
-            *working_prefix,
             "datamodel-codegen",
             *args,
             stdout=asyncio.subprocess.PIPE,

schemez/log.py

@@ -0,0 +1,17 @@
+"""Logging configuration for schemez."""
+
+from __future__ import annotations
+
+import logging
+
+
+def get_logger(name: str) -> logging.Logger:
+    """Get a logger for the given name.
+
+    Args:
+        name: The name of the logger, will be prefixed with 'llmling_agent.'
+
+    Returns:
+        A logger instance
+    """
+    return logging.getLogger(f"schemez.{name}")

schemez/tool_executor/__init__.py

@@ -0,0 +1,8 @@
+"""Tool executor module for HTTP tool generation and execution."""
+
+from __future__ import annotations
+
+from schemez.tool_executor.executor import HttpToolExecutor
+from schemez.tool_executor.types import ToolHandler
+
+__all__ = ["HttpToolExecutor", "ToolHandler"]

schemez/tool_executor/executor.py

@@ -0,0 +1,322 @@
+"""HTTP tool executor for managing tool generation and execution."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from pathlib import Path
+import time
+from typing import TYPE_CHECKING, Any
+
+from pydantic import BaseModel
+from pydantic_core import from_json
+from upath import UPath
+
+from schemez.functionschema import FunctionSchema
+from schemez.tool_executor.helpers import clean_generated_code, generate_input_model
+
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Sequence
+
+    from fastapi import FastAPI
+
+    from schemez.tool_executor.types import ToolHandler
+
+
+logger = logging.getLogger(__name__)
+
+
+class HttpToolExecutor:
+    """Manages HTTP tool generation and execution."""
+
+    def __init__(
+        self,
+        schemas: Sequence[dict[str, Any] | Path],
+        handler: ToolHandler,
+        base_url: str = "http://localhost:8000",
+    ):
+        """Initialize the tool executor.
+
+        Args:
+            schemas: List of tool schema dictionaries or file paths
+            handler: User-provided tool handler function
+            base_url: Base URL for the tool server
+        """
+        self.schemas = schemas
+        self.handler = handler
+        self.base_url = base_url
+
+        # Cached artifacts
+        self._tool_mappings: dict[str, str] | None = None
+        self._tools_code: str | None = None
+        self._server_app: FastAPI | None = None
+        self._tool_functions: dict[str, Callable] | None = None
+
+    async def _load_schemas(self) -> list[dict]:
+        """Load and normalize schemas from various sources."""
+        loaded_schemas = []
+
+        for schema in self.schemas:
+            match schema:
+                case dict():
+                    loaded_schemas.append(schema)
+                case str() | Path():
+                    text = UPath(schema).read_text("utf-8")
+                    loaded_schemas.append(from_json(text))
+                case _:
+                    msg = f"Invalid schema type: {type(schema)}"
+                    raise TypeError(msg)
+
+        return loaded_schemas
+
+    async def _get_tool_mappings(self) -> dict[str, str]:
+        """Get tool name to input class mappings."""
+        if self._tool_mappings is None:
+            self._tool_mappings = {}
+            schemas = await self._load_schemas()
+
+            for schema_dict in schemas:
+                function_schema = FunctionSchema.from_dict(schema_dict)
+                name = "".join(word.title() for word in function_schema.name.split("_"))
+                input_class_name = f"{name}Input"
+                self._tool_mappings[function_schema.name] = input_class_name
+
+        return self._tool_mappings
+
+    async def _generate_http_wrapper(
+        self, schema_dict: dict, input_class_name: str
+    ) -> str:
+        """Generate HTTP wrapper function."""
+        name = schema_dict["name"]
+        description = schema_dict.get("description", "")
+
+        return f'''
+async def {name}(input: {input_class_name}) -> str:
+    """{description}
+
+    Args:
+        input: Function parameters
+
+    Returns:
+        String response from the tool server
+    """
+    import httpx
+    async with httpx.AsyncClient() as client:
+        response = await client.post(
+            "{self.base_url}/tools/{name}",
+            json=input.model_dump(),
+            timeout=30.0
+        )
+        response.raise_for_status()
+        return response.text
+'''
+
+    async def generate_tools_code(self) -> str:
+        """Generate HTTP wrapper tools as Python code."""
+        if self._tools_code is not None:
+            return self._tools_code
+
+        start_time = time.time()
+        logger.info("Starting tools code generation")
+
+        schemas = await self._load_schemas()
+        code_parts: list[str] = []
+        await self._get_tool_mappings()
+
+        # Module header
+        header = '''"""Generated HTTP wrapper tools."""
+
+from __future__ import annotations
+
+from pydantic import BaseModel, Field
+from typing import Literal, List, Any
+from datetime import datetime
+
+'''
+        code_parts.append(header)
+
+        # Generate models and wrappers for each tool
+        all_exports = []
+        for schema_dict in schemas:
+            function_schema = FunctionSchema.from_dict(schema_dict)
+
+            schema_data = {
+                "name": function_schema.name,
+                "description": function_schema.description,
+                "parameters": function_schema.parameters,
+            }
+
+            # Generate input model (strip future imports from generated code)
+            input_code, input_class_name = await generate_input_model(schema_data)
+            # Remove future imports and datamodel-codegen header from individual models
+            cleaned_input_code = clean_generated_code(input_code)
+            code_parts.append(cleaned_input_code)
+            wrapper_code = await self._generate_http_wrapper(
+                schema_data, input_class_name
+            )
+            code_parts.append(wrapper_code)
+
+            all_exports.extend([input_class_name, function_schema.name])
+
+        # Add exports
+        code_parts.append(f"\n__all__ = {all_exports}\n")
+
+        self._tools_code = "\n".join(code_parts)
+        elapsed = time.time() - start_time
+        logger.info(f"Tools code generation completed in {elapsed:.2f}s")  # noqa: G004
+        return self._tools_code
+
+    async def generate_server_app(self) -> FastAPI:
+        """Create configured FastAPI server."""
+        from fastapi import FastAPI, HTTPException
+
+        if self._server_app is not None:
+            return self._server_app
+
+        tool_mappings = await self._get_tool_mappings()
+        app = FastAPI(title="Tool Server", version="1.0.0")
+
+        @app.post("/tools/{tool_name}")
+        async def handle_tool_call(tool_name: str, input_data: dict) -> str:
+            """Generic endpoint that routes all tool calls to user handler."""
+            # Validate tool exists
+            if tool_name not in tool_mappings:
+                tools = list(tool_mappings.keys())
+                detail = f"Tool '{tool_name}' not found. Available: {tools}"
+                raise HTTPException(status_code=404, detail=detail)
+
+            # Create a simple BaseModel for validation
+            class DynamicInput(BaseModel):
+                pass
+
+            # Add fields dynamically (basic validation only)
+            dynamic_input = DynamicInput(**input_data)
+
+            # Call user's handler
+            try:
+                return await self.handler(tool_name, dynamic_input)
+            except Exception as e:
+                msg = f"Tool execution failed: {e}"
+                raise HTTPException(status_code=500, detail=msg) from e
+
+        self._server_app = app
+        return app
+
+    async def get_tool_functions(self) -> dict[str, Callable]:
+        """Get ready-to-use tool functions."""
+        if self._tool_functions is not None:
+            return self._tool_functions
+
+        start_time = time.time()
+        logger.info("Starting tool functions generation")
+
+        # Generate and execute the tools code
+        tools_code = await self.generate_tools_code()
+        logger.debug("Generated %s characters of code", len(tools_code))
+
+        # Create namespace and execute
+        namespace = {
+            "BaseModel": BaseModel,
+            "Field": BaseModel.model_fields_set,
+            "Literal": Any,
+            "List": list,
+            "datetime": __import__("datetime").datetime,
+        }
+
+        logger.debug("Executing generated tools code...")
+        exec_start = time.time()
+        exec(tools_code, namespace)
+        exec_elapsed = time.time() - exec_start
+        logger.debug("Code execution completed in %.2fs", exec_elapsed)
+
+        # Extract tool functions
+        tool_mappings = await self._get_tool_mappings()
+        self._tool_functions = {
+            tool_name: namespace[tool_name]
+            for tool_name in tool_mappings
+            if tool_name in namespace
+        }
+
+        elapsed = time.time() - start_time
+        logger.info(f"Tool functions generation completed in {elapsed:.2f}s")  # noqa: G004
+        return self._tool_functions
+
+    async def start_server(
+        self, host: str = "0.0.0.0", port: int = 8000, background: bool = False
+    ) -> None | asyncio.Task:
+        """Start the FastAPI server.
+
+        Args:
+            host: Host to bind to
+            port: Port to bind to
+            background: If True, run server in background task
+        """
+        import uvicorn
+
+        app = await self.generate_server_app()
+
+        if background:
+            config = uvicorn.Config(app, host=host, port=port)
+            server = uvicorn.Server(config)
+            return asyncio.create_task(server.serve())
+
+        uvicorn.run(app, host=host, port=port)
+        return None
+
+    async def save_to_files(self, output_dir: Path) -> dict[str, Path]:
+        """Save generated code to files.
+
+        Args:
+            output_dir: Directory to save files to
+
+        Returns:
+            Dictionary mapping file types to paths
+        """
+        output_dir = Path(output_dir)
+        output_dir.mkdir(parents=True, exist_ok=True)
+
+        saved_files = {}
+
+        # Save tools module
+        tools_code = await self.generate_tools_code()
+        tools_file = output_dir / "generated_tools.py"
+        tools_file.write_text(tools_code)
+        saved_files["tools"] = tools_file
+
+        # Save server code (as template/example)
+        server_template = f'''"""FastAPI server using HttpToolExecutor."""
+
+import asyncio
+from pathlib import Path
+
+from schemez.tool_executor import HttpToolExecutor, ToolHandler
+from pydantic import BaseModel
+
+
+async def my_tool_handler(method_name: str, input_props: BaseModel) -> str:
+    """Implement your tool logic here."""
+    match method_name:
+        case _:
+            return f"Mock result for {{method_name}}: {{input_props}}"
+
+
+async def main():
+    """Start the server with your handler."""
+    executor = HttpToolExecutor(
+        schemas=[],  # Add your schema files/dicts here
+        handler=my_tool_handler,
+        base_url="{self.base_url}"
+    )
+
+    await executor.start_server()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+'''
+
+        server_file = output_dir / "server_example.py"
+        server_file.write_text(server_template)
+        saved_files["server_example"] = server_file
+        return saved_files

schemez/tool_executor/helpers.py

@@ -0,0 +1,46 @@
+"""Helper functions for the tool executor."""
+
+from __future__ import annotations
+
+import logging
+import time
+
+from schemez.helpers import model_to_python_code
+
+
+logger = logging.getLogger(__name__)
+
+
+async def generate_input_model(schema_dict: dict) -> tuple[str, str]:
+    """Generate input model code from schema."""
+    start_time = time.time()
+    logger.debug("Generating input model for %s", schema_dict["name"])
+
+    words = [word.title() for word in schema_dict["name"].split("_")]
+    cls_name = f"{''.join(words)}Input"
+    code = await model_to_python_code(schema_dict["parameters"], class_name=cls_name)
+    elapsed = time.time() - start_time
+    logger.debug("Generated input model for %s in %.2fs", schema_dict["name"], elapsed)
+    return code, cls_name
+
+
+def clean_generated_code(code: str) -> str:
+    """Clean generated code by removing future imports and headers."""
+    lines = code.split("\n")
+    cleaned_lines = []
+    skip_until_class = True
+
+    for line in lines:
+        # Skip lines until we find a class or other meaningful content
+        if skip_until_class:
+            if line.strip().startswith("class ") or (
+                line.strip()
+                and not line.startswith("#")
+                and not line.startswith("from __future__")
+            ):
+                skip_until_class = False
+                cleaned_lines.append(line)
+            continue
+        cleaned_lines.append(line)
+
+    return "\n".join(cleaned_lines)

schemez/tool_executor/types.py

@@ -0,0 +1,28 @@
+"""Type definitions for tool executor."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Protocol
+
+
+if TYPE_CHECKING:
+    from pydantic import BaseModel
+
+
+class ToolHandler(Protocol):
+    """Protocol for user-provided tool handler."""
+
+    async def __call__(self, method_name: str, input_props: BaseModel) -> str:
+        """Process a tool call.
+
+        Args:
+            method_name: Name of the tool being called (e.g., "get_weather")
+            input_props: Validated input model instance
+
+        Returns:
+            String result from the tool execution
+
+        Raises:
+            Exception: If tool execution fails
+        """
+        ...

schemez/typedefs.py

@@ -163,7 +163,7 @@ def _convert_complex_property(
 
         # 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"):
+        if first_type not in {"string", "number", "integer", "boolean"}:
             first_type = "string"
 
         return _create_simple_property(
@@ -193,7 +193,7 @@ def _convert_complex_property(
         )
 
     type_str = prop.get("type", "string")
-    if type_str not in ("string", "number", "integer", "boolean"):
+    if type_str not in {"string", "number", "integer", "boolean"}:
         type_str = "string"
 
     return _create_simple_property(

schemez-1.2.3.dist-info/METADATA

@@ -0,0 +1,340 @@
+Metadata-Version: 2.4
+Name: schemez
+Version: 1.2.3
+Summary: Pydantic shim for config stuff
+Keywords: 
+Author: Philipp Temminghoff
+Author-email: Philipp Temminghoff <philipptemminghoff@googlemail.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: Pydantic
+Classifier: Framework :: Pydantic :: 2
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+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
+Requires-Dist: llmling-agent ; extra == 'ai'
+Requires-Dist: anyenv>=0.4.14 ; extra == 'ai'
+Requires-Dist: datamodel-code-generator ; extra == 'codegen'
+Requires-Dist: fastapi>=0.118.2 ; extra == 'tool-execution'
+Requires-Dist: yamling ; extra == 'yaml'
+Requires-Python: >=3.13
+Project-URL: Code coverage, https://app.codecov.io/gh/phil65/schemez
+Project-URL: Discussions, https://github.com/phil65/schemez/discussions
+Project-URL: Documentation, https://phil65.github.io/schemez/
+Project-URL: Issues, https://github.com/phil65/schemez/issues
+Project-URL: Source, https://github.com/phil65/schemez
+Provides-Extra: ai
+Provides-Extra: codegen
+Provides-Extra: tool-execution
+Provides-Extra: yaml
+Description-Content-Type: text/markdown
+
+# Schemez
+
+[![PyPI License](https://img.shields.io/pypi/l/schemez.svg)](https://pypi.org/project/schemez/)
+[![Package status](https://img.shields.io/pypi/status/schemez.svg)](https://pypi.org/project/schemez/)
+[![Monthly downloads](https://img.shields.io/pypi/dm/schemez.svg)](https://pypi.org/project/schemez/)
+[![Distribution format](https://img.shields.io/pypi/format/schemez.svg)](https://pypi.org/project/schemez/)
+[![Wheel availability](https://img.shields.io/pypi/wheel/schemez.svg)](https://pypi.org/project/schemez/)
+[![Python version](https://img.shields.io/pypi/pyversions/schemez.svg)](https://pypi.org/project/schemez/)
+[![Implementation](https://img.shields.io/pypi/implementation/schemez.svg)](https://pypi.org/project/schemez/)
+[![Releases](https://img.shields.io/github/downloads/phil65/schemez/total.svg)](https://github.com/phil65/schemez/releases)
+[![Github Contributors](https://img.shields.io/github/contributors/phil65/schemez)](https://github.com/phil65/schemez/graphs/contributors)
+[![Github Discussions](https://img.shields.io/github/discussions/phil65/schemez)](https://github.com/phil65/schemez/discussions)
+[![Github Forks](https://img.shields.io/github/forks/phil65/schemez)](https://github.com/phil65/schemez/forks)
+[![Github Issues](https://img.shields.io/github/issues/phil65/schemez)](https://github.com/phil65/schemez/issues)
+[![Github Issues](https://img.shields.io/github/issues-pr/phil65/schemez)](https://github.com/phil65/schemez/pulls)
+[![Github Watchers](https://img.shields.io/github/watchers/phil65/schemez)](https://github.com/phil65/schemez/watchers)
+[![Github Stars](https://img.shields.io/github/stars/phil65/schemez)](https://github.com/phil65/schemez/stars)
+[![Github Repository size](https://img.shields.io/github/repo-size/phil65/schemez)](https://github.com/phil65/schemez)
+[![Github last commit](https://img.shields.io/github/last-commit/phil65/schemez)](https://github.com/phil65/schemez/commits)
+[![Github release date](https://img.shields.io/github/release-date/phil65/schemez)](https://github.com/phil65/schemez/releases)
+[![Github language count](https://img.shields.io/github/languages/count/phil65/schemez)](https://github.com/phil65/schemez)
+[![Github commits this month](https://img.shields.io/github/commit-activity/m/phil65/schemez)](https://github.com/phil65/schemez)
+[![Package status](https://codecov.io/gh/phil65/schemez/branch/main/graph/badge.svg)](https://codecov.io/gh/phil65/schemez/)
+[![PyUp](https://pyup.io/repos/github/phil65/schemez/shield.svg)](https://pyup.io/repos/github/phil65/schemez/)
+
+[Read the documentation!](https://phil65.github.io/schemez/)
+
+
+
+# OpenAI Function Schema Generator
+
+Convert Python functions to OpenAI-compatible function schemas automatically.
+
+## Installation
+
+```bash
+pip install schemez
+```
+
+## Basic Usage
+
+```python
+from schemez import create_schema
+from typing import Literal
+
+def get_weather(
+    location: str,
+    unit: Literal["C", "F"] = "C",
+    detailed: bool = False,
+) -> dict[str, str | float]:
+    """Get the weather for a location.
+
+    Args:
+        location: City or address to get weather for
+        unit: Temperature unit (Celsius or Fahrenheit)
+        detailed: Include extended forecast
+    """
+    return {"temp": 22.5, "conditions": "sunny"}
+
+# Create schema
+schema = create_schema(get_weather)
+
+# The schema.model_dump_openai() returns a TypedDict with the complete OpenAI tool definition:
+# OpenAIFunctionTool = TypedDict({
+#     "type": Literal["function"],
+#     "function": OpenAIFunctionDefinition
+# })
+
+# Use with OpenAI
+from openai import OpenAI
+
+client = OpenAI()
+response = client.chat.completions.create(
+    model="gpt-4",
+    messages=[{"role": "user", "content": "What's the weather in London?"}],
+    tools=[schema.model_dump_openai()],  # Schema includes the type: "function" wrapper
+    tool_choice="auto"
+)
+```
+
+> **Note**: This library supports the OpenAI API v1 format (openai>=1.0.0). For older
+> versions of the OpenAI package that use the legacy functions API, you'll need to
+> unwrap the function definition using `schema.model_dump_openai()["function"]`.
+```
+
+## Supported Types
+
+### Basic Types
+```python
+def func(
+    text: str,              # -> "type": "string"
+    number: int,            # -> "type": "integer"
+    amount: float,          # -> "type": "number"
+    enabled: bool,          # -> "type": "boolean"
+    anything: Any,          # -> "type": "string"
+) -> None: ...
+```
+
+### Container Types
+```python
+def func(
+    items: list[str],                    # -> "type": "array", "items": {"type": "string"}
+    numbers: set[int],                   # -> same as list
+    mapping: dict[str, Any],            # -> "type": "object", "additionalProperties": true
+    nested: list[dict[str, int]],       # -> nested array/object types
+    sequence: Sequence[str],            # -> "type": "array"
+    collection: Collection[int],        # -> "type": "array"
+) -> None: ...
+```
+
+### Enums and Literals
+```python
+class Color(Enum):
+    RED = "red"
+    BLUE = "blue"
+
+def func(
+    color: Color,                       # -> "type": "string", "enum": ["red", "blue"]
+    mode: Literal["fast", "slow"],      # -> "type": "string", "enum": ["fast", "slow"]
+) -> None: ...
+```
+
+### Optional and Union Types
+```python
+def func(
+    opt1: str | None,                   # -> "type": "string"
+    opt2: int | None,                   # -> "type": "integer"
+    union: str | int,                   # -> "type": "string" (first type)
+) -> None: ...
+```
+
+### Custom Types
+```python
+@dataclass
+class User:
+    name: str
+    age: int
+
+def func(
+    user: User,                         # -> "type": "object"
+    data: JsonDict,                     # -> "type": "object"
+) -> None: ...
+```
+
+### Type Aliases
+```python
+JsonValue = dict[str, Any] | list[Any] | str | int | float | bool | None
+JsonDict = dict[str, JsonValue]
+
+def func(
+    data: JsonDict,                     # -> "type": "object"
+    values: list[JsonValue],            # -> "type": "array"
+) -> None: ...
+```
+
+### Recursive Types
+```python
+def func(
+    tree: dict[str, "dict[str, Any] | str"],  # -> "type": "object"
+    nested: dict[str, list["dict[str, Any]"]], # -> "type": "object"
+) -> None: ...
+```
+
+## Generated Schema Example
+
+```python
+{
+    "type": "function",
+    "function": {
+        "name": "get_weather",
+        "description": "Get the weather for a location.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "location": {
+                    "type": "string",
+                    "description": "City or address to get weather for"
+                },
+                "unit": {
+                    "type": "string",
+                    "enum": ["C", "F"],
+                    "description": "Temperature unit (Celsius or Fahrenheit)",
+                    "default": "C"
+                },
+                "detailed": {
+                    "type": "boolean",
+                    "description": "Include extended forecast",
+                    "default": false
+                }
+            },
+            "required": ["location"]
+        }
+    }
+}
+```
+
+## Schema Generators
+
+### Module Schemas
+
+You can generate schemas for all public functions in a module using `create_schemas_from_module`:
+
+```python
+from schemez import create_schemas_from_module
+import math
+
+# Generate schemas for all public functions
+schemas = create_schemas_from_module(math)
+
+# Generate schemas for specific functions only
+schemas = create_schemas_from_module(math, include_functions=['sin', 'cos'])
+
+# Import module by string name
+schemas = create_schemas_from_module('math')
+```
+
+### Class Schemas
+
+Generate schemas for all public methods in a class using `create_schemas_from_class`:
+
+```python
+from schemez import create_schemas_from_class
+
+class Calculator:
+    def add(self, x: int, y: int) -> int:
+        """Add two numbers.
+
+        Args:
+            x: First number
+            y: Second number
+
+        Returns:
+            Sum of x and y
+        """
+        return x + y
+
+    @classmethod
+    def multiply(cls, x: int, y: int) -> int:
+        """Multiply two numbers.
+
+        Args:
+            x: First number
+            y: Second number
+
+        Returns:
+            Product of x and y
+        """
+        return x * y
+
+    @staticmethod
+    def divide(x: float, y: float) -> float:
+        """Divide two numbers.
+
+        Args:
+            x: Numerator
+            y: Denominator
+
+        Returns:
+            Result of x divided by y
+        """
+        return x / y
+
+# Generate schemas for all public methods
+schemas = create_schemas_from_class(Calculator)
+
+# Access individual method schemas
+add_schema = schemas['Calculator.add']
+multiply_schema = schemas['Calculator.multiply']
+divide_schema = schemas['Calculator.divide']
+```
+
+The schema generators support:
+
+- Regular functions
+- Regular instance methods (bound and unbound)
+- Class methods
+- Static methods
+- Decorated functions / methods
+- Async functions / methods
+- Property methods
+- Basically all stdlib typing features as well as many stdlib types
+- Method docstrings for descriptions
+- Default values
+- Return type hints
+
+
+## Diferences to pydantic schema generation
+
+While Pydantics schema generation preserves detailed type information, `schema.model_dump_openai()`
+simplifies types to match OpenAI's function calling format. Most special types
+(datetime, UUID, Path, etc.) are handled similarly by both (we only strip unused information), but we handle enums
+differently: Instead of preserving enum class information, we extract just the values
+as a string enum. Union types and Optionals are also handled differently - we typically
+pick the first type to keep the schema simple and practical for AI interaction.
+This ensures compatibility with OpenAI's function calling API while maintaining enough
+type information for the AI to understand the function signature.

schemez-1.2.3.dist-info/RECORD

@@ -0,0 +1,25 @@
+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=3sOxOgDaFzV7uiOUSM6_Sy0YlafIlZRSevs5y2vT1Kw,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=NXQsZKeo7GRr7gnhEMHJvnjZhQktn9Kjf1W8xWyWh5Y,26135
+schemez/helpers.py,sha256=_4-S8n7m3yajVYdYckSyrG1GsfMqCOfm5O-bGkYI1qc,7917
+schemez/log.py,sha256=i0SDbIfWmuC_nfJdQOYAdUYaR0TBk3Mhu-K3M-lnAM4,364
+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/tool_executor/__init__.py,sha256=7wLjhA1NGekTMsiIfWLAv6J7qYhWDlanH9DKU4v1c6c,263
+schemez/tool_executor/executor.py,sha256=lQFnVO5J64nFNEsy82jRS-q52PaU3fWsnuQddaLOo6c,10410
+schemez/tool_executor/helpers.py,sha256=jxBv1G_R8rQU3ACHGgfVEecqO0DSZQ6qUIHcn25Ucc4,1470
+schemez/tool_executor/types.py,sha256=l2DxUIEHP9bjLnEaXZ6X428cSviicTDJsc3wfSNqKxg,675
+schemez/typedefs.py,sha256=3OAUQ1nin9nlsOcTPAO5xrsOqVUfwsH_7_cexQYREus,6091
+schemez-1.2.3.dist-info/licenses/LICENSE,sha256=AteGCH9r177TxxrOFEiOARrastASsf7yW6MQxlAHdwA,1078
+schemez-1.2.3.dist-info/WHEEL,sha256=X16MKk8bp2DRsAuyteHJ-9qOjzmnY0x1aj0P1ftqqWA,78
+schemez-1.2.3.dist-info/METADATA,sha256=VPcDp5yYQYgz_YPcUsmDFhVh3-oeL7JTOdS4cAw0Aio,11616
+schemez-1.2.3.dist-info/RECORD,,

{schemez-1.2.0.dist-info → schemez-1.2.3.dist-info}/WHEEL

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

schemez-1.2.3.dist-info/licenses/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2024, Philipp Temminghoff
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

schemez-1.2.0.dist-info/METADATA

@@ -1,86 +0,0 @@
-Metadata-Version: 2.3
-Name: schemez
-Version: 1.2.0
-Summary: Pydantic shim for config stuff
-Keywords: 
-Author: Philipp Temminghoff
-Author-email: Philipp Temminghoff <philipptemminghoff@googlemail.com>
-License: MIT License
-         
-         Copyright (c) 2024, Philipp Temminghoff
-         
-         Permission is hereby granted, free of charge, to any person obtaining a copy
-         of this software and associated documentation files (the "Software"), to deal
-         in the Software without restriction, including without limitation the rights
-         to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-         copies of the Software, and to permit persons to whom the Software is
-         furnished to do so, subject to the following conditions:
-         
-         The above copyright notice and this permission notice shall be included in all
-         copies or substantial portions of the Software.
-         
-         THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-         IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-         FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-         AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-         LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-         OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-         SOFTWARE.
-         
-Classifier: Development Status :: 4 - Beta
-Classifier: Framework :: Pydantic
-Classifier: Framework :: Pydantic :: 2
-Classifier: Intended Audience :: Developers
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Programming Language :: Python :: 3.14
-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
-Requires-Dist: llmling-agent ; extra == 'ai'
-Requires-Dist: anyenv>=0.4.14 ; extra == 'ai'
-Requires-Dist: yamling ; extra == 'yaml'
-Requires-Python: >=3.13
-Project-URL: Code coverage, https://app.codecov.io/gh/phil65/schemez
-Project-URL: Discussions, https://github.com/phil65/schemez/discussions
-Project-URL: Documentation, https://phil65.github.io/schemez/
-Project-URL: Issues, https://github.com/phil65/schemez/issues
-Project-URL: Source, https://github.com/phil65/schemez
-Provides-Extra: ai
-Provides-Extra: yaml
-Description-Content-Type: text/markdown
-
-# Schemez
-
-[![PyPI License](https://img.shields.io/pypi/l/schemez.svg)](https://pypi.org/project/schemez/)
-[![Package status](https://img.shields.io/pypi/status/schemez.svg)](https://pypi.org/project/schemez/)
-[![Monthly downloads](https://img.shields.io/pypi/dm/schemez.svg)](https://pypi.org/project/schemez/)
-[![Distribution format](https://img.shields.io/pypi/format/schemez.svg)](https://pypi.org/project/schemez/)
-[![Wheel availability](https://img.shields.io/pypi/wheel/schemez.svg)](https://pypi.org/project/schemez/)
-[![Python version](https://img.shields.io/pypi/pyversions/schemez.svg)](https://pypi.org/project/schemez/)
-[![Implementation](https://img.shields.io/pypi/implementation/schemez.svg)](https://pypi.org/project/schemez/)
-[![Releases](https://img.shields.io/github/downloads/phil65/schemez/total.svg)](https://github.com/phil65/schemez/releases)
-[![Github Contributors](https://img.shields.io/github/contributors/phil65/schemez)](https://github.com/phil65/schemez/graphs/contributors)
-[![Github Discussions](https://img.shields.io/github/discussions/phil65/schemez)](https://github.com/phil65/schemez/discussions)
-[![Github Forks](https://img.shields.io/github/forks/phil65/schemez)](https://github.com/phil65/schemez/forks)
-[![Github Issues](https://img.shields.io/github/issues/phil65/schemez)](https://github.com/phil65/schemez/issues)
-[![Github Issues](https://img.shields.io/github/issues-pr/phil65/schemez)](https://github.com/phil65/schemez/pulls)
-[![Github Watchers](https://img.shields.io/github/watchers/phil65/schemez)](https://github.com/phil65/schemez/watchers)
-[![Github Stars](https://img.shields.io/github/stars/phil65/schemez)](https://github.com/phil65/schemez/stars)
-[![Github Repository size](https://img.shields.io/github/repo-size/phil65/schemez)](https://github.com/phil65/schemez)
-[![Github last commit](https://img.shields.io/github/last-commit/phil65/schemez)](https://github.com/phil65/schemez/commits)
-[![Github release date](https://img.shields.io/github/release-date/phil65/schemez)](https://github.com/phil65/schemez/releases)
-[![Github language count](https://img.shields.io/github/languages/count/phil65/schemez)](https://github.com/phil65/schemez)
-[![Github commits this month](https://img.shields.io/github/commit-activity/m/phil65/schemez)](https://github.com/phil65/schemez)
-[![Package status](https://codecov.io/gh/phil65/schemez/branch/main/graph/badge.svg)](https://codecov.io/gh/phil65/schemez/)
-[![PyUp](https://pyup.io/repos/github/phil65/schemez/shield.svg)](https://pyup.io/repos/github/phil65/schemez/)
-
-[Read the documentation!](https://phil65.github.io/schemez/)

schemez-1.2.0.dist-info/RECORD

@@ -1,19 +0,0 @@
-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,,