dyff-schema 0.29.0__py3-none-any.whl → 0.30.1__py3-none-any.whl

dyff/schema/__init__.py

@@ -55,8 +55,8 @@ def upcast(
     if not isinstance(obj, dict):
         # Preserve the unset status
         obj = obj.dict(exclude_unset=True)
-    fields = {k: v for k, v in obj.items() if k in t.__fields__}
-    return t.parse_obj(fields)
+    fields = {k: v for k, v in obj.items() if k in t.model_fields}
+    return t.model_validate(fields)
 
 
 __all__ = [

dyff/schema/_version.py

@@ -0,0 +1,2 @@
+__version__ = version = "0.30.1"
+__version_tuple__ = version_tuple = (0, 30, 1)

dyff/schema/copydoc.py

@@ -24,7 +24,7 @@ def copydoc(fromfunc):
         else:
             sourcedoc = fromfunc.__doc__
 
-        if func.__doc__ == None:
+        if func.__doc__ is None:
             func.__doc__ = sourcedoc
         else:
             func.__doc__ = f"{sourcedoc}\n\n{func.__doc__}"

dyff/schema/v0/r1/adapters.py

@@ -789,7 +789,7 @@ def known_adapters() -> dict[str, Type[Adapter]]:
 
 def create_adapter(adapter_spec: SchemaAdapter | dict) -> Adapter:
     if isinstance(adapter_spec, SchemaAdapter):
-        adapter_spec = adapter_spec.dict()
+        adapter_spec = adapter_spec.model_dump()
     kind = adapter_spec["kind"]
     if (adapter_t := known_adapters().get(kind)) is not None:
         adapter_config = adapter_spec.get("configuration")
@@ -1024,7 +1024,7 @@ def _test():
             SchemaAdapter(
                 kind="ExplodeCollections",
                 configuration={"collections": ["text"]},
-            ).dict()
+            ).model_dump()
         ]
     )
 

dyff/schema/v0/r1/base.py

@@ -3,14 +3,13 @@
 
 from __future__ import annotations
 
-import json
 from datetime import datetime, timezone
-from typing import Any, Generic, Literal, NamedTuple, Optional, Type, TypeVar
+from typing import Any, Mapping, NamedTuple, Optional, Type, TypeVar
 
 import pydantic
-
-# ----------------------------------------------------------------------------
-# Fixed-width numeric type value bounds
+from pydantic import ConfigDict, Field, GetCoreSchemaHandler, GetJsonSchemaHandler
+from pydantic_core import CoreSchema, core_schema
+from typing_extensions import Annotated
 
 
 class _dtype(NamedTuple):
@@ -109,174 +108,52 @@ _NumT = TypeVar("_NumT")
 _ConstrainedNumT = TypeVar("_ConstrainedNumT")
 
 
-class FixedWidthNumberMeta(
-    Generic[_NumT, _ConstrainedNumT], pydantic.types.ConstrainedNumberMeta
-):
-    dtype: str
-    minval: _NumT
-    maxval: _NumT
-
-    def __new__(cls, name: str, bases: Any, dct: dict[str, Any]) -> _ConstrainedNumT:  # type: ignore
-        ge = dct.get("ge")
-        gt = dct.get("gt")
-        le = dct.get("le")
-        lt = dct.get("lt")
-        # For integers, we could technically have e.g., ``lt = maxval + 1``,
-        # but then the bound is not representable in the same type, so we don't
-        # allow it
-        if ge is not None and ge < cls.minval:
-            raise ValueError(f"ge must be >= minval")
-        if gt is not None and gt < cls.minval:
-            raise ValueError(f"gt must be >= minval")
-        if le is not None and le > cls.maxval:
-            raise ValueError(f"le must be <= maxval")
-        if lt is not None and lt > cls.maxval:
-            raise ValueError(f"lt must be <= maxval")
-        # Note that the ConstrainedNumberMeta superclass checks that only one
-        # each of ge/gt and le/lt is defined
-        if ge is None and gt is None:
-            ge = cls.minval  # default
-        if le is None and lt is None:
-            le = cls.maxval  # default
-        # pydantic convention seems to be not to add None properties here
-        if ge is not None:
-            dct["ge"] = ge
-        if gt is not None:
-            dct["gt"] = gt
-        if le is not None:
-            dct["le"] = le
-        if lt is not None:
-            dct["lt"] = lt
-        return super().__new__(cls, name, bases, dct)  # type: ignore
-
-
 class DType:
     """Base class for pydantic custom types that have an Arrow .dtype."""
 
     @classmethod
