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

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/typedefs.py

@@ -0,0 +1,205 @@
+from __future__ import annotations
+
+import inspect
+from typing import Any, Literal, NotRequired, TypedDict
+
+
+class PropertyBase(TypedDict, total=False):
+    """Base schema property with common fields."""
+
+    type: str
+    description: str
+    format: str
+    default: Any
+    enum: NotRequired[list[Any]]
+
+
+class SimpleProperty(PropertyBase):
+    """Schema property for primitive types."""
+
+    type: Literal["string", "number", "integer", "boolean"]
+    enum: NotRequired[list[Any]]
+
+
+class ArrayProperty(PropertyBase):
+    """Schema property for array types."""
+
+    type: Literal["array"]
+    items: Property
+
+
+class ObjectProperty(PropertyBase):
+    """Schema property for nested object types."""
+
+    type: Literal["object"]
+    properties: NotRequired[dict[str, Property]]
+    required: NotRequired[list[str]]
+    additionalProperties: NotRequired[bool]
+
+
+Property = ArrayProperty | ObjectProperty | SimpleProperty
+
+
+class ToolParameters(TypedDict):
+    """Schema for function parameters."""
+
+    type: Literal["object"]
+    properties: dict[str, Property]
+    required: NotRequired[list[str]]
+
+
+class OpenAIFunctionDefinition(TypedDict):
+    """Schema for the function definition part of an OpenAI tool.
+
+    This represents the inner "function" object that contains the actual
+    function metadata and parameters.
+    """
+
+    name: str
+    description: str
+    parameters: ToolParameters
+
+
+class OpenAIFunctionTool(TypedDict):
+    """Complete OpenAI tool definition for function calling.
+
+    This represents the top-level tool object that wraps a function definition
+    and identifies it as a function tool type.
+    """
+
+    type: Literal["function"]
+    function: OpenAIFunctionDefinition
+
+
+def _create_simple_property(
+    type_str: Literal["string", "number", "integer", "boolean"],
+    description: str | None = None,
+    enum_values: list[Any] | None = None,
+    default: Any = None,
+    fmt: str | None = None,
+) -> SimpleProperty:
+    """Create a simple property."""
+    prop: SimpleProperty = {"type": type_str}
+    if description is not None:
+        prop["description"] = description
+    if enum_values is not None:
+        prop["enum"] = enum_values
+    if default is not inspect.Parameter.empty and default is not None:
+        prop["default"] = default
+    if fmt is not None:
+        prop["format"] = fmt
+    return prop
+
+
+def _create_array_property(
+    items: Property,
+    description: str | None = None,
+) -> ArrayProperty:
+    """Create an array property."""
+    prop: ArrayProperty = {
+        "type": "array",
+        "items": items,
+    }
+    if description is not None:
+        prop["description"] = description
+    return prop
+
+
+def _create_object_property(
+    description: str | None = None,
+    properties: dict[str, Property] | None = None,
+    required: list[str] | None = None,
+    additional_properties: bool | None = None,
+) -> ObjectProperty:
+    """Create an object property.
+
+    Args:
+        description: Optional property description
+        properties: Optional dict of property definitions
+        required: Optional list of required property names
+        additional_properties: Whether to allow additional properties
+
+    Returns:
+        Object property definition
+    """
+    prop: ObjectProperty = {"type": "object"}
+    if description is not None:
+        prop["description"] = description
+    if properties is not None:
+        prop["properties"] = properties
+    if required is not None:
+        prop["required"] = required
+    if additional_properties is not None:
+        prop["additionalProperties"] = additional_properties
+    return prop
+
+
+def _convert_complex_property(
+    prop: dict[str, Any],
+    description: str | None = None,
+) -> Property:
+    """Convert complex schema properties to simple OpenAI-compatible types.
+
+    Args:
+        prop: Complex property definition
+        description: Optional property description
+
+    Returns:
+        Simplified Property compatible with OpenAI
+    """
+    if "anyOf" in prop or "oneOf" in prop:
+        types = []
+        for subschema in prop.get("anyOf", prop.get("oneOf", [])):
+            if isinstance(subschema, dict):
+                types.append(subschema.get("type"))  # noqa: PERF401
+
+        # If null is allowed, treat as optional string
+        if "null" in types:
+            return _create_simple_property(
+                type_str="string",
+                description=description or prop.get("description"),
+                default=None,
+            )
+
+        # Get first non-null type or default to string
+        first_type = next((t for t in types if t != "null"), "string")
+        if first_type not in ("string", "number", "integer", "boolean"):
+            first_type = "string"
+
+        return _create_simple_property(
+            type_str=first_type,  # type: ignore # Valid since we checked above
+            description=description or prop.get("description"),
+            default=prop.get("default"),
+        )
+
+    if prop.get("type") == "array":
+        items = prop.get("items", {"type": "string"})
+        if isinstance(items, dict):
+            items = _convert_complex_property(items)
+        return _create_array_property(
+            items=items,
+            description=description or prop.get("description"),
+        )
+
+    if prop.get("type") == "object":
+        sub_props = prop.get("properties", {})
+        cleaned_props = {
+            name: _convert_complex_property(p) for name, p in sub_props.items()
+        }
+        return _create_object_property(
+            description=description or prop.get("description"),
+            properties=cleaned_props,
+            required=prop.get("required"),
+        )
+
+    type_str = prop.get("type", "string")
+    if type_str not in ("string", "number", "integer", "boolean"):
+        type_str = "string"
+
+    return _create_simple_property(
+        type_str=type_str,  # type: ignore # Valid since we checked above
+        description=description or prop.get("description"),
+        enum_values=prop.get("enum"),
+        default=prop.get("default"),
+        fmt=prop.get("format"),
+    )

