schemez 0.0.1__py3-none-any.whl → 0.1.0__py3-none-any.whl

schemez/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.0.1"
+__version__ = "0.1.0"
 
 
 from schemez.schema import Schema

schemez/convert.py

@@ -0,0 +1,142 @@
+"""BaseModel tools."""
+
+from __future__ import annotations
+
+import dataclasses
+import inspect
+from types import UnionType
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    TypeAliasType,
+    Union,
+    get_args,
+    get_origin,
+    get_type_hints,
+)
+
+from pydantic import BaseModel, Field, create_model
+
+from schemez.docstrings import get_docstring_info
+from schemez.schema import Schema
+
+
+if TYPE_CHECKING:
+    from llmling_agent.common_types import AnyCallable
+    from pydantic.fields import FieldInfo
+
+
+def get_union_args(tp: Any) -> tuple[Any, ...]:
+    """Extract arguments of a Union type."""
+    if isinstance(tp, TypeAliasType):
+        tp = tp.__value__
+
+    origin = get_origin(tp)
+    if origin is Union or origin is UnionType:
+        return get_args(tp)
+    return ()
+
+
+def get_function_model(func: AnyCallable, *, name: str | None = None) -> type[Schema]:
+    """Convert a function's signature to a Pydantic model.
+
+    Args:
+        func: The function to convert (can be method)
+        name: Optional name for the model
+
+    Returns:
+        Pydantic model representing the function parameters
+
+    Example:
+        >>> def greet(name: str, age: int | None = None) -> str:
+        ...     '''Greet someone.
+        ...     Args:
+        ...         name: Person's name
+        ...         age: Optional age
+        ...     '''
+        ...     return f"Hello {name}"
+        >>> model = get_function_model(greet)
+    """
+    sig = inspect.signature(func)
+    hints = get_type_hints(func, include_extras=True)
+    fields: dict[str, tuple[type, FieldInfo]] = {}
+    description, param_docs = get_docstring_info(func, sig)
+
+    for param_name, param in sig.parameters.items():
+        # Skip self/cls for methods
+        if param_name in ("self", "cls"):
+            continue
+
+        type_hint = hints.get(param_name, Any)
+
+        # Handle unions (including Optional)
+        if union_args := get_union_args(type_hint):  # noqa: SIM102
+            if len(union_args) == 2 and type(None) in union_args:  # noqa: PLR2004
+                type_hint = next(t for t in union_args if t is not type(None))
+
+        # Create field with defaults if available
+        field = Field(
+            default=... if param.default is param.empty else param.default,
+            description=param_docs.get(param_name),  # TODO: Add docstring parsing
+        )
+        fields[param_name] = (type_hint, field)
+
+    model_name = name or f"{func.__name__}Params"
+    return create_model(model_name, **fields, __base__=Schema, __doc__=description)  # type: ignore
+
+
+def get_ctor_basemodel(cls: type) -> type[Schema]:
+    """Convert a class constructor to a Pydantic model.
+
+    Args:
+        cls: The class whose constructor to convert
+
+    Returns:
+        Pydantic model for the constructor parameters
+
+    Example:
+        >>> class Person:
+        ...     def __init__(self, name: str, age: int | None = None):
+        ...         self.name = name
+        ...         self.age = age
+        >>> model = get_ctor_basemodel(Person)
+    """
+    if issubclass(cls, BaseModel):
+        if issubclass(cls, Schema):
+            return cls
+
+        # Create a new Schema-based model with the same fields
+        fields = {}
+        for field_name, field_info in cls.model_fields.items():
+            field_type = field_info.annotation
+            field_default = (
+                field_info.default if field_info.default is not Ellipsis else ...
+            )
+            fields[field_name] = (field_type, field_default)
+
+        return create_model(cls.__name__, **fields, __base__=Schema)  # type: ignore
+
+    if dataclasses.is_dataclass(cls):
+        fields = {}
+        hints = get_type_hints(cls)
+        for field in dataclasses.fields(cls):
+            fields[field.name] = (hints[field.name], ...)
+        return create_model(cls.__name__, __base__=Schema, **fields)  # type: ignore
+    return get_function_model(cls.__init__, name=cls.__name__)
+
+
+if __name__ == "__main__":
+
+    class Person:
+        """Person class."""
+
+        def __init__(self, name: str, age: int | None = None):
+            self.name = name
+            self.age = age
+
+        def func_google(self, name: str, age: int | None = None):
+            """Do something."""
+
+    model = get_function_model(Person.func_google)
+    instance = model(name="Test", age=30)  # type: ignore
+    print(instance, isinstance(instance, BaseModel))

schemez/docstrings.py

