openepd 7.1.0__py3-none-any.whl → 7.3.0__py3-none-any.whl

openepd/bundle/reader.py

@@ -13,10 +13,11 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 #
+from collections.abc import Callable, Iterator, Sequence
 import csv
 import io
 from os import PathLike
-from typing import IO, Callable, Iterator, Sequence, Type, cast
+from typing import IO, cast
 import zipfile
 
 from openepd.bundle.base import AssetFilter, AssetRef, BaseBundleReader
@@ -60,8 +61,12 @@ class DefaultBundleReader(BaseBundleReader):
                 return False
             if name is not None and a.name != name:
                 return False
-            if parent_ref is not None and a.rel_asset != parent_ref:
-                return False
+            if parent_ref is not None:
+                parent_ref_str = self._asset_ref_to_str(parent_ref)
+                # Get the actual list of related assets
+                rel_asset_list = self._get_rel_asset_list(a)
+                if parent_ref_str not in rel_asset_list:
+                    return False
             if ref_type is not None and a.rel_type != ref_type:
                 return False
             if is_translated is not None and a.lang is not None and "translated" in a.lang:
@@ -84,6 +89,20 @@ class DefaultBundleReader(BaseBundleReader):
                 input_dict[x] = None
         return input_dict
 
+    def _get_rel_asset_list(self, asset_info: AssetInfo) -> list[str]:
+        """Get the list of related asset references from an AssetInfo object."""
+        if asset_info.rel_asset is None:
+            return []
+
+        # Deserialize from CSV format (semicolon-separated values)
+        deserialized = self._deserialize_rel_asset_from_csv(asset_info.rel_asset)
+        if isinstance(deserialized, list):
+            return deserialized
+        elif isinstance(deserialized, str):
+            return [deserialized]
+        else:
+            return []
+
     def assets_iter(self) -> Iterator[AssetInfo]:
         """Iterate over all assets in the bundle."""
         with self._bundle_archive.open("toc", "r") as toc_stream:
@@ -95,7 +114,8 @@ 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")
             if not toc_reader.fieldnames or len(toc_reader.fieldnames) < len(self._TOC_FIELDS):
