patito 0.6.2__tar.gz → 0.7.0__tar.gz

{patito-0.6.2 → patito-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: patito
-Version: 0.6.2
+Version: 0.7.0
 Summary: A dataframe modelling library built on top of polars and pydantic.
 Home-page: https://github.com/JakobGM/patito
 License: MIT
@@ -18,9 +18,9 @@ Provides-Extra: docs
 Provides-Extra: pandas
 Requires-Dist: Sphinx (<7) ; extra == "docs"
 Requires-Dist: pandas ; extra == "pandas"
-Requires-Dist: polars (>=0.20.1)
+Requires-Dist: polars (>=1.0.0)
 Requires-Dist: pyarrow (>=5.0.0) ; extra == "caching"
-Requires-Dist: pydantic (>=2.4.1)
+Requires-Dist: pydantic (>=2.7.0)
 Requires-Dist: sphinx-autobuild ; extra == "docs"
 Requires-Dist: sphinx-autodoc-typehints ; extra == "docs"
 Requires-Dist: sphinx-rtd-theme ; extra == "docs"

{patito-0.6.2 → patito-0.7.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "patito"
-version = "0.6.2"
+version = "0.7.0"
 description = "A dataframe modelling library built on top of polars and pydantic."
 authors = ["Jakob Gerhard Martinussen <jakobgm@gmail.com>"]
 license = "MIT"
@@ -12,8 +12,8 @@ keywords = ["validation", "dataframe"]
 
 [tool.poetry.dependencies]
 python = ">=3.9"
-pydantic = ">=2.4.1"
-polars = ">=0.20.1"
+pydantic = ">=2.7.0"
+polars = ">=1.0.0"
 # Required for typing.get_args backports in python3.9 and 3.10
 typing-extensions = "*"
 pandas = {version = "*", optional = true}
@@ -59,6 +59,7 @@ types-setuptools = ">=57.4.14"
 pandas-stubs = ">=1.2.0"
 codecov = "^2.1.12"
 blackdoc = "*"
+ipykernel = "^6.29.4"
 
 
 [tool.poetry.group.docs.dependencies]

{patito-0.6.2 → patito-0.7.0}/src/patito/_pydantic/column_info.py

@@ -71,7 +71,7 @@ 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.serialize(None)
+                expr.meta.serialize(format="json")
             )  # can we access the dictionary directly?
         else:
             raise ValueError(f"Invalid type for expr: {type(expr)}")

{patito-0.6.2 → patito-0.7.0}/src/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 (
@@ -222,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-0.6.2 → patito-0.7.0}/src/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?
@@ -91,7 +92,7 @@ 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:
+    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):
@@ -101,7 +102,7 @@ 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]

{patito-0.6.2 → patito-0.7.0}/src/patito/polars.py

@@ -20,7 +20,7 @@ from typing import (
 )
 
 import polars as pl
-from polars.type_aliases import IntoExpr
+from polars._typing import IntoExpr
 from pydantic import AliasChoices, AliasPath, create_model
 
 from patito._pydantic.column_info import ColumnInfo
@@ -130,7 +130,7 @@ class LazyFrame(pl.LazyFrame, Generic[ModelType]):
         """
         derived_columns = []
         props = self.model._schema_properties()
-        original_columns = set(self.columns)
+        original_columns = set(self.collect_schema())
         to_derive = self.model.derived_columns if columns is None else columns
         for column_name in to_derive:
             if column_name not in derived_columns:
@@ -193,15 +193,15 @@ class LazyFrame(pl.LazyFrame, Generic[ModelType]):
 
         def to_expr(va: str | AliasPath | AliasChoices) -> Optional[pl.Expr]:
             if isinstance(va, str):
-                return pl.col(va) if va in self.columns else None
+                return pl.col(va) if va in self.collect_schema() else None
             elif isinstance(va, AliasPath):
                 if len(va.path) != 2 or not isinstance(va.path[1], int):
                     raise NotImplementedError(
                         f"TODO figure out how this AliasPath behaves ({va})"
                     )
                 return (
-                    pl.col(va.path[0]).list.get(va.path[1])
-                    if va.path[0] in self.columns
+                    pl.col(va.path[0]).list.get(va.path[1], null_on_oob=True)
+                    if va.path[0] in self.collect_schema()
                     else None
                 )
             elif isinstance(va, AliasChoices):
@@ -224,7 +224,7 @@ class LazyFrame(pl.LazyFrame, Generic[ModelType]):
                 exprs.append(pl.col(name))
             else:
                 expr = to_expr(field_info.validation_alias)
-                if name in self.columns:
+                if name in self.collect_schema().names():
                     if expr is None:
                         exprs.append(pl.col(name))
                     else:
@@ -278,9 +278,9 @@ class LazyFrame(pl.LazyFrame, Generic[ModelType]):
         properties = self.model._schema_properties()
         valid_dtypes = self.model.valid_dtypes
         default_dtypes = self.model.dtypes
-        columns = columns or self.columns
+        columns = columns or self.collect_schema().names()
         exprs = []
-        for column, current_dtype in zip(self.columns, self.dtypes):
+        for column, current_dtype in self.collect_schema().items():
             if (column not in columns) or (column not in properties):
                 exprs.append(pl.col(column))
             elif "dtype" in properties[column]:
@@ -865,7 +865,7 @@ class DataFrame(pl.DataFrame, Generic[ModelType]):
             # └─────┴─────┘
 
         """
-        kwargs.setdefault("dtypes", cls.model.dtypes)
+        kwargs.setdefault("schema_overrides", cls.model.dtypes)
         has_header = kwargs.get("has_header", True)
         if not has_header and "columns" not in kwargs:
             kwargs.setdefault("new_columns", cls.model.columns)
@@ -877,9 +877,9 @@ class DataFrame(pl.DataFrame, Generic[ModelType]):
                 field_name: alias_func(field_name)
                 for field_name in cls.model.model_fields
             }
-            kwargs["dtypes"] = {
+            kwargs["schema_overrides"] = {
                 fields_to_cols.get(field, field): dtype
-                for field, dtype in kwargs["dtypes"].items()
+                for field, dtype in kwargs["schema_overrides"].items()
             }
             # TODO: other forms of alias setting like in Field
         df = cls.model.DataFrame._from_pydf(pl.read_csv(*args, **kwargs)._df)

{patito-0.6.2 → patito-0.7.0}/src/patito/pydantic.py

@@ -1200,7 +1200,7 @@ class Model(BaseModel, metaclass=ModelMetaclass):
                     field_type = Optional[field_type]
                 new_fields[new_field_name] = (field_type, field_definition[1])
         return create_model(  # type: ignore
-            __model_name=model_name,
+            model_name,
             __base__=Model,
             **new_fields,
         )