openepd 6.13.2__py3-none-any.whl → 7.0.0__py3-none-any.whl

openepd/api/pcr/sync_api.py

@@ -30,7 +30,7 @@ class PcrApi(BaseApiMethodGroup):
         :raise ValidationError: if openxpd_uuid is invalid
         """
         content = self._client.do_request("get", f"/pcrs/{uuid}").json()
-        return Pcr.parse_obj(content)
+        return Pcr.model_validate(content)
 
     def create(self, pcr: Pcr) -> PcrRef:
         """
@@ -41,4 +41,4 @@ class PcrApi(BaseApiMethodGroup):
         :raise ValidationError: if given object PCR is invalid
         """
         pcr_ref_obj = self._client.do_request("post", "/pcrs", json=pcr.to_serializable()).json()
-        return PcrRef.parse_obj(pcr_ref_obj)
+        return PcrRef.model_validate(pcr_ref_obj)

openepd/bundle/model.py

@@ -16,7 +16,8 @@
 from datetime import datetime
 from enum import StrEnum
 
-from openepd.compat.pydantic import pyd
+import pydantic
+
 from openepd.model.base import BaseOpenEpdSchema
 
 
@@ -29,7 +30,7 @@ class BundleManifestAssetsStats(BaseOpenEpdSchema):
     total_size: int = 0
     """The total size of assets in bytes."""
 
-    count_by_type: dict[str, int] = pyd.Field(default_factory=dict)
+    count_by_type: dict[str, int] = pydantic.Field(default_factory=dict)
     """The number of assets by type."""
 
 
@@ -60,9 +61,9 @@ class BundleManifest(BaseOpenEpdSchema):
     """The format of the bundle."""
     generator: str
     """The generator of the bundle."""
-    assets: BundleManifestAssetsStats = pyd.Field(default_factory=BundleManifestAssetsStats)
-    comment: str | None = pyd.Field(default=None)
-    created_at: datetime = pyd.Field(default_factory=datetime.utcnow)
+    assets: BundleManifestAssetsStats = pydantic.Field(default_factory=BundleManifestAssetsStats)
+    comment: str | None = pydantic.Field(default=None)
+    created_at: datetime = pydantic.Field(default_factory=datetime.utcnow)
     """The date and time when the bundle was generated."""
 
 
@@ -79,8 +80,8 @@ class AssetInfo(BaseOpenEpdSchema):
     """The language of the asset."""
     rel_type: str | None
     rel_asset: str | None
-    comment: str | None = pyd.Field(default=None)
-    content_type: str | None = pyd.Field(default=None)
-    size: int | None = pyd.Field(default=None)
-    custom_type: str | None = pyd.Field(default=None)
-    custom_data: str | None = pyd.Field(default=None)
+    comment: str | None = pydantic.Field(default=None)
+    content_type: str | None = pydantic.Field(default=None)
+    size: int | None = pydantic.Field(default=None)
+    custom_type: str | None = pydantic.Field(default=None)
+    custom_data: str | None = pydantic.Field(default=None)

openepd/bundle/reader.py

@@ -31,7 +31,7 @@ class DefaultBundleReader(BaseBundleReader):
         self._bundle_archive = zipfile.ZipFile(bundle_file, mode="r")
         try:
             with self._bundle_archive.open("manifest", "r") as manifest_stream:
-                self.__manifest = BundleManifest.parse_raw(manifest_stream.read())
+                self.__manifest = BundleManifest.model_validate_json(manifest_stream.read())
         except Exception as e:
             raise ValueError("The bundle file is not valid. Manifest reading error: " + str(e)) from e
         try:
@@ -45,7 +45,7 @@ class DefaultBundleReader(BaseBundleReader):
 
     def get_manifest(self) -> BundleManifest:
         """Get the manifest of the bundle. Manifest object is immutable."""
-        return self.__manifest.copy(deep=True)
+        return self.__manifest.model_copy(deep=True)
 
     def __create_asset_filter(
         self,
@@ -71,7 +71,14 @@ class DefaultBundleReader(BaseBundleReader):
         return _filter
 
     def __preprocess_csv_dict(self, input_dict: dict[str, str | None]) -> dict[str, str | None]:
-        default_to_none_fields = ("rel_type", "rel_asset", "lang", "content_type", "custom_type", "custom_data")
+        default_to_none_fields = (
+            "rel_type",
+            "rel_asset",
+            "lang",
+            "content_type",
+            "custom_type",
+            "custom_data",
+        )
         for x in default_to_none_fields:
             if input_dict[x] == "":
                 input_dict[x] = None
@@ -82,7 +89,7 @@ class DefaultBundleReader(BaseBundleReader):
         with self._bundle_archive.open("toc", "r") as toc_stream:
             toc_reader = csv.DictReader(io.TextIOWrapper(toc_stream, encoding="utf-8"), dialect="toc")
             for x in toc_reader:
-                yield AssetInfo.parse_obj(self.__preprocess_csv_dict(x))
+                yield AssetInfo.model_validate(self.__preprocess_csv_dict(x))
 
     def __check_toc(self):
         with self._bundle_archive.open("toc", "r") as toc_stream:
@@ -154,4 +161,4 @@ class DefaultBundleReader(BaseBundleReader):
         if asset.type != obj_class.get_asset_type():
             raise ValueError(f"Asset type mismatch. Expected {obj_class.get_asset_type()}, got {asset.type}")
         with self._bundle_archive.open(asset.ref, "r") as asset_stream:
-            return obj_class.parse_raw(asset_stream.read())
+            return obj_class.model_validate_json(asset_stream.read())

openepd/bundle/writer.py

@@ -61,7 +61,9 @@ class DefaultBundleWriter(BaseBundleWriter):
         """Write a blob asset to the bundle."""
         rel_ref_str = self._asset_ref_to_str(rel_asset) if rel_asset is not None else None
         ref_str = self.__generate_entry_name(
-            AssetType.Blob, self.__get_ext_for_content_type(content_type, "bin"), file_name
+            AssetType.Blob,
+            self.__get_ext_for_content_type(content_type, "bin"),
+            file_name,
         )
         asset_info = AssetInfo(
             ref=ref_str,
@@ -98,7 +100,9 @@ class DefaultBundleWriter(BaseBundleWriter):
         asset_type = AssetType(asset_type_str)
         rel_ref_str = self._asset_ref_to_str(rel_asset) if rel_asset is not None else None
         ref_str = self.__generate_entry_name(
-            asset_type, self.__get_ext_for_content_type("application/json", "json"), file_name
+            asset_type,
+            self.__get_ext_for_content_type("application/json", "json"),
+            file_name,
         )
         asset_info = AssetInfo(
             ref=ref_str,
@@ -114,7 +118,9 @@ class DefaultBundleWriter(BaseBundleWriter):
         )
         self.__write_data_stream(
             asset_info,
-            BytesIO(obj.json(indent=2, exclude_unset=True, exclude_none=True, by_alias=True).encode("utf-8")),
+            BytesIO(
+                obj.model_dump_json(indent=2, exclude_unset=True, exclude_none=True, by_alias=True).encode("utf-8")
+            ),
         )
         self.__register_entry(asset_info)
         return asset_info
@@ -122,7 +128,7 @@ class DefaultBundleWriter(BaseBundleWriter):
     def commit(self):
         """Write the manifest and TOC to the bundle. This will be called automatically when the bundle is closed."""
         with self._bundle_archive.open("manifest", "w") as manifest_stream:
-            manifest_stream.write(self.__manifest.json(indent=2, exclude_none=True).encode("utf-8"))
+            manifest_stream.write(self.__manifest.model_dump_json(indent=2, exclude_none=True).encode("utf-8"))
         with self._bundle_archive.open("toc", "w") as toc_stream:
             toc_stream.write(self.__toc_buffer.getvalue().encode("utf-8"))
 
@@ -134,7 +140,7 @@ class DefaultBundleWriter(BaseBundleWriter):
     def __register_entry(self, asset_info: AssetInfo):
         if asset_info.ref in self.__added_entries:
             raise ValueError(f"Asset {asset_info.ref} already exists in the bundle.")
-        self._toc_writer.writerow(asset_info.dict(exclude_unset=True, exclude_none=True))
+        self._toc_writer.writerow(asset_info.model_dump(exclude_unset=True, exclude_none=True))
         self.__added_entries.add(asset_info.ref)
         type_counter = self.__manifest.assets.count_by_type.get(asset_info.type, 0) + 1
         self.__manifest.assets.count_by_type[asset_info.type] = type_counter
@@ -143,7 +149,12 @@ class DefaultBundleWriter(BaseBundleWriter):
             raise ValueError("Size of asset is not set.")
         self.__manifest.assets.total_size += asset_info.size
 
-    def __generate_entry_name(self, asset_type: str, extension: str | None = None, file_name: str | None = None) -> str:
+    def __generate_entry_name(
+        self,
+        asset_type: str,
+        extension: str | None = None,
+        file_name: str | None = None,
+    ) -> str:
         current_counter = self.__manifest.assets.count_by_type.get(asset_type, 0)
         current_counter += 1
         if file_name is None:

openepd/model/base.py

@@ -14,17 +14,20 @@
 #  limitations under the License.
 #
 import abc
+from collections.abc import Callable
 from enum import StrEnum
 import json
-from typing import Any, Callable, ClassVar, Generic, Optional, Type, TypeAlias, TypeVar
+from typing import Any, ClassVar, Generic, Optional, Type, TypeAlias, TypeVar
 
-from cqd import open_xpd_uuid  # type:ignore[import-untyped,ignore-not-found]
+from cqd import open_xpd_uuid  # type:ignore[import-untyped]
+import pydantic
+from pydantic import ConfigDict
+import pydantic_core
 
-from openepd.compat.pydantic import pyd, pyd_generics
 from openepd.model.validation.common import validate_version_compatibility, validate_version_format
 from openepd.model.versioning import OpenEpdVersions, Version
 
-AnySerializable: TypeAlias = int | str | bool | float | list | dict | pyd.BaseModel | None
+AnySerializable: TypeAlias = int | str | bool | float | list | dict | pydantic.BaseModel | None
 TAnySerializable = TypeVar("TAnySerializable", bound=AnySerializable)
 
 OPENEPD_VERSION_FIELD = "openepd_version"
@@ -60,29 +63,27 @@ def modify_pydantic_schema(schema_dict: dict, cls: type) -> dict:
     return schema_dict
 
 
-class BaseOpenEpdSchema(pyd.BaseModel):
+class BaseOpenEpdSchema(pydantic.BaseModel):
     """Base class for all OpenEPD models."""
 
-    ext: dict[str, AnySerializable] | None = pyd.Field(alias="ext", default=None)
-
-    class Config:
-        allow_mutation = True
-        validate_assignment = False
-        allow_population_by_field_name = True
-        use_enum_values = True
-        schema_extra: Callable | dict = modify_pydantic_schema
+    ext: dict[str, AnySerializable] | None = pydantic.Field(alias="ext", default=None)
+    model_config: ClassVar[ConfigDict] = ConfigDict(
+        validate_assignment=False,
+        populate_by_name=True,
+        use_enum_values=True,
+    )
 
     def to_serializable(self, *args, **kwargs) -> dict[str, Any]:
         """
         Return a serializable dict representation of the DTO.
 