-                raise ValueError("The bundle file is not valid. TOC reading error: wrong number of fields")
+                msg = "The bundle file is not valid. TOC reading error: wrong number of fields"
+                raise ValueError(msg)
 
     def root_assets_iter(
         self,
@@ -130,7 +150,8 @@ class DefaultBundleReader(BaseBundleReader):
             rel_type = [rel_type]
         asset_ref = self._asset_ref_to_str(asset)
         for x in self.assets_iter():
-            if x.rel_asset == asset_ref:
+            rel_asset_list = self._get_rel_asset_list(x)
+            if asset_ref in rel_asset_list:
                 if rel_type is None or x.rel_type in rel_type:
                     yield x
 
@@ -148,17 +169,21 @@ class DefaultBundleReader(BaseBundleReader):
         """Read the blob asset."""
         asset = self.get_asset_by_ref(asset_ref)
         if asset is None:
-            raise ValueError("Asset not found")
+            msg = "Asset not found"
+            raise ValueError(msg)
         return self._bundle_archive.open(asset.ref, "r")
 
-    def read_object_asset(self, obj_class: Type[TOpenEpdObject], asset_ref: AssetRef) -> TOpenEpdObject:
+    def read_object_asset(self, obj_class: type[TOpenEpdObject], asset_ref: AssetRef) -> TOpenEpdObject:
         """Read the object asset."""
         asset = self.get_asset_by_ref(asset_ref)
         if asset is None:
-            raise ValueError("Asset not found")
+            msg = "Asset not found"
+            raise ValueError(msg)
         if obj_class.get_asset_type() is None:
-            raise ValueError(f"Target object {obj_class.__name__} is not supported asset")
+            msg = f"Target object {obj_class.__name__} is not supported asset"
+            raise ValueError(msg)
         if asset.type != obj_class.get_asset_type():
-            raise ValueError(f"Asset type mismatch. Expected {obj_class.get_asset_type()}, got {asset.type}")
+            msg = f"Asset type mismatch. Expected {obj_class.get_asset_type()}, got {asset.type}"
+            raise ValueError(msg)
         with self._bundle_archive.open(asset.ref, "r") as asset_stream:
             return obj_class.model_validate_json(asset_stream.read())

openepd/bundle/writer.py

@@ -31,8 +31,9 @@ class DefaultBundleWriter(BaseBundleWriter):
     """Default bundle writer implementation. Writes the bundle to a ZIP file."""
 
     def __init__(self, bundle_file: str | PathLike | IO[bytes], comment: str | None = None):
-        if isinstance(bundle_file, (PathLike, str)) and Path(bundle_file).exists():
-            raise ValueError("Amending existing files is not supported yet.")
+        if isinstance(bundle_file, PathLike | str) and Path(bundle_file).exists():
+            msg = "Amending existing files is not supported yet."
+            raise ValueError(msg)
         self._bundle_archive = zipfile.ZipFile(bundle_file, mode="w")
         self.__manifest = BundleManifest(
             format="openEPD Bundle/1.0",
@@ -49,7 +50,7 @@ class DefaultBundleWriter(BaseBundleWriter):
         self,
         data: IO[bytes],
         content_type: str | None = None,
-        rel_asset: AssetRef | None = None,
+        rel_asset: AssetRef | list[AssetRef] | None = None,
         rel_type: str | None = None,
         file_name: str | None = None,
         name: str | None = None,
@@ -59,7 +60,9 @@ class DefaultBundleWriter(BaseBundleWriter):
         custom_data: str | None = None,
     ) -> AssetInfo:
         """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
+        # Convert multiple rel_asset to proper format and serialize for storage
+        rel_ref_converted = self._asset_refs_to_str(rel_asset)
+        rel_ref_serialized = self._serialize_rel_asset_for_csv(rel_ref_converted)
         ref_str = self.__generate_entry_name(
             AssetType.Blob,
             self.__get_ext_for_content_type(content_type, "bin"),
@@ -71,7 +74,7 @@ class DefaultBundleWriter(BaseBundleWriter):
             type=AssetType.Blob,
             lang=lang,
             rel_type=rel_type,
-            rel_asset=rel_ref_str,
+            rel_asset=rel_ref_serialized,
             content_type=content_type,
             comment=comment,
             custom_type=custom_type,
@@ -84,7 +87,7 @@ class DefaultBundleWriter(BaseBundleWriter):
     def write_object_asset(
         self,
         obj: TOpenEpdObject,
-        rel_asset: AssetRef | None = None,
+        rel_asset: list[AssetRef] | AssetRef | None = None,
         rel_type: str | None = None,
         file_name: str | None = None,
         name: str | None = None,
@@ -96,9 +99,12 @@ class DefaultBundleWriter(BaseBundleWriter):
         """Write an object asset to the bundle. Object means subclass of BaseOpenEpdSchem."""
         asset_type_str = obj.get_asset_type()
         if asset_type_str is None:
-            raise ValueError(f"Object {obj} does not have a valid asset type and can't be written to a bundle.")
+            msg = f"Object {obj} does not have a valid asset type and can't be written to a bundle."
+            raise ValueError(msg)
         asset_type = AssetType(asset_type_str)
-        rel_ref_str = self._asset_ref_to_str(rel_asset) if rel_asset is not None else None
+        # Convert multiple rel_asset to proper format and serialize for storage
+        rel_ref_converted = self._asset_refs_to_str(rel_asset)
+        rel_ref_serialized = self._serialize_rel_asset_for_csv(rel_ref_converted)
         ref_str = self.__generate_entry_name(
             asset_type,
             self.__get_ext_for_content_type("application/json", "json"),
@@ -109,7 +115,7 @@ class DefaultBundleWriter(BaseBundleWriter):
             name=name,
             type=asset_type,
             lang=lang,
-            rel_asset=rel_ref_str,
+            rel_asset=rel_ref_serialized,
             rel_type=rel_type,
             content_type="application/json",
             comment=comment,
@@ -139,14 +145,16 @@ 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.")
+            msg = f"Asset {asset_info.ref} already exists in the bundle."
+            raise ValueError(msg)
         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
         self.__manifest.assets.total_count += 1
         if asset_info.size is None:
-            raise ValueError("Size of asset is not set.")
+            msg = "Size of asset is not set."
+            raise ValueError(msg)
         self.__manifest.assets.total_size += asset_info.size
 
     def __generate_entry_name(
@@ -168,7 +176,8 @@ class DefaultBundleWriter(BaseBundleWriter):
             info = self._bundle_archive.getinfo(f"{asset_type}/")
             if info.is_dir():
                 return
-            raise ValueError(f"Object with name {asset_type} already exists in the bundle.")
+            msg = f"Object with name {asset_type} already exists in the bundle."
+            raise ValueError(msg)
         except KeyError:
             self._bundle_archive.mkdir(str(asset_type))
 

openepd/m49/__init__.py

@@ -14,4 +14,6 @@
 #  limitations under the License.
 #
 
+__all__ = ["geo_converter"]
+
 from . import utils as geo_converter  # for backwards compatibility

openepd/m49/const.py

@@ -1169,7 +1169,7 @@ def is_m49_code(to_check: str) -> bool:
     :param to_check: any string
     :return: `True` if passed string is M49 code, `False` otherwise
     """
-    warnings.warn("Use m49.utils.is_m49_code instead.", DeprecationWarning)
+    warnings.warn("Use m49.utils.is_m49_code instead.", DeprecationWarning, stacklevel=2)
     from . import utils
 
     return utils.is_m49_code(to_check)

openepd/m49/utils.py

@@ -14,15 +14,15 @@
 #  limitations under the License.
 #
 __all__ = [
+    "is_m49_code",
     "iso_to_m49",
     "m49_to_iso",
-    "region_and_country_names_to_m49",
+    "m49_to_openepd",
     "m49_to_region_and_country_names",
     "openepd_to_m49",
-    "m49_to_openepd",
-    "is_m49_code",
+    "region_and_country_names_to_m49",
 ]
-from typing import Collection
+from collections.abc import Collection
 
 from openepd.m49.const import (
     COUNTRY_VERBOSE_NAME_TO_M49,
@@ -54,7 +54,8 @@ def iso_to_m49(regions: Collection[str]) -> set[str]:
         if m49_code:
             result.add(m49_code)
         else:
-            raise ValueError(f"Country code '{code}' not found in M49 region codes.")
+            msg = f"Country code '{code}' not found in M49 region codes."
+            raise ValueError(msg)
 
     return result
 
@@ -77,7 +78,8 @@ def m49_to_iso(regions: Collection[str]) -> set[str]:
         if iso_code:
             result.add(iso_code)
         else:
-            raise ValueError(f"Region code '{code}' not found in ISO3166.")
+            msg = f"Region code '{code}' not found in ISO3166."
+            raise ValueError(msg)
 
     return result
 
@@ -99,7 +101,8 @@ def region_and_country_names_to_m49(regions: Collection[str]) -> set[str]:
     for name in regions:
         m49_code = REGION_VERBOSE_NAME_TO_M49.get(name.title()) or COUNTRY_VERBOSE_NAME_TO_M49.get(name.title())
         if not m49_code:
-            raise ValueError(f"Region or country name '{name}' not found in M49 region codes.")
+            msg = f"Region or country name '{name}' not found in M49 region codes."
+            raise ValueError(msg)
         result.add(m49_code)
 
     return result
@@ -120,7 +123,8 @@ def m49_to_region_and_country_names(regions: Collection[str]) -> set[str]:
     result = set()
     for code in regions:
         if code not in M49_TO_REGION_VERBOSE_NAME and code not in M49_TO_COUNTRY_VERBOSE_NAME:
-            raise ValueError(f"Region code '{code}' not found in M49 region codes.")
+            msg = f"Region code '{code}' not found in M49 region codes."
+            raise ValueError(msg)
 
         name = M49_TO_REGION_VERBOSE_NAME.get(code) or M49_TO_COUNTRY_VERBOSE_NAME.get(code, code)
         result.add(name)
@@ -153,7 +157,8 @@ def openepd_to_m49(regions: Collection[str]) -> set[str]:
             elif is_m49_code(region):
                 result.add(region)
             else:
-                raise ValueError(f"Region '{region}' not found in ISO3166 or OpenEPD special regions.")
+                msg = f"Region '{region}' not found in ISO3166 or OpenEPD special regions."
+                raise ValueError(msg)
     return result
 
 
@@ -185,7 +190,8 @@ def m49_to_openepd(regions: list[str]) -> set[str]:
         if iso_code:
             result.add(iso_code)
         else:
-            raise ValueError(f"Region code '{code}' not found in ISO3166 or OpenEPD special regions.")
+            msg = f"Region code '{code}' not found in ISO3166 or OpenEPD special regions."
+            raise ValueError(msg)
 
     return result
 

openepd/model/base.py

@@ -17,7 +17,7 @@ import abc
 from collections.abc import Callable
 from enum import StrEnum
 import json
-from typing import Any, ClassVar, Generic, Optional, Type, TypeAlias, TypeVar
+from typing import Any, ClassVar, Generic, Optional, TypeAlias, TypeVar
 
 from cqd import open_xpd_uuid  # type:ignore[import-untyped]
 import pydantic
@@ -109,8 +109,8 @@ class BaseOpenEpdSchema(pydantic.BaseModel):
     def get_typed_ext_field(
         self,
         key: str,
-        target_type: Type[TAnySerializable],
-        default: Optional[TAnySerializable] = None,
+        target_type: type[TAnySerializable],
+        default: TAnySerializable | None = None,
     ) -> TAnySerializable:
         """
         Get an extension field from the model and convert it to the target type.
@@ -124,13 +124,14 @@ class BaseOpenEpdSchema(pydantic.BaseModel):
             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}")
+        msg = f"Cannot convert {value} to {target_type}"
+        raise ValueError(msg)
 
-    def get_ext(self, ext_type: Type["TOpenEpdExtension"]) -> Optional["TOpenEpdExtension"]:
+    def get_ext(self, ext_type: type["TOpenEpdExtension"]) -> Optional["TOpenEpdExtension"]:
         """Get an extension field from the model or None if it doesn't exist."""
         return self.get_typed_ext_field(ext_type.get_extension_name(), ext_type, None)
 
-    def get_ext_or_empty(self, ext_type: Type["TOpenEpdExtension"]) -> "TOpenEpdExtension":
+    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.model_construct(**{}))  # type: ignore[return-value]
 
@@ -178,7 +179,7 @@ class OpenEpdExtension(BaseOpenEpdSchema, metaclass=abc.ABCMeta):
 
 TOpenEpdExtension = TypeVar("TOpenEpdExtension", bound=OpenEpdExtension)
 TOpenEpdObject = TypeVar("TOpenEpdObject", bound=BaseOpenEpdSchema)
-TOpenEpdObjectClass = TypeVar("TOpenEpdObjectClass", bound=Type[BaseOpenEpdSchema])
+TOpenEpdObjectClass = TypeVar("TOpenEpdObjectClass", bound=type[BaseOpenEpdSchema])
 
 
 class RootDocument(abc.ABC, BaseOpenEpdSchema):
@@ -225,22 +226,24 @@ class BaseDocumentFactory(Generic[TRootDocument]):
         """Create a document from a dictionary."""
         doctype: str | None = data.get("doctype")
         if doctype is None:
-            raise ValueError("Doctype not found in the data.")
+            msg = "Doctype not found in the data."
+            raise ValueError(msg)
         if doctype.lower() != cls.DOCTYPE_CONSTRAINT.lower():
-            raise ValueError(
-                f"Document type {doctype} not supported. This factory supports {cls.DOCTYPE_CONSTRAINT} only."
-            )
+            msg = f"Document type {doctype} not supported. This factory supports {cls.DOCTYPE_CONSTRAINT} only."
+            raise ValueError(msg)
         version = Version.parse_version(data.get(OPENEPD_VERSION_FIELD, ""))
         for x, doc_cls in cls.VERSION_MAP.items():
             if x.major == version.major:
                 if version.minor <= x.minor:
                     return doc_cls.model_validate(data)
                 else:
-                    raise ValueError(
+                    msg = (
                         f"Unsupported version: {version}. The highest supported version from branch {x.major}.x is {x}"
                     )
+                    raise ValueError(msg)
         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}")
+        msg = f"Version {version} is not supported. Supported versions are: {supported_versions}"
+        raise ValueError(msg)
 
 
 class OpenXpdUUID(str):
@@ -253,13 +256,15 @@ class OpenXpdUUID(str):
     @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)}")
