pydantic-function-models 0.1.0__py3-none-any.whl

pydantic_function_models/__init__.py

@@ -0,0 +1,3 @@
+from __future__ import annotations
+
+__version__ = "0.1.0"

pydantic_function_models/log.py

@@ -0,0 +1,7 @@
+from sys import stderr
+
+__all__ = ["err"]
+
+
+def err(*msg) -> None:
+    print(*msg, file=stderr)

pydantic_function_models/validated_function.py

@@ -0,0 +1,292 @@
+import sys
+from functools import wraps
+from inspect import Parameter, signature
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    List,
+    Mapping,
+    Optional,
+    Tuple,
+    TypeVar,
+    get_type_hints,
+    overload,
+)
+
+from pydantic.alias_generators import to_pascal
+from pydantic.errors import PydanticUserError
+from pydantic.functional_validators import field_validator
+from pydantic.main import BaseModel, create_model
+
+__all__ = ("validate_arguments",)
+
+assert sys.version_info >= (3, 10), "typing.get_type_hints needs Python 3.10+"
+
+if TYPE_CHECKING:
+    AnyCallable = Callable[..., Any]
+
+    AnyCallableT = TypeVar("AnyCallableT", bound=AnyCallable)
+
+
+@overload
+def validate_arguments(func: None = None) -> Callable[["AnyCallableT"], "AnyCallableT"]:
+    ...
+
+
+@overload
+def validate_arguments(func: "AnyCallableT") -> "AnyCallableT":
+    ...
+
+
+def validate_arguments(func: Optional["AnyCallableT"] = None) -> Any:
+    """Decorator to validate the arguments passed to a function."""
+
+    def validate(_func: "AnyCallable") -> "AnyCallable":
+        vd = ValidatedFunction(_func)
+
+        @wraps(_func)
+        def wrapper_function(*args: Any, **kwargs: Any) -> Any:
+            return vd.call(*args, **kwargs)
+
+        wrapper_function.vd = vd  # type: ignore
+        wrapper_function.validate = vd.init_model_instance  # type: ignore
+        wrapper_function.raw_function = vd.raw_function  # type: ignore
+        wrapper_function.model = vd.model  # type: ignore
+        return wrapper_function
+
+    if func:
+        return validate(func)
+    else:
+        return validate
+
+
+ALT_V_ARGS = "v__args"
+ALT_V_KWARGS = "v__kwargs"
+V_POSITIONAL_ONLY_NAME = "v__positional_only"
+V_DUPLICATE_KWARGS = "v__duplicate_kwargs"
+
+
+class ValidatedFunction:
+    def __init__(self, function: "AnyCallable"):
+        parameters: Mapping[str, Parameter] = signature(function).parameters
+
+        if parameters.keys() & {
+            ALT_V_ARGS,
+            ALT_V_KWARGS,
+            V_POSITIONAL_ONLY_NAME,
+            V_DUPLICATE_KWARGS,
+        }:
+            raise PydanticUserError(
+                f'"{ALT_V_ARGS}", "{ALT_V_KWARGS}", "{V_POSITIONAL_ONLY_NAME}" and "{V_DUPLICATE_KWARGS}" '
+                f'are not permitted as argument names when using the "{validate_arguments.__name__}" decorator',
+                code=None,
+            )
+
+        self.raw_function = function
+        self.arg_mapping: Dict[int, str] = {}
+        self.positional_only_args: set[str] = set()
+        self.v_args_name = "args"
+        self.v_kwargs_name = "kwargs"
+
+        type_hints = get_type_hints(function, include_extras=True)
+        takes_args = False
+        takes_kwargs = False
+        fields: Dict[str, Tuple[Any, Any]] = {}
+        for i, (name, p) in enumerate(parameters.items()):
+            if p.annotation is p.empty:
+                annotation = Any
+            else:
+                annotation = type_hints[name]
+
+            default = ... if p.default is p.empty else p.default
+            if p.kind == Parameter.POSITIONAL_ONLY:
+                self.arg_mapping[i] = name
+                fields[name] = annotation, default
+                fields[V_POSITIONAL_ONLY_NAME] = List[str], None
+                self.positional_only_args.add(name)
+            elif p.kind == Parameter.POSITIONAL_OR_KEYWORD:
+                self.arg_mapping[i] = name
+                fields[name] = annotation, default
+                fields[V_DUPLICATE_KWARGS] = List[str], None
+            elif p.kind == Parameter.KEYWORD_ONLY:
+                fields[name] = annotation, default
+            elif p.kind == Parameter.VAR_POSITIONAL:
+                self.v_args_name = name
+                fields[name] = Tuple[annotation, ...], None
+                takes_args = True
+            else:
+                assert p.kind == Parameter.VAR_KEYWORD, p.kind
+                self.v_kwargs_name = name
+                fields[name] = Dict[str, annotation], None  # type: ignore[valid-type]
+                takes_kwargs = True
+
+        # these checks avoid a clash between "args" and a field with that name
+        if not takes_args and self.v_args_name in fields:
+            self.v_args_name = ALT_V_ARGS
+
+        # same with "kwargs"
+        if not takes_kwargs and self.v_kwargs_name in fields:
+            self.v_kwargs_name = ALT_V_KWARGS
+
+        if not takes_args:
+            # we add the field so validation below can raise the correct exception
+            fields[self.v_args_name] = List[Any], None
+
+        if not takes_kwargs:
+            # same with kwargs
+            fields[self.v_kwargs_name] = Dict[Any, Any], None
+
+        self.create_model(fields, takes_args, takes_kwargs)
+
+    def init_model_instance(self, *args: Any, **kwargs: Any) -> BaseModel:
+        values = self.build_values(args, kwargs)
+        return self.model(**values)
+
+    def call(self, *args: Any, **kwargs: Any) -> Any:
+        m = self.init_model_instance(*args, **kwargs)
+        return self.execute(m)
+
+    def build_values(
+        self,
+        args: Tuple[Any, ...],
+        kwargs: Dict[str, Any],
+    ) -> Dict[str, Any]:
+        values: Dict[str, Any] = {}
+        if args:
+            arg_iter = enumerate(args)
+            while True:
+                try:
+                    i, a = next(arg_iter)
+                except StopIteration:
+                    break
+                arg_name = self.arg_mapping.get(i)
+                if arg_name is not None:
+                    values[arg_name] = a
+                else:
+                    values[self.v_args_name] = [a] + [a for _, a in arg_iter]
+                    break
+
+        var_kwargs: Dict[str, Any] = {}
+        wrong_positional_args = []
+        duplicate_kwargs = []
+        fields_alias = [
+            field.alias
+            for name, field in self.model.model_fields.items()
+            if name not in (self.v_args_name, self.v_kwargs_name)
+        ]
+        non_var_fields = set(self.model.model_fields) - {
+            self.v_args_name,
+            self.v_kwargs_name,
+        }
+        for k, v in kwargs.items():
+            if k in non_var_fields or k in fields_alias:
+                if k in self.positional_only_args:
+                    wrong_positional_args.append(k)
+                if k in values:
+                    duplicate_kwargs.append(k)
+                values[k] = v
+            else:
+                var_kwargs[k] = v
+
+        if var_kwargs:
+            values[self.v_kwargs_name] = var_kwargs
+        if wrong_positional_args:
+            values[V_POSITIONAL_ONLY_NAME] = wrong_positional_args
+        if duplicate_kwargs:
+            values[V_DUPLICATE_KWARGS] = duplicate_kwargs
+        return values
+
+    def execute(self, m: BaseModel) -> Any:
+        d = {
+            k: v
+            for k, v in m.__dict__.items()
+            if k in m.__pydantic_fields_set__ or m.model_fields[k].default_factory
+        }
+        var_kwargs = d.pop(self.v_kwargs_name, {})
+
+        if self.v_args_name in d:
+            args_: List[Any] = []
+            in_kwargs = False
+            kwargs = {}
+            for name, value in d.items():
+                if in_kwargs:
+                    kwargs[name] = value
+                elif name == self.v_args_name:
+                    args_ += value
+                    in_kwargs = True
+                else:
+                    args_.append(value)
+            return self.raw_function(*args_, **kwargs, **var_kwargs)
+        elif self.positional_only_args:
+            args_ = []
+            kwargs = {}
+            for name, value in d.items():
+                if name in self.positional_only_args:
+                    args_.append(value)
+                else:
+                    kwargs[name] = value
+            return self.raw_function(*args_, **kwargs, **var_kwargs)
+        else:
+            return self.raw_function(**d, **var_kwargs)
+
+    def create_model(
+        self,
+        fields: Dict[str, Any],
+        takes_args: bool,
+        takes_kwargs: bool,
+    ) -> None:
+        pos_args = len(self.arg_mapping)
+
+        class DecoratorBaseModel(BaseModel):
+            @field_validator(self.v_args_name, check_fields=False)
+            @classmethod
+            def check_args(cls, v: Optional[List[Any]]) -> Optional[List[Any]]:
+                if takes_args or v is None:
+                    return v
+
+                raise TypeError(
+                    f"{pos_args} positional arguments expected but {pos_args + len(v)} given",
+                )
+
+            @field_validator(self.v_kwargs_name, check_fields=False)
+            @classmethod
+            def check_kwargs(
+                cls,
+                v: Optional[Dict[str, Any]],
+            ) -> Optional[Dict[str, Any]]:
+                if takes_kwargs or v is None:
+                    return v
+
+                plural = "" if len(v) == 1 else "s"
+                keys = ", ".join(map(repr, v.keys()))
+                raise TypeError(f"unexpected keyword argument{plural}: {keys}")
+
+            @field_validator(V_POSITIONAL_ONLY_NAME, check_fields=False)
+            @classmethod
+            def check_positional_only(cls, v: Optional[List[str]]) -> None:
+                if v is None:
+                    return
+
+                plural = "" if len(v) == 1 else "s"
+                keys = ", ".join(map(repr, v))
+                raise TypeError(
+                    f"positional-only argument{plural} passed as keyword argument{plural}: {keys}",
+                )
+
+            @field_validator(V_DUPLICATE_KWARGS, check_fields=False)
+            @classmethod
+            def check_duplicate_kwargs(cls, v: Optional[List[str]]) -> None:
+                if v is None:
+                    return
+
+                plural = "" if len(v) == 1 else "s"
+                keys = ", ".join(map(repr, v))
+                raise TypeError(f"multiple values for argument{plural}: {keys}")
+
+        self.model = create_model(
+            to_pascal(self.raw_function.__name__),
+            __base__=DecoratorBaseModel,
+            **fields,
+        )