-        It expects the same arguments as the pyd.BaseModel.json() method.
+        It expects the same arguments as the pydantic.BaseModel.model_dump_json() method.
         """
-        return json.loads(self.json(*args, **kwargs))
+        return json.loads(self.model_dump_json(*args, **kwargs))
 
     def has_values(self) -> bool:
         """Return True if the model has any values."""
-        return len(self.dict(exclude_unset=True, exclude_none=True)) > 0
+        return len(self.model_dump(exclude_unset=True, exclude_none=True)) > 0
 
     def set_ext(self, ext: "OpenEpdExtension") -> None:
         """Set the extension field."""
@@ -106,7 +107,10 @@ class BaseOpenEpdSchema(pyd.BaseModel):
         return self.ext.get(key, default)
 
     def get_typed_ext_field(
-        self, key: str, target_type: Type[TAnySerializable], default: Optional[TAnySerializable] = None
+        self,
+        key: str,
+        target_type: Type[TAnySerializable],
+        default: Optional[TAnySerializable] = None,
     ) -> TAnySerializable:
         """
         Get an extension field from the model and convert it to the target type.
@@ -116,8 +120,8 @@ class BaseOpenEpdSchema(pyd.BaseModel):
         value = self.get_ext_field(key, default)
         if value is None:
             return None  # type: ignore
