patito 0.6.1__py3-none-any.whl → 0.7.0__py3-none-any.whl

patito/__init__.py

@@ -1,4 +1,5 @@
 """Patito, a data-modelling library built on top of polars and pydantic."""
+
 from polars import Expr, Series, col
 
 from patito import exceptions

patito/_docs.py

@@ -1,2 +1,3 @@
 """Ugly workaround for Sphinx + autodoc + ModelMetaclass + classproperty."""
+
 from patito.pydantic import ModelMetaclass as Model  # noqa: F401, pragma: no cover

patito/_pydantic/__init__.py

@@ -1 +0,0 @@
-

patito/_pydantic/column_info.py

@@ -19,10 +19,9 @@ from patito._pydantic.dtypes import parse_composite_dtype
 
 
 class ColumnInfo(BaseModel, arbitrary_types_allowed=True):
-    """patito-side model for storing column metadata
+    """patito-side model for storing column metadata.
 
     Args:
-    ----
         constraints (Union[polars.Expression, List[polars.Expression]): A single
             constraint or list of constraints, expressed as a polars expression objects.
             All rows must satisfy the given constraint. You can refer to the given column
@@ -40,6 +39,22 @@ class ColumnInfo(BaseModel, arbitrary_types_allowed=True):
     derived_from: Optional[Union[str, pl.Expr]] = None
     unique: Optional[bool] = None
 
+    def __repr__(self) -> str:
+        """Print only Field attributes whose values are not default (mainly None)."""
+        not_default_field = {
+            field: getattr(self, field)
+            for field in self.model_fields
+            if getattr(self, field) is not self.model_fields[field].default
+        }
+
+        string = ""
+        for field, value in not_default_field.items():
+            string += f"{field}={value}, "
+        if string:
+            # remove trailing comma and space
+            string = string[:-2]
+        return f"ColumnInfo({string})"
+
     @field_serializer("constraints", "derived_from")
     def serialize_exprs(self, exprs: str | pl.Expr | Sequence[pl.Expr] | None) -> Any:
         if exprs is None:
@@ -56,17 +71,17 @@ class ColumnInfo(BaseModel, arbitrary_types_allowed=True):
     def _serialize_expr(self, expr: pl.Expr) -> Dict:
         if isinstance(expr, pl.Expr):
             return json.loads(
-                expr.meta.write_json(None)
+                expr.meta.serialize(format="json")
             )  # can we access the dictionary directly?
         else:
             raise ValueError(f"Invalid type for expr: {type(expr)}")
 
     @field_serializer("dtype")
     def serialize_dtype(self, dtype: DataTypeClass | DataType | None) -> Any:
-        """References
-        ----------
-            [1] https://stackoverflow.com/questions/76572310/how-to-serialize-deserialize-polars-datatypes
+        """Serialize a polars dtype.
 
+        References:
+            [1] https://stackoverflow.com/questions/76572310/how-to-serialize-deserialize-polars-datatypes
         """
         if dtype is None:
             return None

patito/_pydantic/dtypes/dtypes.py

@@ -5,7 +5,8 @@ from operator import and_
 from typing import TYPE_CHECKING, Any, Dict, FrozenSet, Mapping, Optional, Type
 
 import polars as pl
-from polars.datatypes import DataType, DataTypeClass, DataTypeGroup
+from polars.datatypes import DataType, DataTypeClass
+from polars.datatypes.group import DataTypeGroup
 from pydantic import TypeAdapter
 
 from patito._pydantic.dtypes.utils import (
@@ -39,24 +40,17 @@ def valid_dtypes_for_model(
 @cache
 def default_dtypes_for_model(
     cls: Type[ModelType],
-) -> dict[str, DataTypeClass | DataType]:
-    default_dtypes = {}
+) -> dict[str, DataType]:
+    default_dtypes: dict[str, DataType] = {}
     for column in cls.columns:
-        dtype = cls.column_infos[column].dtype
+        dtype = (
+            cls.column_infos[column].dtype
+            or DtypeResolver(cls.model_fields[column].annotation).default_polars_dtype()
+        )
         if dtype is None:
-            default_dtype = DtypeResolver(
-                cls.model_fields[column].annotation
-            ).default_polars_dtype()
-            if default_dtype is None:
-                raise ValueError(
-                    f"Unable to find a default dtype for column `{column}`"
-                )
-            else:
-                default_dtypes[column] = default_dtype
-        else:
-            default_dtypes[column] = (
-                dtype if isinstance(dtype, DataType) else dtype()
-            )  # if dtype is not instantiated, instantiate it
+            raise ValueError(f"Unable to find a default dtype for column `{column}`")
+
+        default_dtypes[column] = dtype if isinstance(dtype, DataType) else dtype()
     return default_dtypes
 
 
@@ -68,7 +62,6 @@ def validate_polars_dtype(
     """Check that the polars dtype is valid for the given annotation. Raises ValueError if not.
 
     Args:
-    ----
         annotation (type[Any] | None): python type annotation
         dtype (DataType | DataTypeClass | None): polars dtype
         column (Optional[str], optional): column name. Defaults to None.
@@ -96,7 +89,6 @@ def validate_annotation(
     """Check that the provided annotation has polars/patito support (we can resolve it to a default dtype). Raises ValueError if not.
 
     Args:
-    ----
         annotation (type[Any] | None): python type annotation
         column (Optional[str], optional): column name. Defaults to None.
 
@@ -130,9 +122,9 @@ class DtypeResolver:
             return PT_BASE_SUPPORTED_DTYPES
         return self._valid_polars_dtypes_for_schema(self.schema)
 
-    def default_polars_dtype(self) -> DataTypeClass | DataType | None:
+    def default_polars_dtype(self) -> DataType | None:
         if self.annotation == Any:
-            return pl.String
+            return pl.String()
         return self._default_polars_dtype_for_schema(self.schema)
 
     def _valid_polars_dtypes_for_schema(
@@ -197,9 +189,7 @@ class DtypeResolver:
             PydanticBaseType(pyd_type), props.get("format"), props.get("enum")
         )
 
-    def _default_polars_dtype_for_schema(
-        self, schema: Dict
-    ) -> DataTypeClass | DataType | None:
+    def _default_polars_dtype_for_schema(self, schema: Dict) -> DataType | None:
         if "anyOf" in schema:
             if len(schema["anyOf"]) == 2:  # look for optionals first
                 schema = _without_optional(schema)
@@ -216,10 +206,12 @@ class DtypeResolver:
     def _pydantic_subschema_to_default_dtype(
         self,
         props: Dict,
-    ) -> DataTypeClass | DataType | None:
+    ) -> DataType | None:
         if "column_info" in props:  # user has specified in patito model
             if props["column_info"]["dtype"] is not None:
-                return dtype_from_string(props["column_info"]["dtype"])
+                dtype = dtype_from_string(props["column_info"]["dtype"])
+                dtype = dtype() if isinstance(dtype, DataTypeClass) else dtype
+                return dtype
         if "type" not in props:
             if "enum" in props:
                 raise TypeError("Mixed type enums not supported by patito.")
@@ -231,6 +223,8 @@ class DtypeResolver:
                 )
             return None
         pyd_type = props.get("type")
+        if pyd_type == "numeric":
+            pyd_type = "number"
         if pyd_type == "array":
             if "items" not in props:
                 raise NotImplementedError(

patito/_pydantic/dtypes/utils.py

@@ -15,12 +15,13 @@ from typing import (
 )
 
 import polars as pl
-from polars.datatypes import DataType, DataTypeClass, DataTypeGroup, convert
-from polars.datatypes.constants import (
+from polars.datatypes import DataType, DataTypeClass, convert
+from polars.datatypes.group import (
     DATETIME_DTYPES,
     DURATION_DTYPES,
     FLOAT_DTYPES,
     INTEGER_DTYPES,
+    DataTypeGroup,
 )
 from polars.polars import (
     dtype_str_repr,  # TODO: this is a rust function, can we implement our own string parser for Time/Duration/Datetime?
@@ -78,11 +79,9 @@ def is_optional(type_annotation: type[Any] | Any | None) -> bool:
     """Return True if the given type annotation is an Optional annotation.
 
     Args:
-    ----
         type_annotation: The type annotation to be checked.
 
     Returns:
-    -------
         True if the outermost type is Optional.
 
     """
@@ -92,8 +91,8 @@ def is_optional(type_annotation: type[Any] | Any | None) -> bool:
 
 
 def parse_composite_dtype(dtype: DataTypeClass | DataType) -> str:
-    """For serialization, converts polars dtype to string representation"""
-    if dtype in pl.NESTED_DTYPES:
+    """For serialization, converts polars dtype to string representation."""
+    if dtype.is_nested():
         if dtype == pl.Struct or isinstance(dtype, pl.Struct):
             raise NotImplementedError("Structs not yet supported by patito")
         if not isinstance(dtype, pl.List) or isinstance(dtype, pl.Array):
@@ -103,14 +102,14 @@ def parse_composite_dtype(dtype: DataTypeClass | DataType) -> str:
         if dtype.inner is None:
             return convert.DataTypeMappings.DTYPE_TO_FFINAME[dtype.base_type()]
         return f"{convert.DataTypeMappings.DTYPE_TO_FFINAME[dtype.base_type()]}[{parse_composite_dtype(dtype.inner)}]"
-    elif dtype in pl.TEMPORAL_DTYPES:
+    elif dtype.is_temporal():
         return cast(str, dtype_str_repr(dtype))
     else:
         return convert.DataTypeMappings.DTYPE_TO_FFINAME[dtype]
 
 
 def dtype_from_string(v: str) -> Optional[Union[DataTypeClass, DataType]]:
-    """For deserialization"""
+    """For deserialization."""
     # TODO test all dtypes
     return convert.dtype_short_repr_to_dtype(v)
 

patito/_pydantic/repr.py

@@ -82,7 +82,7 @@ class Representation:
     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"""
+        """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__():
@@ -101,7 +101,7 @@ class Representation:
         return f'{self.__repr_name__()}({self.__repr_str__(", ")})'
 
     def __rich_repr__(self) -> "RichReprResult":
-        """Get fields for Rich library"""
+        """Get fields for Rich library."""
         for name, field_repr in self.__repr_args__():
             if name is None:
                 yield field_repr

patito/_pydantic/schema.py

@@ -16,14 +16,12 @@ if TYPE_CHECKING:
 def schema_for_model(cls: Type[ModelType]) -> Dict[str, Dict[str, Any]]:
     """Return schema properties where definition references have been resolved.
 
-    Returns
-    -------
+    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
-    ------
+    Raises:
         TypeError: if a field is annotated with an enum where the values are of
             different types.
 

patito/exceptions.py

@@ -1,3 +1,5 @@
+"""Exceptions used by patito."""
+
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -34,19 +36,24 @@ __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())]
 
 
@@ -56,19 +63,24 @@ 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 (
@@ -77,6 +89,7 @@ class DataFrameValidationError(Representation, ValueError):
         )
 
     def __repr_args__(self) -> "ReprArgs":
+        """Pydantic repr."""
         return [("model", self.model.__name__), ("errors", self.errors())]