{schemez-1.1.1.dist-info → schemez-1.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: schemez
-Version: 1.1.1
+Version: 1.2.0
 Summary: Pydantic shim for config stuff
 Keywords: 
 Author: Philipp Temminghoff
@@ -41,6 +41,7 @@ Classifier: Topic :: Documentation
 Classifier: Topic :: Software Development
 Classifier: Topic :: Utilities
 Classifier: Typing :: Typed
+Requires-Dist: docstring-parser>=0.17.0
 Requires-Dist: griffe>=1.7.3
 Requires-Dist: pydantic
 Requires-Dist: universal-pathlib>=0.2.6

schemez-1.2.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+schemez/__init__.py,sha256=KkwJF8pfbzw_4cBxwXuUyXIExqdxS8iumvyAL-JUED4,1669
+schemez/bind_kwargs.py,sha256=ChyArgNa5R8VdwSJmmrQItMH9Ld6hStWBISw-T1wyws,6228
+schemez/code.py,sha256=usZLov9i5KpK1W2VJxngUzeetgrINtodiooG_AxN-y4,2072
+schemez/convert.py,sha256=b6Sz11lq0HvpXfMREOqnnw8rcVg2XzTKhjjPNc4YIoE,4403
+schemez/create_type.py,sha256=wrdqdzXtfxZfsgp9IroldoYGTJs_Rdli8TiscqhV2bI,11647
+schemez/docstrings.py,sha256=kmd660wcomXzKac0SSNYxPRNbVCUovrpmE9jwnVRS6c,4115
+schemez/executable.py,sha256=YM4WcmRyJ9CpzKpNgS0A-Ri0Jd7mAzfHmoaXONI-mIs,7134
+schemez/functionschema.py,sha256=Z8kL1ckU6pEoRhOsFY6NziLhVudELHyylsFVXrCUcwU,26127
+schemez/helpers.py,sha256=IVuoFbzPJs3eqJBrr0BA6SIHncoU6BFJGP41zTijzXM,8716
+schemez/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+schemez/pydantic_types.py,sha256=8vgSl8i2z9n0fB-8AJj-D3TBByEWE5IxItBxQ0XwXFI,1640
+schemez/schema.py,sha256=u6SDhYDtfCjgy2Aa-_MDLLNcUfEXbeye4T-W6s3AED8,9558
+schemez/schema_generators.py,sha256=Gze7S7dQkTsl_1ckeHLXPxx4jQo7RB6hHQM-5fpAsrA,6973
+schemez/schemadef/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+schemez/schemadef/schemadef.py,sha256=FtD7TOnYxiuYOIfadRHKkkbZn98mWFb0_lKfPsPR-hI,14393
+schemez/typedefs.py,sha256=kxh-Vc5eKvCShdznJrg5N4_Fr8g1kYlkadEAdzgQ43w,6091
+schemez-1.2.0.dist-info/WHEEL,sha256=I8-bO5cg2sb8TH6ZM6EgCP87Y1cV_f9UGgWnfAhVOZI,78
+schemez-1.2.0.dist-info/METADATA,sha256=Nao7AGsQ0CGUiHDXT2nSE0AMOnwqlMybd8KTQSAaIB0,5399
+schemez-1.2.0.dist-info/RECORD,,

schemez-1.1.1.dist-info/RECORD

@@ -1,13 +0,0 @@
-schemez/__init__.py,sha256=iDo1ZpV07BUOmRmISV6QDA8s3viJR5V1NnrBsdw6eVM,985
-schemez/code.py,sha256=usZLov9i5KpK1W2VJxngUzeetgrINtodiooG_AxN-y4,2072
-schemez/convert.py,sha256=b6Sz11lq0HvpXfMREOqnnw8rcVg2XzTKhjjPNc4YIoE,4403
-schemez/docstrings.py,sha256=kmd660wcomXzKac0SSNYxPRNbVCUovrpmE9jwnVRS6c,4115
-schemez/helpers.py,sha256=IVuoFbzPJs3eqJBrr0BA6SIHncoU6BFJGP41zTijzXM,8716
-schemez/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-schemez/pydantic_types.py,sha256=8vgSl8i2z9n0fB-8AJj-D3TBByEWE5IxItBxQ0XwXFI,1640
-schemez/schema.py,sha256=u6SDhYDtfCjgy2Aa-_MDLLNcUfEXbeye4T-W6s3AED8,9558
-schemez/schemadef/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-schemez/schemadef/schemadef.py,sha256=FtD7TOnYxiuYOIfadRHKkkbZn98mWFb0_lKfPsPR-hI,14393
-schemez-1.1.1.dist-info/WHEEL,sha256=I8-bO5cg2sb8TH6ZM6EgCP87Y1cV_f9UGgWnfAhVOZI,78
-schemez-1.1.1.dist-info/METADATA,sha256=JwgerPl41Wss2TGr4FLUr3tic62ma4lUAN8rTqgJA9I,5359
-schemez-1.1.1.dist-info/RECORD,,