-        if issubclass(target_type, pyd.BaseModel) and isinstance(value, dict):
-            return target_type.parse_obj(value)  # type: ignore[return-value]
+        if issubclass(target_type, pydantic.BaseModel) and isinstance(value, dict):
+            return target_type.model_validate(value)  # type: ignore[return-value]
         elif isinstance(value, target_type):
             return value
         raise ValueError(f"Cannot convert {value} to {target_type}")
@@ -128,7 +132,7 @@ class BaseOpenEpdSchema(pyd.BaseModel):
 
     def get_ext_or_empty(self, ext_type: Type["TOpenEpdExtension"]) -> "TOpenEpdExtension":
         """Get an extension field from the model or an empty instance if it doesn't exist."""
-        return self.get_typed_ext_field(ext_type.get_extension_name(), ext_type, ext_type.construct(**{}))
+        return self.get_typed_ext_field(ext_type.get_extension_name(), ext_type, ext_type.model_construct(**{}))  # type: ignore[return-value]
 
     @classmethod
     def is_allowed_field_name(cls, field_name: str) -> bool:
@@ -137,10 +141,10 @@ class BaseOpenEpdSchema(pyd.BaseModel):
 
         Both property name and aliases are checked.
         """
-        if field_name in cls.__fields__:
+        if field_name in cls.model_fields:
             return True
         else:
-            for x in cls.__fields__.values():
+            for x in cls.model_fields.values():
                 if x.alias == field_name:
                     return True
         return False
@@ -156,7 +160,7 @@ class BaseOpenEpdSchema(pyd.BaseModel):
         return None
 
 
-class BaseOpenEpdGenericSchema(pyd_generics.GenericModel, BaseOpenEpdSchema):
+class BaseOpenEpdGenericSchema(BaseOpenEpdSchema):
     """Base class for all OpenEPD generic models."""
 
     pass
@@ -183,21 +187,24 @@ class RootDocument(abc.ABC, BaseOpenEpdSchema):
     _FORMAT_VERSION: ClassVar[str]
     """Version of this document format. Must be defined in the concrete class."""
 
-    doctype: str = pyd.Field(
+    doctype: str = pydantic.Field(
         description='Describes the type and schema of the document. Must always always read "openEPD".',
         default="openEPD",
     )
-    openepd_version: str = pyd.Field(
+    openepd_version: str = pydantic.Field(
         description="Version of the document format, related to /doctype",
         default=OpenEpdVersions.get_current().as_str(),
     )
 
-    _version_format_validator = pyd.validator(OPENEPD_VERSION_FIELD, allow_reuse=True, check_fields=False)(
-        validate_version_format
-    )
-    _version_major_match_validator = pyd.validator(OPENEPD_VERSION_FIELD, allow_reuse=True, check_fields=False)(
-        validate_version_compatibility("_FORMAT_VERSION")
-    )
+    @pydantic.field_validator(OPENEPD_VERSION_FIELD)
+    def version_format_validator(cls, value: str) -> str:
+        """Validate the correctness of version format."""
+        return validate_version_format(value)
+
+    @pydantic.field_validator(OPENEPD_VERSION_FIELD)
+    def version_major_match_validator(cls, value: str) -> str:
+        """Validate that the version major matches the class version major."""
+        return validate_version_compatibility("_FORMAT_VERSION")(cls, value)  # type: ignore[arg-type]
 
 
 TRootDocument = TypeVar("TRootDocument", bound=RootDocument)
@@ -230,8 +237,7 @@ class BaseDocumentFactory(Generic[TRootDocument]):
                     return doc_cls(**data)
                 else:
                     raise ValueError(
-                        f"Unsupported version: {version}. "
-                        f"The highest supported version from branch {x.major}.x is {x}"
+                        f"Unsupported version: {version}. The highest supported version from branch {x.major}.x is {x}"
                     )
         supported_versions = ", ".join(f"{v.major}.x" for v in cls.VERSION_MAP.keys())
         raise ValueError(f"Version {version} is not supported. Supported versions are: {supported_versions}")
@@ -244,22 +250,33 @@ class OpenXpdUUID(str):
     See https://github.com/cchangelabs/open-xpd-uuid-lib for details.
     """
 