-    def __modify_schema__(
-        cls,
-        field_schema: dict[str, Any],
-    ) -> None:
-        dtype = type(cls).dtype  # type: ignore
+    # TODO[pydantic]: We couldn't refactor `__modify_schema__`, please create the `__get_pydantic_json_schema__` manually.
+    # Check https://docs.pydantic.dev/latest/migration/#defining-custom-types for more information.
+    @classmethod
+    def __get_pydantic_json_schema__(
+        cls, _core_schema: CoreSchema, handler: GetJsonSchemaHandler
+    ):
+        """Custom JSON schema generation for DType."""
+        json_schema = handler(_core_schema)
+        dtype = getattr(cls, "dtype", None)
         if dtype is None:
             raise ValueError("subclasses must set cls.dtype")
-        super().__modify_schema__(field_schema)  # type: ignore
-        field_schema.update({"dyff.io/dtype": dtype})
-
-
-# DType must come first
-class FixedWidthInt(DType, pydantic.ConstrainedInt):
-    pass
-
-
-# DType must come first
-class FixedWidthFloat(DType, pydantic.ConstrainedFloat):
-    pass
-
-
-class Float32Meta(FixedWidthNumberMeta[float, pydantic.ConstrainedFloat]):
-    dtype: str = DTYPE.float32
-    minval: float = -float32_max()
-    maxval: float = float32_max()
-
-
-class Float64Meta(FixedWidthNumberMeta[float, pydantic.ConstrainedFloat]):
-    dtype: str = DTYPE.float64
-    minval: float = -float64_max()
-    maxval: float = float64_max()
-
-
-class Float32(FixedWidthFloat, metaclass=Float32Meta):
-    """A 32-bit float ("single precision")"""
-
-
-class Float64(FixedWidthFloat, metaclass=Float64Meta):
-    """A 64-bit float ("double precision")"""
-
-
-class Int8Meta(FixedWidthNumberMeta[int, pydantic.ConstrainedInt]):
-    dtype: str = DTYPE.int8
-    minval: int = int8_min()
-    maxval: int = int8_max()
-
-
-class Int16Meta(FixedWidthNumberMeta[int, pydantic.ConstrainedInt]):
-    dtype: str = DTYPE.int16
-    minval: int = int16_min()
-    maxval: int = int16_max()
-
-
-class Int32Meta(FixedWidthNumberMeta[int, pydantic.ConstrainedInt]):
-    dtype: str = DTYPE.int32
-    minval: int = int32_min()
-    maxval: int = int32_max()
-
-
-class Int64Meta(FixedWidthNumberMeta[int, pydantic.ConstrainedInt]):
-    dtype: str = DTYPE.int64
-    minval: int = int64_min()
-    maxval: int = int64_max()
-
-
-class UInt8Meta(FixedWidthNumberMeta[int, pydantic.ConstrainedInt]):
-    dtype: str = DTYPE.uint8
-    minval: int = uint8_min()
-    maxval: int = uint8_max()
-
-
-class UInt16Meta(FixedWidthNumberMeta[int, pydantic.ConstrainedInt]):
-    dtype: str = DTYPE.uint16
-    minval: int = uint16_min()
-    maxval: int = uint16_max()
-
-
-class UInt32Meta(FixedWidthNumberMeta[int, pydantic.ConstrainedInt]):
-    dtype: str = DTYPE.uint32
-    minval: int = uint32_min()
-    maxval: int = uint32_max()
-
-
-class UInt64Meta(FixedWidthNumberMeta[int, pydantic.ConstrainedInt]):
-    dtype: str = DTYPE.uint64
-    minval: int = uint64_min()
-    maxval: int = uint64_max()
-
-
-class Int8(FixedWidthInt, metaclass=Int8Meta):
-    """An 8-bit integer."""
-
-
-class Int16(FixedWidthInt, metaclass=Int16Meta):
-    """A 16-bit integer."""
-
-
-class Int32(FixedWidthInt, metaclass=Int32Meta):
-    """A 32-bit integer."""
-
-
-class Int64(FixedWidthInt, metaclass=Int64Meta):
-    """A 64-bit integer."""
-
-
-class UInt8(FixedWidthInt, metaclass=UInt8Meta):
-    """An 8-bit unsigned integer."""
-
-
-class UInt16(FixedWidthInt, metaclass=UInt16Meta):
-    """A 16-bit unsigned integer."""
-
-
-class UInt32(FixedWidthInt, metaclass=UInt32Meta):
-    """A 32-bit unsigned integer."""
-
-
-class UInt64(FixedWidthInt, metaclass=UInt64Meta):
-    """A 64-bit unsigned integer."""
-
+        json_schema["dyff.io/dtype"] = dtype
+        return json_schema
+
+
+def constrained_type(
+    _name: str, _dtype: str, base_type: type, **field_constraints: Any
+) -> Type:
+    float_annotated_type = Annotated[
+        base_type,  # type: ignore [valid-type]
+        Field(**field_constraints, json_schema_extra={"dyff.io/dtype": _dtype}),
+    ]
+
+    def __get_pydantic_core_schema__(
+        cls, source_type: Any, handler: GetCoreSchemaHandler
+    ) -> CoreSchema:
+        if issubclass(base_type, float):
+            schema: CoreSchema = core_schema.float_schema(**field_constraints)
+        elif issubclass(base_type, int):
+            schema = core_schema.int_schema(**field_constraints)
+        else:
+            raise TypeError(f"Unsupported base_type: {base_type}")
+        return core_schema.no_info_after_validator_function(cls.val_type, schema)
 