+            msg = f"Invalid value type: {type(value)}"
+            raise ValueError(msg)
 
         try:
             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
+            msg = "Invalid format"
+            raise ValueError(msg) from e
 
     @classmethod
     def __get_pydantic_core_schema__(

openepd/model/common.py

@@ -39,7 +39,8 @@ class Amount(BaseOpenEpdSchema):
         """Ensure that qty or unit is provided."""
 
         if self.qty is None and self.unit is None:
-            raise ValueError("Either qty or unit must be provided.")
+            msg = "Either qty or unit must be provided."
+            raise ValueError(msg)
         return self
 
     def to_quantity_str(self):
@@ -135,9 +136,11 @@ class Ingredient(BaseOpenEpdSchema):
         # for in the calculation of uncertainty
         if values.get("gwp_fraction"):
             if not values.get("evidence_type"):
-                raise ValueError("evidence_type is required if gwp_fraction is provided")
+                msg = "evidence_type is required if gwp_fraction is provided"
+                raise ValueError(msg)
             if not (values.get("citation") or values.get("link")):
-                raise ValueError("link or citation is required if gwp_fraction is provided")
+                msg = "link or citation is required if gwp_fraction is provided"
+                raise ValueError(msg)
 
         return values
 
@@ -207,7 +210,8 @@ class AttachmentDict(dict[str, pydantic.AnyUrl]):
     def _validate(cls, value: Any) -> "AttachmentDict":
         # Ensure the input is a dict.
         if not isinstance(value, dict):
-            raise TypeError("AttachmentDict must be a dict")
+            msg = "AttachmentDict must be a dict"
+            raise TypeError(msg)
 
         return cls(value)
 
@@ -315,7 +319,8 @@ class RangeBase(BaseOpenEpdSchema):
         min_boundary = values.get("min")
         max_boundary = values.get("max")
         if min_boundary is not None and max_boundary is not None and min_boundary > max_boundary:
-            raise ValueError("Max should be greater than min")
+            msg = "Max should be greater than min"
+            raise ValueError(msg)
         return values
 
 

openepd/model/declaration.py

@@ -44,12 +44,12 @@ class BaseDeclaration(RootDocument, abc.ABC):
         default=None,
     )
     date_of_issue: datetime.datetime | None = pydantic.Field(
-        examples=[datetime.datetime(day=11, month=9, year=2019, tzinfo=datetime.timezone.utc)],
+        examples=[datetime.datetime(day=11, month=9, year=2019, tzinfo=datetime.UTC)],
         description="Date the document was issued. This should be the first day on which the document is valid.",
         default=None,
     )
     valid_until: datetime.datetime | None = pydantic.Field(
-        examples=[datetime.datetime(day=11, month=9, year=2028, tzinfo=datetime.timezone.utc)],
+        examples=[datetime.datetime(day=11, month=9, year=2028, tzinfo=datetime.UTC)],
         description="Last date the document is valid on, including any extensions.",
         default=None,
     )

