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

schemez/code_generation/tool_code_generator.py

@@ -2,11 +2,9 @@
 
 from __future__ import annotations
 
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 import inspect
-from typing import TYPE_CHECKING, Any
-
-from pydantic_ai import RunContext
+from typing import TYPE_CHECKING, Any, get_origin
 
 from schemez import create_schema
 from schemez.code_generation.route_helpers import (
@@ -38,22 +36,29 @@ TYPE_MAP = {
 class ToolCodeGenerator:
     """Generates code artifacts for a single tool."""
 
-    schema: OpenAIFunctionTool
-    """Schema of the tool."""
-
     callable: Callable
     """Tool to generate code for."""
 
+    schema: OpenAIFunctionTool
+    """Schema of the tool."""
+
     name_override: str | None = None
-    """Name of the tool."""
+    """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) -> ToolCodeGenerator:
+    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=callable)
+        return cls(schema=schema, callable=fn, exclude_types=exclude_types or [])
 
     @property
     def name(self) -> str:
@@ -162,7 +167,7 @@ class ToolCodeGenerator:
             self.callable
         )
 
-    def _is_context_parameter(self, param_name: str) -> bool:  # noqa: PLR0911
+    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()
@@ -173,26 +178,49 @@ class ToolCodeGenerator:
             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
+            for typ in self.exclude_types:
+                if self._types_match(annotation, typ):
+                    return True
+        except Exception:  # noqa: BLE001
+            pass
 
-            # Check for parameterized RunContext using string matching
-            if "RunContext" in annotation_str:
-                return True
+        return False
 
-            # Handle AgentContext
-            if hasattr(annotation, "__name__") and annotation.__name__ == "AgentContext":
+    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
 
-            # Check for AgentContext in string representation
-            if "AgentContext" in annotation_str:
+            # 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
 

schemez/code_generation/toolset_code_generator.py

@@ -4,6 +4,7 @@ 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
@@ -56,6 +57,7 @@ class ToolsetCodeGenerator:
         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.
 
@@ -63,11 +65,16 @@ class ToolsetCodeGenerator:
             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) for i in callables]
+        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:
@@ -101,6 +108,13 @@ class ToolsetCodeGenerator:
                 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("")
 
@@ -142,9 +156,11 @@ class ToolsetCodeGenerator:
 
 
 if __name__ == "__main__":
-    import webbrowser
 
-    generator = ToolsetCodeGenerator.from_callables([webbrowser.open])
+    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()

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-1.4.0.dist-info → schemez-1.4.4.dist-info}/METADATA

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

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

@@ -4,13 +4,13 @@ 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=yM29h4nccZEV21FMSZaKJI-IBdDezxpHld3n4WFWfkM,9627
-schemez/code_generation/toolset_code_generator.py,sha256=Uw4UEjLzzHsm6YzsPFaEPxYHpFgIv_DKaFVP0XePjjI,5083
+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
@@ -24,7 +24,7 @@ schemez/tool_executor/executor.py,sha256=0VOY9N4Epqdv_MYU-BoDiTKbFiyIwGk_pfe5Jcx
 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.4.0.dist-info/licenses/LICENSE,sha256=AteGCH9r177TxxrOFEiOARrastASsf7yW6MQxlAHdwA,1078
-schemez-1.4.0.dist-info/WHEEL,sha256=DpNsHFUm_gffZe1FgzmqwuqiuPC6Y-uBCzibcJcdupM,78
-schemez-1.4.0.dist-info/METADATA,sha256=PyncybCr23T22f_d0yl76k-YwHfXv2XHHGAGeuEgdw4,11616
-schemez-1.4.0.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,,