schemez 1.2.2__tar.gz → 1.4.1__tar.gz

{schemez-1.2.2 → schemez-1.4.1}/PKG-INFO

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

{schemez-1.2.2 → schemez-1.4.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "schemez"
-version = "1.2.2"
+version = "1.4.1"
 description = "Pydantic shim for config stuff"
 readme = "README.md"
 requires-python = ">=3.13"

{schemez-1.2.2 → schemez-1.4.1}/src/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-1.4.1/src/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-1.4.1/src/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-1.4.1/src/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-1.4.1/src/schemez/code_generation/tool_code_generator.py

@@ -0,0 +1,272 @@
+"""Meta-resource provider that exposes tools through Python execution."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+import inspect
+from typing import TYPE_CHECKING, Any
+
+from pydantic_ai import RunContext
+
+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."""
+
+    @classmethod
+    def from_callable(cls, fn: Callable) -> 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=callable)
+
+    @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:  # noqa: PLR0911
+        """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
+
+            # Check if parameter is RunContext or AgentContext
+            annotation = param.annotation
+            annotation_str = str(annotation)
+
+            # Handle RunContext (including parameterized like RunContext[None])
+            if annotation is RunContext:
+                return True
+
+            # Check for parameterized RunContext using string matching
+            if "RunContext" in annotation_str:
+                return True
+
+            # Handle AgentContext
+            if hasattr(annotation, "__name__") and annotation.__name__ == "AgentContext":
+                return True
+
+            # Check for AgentContext in string representation
+            if "AgentContext" in annotation_str:
+                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-1.4.1/src/schemez/code_generation/toolset_code_generator.py

@@ -0,0 +1,159 @@
+"""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,
+    ) -> 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
+
+        Returns:
+            ToolsetCodeGenerator instance
+        """
+        generators = [ToolCodeGenerator.from_callable(i) 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__":
+    import webbrowser
+
+    generator = ToolsetCodeGenerator.from_callables([webbrowser.open])
+    models = generator.generate_return_models()
+    print(models)
+    namespace = generator.generate_execution_namespace()
+    print(namespace)