openepd/model/epd.py

@@ -239,7 +239,8 @@ class EpdPreviewV0(
         """
         if not v or v.lower() == "openepd":
             return "openEPD"
-        raise ValueError("Invalid doctype")
+        msg = "Invalid doctype"
+        raise ValueError(msg)
 
 
 EpdPreview = EpdPreviewV0

openepd/model/factory.py

@@ -38,7 +38,8 @@ class DocumentFactory:
         :raise ValueError if doctype not supported or not found.
         """
         if doctype is None:
-            raise ValueError("The document type is not specified.")
+            msg = "The document type is not specified."
+            raise ValueError(msg)
         factory = cls.DOCTYPE_TO_FACTORY.get(doctype)
         if factory is None:
             raise ValueError(
@@ -56,11 +57,12 @@ class DocumentFactory:
         :raise ValueError: if the document type is not specified or not supported.
         """
         doctype = data.get("doctype")
-        if doctype is None or not isinstance(doctype, (str, OpenEpdDoctypes)):
-            raise ValueError(
+        if doctype is None or not isinstance(doctype, str | OpenEpdDoctypes):
+            msg = (
                 f"The document type is not specified or not supported. "
                 f"Please specify it in `doctype` field. Supported are: {','.join(cls.DOCTYPE_TO_FACTORY)}"
             )
+            raise ValueError(msg)
 
         factory = cls.get_factory(OpenEpdDoctypes(doctype))
         return factory.from_dict(data)

openepd/model/generic_estimate.py

@@ -87,6 +87,10 @@ class GenericEstimatePreviewV0(
         description="A link to the shared git repository containing the LCA model used for this estimate.",
     )
 
+    model_config = pydantic.ConfigDict(
+        protected_namespaces=(),
+    )
+
 
 GenericEstimatePreview = GenericEstimatePreviewV0
 

openepd/model/lcia.py

@@ -14,11 +14,10 @@
 #  limitations under the License.
 #
 from enum import StrEnum
-from typing import Any, ClassVar
+from typing import Any, ClassVar, Self
 
 import pydantic
 from pydantic import ConfigDict
-from typing_extensions import Self
 
 from openepd.model.base import BaseOpenEpdSchema
 from openepd.model.common import Measurement
@@ -215,7 +214,8 @@ class ScopeSet(BaseOpenEpdSchema):
         if not self.allowed_units:
             # For unknown units - only units should be the same across all measurements (textually)
             if len(all_units) > 1:
-                raise ValueError("All scopes and measurements should be expressed in the same unit.")
+                msg = "All scopes and measurements should be expressed in the same unit."
+                raise ValueError(msg)
         else:
             # might be multiple variations of the same unit (kgCFC-11e, kgCFC11e)
             if len(all_units) > 1 and ExternalValidationConfig.QUANTITY_VALIDATOR:
@@ -237,9 +237,8 @@ class ScopeSet(BaseOpenEpdSchema):
                 except ValueError:
                     ...
             if not matched_unit:
-                raise ValueError(
-                    f"'{', '.join(allowed_units)}' is only allowed unit for this scopeset. Provided '{unit}'"
-                )
+                msg = f"'{', '.join(allowed_units)}' is only allowed unit for this scopeset. Provided '{unit}'"
+                raise ValueError(msg)
 
         return self
 
@@ -254,10 +253,10 @@ class ScopesetByNameBase(BaseOpenEpdSchema, extra="allow"):
         :return: set of names, for example ['gwp', 'odp']
         """
         result = []
-        for f in self.__fields_set__:
+        for f in self.model_fields_set:
             if f in ("ext",):
                 continue
-            field = self.__fields__.get(f)
+            field = self.model_fields.get(f)
             # field can be explicitly specified, or can be an unknown impact covered by extra='allow'
             result.append(field.alias if field and field.alias else f)
 
@@ -271,7 +270,7 @@ class ScopesetByNameBase(BaseOpenEpdSchema, extra="allow"):
         :return: A scopeset if found, None otherwise
         """
         # check known impacts first
-        for f_name, f in self.__fields__.items():
+        for f_name, f in self.model_fields.items():
             if f.alias == name:
                 return getattr(self, f_name)
             if f_name == name:
@@ -294,7 +293,8 @@ class ScopesetByNameBase(BaseOpenEpdSchema, extra="allow"):
                 case dict():
                     values[f] = ScopeSet(**extra_scopeset)
                 case _:
-                    raise ValueError(f"{f} must be a ScopeSet schema")
+                    msg = f"{f} must be a ScopeSet schema"
+                    raise ValueError(msg)
 
         return values
 

openepd/model/org.py

@@ -61,10 +61,12 @@ class Org(WithAttachmentsMixin, WithAltIdsMixin, OrgRef):
             return value
 
         if not isinstance(value, list):
-            raise TypeError(f"Expected type list or None, got {type(value)}")
+            msg = f"Expected type list or None, got {type(value)}"
+            raise TypeError(msg)
 
         if any((len(item) > 200) for item in value):
-            raise ValueError("One or more alt_names are longer than 200 characters")
+            msg = "One or more alt_names are longer than 200 characters"
+            raise ValueError(msg)
 
         return value
 
@@ -79,11 +81,13 @@ class Org(WithAttachmentsMixin, WithAltIdsMixin, OrgRef):
             return value
 
         if not isinstance(value, list):
-            raise TypeError(f"Expected type list or None, got {type(value)}")
+            msg = f"Expected type list or None, got {type(value)}"
+            raise TypeError(msg)
 
         for item in value:
             if len(item.name) > 200:
-                raise ValueError("One or more subsidiaries name are longer than 200 characters")
+                msg = "One or more subsidiaries name are longer than 200 characters"
+                raise ValueError(msg)
 
         return value
 
@@ -158,13 +162,16 @@ class Plant(PlantRef, WithAttachmentsMixin, WithAltIdsMixin):
         try:
             pluscode, web_domain = v.split(".", maxsplit=1)
         except ValueError as e:
-            raise ValueError("Incorrectly formed id: should be pluscode.owner_web_domain") from e
+            msg = "Incorrectly formed id: should be pluscode.owner_web_domain"
+            raise ValueError(msg) from e
 
         if not openlocationcode.isValid(pluscode):
-            raise ValueError("Incorrect pluscode for plant")
+            msg = "Incorrect pluscode for plant"
+            raise ValueError(msg)
 
         if not web_domain:
-            raise ValueError("Incorrect web_domain for plant")
+            msg = "Incorrect web_domain for plant"
+            raise ValueError(msg)
         return v
 
     model_config = ConfigDict(populate_by_name=True)

openepd/model/pcr.py

@@ -93,12 +93,12 @@ class Pcr(WithAttachmentsMixin, WithAltIdsMixin, BaseOpenEpdSchema):
         default=None,
     )
     date_of_issue: datetime.datetime | None = pydantic.Field(
-        examples=[datetime.datetime(day=11, month=9, year=2019, tzinfo=datetime.timezone.utc)],
+        examples=[datetime.datetime(day=11, month=9, year=2019, tzinfo=datetime.UTC)],
         default=None,
         description="First day on which the document is valid",
     )
     valid_until: datetime.datetime | None = pydantic.Field(
-        examples=[datetime.datetime(day=11, month=9, year=2019, tzinfo=datetime.timezone.utc)],
+        examples=[datetime.datetime(day=11, month=9, year=2019, tzinfo=datetime.UTC)],
         default=None,
         description="Last day on which the document is valid",
     )