-# ----------------------------------------------------------------------------
-# Type annotation constructors
+    namespace = {
+        "val_type": float_annotated_type,
+        "name": _name,
+        "__get_pydantic_core_schema__": classmethod(__get_pydantic_core_schema__),
+        "dtype": _dtype,
+        "description": f"A {base_type.__name__} with constraints {field_constraints}",
+    }
+    return type(_name, (base_type,), namespace)
 
 
 def float32(
@@ -310,7 +187,7 @@ def float32(
         multiple_of=multiple_of,
         allow_inf_nan=allow_inf_nan,
     )
-    return type("Float32Value", (Float32,), namespace)
+    return constrained_type("Float32Value", DTYPE.float32, float, **namespace)
 
 
 def float64(
@@ -344,7 +221,7 @@ def float64(
         multiple_of=multiple_of,
         allow_inf_nan=allow_inf_nan,
     )
-    return type("Float64Value", (Float64,), namespace)
+    return constrained_type("Float64Value", DTYPE.float64, float, **namespace)
 
 
 def int8(
@@ -369,7 +246,7 @@ def int8(
             x: int8(lt=42) = pydantic.Field(description="some field")
     """
     namespace = dict(strict=strict, gt=gt, ge=ge, lt=lt, le=le, multiple_of=multiple_of)
-    return type("Int8Value", (Int8,), namespace)
+    return constrained_type("Int8Value", DTYPE.int8, int, **namespace)
 
 
 def int16(
@@ -394,7 +271,7 @@ def int16(
             x: int16(lt=42) = pydantic.Field(description="some field")
     """
     namespace = dict(strict=strict, gt=gt, ge=ge, lt=lt, le=le, multiple_of=multiple_of)
-    return type("Int16Value", (Int16,), namespace)
+    return constrained_type("Int16Value", DTYPE.int16, int, **namespace)
 
 
 def int32(
@@ -419,7 +296,7 @@ def int32(
             x: int32(lt=42) = pydantic.Field(description="some field")
     """
     namespace = dict(strict=strict, gt=gt, ge=ge, lt=lt, le=le, multiple_of=multiple_of)
-    return type("Int32Value", (Int32,), namespace)
+    return constrained_type("Int32Value", DTYPE.int32, int, **namespace)
 
 
 def int64(
@@ -444,7 +321,7 @@ def int64(
             x: int64(lt=42) = pydantic.Field(description="some field")
     """
     namespace = dict(strict=strict, gt=gt, ge=ge, lt=lt, le=le, multiple_of=multiple_of)
-    return type("Int64Value", (Int64,), namespace)
+    return constrained_type("Int64Value", DTYPE.int64, int, **namespace)
 
 
 def uint8(
@@ -469,7 +346,7 @@ def uint8(
             x: uint8(lt=42) = pydantic.Field(description="some field")
     """
     namespace = dict(strict=strict, gt=gt, ge=ge, lt=lt, le=le, multiple_of=multiple_of)
-    return type("UInt8Value", (UInt8,), namespace)
+    return constrained_type("UInt8Value", DTYPE.uint8, int, **namespace)
 
 
 def uint16(
@@ -494,7 +371,7 @@ def uint16(
             x: uint16(lt=42) = pydantic.Field(description="some field")
     """
     namespace = dict(strict=strict, gt=gt, ge=ge, lt=lt, le=le, multiple_of=multiple_of)
-    return type("UInt16Value", (UInt16,), namespace)
+    return constrained_type("UInt16Value", DTYPE.uint16, int, **namespace)
 
 
 def uint32(
@@ -519,7 +396,7 @@ def uint32(
             x: uint32(lt=42) = pydantic.Field(description="some field")
     """
     namespace = dict(strict=strict, gt=gt, ge=ge, lt=lt, le=le, multiple_of=multiple_of)
-    return type("UInt32Value", (UInt32,), namespace)
+    return constrained_type("UInt32Value", DTYPE.uint32, int, **namespace)
 
 
 def uint64(
@@ -544,40 +421,21 @@ def uint64(
             x: uint64(lt=42) = pydantic.Field(description="some field")
     """
     namespace = dict(strict=strict, gt=gt, ge=ge, lt=lt, le=le, multiple_of=multiple_of)
-    return type("UInt64Value", (UInt64,), namespace)
+    return constrained_type("UInt64Value", DTYPE.uint64, int, **namespace)
 
 
 _ListElementT = TypeVar("_ListElementT")
 
 
 def list_(
-    item_type: Type[_ListElementT], *, list_size: Optional[int] = None
-) -> Type[list]:
+    item_type: type[_ListElementT], *, list_size: Optional[int] = None
+) -> type[list]:
     if list_size is None:
-        return pydantic.conlist(item_type)
+        return Annotated[list[item_type], Field()]  # type: ignore [return-value, valid-type]
     else:
         if list_size <= 0:
             raise ValueError(f"list_size {list_size} must be > 0")
-        return pydantic.conlist(item_type, min_items=list_size, max_items=list_size)
-
-
-class Null:
-    """Use this type in a Union to make Pydantic generate a JSON Schema that accepts
-    'null' for the field value."""
-
-    @classmethod
-    def __get_validators__(cls):  # -> Generator[Callable, None, None]:
-        yield cls.validate
-
-    @classmethod
-    def validate(cls, value: Any, field: pydantic.fields.ModelField) -> None:
-        if value is not None:
-            raise ValueError()
-        return None
-
-    @classmethod
-    def __modify_schema__(cls, field_schema: dict[str, Any]) -> None:
-        field_schema["type"] = "null"
+        return Annotated[list[item_type], Field(min_length=list_size, max_length=list_size)]  # type: ignore [return-value, valid-type]
 
 
 # mypy gets confused because 'dict' is the name of a method in DyffBaseModel
@@ -593,8 +451,7 @@ class DyffBaseModel(pydantic.BaseModel):
     Python reserved words like 'bytes' as field names.
     """
 
-    class Config:
-        extra = pydantic.Extra.forbid
+    model_config = ConfigDict(extra="forbid")
 
     # TODO: (DYFF-223) I think that exclude_unset=True should be the default
     # for all schema objects, but I'm unsure of the consequences of making
@@ -602,31 +459,28 @@ class DyffBaseModel(pydantic.BaseModel):
     def dict(
         self, *, by_alias: bool = True, exclude_none: bool = True, **kwargs
     ) -> _ModelAsDict:
-        return super().dict(by_alias=by_alias, exclude_none=exclude_none, **kwargs)
+        return self.model_dump(by_alias=by_alias, exclude_none=exclude_none, **kwargs)
 
     def json(
         self, *, by_alias: bool = True, exclude_none: bool = True, **kwargs
     ) -> str:
-        return super().json(by_alias=by_alias, exclude_none=exclude_none, **kwargs)
+        return self.model_dump_json(
+            by_alias=by_alias, exclude_none=exclude_none, **kwargs
+        )
 
-    def model_dump(
-        self,
-        *,
-        mode: Literal["python", "json"] = "python",
-        **kwargs,
+    def model_dump(  # type: ignore [override]
+        self, *, by_alias: bool = True, exclude_none: bool = True, **kwargs
     ) -> _ModelAsDict:
-        """Encode the object as a dict containing only JSON datatypes.
-
-        .. deprecated:: 0.8.0
+        return super().model_dump(
+            by_alias=by_alias, exclude_none=exclude_none, **kwargs
+        )
 
-            FIXME: This emulates a Pydantic 2 feature, but the mode="json"
-            option can only be implemented in an inefficient way. Remove when
-            we convert to Pydantic 2. See: DYFF-223
-        """
-        if mode == "python":
-            return self.dict(**kwargs)
-        else:
-            return json.loads(self.json(**kwargs))
+    def model_dump_json(  # type: ignore [override]
+        self, *, by_alias: bool = True, exclude_none: bool = True, **kwargs
+    ) -> str:
+        return super().model_dump_json(
+            by_alias=by_alias, exclude_none=exclude_none, **kwargs
+        )
 
 
 # Note: I *really* wanted to require datetimes to have timezones, like in
@@ -645,16 +499,18 @@ class DyffSchemaBaseModel(DyffBaseModel):
     datetimes are well-ordered.
     """
 
-    @pydantic.root_validator
+    @pydantic.model_validator(mode="after")
     def _ensure_datetime_timezone_utc(cls, values):
-        update = {}
-        for k, v in values.items():
-            if isinstance(v, datetime):
-                if v.tzinfo is None:
-                    update[k] = v.replace(tzinfo=timezone.utc)
-                elif v.tzinfo != timezone.utc:
-                    update[k] = v.astimezone(timezone.utc)
-        values.update(update)
+        for field_name, field_value in values.__dict__.items():
+            if isinstance(field_value, datetime):
+                if field_value.tzinfo is None:
+                    # Set UTC timezone for naive datetime
+                    setattr(
+                        values, field_name, field_value.replace(tzinfo=timezone.utc)
+                    )
+                elif field_value.tzinfo != timezone.utc:
+                    # Convert to UTC timezone
+                    setattr(values, field_name, field_value.astimezone(timezone.utc))
         return values
 
 
@@ -666,18 +522,93 @@ class JsonMergePatchSemantics(DyffSchemaBaseModel):
     means "leave this field unchanged".
     """
 
-    def dict(
-        self, *, by_alias: bool = True, exclude_unset=True, exclude_none=False, **kwargs
+    @classmethod
+    def __pydantic_init_subclass__(cls, **kwargs):
+        """This method runs automatically when ANY class inherits from
+        JsonMergePatchSemantics."""
+        super().__pydantic_init_subclass__(**kwargs)
+
+        current_config = getattr(cls, "model_config", {})
+        if hasattr(current_config, "copy"):
+            current_config = current_config.copy()
+        else:
+            current_config = dict(current_config) if current_config else {}
+
+        existing_json_schema_extra = current_config.get("json_schema_extra", None)
+
+        def remove_defaults_from_schema(schema: dict, model_type: type) -> None:
+            if existing_json_schema_extra:
+                if callable(existing_json_schema_extra):
+                    existing_json_schema_extra(schema, model_type)
+                elif isinstance(existing_json_schema_extra, dict):
+                    schema.update(existing_json_schema_extra)
+
+            properties = schema.get("properties", {})
+            for field_name, field_schema in properties.items():
+                if isinstance(field_schema, dict) and "default" in field_schema:
+                    field_schema.pop("default")
+
+        current_config["json_schema_extra"] = remove_defaults_from_schema
+        cls.model_config = current_config
+
+    def dict(  # type: ignore [override]
+        self,
+        *,
+        by_alias: bool = True,
+        exclude_unset=True,
+        exclude_none=False,
+        **kwargs: Mapping[str, Any],
     ) -> _ModelAsDict:
-        return super().dict(
-            by_alias=by_alias, exclude_unset=True, exclude_none=False, **kwargs
+        return self.model_dump(
+            by_alias=by_alias,
+            exclude_unset=exclude_unset,
+            exclude_none=exclude_none,
+            **kwargs,
         )
 
-    def json(
-        self, *, by_alias: bool = True, exclude_unset=True, exclude_none=False, **kwargs
+    def json(  # type: ignore [override]
+        self,
+        *,
+        by_alias: bool = True,
+        exclude_unset: bool = True,
+        exclude_none: bool = False,
+        **kwargs: Mapping[str, Any],
+    ) -> str:
+        return self.model_dump_json(
+            by_alias=by_alias,
+            exclude_unset=exclude_unset,
+            exclude_none=exclude_none,
+            **kwargs,
+        )
+
+    def model_dump(  # type: ignore [override]
+        self,
+        *,
+        by_alias: bool = True,
+        exclude_unset: bool = True,
+        exclude_none: bool = False,
+        **kwargs: Mapping[str, Any],
+    ) -> _ModelAsDict:
+        return super().model_dump(
+            by_alias=by_alias,
+            exclude_unset=exclude_unset,
+            exclude_none=exclude_none,
+            **kwargs,
+        )
+
+    def model_dump_json(  # type: ignore [override]
+        self,
+        *,
+        by_alias: bool = True,
+        exclude_unset: bool = True,
+        exclude_none: bool = False,
+        **kwargs: Mapping[str, Any],
     ) -> str:
-        return super().json(
-            by_alias=by_alias, exclude_unset=True, exclude_none=False, **kwargs
+        return super().model_dump_json(
+            by_alias=by_alias,
+            exclude_unset=exclude_unset,
+            exclude_none=exclude_none,
+            **kwargs,
         )
 
 
@@ -686,20 +617,7 @@ __all__ = [
     "DType",
     "DyffBaseModel",
     "DyffSchemaBaseModel",
-    "FixedWidthFloat",
-    "FixedWidthInt",
-    "Float32",
-    "Float64",
-    "Int8",
-    "Int16",
-    "Int32",
-    "Int64",
     "JsonMergePatchSemantics",
-    "Null",
-    "UInt8",
-    "UInt16",
-    "UInt32",
-    "UInt64",
     "float32",
     "float32_max",
     "float64",