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

schemez/helpers.py

@@ -214,16 +214,16 @@ async def _detect_command(command: str, *, test_flag: str = "--version") -> list
 
 
 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.
@@ -238,8 +238,12 @@ async def model_to_python_code(
     """
     working_prefix = await _detect_command("datamodel-codegen")
 
-    schema = model.model_json_schema()
-    name = class_name or model.__name__
+    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

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/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/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
+        """
+        ...