patito 0.5.1__py3-none-any.whl → 0.6.2__py3-none-any.whl

patito/_pydantic/repr.py

@@ -0,0 +1,139 @@
+import sys
+import types
+import typing
+from typing import (
+    Any,
+    Callable,
+    Generator,
+    Iterable,
+    Literal,
+    Optional,
+    Sequence,
+    Tuple,
+    Type,
+    Union,
+    get_args,
+    get_origin,
+)
+
+if typing.TYPE_CHECKING:
+    Loc = Tuple[Union[int, str], ...]
+    ReprArgs = Sequence[Tuple[Optional[str], Any]]
+    RichReprResult = Iterable[
+        Union[Any, Tuple[Any], Tuple[str, Any], Tuple[str, Any, Any]]
+    ]
+
+try:
+    from typing import _TypingBase  # type: ignore[attr-defined]
+except ImportError:
+    from typing import _Final as _TypingBase  # type: ignore[attr-defined]
+
+typing_base = _TypingBase
+
+if sys.version_info < (3, 9):
+    # python < 3.9 does not have GenericAlias (list[int], tuple[str, ...] and so on)
+    TypingGenericAlias = ()
+else:
+    from typing import GenericAlias as TypingGenericAlias  # type: ignore
+
+if sys.version_info < (3, 10):
+
+    def origin_is_union(tp: Optional[Type[Any]]) -> bool:
+        return tp is typing.Union
+
+    WithArgsTypes = (TypingGenericAlias,)
+
+else:
+
+    def origin_is_union(tp: type[Any] | None) -> bool:
+        return tp is typing.Union or tp is types.UnionType
+
+    WithArgsTypes = typing._GenericAlias, types.GenericAlias, types.UnionType  # type: ignore[attr-defined]
+
+
+class Representation:
+    """Mixin to provide __str__, __repr__, and __pretty__ methods. See #884 for more details.
+
+    __pretty__ is used by [devtools](https://python-devtools.helpmanual.io/) to provide human readable representations
+    of objects.
+    """
+
+    __slots__: Tuple[str, ...] = tuple()
+
+    def __repr_args__(self) -> "ReprArgs":
+        """Returns the attributes to show in __str__, __repr__, and __pretty__ this is generally overridden.
+
+        Can either return:
+        * name - value pairs, e.g.: `[('foo_name', 'foo'), ('bar_name', ['b', 'a', 'r'])]`
+        * or, just values, e.g.: `[(None, 'foo'), (None, ['b', 'a', 'r'])]`
+        """
+        attrs = ((s, getattr(self, s)) for s in self.__slots__)
+        return [(a, v) for a, v in attrs if v is not None]
+
+    def __repr_name__(self) -> str:
+        """Name of the instance's class, used in __repr__."""
+        return self.__class__.__name__
+
+    def __repr_str__(self, join_str: str) -> str:
+        return join_str.join(
+            repr(v) if a is None else f"{a}={v!r}" for a, v in self.__repr_args__()
+        )
+
+    def __pretty__(
+        self, fmt: Callable[[Any], Any], **kwargs: Any
+    ) -> Generator[Any, None, None]:
+        """Used by devtools (https://python-devtools.helpmanual.io/) to provide a human readable representations of objects."""
+        yield self.__repr_name__() + "("
+        yield 1
+        for name, value in self.__repr_args__():
+            if name is not None:
+                yield name + "="
+            yield fmt(value)
+            yield ","
+            yield 0
+        yield -1
+        yield ")"
+
+    def __str__(self) -> str:
+        return self.__repr_str__(" ")
+
+    def __repr__(self) -> str:
+        return f'{self.__repr_name__()}({self.__repr_str__(", ")})'
+
+    def __rich_repr__(self) -> "RichReprResult":
+        """Get fields for Rich library."""
+        for name, field_repr in self.__repr_args__():
+            if name is None:
+                yield field_repr
+            else:
+                yield name, field_repr
+
+
+def display_as_type(obj: Any) -> str:
+    """Pretty representation of a type, should be as close as possible to the original type definition string.
+
+    Takes some logic from `typing._type_repr`.
+    """
+    if isinstance(obj, types.FunctionType):
+        return obj.__name__
+    elif obj is ...:
+        return "..."
+    elif isinstance(obj, Representation):
+        return repr(obj)
+
+    if not isinstance(obj, (typing_base, WithArgsTypes, type)):
+        obj = obj.__class__
+
+    if origin_is_union(get_origin(obj)):
+        args = ", ".join(map(display_as_type, get_args(obj)))
+        return f"Union[{args}]"
+    elif isinstance(obj, WithArgsTypes):
+        if get_origin(obj) == Literal:
+            args = ", ".join(map(repr, get_args(obj)))
+        else:
+            args = ", ".join(map(display_as_type, get_args(obj)))
+        return f"{obj.__qualname__}[{args}]"
+    elif isinstance(obj, type):
+        return obj.__qualname__
+    else:
+        return repr(obj).replace("typing.", "").replace("typing_extensions.", "")

patito/_pydantic/schema.py