pydantic_function_models-0.1.0.dist-info/METADATA

@@ -0,0 +1,30 @@
+Metadata-Version: 2.1
+Name: pydantic-function-models
+Version: 0.1.0
+Summary: Migrating v1 Pydantic ValidatedFunction to v2.
+Keywords: pydantic serialization deserialization parsing
+Author-Email: Louis Maddox <louismmx@gmail.com>
+License: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Framework :: Pydantic
+Classifier: Framework :: Pydantic :: 2
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.10
+Requires-Dist: pydantic>=2.1.1
+Description-Content-Type: text/markdown
+
+# pydantic-function-models
+
+Migrating v1 Pydantic ValidatedFunction to v2
+
+![PyPI](https://img.shields.io/pypi/v/pydantic-function-models?logo=python&logoColor=%23cccccc)
+[![pdm-managed](https://img.shields.io/badge/pdm-managed-blueviolet)](https://pdm.fming.dev)
+[![pre-commit.ci status](https://results.pre-commit.ci/badge/github/lmmx/pydantic-function-models/master.svg)](https://results.pre-commit.ci/latest/github/lmmx/pydantic-function-models/master)
+[![Supported Python versions](https://img.shields.io/pypi/pyversions/magic-scrape.svg)](https://pypi.org/project/pydantic-function-models)
+
+<!-- [![build status](https://github.com/lmmx/pydantic-function-models/actions/workflows/master.yml/badge.svg)](https://github.com/lmmx/pydantic-function-models/actions/workflows/master.yml) -->

pydantic_function_models-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+pydantic_function_models-0.1.0.dist-info/METADATA,sha256=V-CN7c7j8FoX4r2dultBKif_nPsL_D4ra0n1AAkCsSU,1531
+pydantic_function_models-0.1.0.dist-info/WHEEL,sha256=bbAwydobi_oZ_0rI4gBBovxINCqHVHcC26TV6S2A2Io,90
+pydantic_function_models-0.1.0.dist-info/licenses/LICENSE.txt,sha256=G3lig0yYU_DFJj7coAP8MNr-6A-MyNHzke0czVRCsJM,1069
+pydantic_function_models/__init__.py,sha256=C52JK4KMjf9MnPZNJ_yYBD0f49c1qgMV5818fiDNO7Y,58
+pydantic_function_models/log.py,sha256=-TmYMXb1cKLtoTa9cRFhPDua2nnk99WZmPJueriYmwY,96
+pydantic_function_models/validated_function.py,sha256=2FDqwYd3nFYVswdLxdEeln6wXe3b4s-I8w9VDZe4J08,10027
+pydantic_function_models-0.1.0.dist-info/RECORD,,

pydantic_function_models-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: pdm-backend (2.1.5)
+Root-Is-Purelib: true
+Tag: py3-none-any

pydantic_function_models-0.1.0.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Louis Maddox
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.