@@ -0,0 +1,157 @@
+"""Credits to pydantic-ai."""
+
+from __future__ import annotations as _annotations
+
+from collections.abc import Callable
+from contextlib import contextmanager
+import logging
+import re
+from typing import TYPE_CHECKING, Any, Literal, cast
+
+from griffe import Docstring, DocstringSectionKind, Object as GriffeObject
+
+
+if TYPE_CHECKING:
+    from inspect import Signature
+
+
+DocstringStyle = Literal["google", "numpy", "sphinx"]
+DocstringFormat = Literal["google", "numpy", "sphinx", "auto"]
+AnyCallable = Callable[..., Any]
+
+
+def get_docstring_info(
+    func: AnyCallable,
+    sig: Signature,
+    *,
+    docstring_format: DocstringFormat = "auto",
+) -> tuple[str, dict[str, str]]:
+    """Extract the fn description and parameter descriptions from a fn's docstring.
+
+    Returns:
+        A tuple of (main function description, parameter descriptions).
+    """
+    doc = func.__doc__
+    if doc is None:
+        return "", {}
+
+    # see https://github.com/mkdocstrings/griffe/issues/293
+    parent = cast(GriffeObject, sig)
+
+    docstring_style = (
+        _infer_docstring_style(doc) if docstring_format == "auto" else docstring_format
+    )
+    docstring = Docstring(doc, lineno=1, parser=docstring_style, parent=parent)
+    with _disable_griffe_logging():
+        sections = docstring.parse()
+
+    params = {}
+    if parameters := next(
+        (p for p in sections if p.kind == DocstringSectionKind.parameters), None
+    ):
+        params = {p.name: p.description for p in parameters.value}
+
+    main_desc = ""
+    if main := next((p for p in sections if p.kind == DocstringSectionKind.text), None):
+        main_desc = main.value
+
+    return main_desc, params
+
+
+def _infer_docstring_style(doc: str) -> DocstringStyle:
+    """Simplistic docstring style inference."""
+    for pattern, replacements, style in _docstring_style_patterns:
+        matches = (
+            re.search(pattern.format(replacement), doc, re.IGNORECASE | re.MULTILINE)
+            for replacement in replacements
+        )
+        if any(matches):
+            return style
+    # fallback to google style
+    return "google"
+
+
+# See https://github.com/mkdocstrings/griffe/issues/329#issuecomment-2425017804
+_docstring_style_patterns: list[tuple[str, list[str], DocstringStyle]] = [
+    (
+        r"\n[ \t]*:{0}([ \t]+\w+)*:([ \t]+.+)?\n",
+        [
+            "param",
+            "parameter",
+            "arg",
+            "argument",
+            "key",
+            "keyword",
+            "type",
+            "var",
+            "ivar",
+            "cvar",
+            "vartype",
+            "returns",
+            "return",
+            "rtype",
+            "raises",
+            "raise",
+            "except",
+            "exception",
+        ],
+        "sphinx",
+    ),
+    (
+        r"\n[ \t]*{0}:([ \t]+.+)?\n[ \t]+.+",
+        [
+            "args",
+            "arguments",
+            "params",
+            "parameters",
+            "keyword args",
+            "keyword arguments",
+            "other args",
+            "other arguments",
+            "other params",
+            "other parameters",
+            "raises",
+            "exceptions",
+            "returns",
+            "yields",
+            "receives",
+            "examples",
+            "attributes",
+            "functions",
+            "methods",
+            "classes",
+            "modules",
+            "warns",
+            "warnings",
+        ],
+        "google",
+    ),
+    (
+        r"\n[ \t]*{0}\n[ \t]*---+\n",
+        [
+            "deprecated",
+            "parameters",
+            "other parameters",
+            "returns",
+            "yields",
+            "receives",
+            "raises",
+            "warns",
+            "attributes",
+            "functions",
+            "methods",
+            "classes",
+            "modules",
+        ],
+        "numpy",
+    ),
+]
+
+
+@contextmanager
+def _disable_griffe_logging():
+    # Hacky, but suggested here: https://github.com/mkdocstrings/griffe/issues/293#issuecomment-2167668117
+    old_level = logging.root.getEffectiveLevel()
+    logging.root.setLevel(logging.ERROR)
+    yield
+    logging.root.setLevel(old_level)

schemez/helpers.py