@@ -0,0 +1,96 @@
+from __future__ import annotations
+
+from functools import cache
+from typing import TYPE_CHECKING, Any, Dict, Mapping, Optional, Type, cast, get_args
+
+from pydantic.fields import FieldInfo
+
+from patito._pydantic.column_info import ColumnInfo
+from patito._pydantic.dtypes import PYTHON_TO_PYDANTIC_TYPES
+
+if TYPE_CHECKING:
+    from patito.pydantic import ModelType
+
+
+@cache
+def schema_for_model(cls: Type[ModelType]) -> Dict[str, Dict[str, Any]]:
+    """Return schema properties where definition references have been resolved.
+
+    Returns:
+        Field information as a dictionary where the keys are field names and the
+            values are dictionaries containing metadata information about the field
+            itself.
+
+    Raises:
+        TypeError: if a field is annotated with an enum where the values are of
+            different types.
+
+    """
+    schema = cls.model_json_schema(by_alias=False, ref_template="{model}")
+    fields = {}
+    # first resolve definitions for nested models TODO checks for one-way references, if models are self-referencing this falls apart with recursion depth error
+    for f in cls.model_fields.values():
+        annotation = f.annotation
+        cls._update_dfn(annotation, schema)
+        for a in get_args(annotation):
+            cls._update_dfn(a, schema)
+    for field_name, field_info in schema["properties"].items():
+        fields[field_name] = _append_field_info_to_props(
+            field_info=field_info,
+            field_name=field_name,
+            required=field_name in schema.get("required", set()),
+            model_schema=schema,
+        )
+    schema["properties"] = fields
+    return schema
+
+
+@cache
+def column_infos_for_model(cls: Type[ModelType]) -> Mapping[str, ColumnInfo]:
+    fields = cls.model_fields
+
+    def get_column_info(field: FieldInfo) -> ColumnInfo:
+        if field.json_schema_extra is None:
+            return cast(ColumnInfo, cls.column_info_class())
+        elif callable(field.json_schema_extra):
+            raise NotImplementedError(
+                "Callable json_schema_extra not supported by patito."
+            )
+        return cast(ColumnInfo, field.json_schema_extra["column_info"])
+
+    return {k: get_column_info(v) for k, v in fields.items()}
+
+
+def _append_field_info_to_props(
+    field_info: Dict[str, Any],
+    field_name: str,
+    model_schema: Dict[str, Any],
+    required: Optional[bool] = None,
+) -> Dict[str, Any]:
+    if "$ref" in field_info:  # TODO onto runtime append
+        definition = model_schema["$defs"][field_info["$ref"]]
+        if "enum" in definition and "type" not in definition:
+            enum_types = set(type(value) for value in definition["enum"])
+            if len(enum_types) > 1:
+                raise TypeError(
+                    "All enumerated values of enums used to annotate "
+                    "Patito model fields must have the same type. "
+                    "Encountered types: "
+                    f"{sorted(map(lambda t: t.__name__, enum_types))}."
+                )
+            enum_type = enum_types.pop()
+            definition["type"] = PYTHON_TO_PYDANTIC_TYPES[enum_type]
+        field = definition
+    else:
+        field = field_info
+    if "items" in field_info:
+        field["items"] = _append_field_info_to_props(
+            field_info=field_info["items"],
+            field_name=field_name,
+            model_schema=model_schema,
+        )
+    if required is not None:
+        field["required"] = required
+    if "const" in field_info and "type" not in field_info:
+        field["type"] = PYTHON_TO_PYDANTIC_TYPES[type(field_info["const"])]
+    return field

patito/exceptions.py

@@ -1,14 +1,181 @@
-"""Module containing all custom exceptions raised by patito."""
+"""Exceptions used by patito."""
 
-import pydantic
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Dict,
+    Generator,
+    List,
+    Optional,
+    Sequence,
+    Tuple,
+    Type,
+    TypedDict,
+    Union,
+)
 
+from patito._pydantic.repr import Representation
 
-class ValidationError(pydantic.ValidationError):
-    """Exception raised when dataframe does not match schema."""
+if TYPE_CHECKING:
+    from pydantic import BaseModel
 
+    Loc = Tuple[Union[int, str], ...]
 