-    def _validate_id(cls, v: str | None) -> str | None:
-        if v is None:
-            return v
+    @classmethod
+    def _validate_id(cls, value: Any, _: pydantic_core.core_schema.ValidatorFunctionWrapHandler) -> Any:
+        if not isinstance(value, str | None):
+            raise ValueError(f"Invalid value type: {type(value)}")
 
         try:
-            open_xpd_uuid.validate(open_xpd_uuid.sanitize(str(v)))
-            return v
+            open_xpd_uuid.validate(open_xpd_uuid.sanitize(str(value)))
+            return value
         except open_xpd_uuid.GuidValidationError as e:
             raise ValueError("Invalid format") from e
 
     @classmethod
-    def __get_validators__(cls):
-        yield cls._validate_id
+    def __get_pydantic_core_schema__(
+        cls,
+        source_type: Any,
+        handler: Callable[[Any], pydantic_core.core_schema.CoreSchema],
+    ) -> pydantic_core.core_schema.CoreSchema:
+        # In this example we assume that the underlying type to validate is a string.
+        # If it's different, adjust the call to handler() accordingly.
+        underlying_schema = handler(str)
+        # Wrap the underlying schema with your custom validator.
+        return pydantic_core.core_schema.no_info_wrap_validator_function(cls._validate_id, underlying_schema)
 
     @classmethod