@@ -1,35 +1,35 @@
-"""Helpers for BaseModels."""
-
-from __future__ import annotations
-
-import os
-
-from pydantic import BaseModel
-
-
-StrPath = str | os.PathLike[str]
-
-
-def merge_models[T: BaseModel](base: T, overlay: T) -> T:
-    """Deep merge two Pydantic models."""
-    if not isinstance(overlay, type(base)):
-        msg = f"Cannot merge different types: {type(base)} and {type(overlay)}"
-        raise TypeError(msg)
-
-    merged_data = base.model_dump()
-    overlay_data = overlay.model_dump(exclude_none=True)
-    for field_name, field_value in overlay_data.items():
-        base_value = merged_data.get(field_name)
-
-        match (base_value, field_value):
-            case (list(), list()):
-                merged_data[field_name] = [
-                    *base_value,
-                    *(item for item in field_value if item not in base_value),
-                ]
-            case (dict(), dict()):
-                merged_data[field_name] = base_value | field_value
-            case _:
-                merged_data[field_name] = field_value
-
-    return base.__class__.model_validate(merged_data)
+"""Helpers for BaseModels."""
+
+from __future__ import annotations
+
+import os
+
+from pydantic import BaseModel
+
+
+StrPath = str | os.PathLike[str]
+
+
+def merge_models[T: BaseModel](base: T, overlay: T) -> T:
+    """Deep merge two Pydantic models."""
+    if not isinstance(overlay, type(base)):
+        msg = f"Cannot merge different types: {type(base)} and {type(overlay)}"
+        raise TypeError(msg)
+
+    merged_data = base.model_dump()
+    overlay_data = overlay.model_dump(exclude_none=True)
+    for field_name, field_value in overlay_data.items():
+        base_value = merged_data.get(field_name)
+
+        match (base_value, field_value):
+            case (list(), list()):
+                merged_data[field_name] = [
+                    *base_value,
+                    *(item for item in field_value if item not in base_value),
+                ]
+            case (dict(), dict()):
+                merged_data[field_name] = base_value | field_value
+            case _:
+                merged_data[field_name] = field_value
+
+    return base.__class__.model_validate(merged_data)

schemez/schema.py

@@ -1,67 +1,102 @@
-"""Configuration models for Schemez."""
-
-from __future__ import annotations
-
-import os
-from typing import Self
-
-from pydantic import BaseModel, ConfigDict
-import upath
-
-
-StrPath = str | os.PathLike[str]
-
-
-class Schema(BaseModel):
-    """Base class configuration models.
-
-    Provides:
-    - Common Pydantic settings
-    - YAML serialization
-    - Basic merge functionality
-    """
-
-    model_config = ConfigDict(extra="forbid", use_attribute_docstrings=True)
-
-    def merge(self, other: Self) -> Self:
-        """Merge with another instance by overlaying its non-None values."""
-        from schemez.helpers import merge_models
-
-        return merge_models(self, other)
-
-    @classmethod
-    def from_yaml(cls, content: str, inherit_path: StrPath | None = None) -> Self:
-        """Create from YAML string."""
-        import yamling
-
-        data = yamling.load_yaml(content, resolve_inherit=inherit_path or False)
-        return cls.model_validate(data)
-
-    def model_dump_yaml(self) -> str:
-        """Dump configuration to YAML string."""
-        import yamling
-
-        return yamling.dump_yaml(self.model_dump(exclude_none=True))
-
-    def save(self, path: StrPath, overwrite: bool = False) -> None:
-        """Save configuration to a YAML file.
-
-        Args:
-            path: Path to save the configuration to
-            overwrite: Whether to overwrite an existing file
-
-        Raises:
-            OSError: If file cannot be written
-            ValueError: If path is invalid
-        """
-        yaml_str = self.model_dump_yaml()
-        try:
-            file_path = upath.UPath(path)
-            if file_path.exists() and not overwrite:
-                msg = f"File already exists: {path}"
-                raise FileExistsError(msg)  # noqa: TRY301
-            file_path.parent.mkdir(parents=True, exist_ok=True)
-            file_path.write_text(yaml_str)
-        except Exception as exc:
-            msg = f"Failed to save configuration to {path}"
-            raise ValueError(msg) from exc
+"""Configuration models for Schemez."""
+
+from __future__ import annotations
+
+import os
+from typing import TYPE_CHECKING, Any, Self
+
+from pydantic import BaseModel, ConfigDict
+import upath
+
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+
+StrPath = str | os.PathLike[str]
+
+
+class Schema(BaseModel):
+    """Base class configuration models.
+
+    Provides:
+    - Common Pydantic settings
+    - YAML serialization
+    - Basic merge functionality
+    """
+
+    model_config = ConfigDict(extra="forbid", use_attribute_docstrings=True)
+
+    def merge(self, other: Self) -> Self:
+        """Merge with another instance by overlaying its non-None values."""
+        from schemez.helpers import merge_models
+
+        return merge_models(self, other)
+
+    @classmethod
+    def from_yaml(cls, content: str, inherit_path: StrPath | None = None) -> Self:
+        """Create from YAML string."""
+        import yamling
+
+        data = yamling.load_yaml(content, resolve_inherit=inherit_path or False)
+        return cls.model_validate(data)
+
+    @classmethod
+    def for_function(
+        cls, func: Callable[..., Any], *, name: str | None = None
+    ) -> type[Schema]:
+        """Create a schema model from a function's signature.
+
+        Args:
+            func: The function to create a schema from
+            name: Optional name for the model
+
+        Returns:
+            A new schema model class based on the function parameters
+        """
+        from schemez.convert import get_function_model
+
+        return get_function_model(func, name=name)
+
+    @classmethod
+    def for_class_ctor(cls, target_cls: type) -> type[Schema]:
+        """Create a schema model from a class constructor.
+
+        Args:
+            target_cls: The class whose constructor to convert
+
+        Returns:
+            A new schema model class based on the constructor parameters
+        """
+        from schemez.convert import get_ctor_basemodel
+
+        return get_ctor_basemodel(target_cls)
+
+    def model_dump_yaml(self) -> str:
+        """Dump configuration to YAML string."""
+        import yamling
+
+        return yamling.dump_yaml(self.model_dump(exclude_none=True))
+
+    def save(self, path: StrPath, overwrite: bool = False) -> None:
+        """Save configuration to a YAML file.
+
+        Args:
+            path: Path to save the configuration to
+            overwrite: Whether to overwrite an existing file
+
+        Raises:
+            OSError: If file cannot be written
+            ValueError: If path is invalid
+        """
+        yaml_str = self.model_dump_yaml()
+        try:
+            file_path = upath.UPath(path)
+            if file_path.exists() and not overwrite:
+                msg = f"File already exists: {path}"
+                raise FileExistsError(msg)  # noqa: TRY301
+            file_path.parent.mkdir(parents=True, exist_ok=True)
+            file_path.write_text(yaml_str)
+        except Exception as exc:
+            msg = f"Failed to save configuration to {path}"
+            raise ValueError(msg) from exc