-class ErrorWrapper(pydantic.error_wrappers.ErrorWrapper):
-    """Wrapper for specific column validation error."""
+    class _ErrorDictRequired(TypedDict):
+        loc: Loc
+        msg: str
+        type: str
+
+    class ErrorDict(_ErrorDictRequired, total=False):
+        ctx: Dict[str, Any]
+
+    from patito._pydantic.repr import ReprArgs
+
+
+__all__ = "ErrorWrapper", "DataFrameValidationError"
+
+
+class ErrorWrapper(Representation):
+    """Error handler for nicely accumulating errors."""
+
+    __slots__ = "exc", "_loc"
+
+    def __init__(self, exc: Exception, loc: Union[str, "Loc"]) -> None:
+        """Wrap an error in an ErrorWrapper."""
+        self.exc = exc
+        self._loc = loc
+
+    def loc_tuple(self) -> "Loc":
+        """Represent error as tuple."""
+        if isinstance(self._loc, tuple):
+            return self._loc
+        else:
+            return (self._loc,)
+
+    def __repr_args__(self) -> "ReprArgs":
+        """Pydantic repr."""
+        return [("exc", self.exc), ("loc", self.loc_tuple())]
+
+
+# ErrorList is something like Union[List[Union[List[ErrorWrapper], ErrorWrapper]], ErrorWrapper]
+# but recursive, therefore just use:
+ErrorList = Union[Sequence[Any], ErrorWrapper]
+
+
+class DataFrameValidationError(Representation, ValueError):
+    """Parent error for DataFrame validation errors."""
+
+    __slots__ = "raw_errors", "model", "_error_cache"
+
+    def __init__(self, errors: Sequence[ErrorList], model: Type["BaseModel"]) -> None:
+        """Create a dataframe validation error."""
+        self.raw_errors = errors
+        self.model = model
+        self._error_cache: Optional[List["ErrorDict"]] = None
+
+    def errors(self) -> List["ErrorDict"]:
+        """Get list of errors."""
+        if self._error_cache is None:
+            self._error_cache = list(flatten_errors(self.raw_errors))
+        return self._error_cache
+
+    def __str__(self) -> str:
+        """String reprentation of error."""
+        errors = self.errors()
+        no_errors = len(errors)
+        return (
+            f'{no_errors} validation error{"" if no_errors == 1 else "s"} for {self.model.__name__}\n'
+            f"{display_errors(errors)}"
+        )
+
+    def __repr_args__(self) -> "ReprArgs":
+        """Pydantic repr."""
+        return [("model", self.model.__name__), ("errors", self.errors())]
+
+
+def display_errors(errors: List["ErrorDict"]) -> str:
+    return "\n".join(
+        f'{_display_error_loc(e)}\n  {e["msg"]} ({_display_error_type_and_ctx(e)})'
+        for e in errors
+    )
+
+
+def _display_error_loc(error: "ErrorDict") -> str:
+    return " -> ".join(str(e) for e in error["loc"])
+
+
+def _display_error_type_and_ctx(error: "ErrorDict") -> str:
+    t = "type=" + error["type"]
+    ctx = error.get("ctx")
+    if ctx:
+        return t + "".join(f"; {k}={v}" for k, v in ctx.items())
+    else:
+        return t
+
+
+def flatten_errors(
+    errors: Sequence[Any], loc: Optional["Loc"] = None
+) -> Generator["ErrorDict", None, None]:
+    for error in errors:
+        if isinstance(error, ErrorWrapper):
+            if loc:
+                error_loc = loc + error.loc_tuple()
+            else:
+                error_loc = error.loc_tuple()
+
+            if isinstance(error.exc, DataFrameValidationError):
+                yield from flatten_errors(error.exc.raw_errors, error_loc)
+            else:
+                yield error_dict(error.exc, error_loc)
+        elif isinstance(error, list):
+            yield from flatten_errors(error, loc=loc)
+        else:
+            raise RuntimeError(f"Unknown error object: {error}")
+
+
+def error_dict(exc: Exception, loc: "Loc") -> "ErrorDict":
+    type_ = get_exc_type(exc.__class__)
+    msg_template = getattr(exc, "msg_template", None)
+    ctx = exc.__dict__
+    if msg_template:
+        msg = msg_template.format(**ctx)
+    else:
+        msg = str(exc)
+
+    d: "ErrorDict" = {"loc": loc, "msg": msg, "type": type_}
+
+    if ctx:
+        d["ctx"] = ctx
+
+    return d
+
+
+_EXC_TYPE_CACHE: Dict[Type[Exception], str] = {}
+
+
+def get_exc_type(cls: Type[Exception]) -> str:
+    # slightly more efficient than using lru_cache since we don't need to worry about the cache filling up
+    try:
+        return _EXC_TYPE_CACHE[cls]
+    except KeyError:
+        r = _get_exc_type(cls)
+        _EXC_TYPE_CACHE[cls] = r
+        return r
+
+
+def _get_exc_type(cls: Type[Exception]) -> str:
+    if issubclass(cls, AssertionError):
+        return "assertion_error"
+
+    base_name = "type_error" if issubclass(cls, TypeError) else "value_error"
+    if cls in (TypeError, ValueError):
+        # just TypeError or ValueError, no extra code
+        return base_name
+
+    # if it's not a TypeError or ValueError, we just take the lowercase of the exception name
+    # no chaining or snake case logic, use "code" for more complex error types.
+    code = getattr(cls, "code", None) or cls.__name__.replace("Error", "").lower()
+    return base_name + "." + code
 
 
 class WrongColumnsError(TypeError):
@@ -19,7 +186,7 @@ class MissingColumnsError(WrongColumnsError):
     """Exception for when a dataframe is missing one or more columns."""
 
 
-class SuperflousColumnsError(WrongColumnsError):
+class SuperfluousColumnsError(WrongColumnsError):
     """Exception for when a dataframe has one ore more non-specified columns."""