-    def __modify_schema__(cls, field_schema):
-        field_schema.update(
-            example="XC300001",
+    def __get_pydantic_json_schema__(cls, core_schema, handler):
+        json_schema = handler(core_schema)
+        json_schema.update(
+            examples=["XC300001"],
         )
+        return json_schema

openepd/model/category.py

@@ -13,7 +13,8 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 #
-from openepd.compat.pydantic import pyd
+import pydantic
+
 from openepd.model.base import BaseOpenEpdSchema
 from openepd.model.common import Amount
 
@@ -21,15 +22,17 @@ from openepd.model.common import Amount
 class Category(BaseOpenEpdSchema):
     """DTO for Category model, recursive."""
 
-    id: str = pyd.Field(description="Category short ID (readable unique string)")
-    name: str = pyd.Field(description="Category display name (user-friendly)")
-    short_name: str = pyd.Field(description="Category short user-friendly name")
-    openepd_hierarchical_name: str = pyd.Field(
+    id: str = pydantic.Field(description="Category short ID (readable unique string)")
+    name: str = pydantic.Field(description="Category display name (user-friendly)")
+    short_name: str = pydantic.Field(description="Category short user-friendly name")
+    openepd_hierarchical_name: str = pydantic.Field(
         "Special form of hierarchical category ID where the >> is hierarchy separator"
     )
-    masterformat: str | None = pyd.Field(description="Default category code in Masterformat")
-    description: str | None = pyd.Field(description="Category verbose description")
-    declared_unit: Amount | None = pyd.Field(description="Declared unit of category, for example 1 kg")
-    subcategories: list["Category"] = pyd.Field(
-        description="List of subcategories. This makes categories tree-like structure"
+    masterformat: str | None = pydantic.Field(description="Default category code in Masterformat", default=None)
+    description: str | None = pydantic.Field(description="Category verbose description", default=None)
+    declared_unit: Amount | None = pydantic.Field(
+        description="Declared unit of category, for example 1 kg", default=None
+    )
+    subcategories: list["Category"] = pydantic.Field(
+        description="List of subcategories. This makes categories tree-like structure", default_factory=list
     )