{schemez-0.0.1.dist-info → schemez-0.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: schemez
-Version: 0.0.1
+Version: 0.1.0
 Summary: Pydantic shim for config stuff
 Project-URL: Documentation, https://phil65.github.io/schemez/
 Project-URL: Source, https://github.com/phil65/schemez
@@ -46,6 +46,7 @@ Classifier: Topic :: Software Development
 Classifier: Topic :: Utilities
 Classifier: Typing :: Typed
 Requires-Python: >=3.12
+Requires-Dist: griffe>=1.7.3
 Requires-Dist: pydantic
 Requires-Dist: universal-pathlib>=0.2.6
 Description-Content-Type: text/markdown

schemez-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+schemez/__init__.py,sha256=VpbilATEu92pmAaUaenQPcyPCRA2itKLdszXxI-pakM,80
+schemez/convert.py,sha256=b6Sz11lq0HvpXfMREOqnnw8rcVg2XzTKhjjPNc4YIoE,4403
+schemez/docstrings.py,sha256=kmd660wcomXzKac0SSNYxPRNbVCUovrpmE9jwnVRS6c,4115
+schemez/helpers.py,sha256=_leGedEf5AoeQOV0eyrJpDnvDOPB5XV3pd5YNANASeI,1081
+schemez/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+schemez/schema.py,sha256=qlkNigpDQJIopjSjfS4yp8vXReCr2o2eWBEDjIN7YjM,3021
+schemez-0.1.0.dist-info/METADATA,sha256=N5ew7ne2W8qznqDjxcI15hMDPbzzDJRC_Hw4U11ECRw,5722
+schemez-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+schemez-0.1.0.dist-info/licenses/LICENSE,sha256=AteGCH9r177TxxrOFEiOARrastASsf7yW6MQxlAHdwA,1078
+schemez-0.1.0.dist-info/RECORD,,

schemez-0.0.1.dist-info/RECORD

@@ -1,8 +0,0 @@
-schemez/__init__.py,sha256=8GownnUkTUVUdUuosh5mCOW9OqoY_9-_66_BmQL9yEM,80
-schemez/helpers.py,sha256=bbmtpB9hz3iyc7u9zpuOPQnUuwj5J751C3RtmXs8PzU,1116
-schemez/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-schemez/schema.py,sha256=6rubAfdwdcmFRP8SfPQpfyuR674uuIy9u3zo7PndlWU,2070
-schemez-0.0.1.dist-info/METADATA,sha256=o78fWu1GlwqnJGwjWGZVNGyVETwb66CWcBMzNsQoYv8,5693
-schemez-0.0.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-schemez-0.0.1.dist-info/licenses/LICENSE,sha256=AteGCH9r177TxxrOFEiOARrastASsf7yW6MQxlAHdwA,1078
-schemez-0.0.1.dist-info/RECORD,,