schemez 1.2.4__py3-none-any.whl → 1.4.4__py3-none-any.whl

schemez/__init__.py

@@ -35,9 +35,11 @@ from schemez.schema_generators import (
     create_constructor_schema,
 )
 from schemez.typedefs import OpenAIFunctionDefinition, OpenAIFunctionTool
+from schemez.code_generation import ToolCodeGenerator, ToolsetCodeGenerator
 
 __version__ = version("schemez")
 
+
 __all__ = [
     "ExecutableFunction",
     "FunctionType",
@@ -54,6 +56,8 @@ __all__ = [
     "SchemaDef",
     "SchemaField",
     "TOMLCode",
+    "ToolCodeGenerator",
+    "ToolsetCodeGenerator",
     "YAMLCode",
     "__version__",
     "create_constructor_schema",

schemez/code_generation/__init__.py

@@ -0,0 +1,6 @@
+"""Meta-resource provider that exposes tools through Python execution."""
+
+from schemez.code_generation.tool_code_generator import ToolCodeGenerator
+from schemez.code_generation.toolset_code_generator import ToolsetCodeGenerator
+
+__all__ = ["ToolCodeGenerator", "ToolsetCodeGenerator"]

schemez/code_generation/namespace_callable.py

@@ -0,0 +1,76 @@
+"""Namespace callable wrapper for tools."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+import inspect
+from typing import TYPE_CHECKING, Any
+
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from schemez.code_generation.tool_code_generator import ToolCodeGenerator
+
+
+@dataclass
+class NamespaceCallable:
+    """Wrapper for tool functions with proper repr and call interface."""
+
+    callable: Callable
+    """The callable function to execute."""
+
+    name_override: str | None = None
+    """Override name for the callable, defaults to callable.__name__."""
+
+    def __post_init__(self) -> None:
+        """Set function attributes for introspection."""
+        self.__name__ = self.name_override or self.callable.__name__
+        self.__doc__ = self.callable.__doc__ or ""
+
+    @property
+    def name(self) -> str:
+        """Get the effective name of the callable."""
+        return self.name_override or self.callable.__name__
+
+    @classmethod
+    def from_generator(cls, generator: ToolCodeGenerator) -> NamespaceCallable:
+        """Create a NamespaceCallable from a ToolCodeGenerator.
+
+        Args:
+            generator: The generator to wrap
+
+        Returns:
+            NamespaceCallable instance
+        """
+        return cls(generator.callable, generator.name_override)
+
+    async def __call__(self, *args, **kwargs) -> Any:
+        """Execute the wrapped callable."""
+        try:
+            if inspect.iscoroutinefunction(self.callable):
+                result = await self.callable(*args, **kwargs)
+
+            result = self.callable(*args, **kwargs)
+        except Exception as e:  # noqa: BLE001
+            return f"Error executing {self.name}: {e!s}"
+        else:
+            return result if result is not None else "Operation completed successfully"
+
+    def __repr__(self) -> str:
+        """Return detailed representation for debugging."""
+        return f"NamespaceCallable(name='{self.name}')"
+
+    def __str__(self) -> str:
+        """Return readable string representation."""
+        return f"<tool: {self.name}>"
+
+    @property
+    def signature(self) -> str:
+        """Get function signature for debugging."""
+        try:
+            sig = inspect.signature(self.callable)
+        except (ValueError, TypeError):
+            return f"{self.name}(...)"
+        else:
+            return f"{self.name}{sig}"

schemez/code_generation/route_helpers.py

@@ -0,0 +1,126 @@
+"""Helper functions for FastAPI route generation."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from schemez.schema import json_schema_to_base_model
+
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from pydantic import BaseModel
+    from pydantic.fields import FieldInfo
+
+
+def create_param_model(parameters_schema: dict[str, Any]) -> type[BaseModel] | None:
+    """Create Pydantic model for parameter validation using schemez.
+
+    Args:
+        parameters_schema: JSON schema for tool parameters
+
+    Returns:
+        Pydantic model class or None if no parameters
+    """
+    if parameters_schema.get("properties"):
+        return json_schema_to_base_model(parameters_schema)  # type: ignore
+    return None
+
+
+def generate_func_code(model_fields: dict[str, FieldInfo]) -> str:
+    """Generate dynamic function code for FastAPI route handler.
+
+    Args:
+        model_fields: Model fields from Pydantic model
+
+    Returns:
+        Generated function code as string
+    """
+    route_params = []
+    for name, field_info in model_fields.items():
+        field_type = field_info.annotation
+        if field_info.is_required():
+            route_params.append(f"{name}: {field_type.__name__}")  # type: ignore
+        else:
+            route_params.append(f"{name}: {field_type.__name__} = None")  # type: ignore
+
+    # Create function signature dynamically
+    param_str = ", ".join(route_params)
+    return f"""
+async def dynamic_handler({param_str}) -> dict[str, Any]:
+    kwargs = {{{", ".join(f'"{name}": {name}' for name in model_fields)}}}
+    return await route_handler(**kwargs)
+"""
+
+
+def create_route_handler(tool_callable: Callable, param_cls: type | None) -> Callable:
+    """Create FastAPI route handler for a tool.
+
+    Args:
+        tool_callable: The tool function to execute
+        param_cls: Pydantic model for parameter validation
+
+    Returns:
+        Async route handler function
+    """
+
+    async def route_handler(*args, **kwargs) -> Any:
+        """Route handler for the tool."""
+        if param_cls:
+            params_instance = param_cls(**kwargs)  # Parse and validate parameters
+            dct = params_instance.model_dump()  # Convert to dict and remove None values
+            clean_params = {k: v for k, v in dct.items() if v is not None}
+            result = await _execute_tool_function(tool_callable, **clean_params)
+        else:
+            result = await _execute_tool_function(tool_callable)
+        return {"result": result}
+
+    return route_handler
+
+
+async def _execute_tool_function(tool_callable: Callable, **kwargs) -> Any:
+    """Execute a tool function with the given parameters.
+
+    Args:
+        tool_callable: Tool function to execute
+        **kwargs: Tool parameters
+
+    Returns:
+        Tool execution result
+    """
+    try:
+        # For now, just simulate execution
+        # In real implementation, this would call the actual tool
+        # potentially through sandbox providers
+        return f"Executed {tool_callable.__name__} with params: {kwargs}"
+    except Exception as e:  # noqa: BLE001
+        return f"Error executing {tool_callable.__name__}: {e!s}"
+
+
+if __name__ == "__main__":
+    from llmling_agent.tools.base import Tool
+
+    def greet(name: str, greeting: str = "Hello") -> str:
+        """Greet someone."""
+        return f"{greeting}, {name}!"
+
+    # Create a tool and demonstrate helper functions
+    tool = Tool.from_callable(greet)
+    schema = tool.schema["function"]
+    parameters_schema = schema.get("parameters", {})
+
+    # Create parameter model
+    param_cls = create_param_model(dict(parameters_schema))
+    print(f"Generated parameter model: {param_cls}")
+
+    if param_cls:
+        print(f"Model fields: {param_cls.model_fields}")
+
+        # Generate function code
+        func_code = generate_func_code(param_cls.model_fields)
+        print(f"Generated function code:\n{func_code}")
+
+    # Create route handler
+    handler = create_route_handler(greet, param_cls)
+    print(f"Generated route handler: {handler}")

schemez/code_generation/tool_code_generator.py

@@ -0,0 +1,300 @@
+"""Meta-resource provider that exposes tools through Python execution."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+import inspect
+from typing import TYPE_CHECKING, Any, get_origin
+
+from schemez import create_schema
+from schemez.code_generation.route_helpers import (
+    create_param_model,
+    create_route_handler,
+    generate_func_code,
+)
+
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from fastapi import FastAPI
+
+    from schemez.typedefs import OpenAIFunctionTool, Property
+
+
+TYPE_MAP = {
+    "string": "str",
+    "integer": "int",
+    "number": "float",
+    "boolean": "bool",
+    "array": "list",
+    "null": "None",
+}
+
+
+@dataclass
+class ToolCodeGenerator:
+    """Generates code artifacts for a single tool."""
+
+    callable: Callable
+    """Tool to generate code for."""
+
+    schema: OpenAIFunctionTool
+    """Schema of the tool."""
+
+    name_override: str | None = None
+    """Name override for the function to generate code for."""
+
+    exclude_types: list[type] = field(default_factory=list)
+    """Exclude parameters from generated code (like context types)."""
+
+    @classmethod
+    def from_callable(
+        cls,
+        fn: Callable,
+        exclude_types: list[type] | None = None,
+    ) -> ToolCodeGenerator:
+        """Create a ToolCodeGenerator from a Tool."""
+        schema = create_schema(fn).model_dump_openai()
+        schema["function"]["name"] = fn.__name__
+        schema["function"]["description"] = fn.__doc__ or ""
+        return cls(schema=schema, callable=fn, exclude_types=exclude_types or [])
+
+    @property
+    def name(self) -> str:
+        """Name of the tool."""
+        return self.name_override or self.callable.__name__
+
+    def _extract_basic_signature(self, return_type: str = "Any") -> str:
+        """Fallback signature extraction from tool schema."""
+        schema = self.schema["function"]
+        params = schema.get("parameters", {}).get("properties", {})
+        required = set(schema.get("parameters", {}).get("required", []))
+
+        param_strs = []
+        for name, param_info in params.items():
+            # Skip context parameters that should be hidden from users
+            if self._is_context_parameter(name):
+                continue
+
+            type_hint = self._infer_parameter_type(name, param_info)
+
+            if name not in required:
+                # Check for actual default value in schema
+                default_value = param_info.get("default")
+                if default_value is not None:
+                    if isinstance(default_value, str):
+                        param_strs.append(f"{name}: {type_hint} = {default_value!r}")
+                    else:
+                        param_strs.append(f"{name}: {type_hint} = {default_value}")
+                else:
+                    param_strs.append(f"{name}: {type_hint} = None")
+            else:
+                param_strs.append(f"{name}: {type_hint}")
+
+        return f"{self.name}({', '.join(param_strs)}) -> {return_type}"
+
+    def _infer_parameter_type(self, param_name: str, param_info: Property) -> str:
+        """Infer parameter type from schema and function inspection."""
+        schema_type = param_info.get("type", "Any")
+
+        # If schema has a specific type, use it
+        if schema_type != "object":
+            return TYPE_MAP.get(schema_type, "Any")
+
+        # For 'object' type, try to infer from function signature
+        try:
+            callable_func = self.callable
+            # Use wrapped signature if available (for context parameter hiding)
+            sig = getattr(callable_func, "__signature__", None) or inspect.signature(
+                callable_func
+            )
+
+            if param_name in sig.parameters:
+                param = sig.parameters[param_name]
+
+                # Try annotation first
+                if param.annotation != inspect.Parameter.empty:
+                    if hasattr(param.annotation, "__name__"):
+                        return param.annotation.__name__
+                    return str(param.annotation)
+
+                # Infer from default value
+                if param.default != inspect.Parameter.empty:
+                    default_type = type(param.default).__name__
+                    # Map common types
+                    if default_type in ["int", "float", "str", "bool"]:
+                        return default_type
+                # If no default and it's required, assume str for web-like functions
+                required = set(
+                    self.schema.get("function", {})
+                    .get("parameters", {})
+                    .get("required", [])
+                )
+                if param_name in required:
+                    return "str"
+
+        except Exception:  # noqa: BLE001
+            pass
+
+        # Fallback to Any for unresolved object types
+        return "Any"
+
+    def _get_return_model_name(self) -> str:
+        """Get the return model name for a tool."""
+        try:
+            schema = create_schema(self.callable)
+            if schema.returns.get("type") == "object":
+                return f"{self.name.title()}Response"
+            if schema.returns.get("type") == "array":
+                return f"list[{self.name.title()}Item]"
+            return TYPE_MAP.get(schema.returns.get("type", "string"), "Any")
+        except Exception:  # noqa: BLE001
+            return "Any"
+
+    def get_function_signature(self) -> str:
+        """Extract function signature using schemez."""
+        try:
+            return_model_name = self._get_return_model_name()
+            return self._extract_basic_signature(return_model_name)
+        except Exception:  # noqa: BLE001
+            return self._extract_basic_signature("Any")
+
+    def _get_callable_signature(self) -> inspect.Signature:
+        """Get signature from callable, respecting wrapped signatures."""
+        # Use wrapped signature if available (for context parameter hiding)
+        return getattr(self.callable, "__signature__", None) or inspect.signature(
+            self.callable
+        )
+
+    def _is_context_parameter(self, param_name: str) -> bool:
+        """Check if a parameter is a context parameter that should be hidden."""
+        try:
+            sig = self._get_callable_signature()
+            if param_name not in sig.parameters:
+                return False
+
+            param = sig.parameters[param_name]
+            if param.annotation == inspect.Parameter.empty:
+                return False
+
+            annotation = param.annotation
+
+            for typ in self.exclude_types:
+                if self._types_match(annotation, typ):
+                    return True
+        except Exception:  # noqa: BLE001
+            pass
+
+        return False
+
+    def _types_match(self, annotation: Any, exclude_type: type) -> bool:
+        """Check if annotation matches exclude_type using various strategies."""
+        try:
+            # Direct type match
+            if annotation is exclude_type:
+                return True
+
+            # Handle generic types - get origin for comparison
+            origin_annotation = get_origin(annotation)
+            if origin_annotation is exclude_type:
+                return True
+
+            # String-based comparison for forward references and __future__.annotations
+            annotation_str = str(annotation)
+            exclude_type_name = exclude_type.__name__
+            exclude_type_full_name = f"{exclude_type.__module__}.{exclude_type.__name__}"
+
+            # Check various string representations
+            if (
+                exclude_type_name in annotation_str
+                or exclude_type_full_name in annotation_str
+            ):
+                # Be more specific to avoid false positives
+                # Check if it's the exact type name, not just a substring
+                import re
+
+                patterns = [
+                    rf"\b{re.escape(exclude_type_name)}\b",
+                    rf"\b{re.escape(exclude_type_full_name)}\b",
+                ]
+                if any(re.search(pattern, annotation_str) for pattern in patterns):
+                    return True
+
+        except Exception:  # noqa: BLE001
+            pass
+
+        return False
+
+    def generate_return_model(self) -> str | None:
+        """Generate Pydantic model code for the tool's return type."""
+        try:
+            schema = create_schema(self.callable)
+            if schema.returns.get("type") not in {"object", "array"}:
+                return None
+
+            class_name = f"{self.name.title()}Response"
+            model_code = schema.to_pydantic_model_code(class_name=class_name)
+            return model_code.strip() or None
+
+        except Exception:  # noqa: BLE001
+            return None
+
+    # Route generation methods
+    def generate_route_handler(self) -> Callable:
+        """Generate FastAPI route handler for this tool.
+
+        Returns:
+            Async route handler function
+        """
+        # Extract parameter schema
+        schema = self.schema["function"]
+        parameters_schema = schema.get("parameters", {})
+
+        # Create parameter model
+        param_cls = create_param_model(dict(parameters_schema))
+
+        # Create route handler
+        return create_route_handler(self.callable, param_cls)
+
+    def add_route_to_app(self, app: FastAPI, path_prefix: str = "/tools") -> None:
+        """Add this tool's route to FastAPI app.
+
+        Args:
+            app: FastAPI application instance
+            path_prefix: Path prefix for the route
+        """
+        # Extract parameter schema
+        schema = self.schema["function"]
+        parameters_schema = schema.get("parameters", {})
+
+        # Create parameter model
+        param_cls = create_param_model(dict(parameters_schema))
+
+        # Create the route handler
+        route_handler = self.generate_route_handler()
+
+        # Set up the route with proper parameter annotations for FastAPI
+        if param_cls:
+            # Get field information from the generated model
+            model_fields = param_cls.model_fields
+            func_code = generate_func_code(model_fields)
+            # Execute the dynamic function creation
+            namespace = {"route_handler": route_handler, "Any": Any}
+            exec(func_code, namespace)
+            dynamic_handler: Callable = namespace["dynamic_handler"]  # type: ignore
+        else:
+
+            async def dynamic_handler() -> dict[str, Any]:
+                return await route_handler()
+
+        # Add route to FastAPI app
+        app.get(f"{path_prefix}/{self.name}")(dynamic_handler)
+
+
+if __name__ == "__main__":
+    import webbrowser
+
+    generator = ToolCodeGenerator.from_callable(webbrowser.open)
+    sig = generator.get_function_signature()
+    print(sig)

schemez/code_generation/toolset_code_generator.py

@@ -0,0 +1,167 @@
+"""Orchestrates code generation for multiple tools."""
+
+from __future__ import annotations
+
+import contextlib
+from dataclasses import dataclass
+import inspect
+from typing import TYPE_CHECKING, Any
+
+from schemez.code_generation.namespace_callable import NamespaceCallable
+from schemez.code_generation.tool_code_generator import ToolCodeGenerator
+
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Sequence
+
+    from fastapi import FastAPI
+
+
+USAGE = """\
+Usage notes:
+- Write your code inside an 'async def main():' function
+- All tool functions are async, use 'await'
+- Use 'return' statements to return values from main()
+- Generated model classes are available for type checking
+- Use 'await report_progress(current, total, message)' for long-running operations
+- DO NOT call asyncio.run() or try to run the main function yourself
+- DO NOT import asyncio or other modules - tools are already available
+- Example:
+    async def main():
+        for i in range(5):
+            await report_progress(i, 5, f'Step {i+1} for {name}')
+            should_continue = await ask_user('Continue?', 'bool')
+            if not should_continue:
+                break
+        return f'Completed for {name}'
+
+"""
+
+
+@dataclass
+class ToolsetCodeGenerator:
+    """Generates code artifacts for multiple tools."""
+
+    generators: Sequence[ToolCodeGenerator]
+    """ToolCodeGenerator instances for each tool."""
+
+    include_signatures: bool = True
+    """Include function signatures in documentation."""
+
+    include_docstrings: bool = True
+    """Include function docstrings in documentation."""
+
+    @classmethod
+    def from_callables(
+        cls,
+        callables: Sequence[Callable],
+        include_signatures: bool = True,
+        include_docstrings: bool = True,
+        exclude_types: list[type] | None = None,
+    ) -> ToolsetCodeGenerator:
+        """Create a ToolsetCodeGenerator from a sequence of Tools.
+
+        Args:
+            callables: Callables to generate code for
+            include_signatures: Include function signatures in documentation
+            include_docstrings: Include function docstrings in documentation
+            exclude_types: Parameter Types to exclude from the generated code
+                           Often used for context parameters.
+
+        Returns:
+            ToolsetCodeGenerator instance
+        """
+        generators = [
+            ToolCodeGenerator.from_callable(i, exclude_types=exclude_types)
+            for i in callables
+        ]
+        return cls(generators, include_signatures, include_docstrings)
+
+    def generate_tool_description(self) -> str:
+        """Generate comprehensive tool description with available functions."""
+        if not self.generators:
+            return "Execute Python code (no tools available)"
+
+        return_models = self.generate_return_models()
+        parts = [
+            "Execute Python code with the following tools available as async functions:",
+            "",
+        ]
+
+        if return_models:
+            parts.extend([
+                "# Generated return type models",
+                return_models,
+                "",
+                "# Available functions:",
+                "",
+            ])
+
+        for generator in self.generators:
+            if self.include_signatures:
+                signature = generator.get_function_signature()
+                parts.append(f"async def {signature}:")
+            else:
+                parts.append(f"async def {generator.name}(...):")
+
+            if self.include_docstrings and generator.callable.__doc__:
+                indented_desc = "    " + generator.callable.__doc__.replace(
+                    "\n", "\n    "
+                )
+
+                # Add warning for async functions without proper return type hints
+                if inspect.iscoroutinefunction(generator.callable):
+                    sig = inspect.signature(generator.callable)
+                    if sig.return_annotation == inspect.Signature.empty:
+                        indented_desc += "\n    \n    Note: This async function should explicitly return a value."  # noqa: E501
+
+                parts.append(f'    """{indented_desc}"""')
+            parts.append("")
+
+        parts.append(USAGE)
+
+        return "\n".join(parts)
+
+    def generate_execution_namespace(self) -> dict[str, Any]:
+        """Build Python namespace with tool functions and generated models."""
+        namespace: dict[str, Any] = {"__builtins__": __builtins__, "_result": None}
+
+        # Add tool functions
+        for generator in self.generators:
+            namespace[generator.name] = NamespaceCallable.from_generator(generator)
+
+        # Add generated model classes to namespace
+        if models_code := self.generate_return_models():
+            with contextlib.suppress(Exception):
+                exec(models_code, namespace)
+
+        return namespace
+
+    def generate_return_models(self) -> str:
+        """Generate Pydantic models for tool return types."""
+        model_parts = [
+            code for g in self.generators if (code := g.generate_return_model())
+        ]
+        return "\n\n".join(model_parts) if model_parts else ""
+
+    def add_all_routes(self, app: FastAPI, path_prefix: str = "/tools") -> None:
+        """Add FastAPI routes for all tools.
+
+        Args:
+            app: FastAPI application instance
+            path_prefix: Path prefix for routes
+        """
+        for generator in self.generators:
+            generator.add_route_to_app(app, path_prefix)
+
+
+if __name__ == "__main__":
+
+    async def no_annotations_func(test):
+        pass
+
+    generator = ToolsetCodeGenerator.from_callables([no_annotations_func])
+    models = generator.generate_return_models()
+    print(models)
+    namespace = generator.generate_execution_namespace()
+    print(namespace)

schemez/executable.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import asyncio
 from collections.abc import AsyncIterator, Callable  # noqa: TC003
-from typing import TYPE_CHECKING, Any, TypeVar, overload
+from typing import TYPE_CHECKING, Any, TypeVar, assert_never, overload
 
 from schemez.functionschema import FunctionType, create_schema
 
@@ -34,8 +34,11 @@ class ExecutableFunction[T_co]:
             schema: OpenAI function schema
             func: The actual function to execute
         """
+        from schemez.functionschema import _determine_function_type
+
         self.schema = schema
         self.func = func
+        self.function_type = _determine_function_type(self.func)
 
     def run(self, *args: Any, **kwargs: Any) -> T_co | list[T_co]:  # noqa: PLR0911
         """Run the function synchronously.
@@ -47,7 +50,7 @@ class ExecutableFunction[T_co]:
         Returns:
             Either a single result or list of results for generators
         """
-        match self.schema.function_type:
+        match self.function_type:
             case FunctionType.SYNC:
                 return self.func(*args, **kwargs)  # type: ignore
             case FunctionType.ASYNC:
@@ -86,9 +89,8 @@ class ExecutableFunction[T_co]:
                     return loop.run_until_complete(
                         self._collect_async_gen(*args, **kwargs),
                     )
-            case _:
-                msg = f"Unknown function type: {self.schema.function_type}"
-                raise ValueError(msg)
+            case _ as unreachable:
+                assert_never(unreachable)
 
     async def _collect_async_gen(self, *args: Any, **kwargs: Any) -> list[T_co]:
         """Collect async generator results into a list.
@@ -115,7 +117,7 @@ class ExecutableFunction[T_co]:
         Raises:
             ValueError: If the function type is unknown
         """
-        match self.schema.function_type:
+        match self.function_type:
             case FunctionType.SYNC:
                 return self.func(*args, **kwargs)  # type: ignore
             case FunctionType.ASYNC:
@@ -125,7 +127,7 @@ class ExecutableFunction[T_co]:
             case FunctionType.ASYNC_GENERATOR:
                 return [x async for x in self.func(*args, **kwargs)]  # type: ignore
             case _:
-                msg = f"Unknown function type: {self.schema.function_type}"
+                msg = f"Unknown function type: {self.function_type}"
                 raise ValueError(msg)
 
     async def astream(self, *args: Any, **kwargs: Any) -> AsyncIterator[T_co]:
@@ -141,7 +143,7 @@ class ExecutableFunction[T_co]:
         Raises:
             ValueError: If the function type is unknown
         """
-        match self.schema.function_type:
+        match self.function_type:
             case FunctionType.SYNC_GENERATOR:
                 for x in self.func(*args, **kwargs):  # type: ignore
                     yield x
@@ -153,7 +155,7 @@ class ExecutableFunction[T_co]:
             case FunctionType.ASYNC:
                 yield await self.func(*args, **kwargs)  # type: ignore
             case _:
-                msg = f"Unknown function type: {self.schema.function_type}"
+                msg = f"Unknown function type: {self.function_type}"
                 raise ValueError(msg)
 
 

schemez/functionschema.py

@@ -23,11 +23,7 @@ import docstring_parser
 import pydantic
 
 from schemez import log
-from schemez.typedefs import (
-    OpenAIFunctionDefinition,
-    OpenAIFunctionTool,
-    ToolParameters,
-)
+from schemez.typedefs import OpenAIFunctionDefinition, OpenAIFunctionTool, ToolParameters
 
 
 if typing.TYPE_CHECKING:
@@ -77,38 +73,22 @@ class FunctionSchema(pydantic.BaseModel):
     """The name of the function as it will be presented to the OpenAI API."""
 
     description: str | None = None
-    """
-    Optional description of what the function does. This helps the AI understand
-    when and how to use the function.
-    """
+    """Optional description of what the function does."""
 
     parameters: ToolParameters = pydantic.Field(
         default_factory=lambda: ToolParameters(type="object", properties={}),
     )
-    """
-    JSON Schema object describing the function's parameters. Contains type information,
-    descriptions, and constraints for each parameter.
-    """
+    """JSON Schema object describing the function's parameters."""
 
     required: list[str] = pydantic.Field(default_factory=list)
     """
     List of parameter names that are required (do not have default values).
-    These parameters must be provided when calling the function.
     """
 
     returns: dict[str, Any] = pydantic.Field(
         default_factory=lambda: {"type": "object"},
     )
-    """
-    JSON Schema object describing the function's return type. Used for type checking
-    and documentation purposes.
-    """
-
-    function_type: FunctionType = FunctionType.SYNC
-    """
-    The execution pattern of the function (sync, async, generator, or async generator).
-    Used to determine how to properly invoke the function.
-    """
+    """JSON Schema object describing the function's return type."""
 
     model_config = pydantic.ConfigDict(frozen=True)
 
@@ -377,7 +357,6 @@ class FunctionSchema(pydantic.BaseModel):
             parameters=parameters,
             required=required,
             returns={"type": "object"},
-            function_type=FunctionType.SYNC,
         )
 
 
@@ -647,22 +626,26 @@ def _determine_function_type(func: Callable[..., Any]) -> FunctionType:
 def create_schema(
     func: Callable[..., Any],
     name_override: str | None = None,
+    description_override: str | None = None,
 ) -> FunctionSchema:
     """Create an OpenAI function schema from a Python function.
 
+    If an iterator is passed, the schema return type is a list of the iterator's
+    element type.
+    Variable arguments (*args) and keyword arguments (**kwargs) are not
+    supported in OpenAI function schemas and will be ignored with a warning.
+
     Args:
         func: Function to create schema for
         name_override: Optional name override (otherwise the function name)
+        description_override: Optional description override
+                              (otherwise the function docstring)
 
     Returns:
         Schema representing the function
 
     Raises:
         TypeError: If input is not callable
-
-    Note:
-        Variable arguments (*args) and keyword arguments (**kwargs) are not
-        supported in OpenAI function schemas and will be ignored with a warning.
     """
     if not callable(func):
         msg = f"Expected callable, got {type(func)}"
@@ -737,11 +720,10 @@ def create_schema(
 
     return FunctionSchema(
         name=name_override or getattr(func, "__name__", "unknown") or "unknown",
-        description=docstring.short_description,
+        description=description_override or docstring.short_description,
         parameters=parameters,  # Now includes required fields
         required=required,
         returns=returns_dct,
-        function_type=function_type,
     )
 
 

schemez/schema.py

@@ -2,17 +2,16 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Literal, Self
+from enum import Enum
+from typing import TYPE_CHECKING, Any, Literal, Optional, Self
 
-import anyenv
-from pydantic import BaseModel, ConfigDict
+from pydantic import BaseModel, ConfigDict, Field, create_model
 import upath
 
 
 if TYPE_CHECKING:
     from collections.abc import Callable
 
-    from llmling_agent.agent.agent import AgentType
     from llmling_agent.models.content import BaseContent
     from upath.types import JoinablePathLike
 
@@ -69,41 +68,47 @@ class Schema(BaseModel):
         return get_function_model(func, name=name)
 
     @classmethod
-    def from_vision_llm_sync(
-        cls,
-        file_content: bytes,
-        source_type: SourceType = "pdf",
-        model: str = "google-gla:gemini-2.0-flash",
-        system_prompt: str = DEFAULT_SYSTEM_PROMPT,
-        user_prompt: str = DEFAULT_USER_PROMPT,
-        provider: AgentType = "pydantic_ai",
-    ) -> Self:
-        """Create a schema model from a document using AI.
+    def from_json_schema(cls, json_schema: dict[str, Any]) -> type[Schema]:
+        """Create a schema model from a JSON schema.
 
         Args:
-            file_content: The document content to create a schema from
-            source_type: The type of the document
-            model: The AI model to use for schema extraction
-            system_prompt: The system prompt to use for schema extraction
-            user_prompt: The user prompt to use for schema extraction
-            provider: The provider to use for schema extraction
+            json_schema: The JSON schema to create a schema from
 
         Returns:
-            A new schema model class based on the document
+            A new schema model class based on the JSON schema
         """
-        from llmling_agent import Agent, ImageBase64Content, PDFBase64Content
+        from datamodel_code_generator import DataModelType, PythonVersion
+        from datamodel_code_generator.model import get_data_model_types
+        from datamodel_code_generator.parser.jsonschema import JsonSchemaParser
+        from pydantic.v1.main import ModelMetaclass
 
-        if source_type == "pdf":
-            content: BaseContent = PDFBase64Content.from_bytes(file_content)
-        else:
-            content = ImageBase64Content.from_bytes(file_content)
-        agent = Agent[None](  # type:ignore[var-annotated]
-            model=model,
-            system_prompt=system_prompt.format(name=cls.__name__),
-            provider=provider,
-        ).to_structured(cls)
-        chat_message = anyenv.run_sync(agent.run(user_prompt, content))
-        return chat_message.content
+        data_model_types = get_data_model_types(
+            DataModelType.PydanticBaseModel, target_python_version=PythonVersion.PY_312
+        )
+        parser = JsonSchemaParser(
+            f"""{json_schema}""",
+            data_model_type=data_model_types.data_model,
+            data_model_root_type=data_model_types.root_model,
+            data_model_field_type=data_model_types.field_model,
+            data_type_manager_type=data_model_types.data_type_manager,
+            dump_resolve_reference_action=data_model_types.dump_resolve_reference_action,
+        )
+        code_str = (
+            parser.parse()
+            .replace("from pydantic ", "from pydantic.v1 ")  # type: ignore
+            .replace("from __future__ import annotations\n\n", "")
+        )
+        ex_namespace: dict[str, Any] = {}
+        exec(code_str, ex_namespace, ex_namespace)
+        model = None
+        for v in ex_namespace.values():
+            if isinstance(v, ModelMetaclass):
+                model = v
+        if not model:
+            msg = "Class not found in output"
+            raise Exception(msg)  # noqa: TRY002
+        model.__module__ = __name__
+        return model  # type: ignore
 
     @classmethod
     async def from_vision_llm(
@@ -113,7 +118,6 @@ class Schema(BaseModel):
         model: str = "google-gla:gemini-2.0-flash",
         system_prompt: str = DEFAULT_SYSTEM_PROMPT,
         user_prompt: str = DEFAULT_USER_PROMPT,
-        provider: AgentType = "pydantic_ai",
     ) -> Self:
         """Create a schema model from a document using AI.
 
@@ -123,7 +127,6 @@ class Schema(BaseModel):
             model: The AI model to use for schema extraction
             system_prompt: The system prompt to use for schema extraction
             user_prompt: The user prompt to use for schema extraction
-            provider: The provider to use for schema extraction
 
         Returns:
             A new schema model class based on the document
@@ -134,45 +137,11 @@ class Schema(BaseModel):
             content: BaseContent = PDFBase64Content.from_bytes(file_content)
         else:
             content = ImageBase64Content.from_bytes(file_content)
-        agent = Agent[None](  # type:ignore[var-annotated]
-            model=model,
-            system_prompt=system_prompt.format(name=cls.__name__),
-            provider=provider,
-        ).to_structured(cls)
+        prompt = system_prompt.format(name=cls.__name__)
+        agent = Agent(model=model, system_prompt=prompt, output_type=cls)
         chat_message = await agent.run(user_prompt, content)
         return chat_message.content
 
-    @classmethod
-    def from_llm_sync(
-        cls,
-        text: str,
-        model: str = "google-gla:gemini-2.0-flash",
-        system_prompt: str = DEFAULT_SYSTEM_PROMPT,
-        user_prompt: str = DEFAULT_USER_PROMPT,
-        provider: AgentType = "pydantic_ai",
-    ) -> Self:
-        """Create a schema model from a text snippet using AI.
-
-        Args:
-            text: The text to create a schema from
-            model: The AI model to use for schema extraction
-            system_prompt: The system prompt to use for schema extraction
-            user_prompt: The user prompt to use for schema extraction
-            provider: The provider to use for schema extraction
-
-        Returns:
-            A new schema model class based on the document
-        """
-        from llmling_agent import Agent
-
-        agent = Agent[None](  # type:ignore[var-annotated]
-            model=model,
-            system_prompt=system_prompt.format(name=cls.__name__),
-            provider=provider,
-        ).to_structured(cls)
-        chat_message = anyenv.run_sync(agent.run(user_prompt, text))
-        return chat_message.content
-
     @classmethod
     async def from_llm(
         cls,
@@ -180,7 +149,6 @@ class Schema(BaseModel):
         model: str = "google-gla:gemini-2.0-flash",
         system_prompt: str = DEFAULT_SYSTEM_PROMPT,
         user_prompt: str = DEFAULT_USER_PROMPT,
-        provider: AgentType = "pydantic_ai",
     ) -> Self:
         """Create a schema model from a text snippet using AI.
 
@@ -189,18 +157,14 @@ class Schema(BaseModel):
             model: The AI model to use for schema extraction
             system_prompt: The system prompt to use for schema extraction
             user_prompt: The user prompt to use for schema extraction
-            provider: The provider to use for schema extraction
 
         Returns:
             A new schema model class based on the document
         """
         from llmling_agent import Agent
 
-        agent = Agent[None](  # type:ignore[var-annotated]
-            model=model,
-            system_prompt=system_prompt.format(name=cls.__name__),
-            provider=provider,
-        ).to_structured(cls)
+        prompt = system_prompt.format(name=cls.__name__)
+        agent = Agent(model=model, system_prompt=prompt, output_type=cls)
         chat_message = await agent.run(user_prompt, text)
         return chat_message.content
 
@@ -280,3 +244,87 @@ class Schema(BaseModel):
             class_name=class_name,
             target_python_version=target_python_version,
         )
+
+
+def json_schema_to_base_model(
+    schema: dict[str, Any], model_cls: type[BaseModel] = Schema
+) -> type[Schema]:
+    type_mapping: dict[str, type] = {
+        "string": str,
+        "integer": int,
+        "number": float,
+        "boolean": bool,
+        "array": list,
+        "object": dict,
+    }
+
+    properties = schema.get("properties", {})
+    required_fields = schema.get("required", [])
+    model_fields = {}
+
+    def process_field(field_name: str, field_props: dict[str, Any]) -> tuple:
+        """Recursively processes a field and returns its type and Field instance."""
+        json_type = field_props.get("type", "string")
+        enum_values = field_props.get("enum")
+
+        # Handle Enums
+        if enum_values:
+            enum_name: str = f"{field_name.capitalize()}Enum"
+            field_type: Any = Enum(enum_name, {v: v for v in enum_values})
+        # Handle Nested Objects
+        elif json_type == "object" and "properties" in field_props:
+            # Recursively create submodel
+            field_type = json_schema_to_base_model(field_props)  # type: ignore
+        # Handle Arrays with Nested Objects
+        elif json_type == "array" and "items" in field_props:
+            item_props = field_props["items"]
+            if item_props.get("type") == "object":
+                item_type: Any = json_schema_to_base_model(item_props)  # pyright: ignore[reportRedeclaration]
+            else:
+                item_type = type_mapping.get(item_props.get("type"), Any)  # pyright: ignore[reportAssignmentType]
+            field_type = list[item_type]  # type: ignore
+        else:
+            field_type = type_mapping.get(json_type, Any)  # type: ignore
+
+        # Handle default values and optionality
+        default_value = field_props.get("default", ...)
+        nullable = field_props.get("nullable", False)
+        description = field_props.get("title", "")
+
+        if nullable:
+            field_type = Optional[field_type]  # type: ignore  # noqa: UP045
+
+        if field_name not in required_fields:
+            default_value = field_props.get("default")
+
+        return field_type, Field(default_value, description=description)
+
+    # Process each field
+    for field_name, field_props in properties.items():
+        model_fields[field_name] = process_field(field_name, field_props)
+
+    return create_model(  # type: ignore
+        schema.get("title", "DynamicModel"), **model_fields, __base__=model_cls
+    )
+
+
+if __name__ == "__main__":
+    schema = {
+        "$id": "https://example.com/person.schema.json",
+        "$schema": "https://json-schema.org/draft/2020-12/schema",
+        "title": "Person",
+        "type": "object",
+        "properties": {
+            "firstName": {"type": "string", "description": "The person's first name."},
+            "lastName": {"type": "string", "description": "The person's last name."},
+            "age": {
+                "description": "Age in years, must be equal to or greater than zero.",
+                "type": "integer",
+                "minimum": 0,
+            },
+        },
+    }
+    model = Schema.from_json_schema(schema)
+    import devtools
+
+    devtools.debug(model.__fields__)

schemez/tool_executor/executor.py

@@ -33,7 +33,7 @@ class HttpToolExecutor:
 
     def __init__(
         self,
-        schemas: Sequence[dict[str, Any] | UPath],
+        schemas: Sequence[dict[str, Any] | JoinablePathLike],
         handler: ToolHandler,
         base_url: str = "http://localhost:8000",
     ):

{schemez-1.2.4.dist-info → schemez-1.4.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: schemez
-Version: 1.2.4
+Version: 1.4.4
 Summary: Pydantic shim for config stuff
 Keywords: 
 Author: Philipp Temminghoff

{schemez-1.2.4.dist-info → schemez-1.4.4.dist-info}/RECORD

@@ -1,25 +1,30 @@
-schemez/__init__.py,sha256=KkwJF8pfbzw_4cBxwXuUyXIExqdxS8iumvyAL-JUED4,1669
+schemez/__init__.py,sha256=UwLAA0B5whh63w9sYQvs_b_NNm6TBCm86-zPQiDxj3g,1799
 schemez/bind_kwargs.py,sha256=ChyArgNa5R8VdwSJmmrQItMH9Ld6hStWBISw-T1wyws,6228
 schemez/code.py,sha256=usZLov9i5KpK1W2VJxngUzeetgrINtodiooG_AxN-y4,2072
+schemez/code_generation/__init__.py,sha256=KV2ETgN8sKHlAOGnktURAHDJbz8jImBNputaxhdlin8,286
+schemez/code_generation/namespace_callable.py,sha256=LiQHsS3J46snBj4uhKNrI-dboeQNPO2QwdbhSk3-gyE,2382
+schemez/code_generation/route_helpers.py,sha256=YZfD0BUZ6_0iLnSzf2vKa8Fu2kJNfC-8oYzaQ--x8fA,4056
+schemez/code_generation/tool_code_generator.py,sha256=6j6F6dDhXruInaZeu3ReK0x7wA56oAGRfzRCytnlaQk,10766
+schemez/code_generation/toolset_code_generator.py,sha256=0L3Wrqc4XUbtbptHFLWARogBWMy50iVpQzzvYQlzNe0,5806
 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=D5nJIOQYwfOwuNSHLIoqNZtYkA1Y0DIFH18qMI6--ik,26141
+schemez/executable.py,sha256=ZvZJdUMI_EWjTqp-wUTzob3-cZDPmHgA03W756gSzKc,7190
+schemez/functionschema.py,sha256=LCNHn4ZCitUIoiEylfI59i0Em5TmnJ5N0rfxUWWlE38,25803
 schemez/helpers.py,sha256=YFx7UKYDI_sn5sVGAzzl5rcB26iBvLatvZlEFsQM5rc,7874
 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=Qt4INzB22jj-Uu61T-QI-USpNKMEeATdp98zE0Q8pL8,9592
+schemez/schema.py,sha256=OUiMNkoJZzsRQ2hTdKLvHFrmeoSZZhtbgnV4EjeIPA4,11552
 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=-uSPfkE5JrpUQWbmD0QdEpAXVBsWiRmCWCcFvDWqtus,10486
+schemez/tool_executor/executor.py,sha256=0VOY9N4Epqdv_MYU-BoDiTKbFiyIwGk_pfe5JcxJq4o,10497
 schemez/tool_executor/helpers.py,sha256=zxfI9tUkUx8Dy9fNP89-2kqfV8eZwQ3re2Gmd-oekb0,1476
 schemez/tool_executor/types.py,sha256=l2DxUIEHP9bjLnEaXZ6X428cSviicTDJsc3wfSNqKxg,675
 schemez/typedefs.py,sha256=3OAUQ1nin9nlsOcTPAO5xrsOqVUfwsH_7_cexQYREus,6091
-schemez-1.2.4.dist-info/licenses/LICENSE,sha256=AteGCH9r177TxxrOFEiOARrastASsf7yW6MQxlAHdwA,1078
-schemez-1.2.4.dist-info/WHEEL,sha256=ELhySV62sOro8I5wRaLaF3TWxhBpkcDkdZUdAYLy_Hk,78
-schemez-1.2.4.dist-info/METADATA,sha256=ycelBanzLf1RK3HpheIamKERJ8lcEMdxmxmecfKotzk,11616
-schemez-1.2.4.dist-info/RECORD,,
+schemez-1.4.4.dist-info/licenses/LICENSE,sha256=AteGCH9r177TxxrOFEiOARrastASsf7yW6MQxlAHdwA,1078
+schemez-1.4.4.dist-info/WHEEL,sha256=DpNsHFUm_gffZe1FgzmqwuqiuPC6Y-uBCzibcJcdupM,78
+schemez-1.4.4.dist-info/METADATA,sha256=3iBXsicqp4iXZ3nwDFvwHU_akqL17f0_zt5jqyCbNOE,11616
+schemez-1.4.4.dist-info/RECORD,,

{schemez-1.2.4.dist-info → schemez-1.4.4.dist-info}/WHEEL

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