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

openepd/__version__.py

@@ -13,4 +13,4 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 #
-VERSION = "6.13.2"
+VERSION = "6.15.0"

openepd/api/average_dataset/generic_estimate_sync_api.py

@@ -135,7 +135,8 @@ class GenericEstimateApi(BaseApiMethodGroup):
         """
         ge_id = ge.id
         if not ge_id:
-            raise ValueError("The ID must be set to edit a GenericEstimate.")
+            msg = "The ID must be set to edit a GenericEstimate."
+            raise ValueError(msg)
 
         response = self._client.do_request(
             "put",

openepd/api/average_dataset/industry_epd_sync_api.py

@@ -90,7 +90,8 @@ class IndustryEpdApi(BaseApiMethodGroup):
         """
         iepd_id = iepd.id
         if not iepd_id:
-            raise ValueError("The ID must be set to edit a IndustryEpd.")
+            msg = "The ID must be set to edit a IndustryEpd."
+            raise ValueError(msg)
 
         response = self._client.do_request(
             "put",

openepd/api/base_sync_client.py

@@ -14,14 +14,15 @@
 #  limitations under the License.
 #
 __all__ = (
-    "HttpStreamReader",
-    "SyncHttpClient",
+    "USER_AGENT_DEFAULT",
+    "BaseApiMethodGroup",
     "DoRequest",
+    "HttpStreamReader",
     "RetryHandler",
-    "BaseApiMethodGroup",
-    "USER_AGENT_DEFAULT",
+    "SyncHttpClient",
 )
 
+from collections.abc import Callable
 import datetime
 from functools import partial, wraps
 from io import IOBase
@@ -29,7 +30,7 @@ import logging
 import random
 import shutil
 import time
-from typing import IO, Any, BinaryIO, Callable, Final, NamedTuple
+from typing import IO, Any, BinaryIO, Final, NamedTuple
 
 import requests
 from requests import PreparedRequest, Response, Session, Timeout
@@ -180,7 +181,7 @@ class SyncHttpClient:
         self._throttler = Throttler(rate_per_sec=requests_per_sec)
         self._throttle_retry_timeout: float = (
             float(throttle_retry_timeout)
-            if isinstance(throttle_retry_timeout, (float, int))
+            if isinstance(throttle_retry_timeout, float | int)
             else throttle_retry_timeout.total_seconds()
         )
         self.user_agent = user_agent
@@ -396,7 +397,8 @@ class SyncHttpClient:
 
         response.raise_for_status()
         # This can't be handled by static checker because of the dynamic nature of the raise_for_status method
-        raise RuntimeError("This line should never be reached")
+        msg = "This line should never be reached"
+        raise RuntimeError(msg)
 
     def _get_url_for_request(self, path_or_url: str) -> str:
         """
@@ -451,7 +453,7 @@ class SyncHttpClient:
                     exception = e
 
                 if exception or response.status_code == requests_codes.service_unavailable:
-                    secs = random.randint(60, 60 * 5)
+                    secs = random.randint(60, 60 * 5)  # noqa: S311
                     logger.warning(
                         "%s %s is unavailable. Attempts left: %s. Waiting %s seconds...", method, url, attempts, secs
                     )

openepd/api/common.py

@@ -13,12 +13,12 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 #
-from collections.abc import Iterable
+from collections.abc import Callable, Iterable, Iterator
 from contextlib import contextmanager
 from datetime import datetime, timedelta
 import threading
 from time import sleep
-from typing import Callable, Generic, Iterator, cast
+from typing import Generic, cast
 
 from requests import Response
 
@@ -126,20 +126,26 @@ class StreamingListResponse(Iterable[TOpenEpdObject], Generic[TOpenEpdObject]):
         :return: list of items on the page
         """
         if page_num <= 0:
-            raise ValueError("Page number must be positive")
+            msg = "Page number must be positive"
+            raise ValueError(msg)
         if self.__current_page != page_num or force_reload:
             self.__recent_response = self.__fetch_handler(page_num, self.__page_size)
             self.__current_page = page_num
         if self.__recent_response is None:
-            raise RuntimeError("Response is empty, this should not happen, check if fetch_handler is compatible")
+            msg = "Response is empty, this should not happen, check if fetch_handler is compatible"
+            raise RuntimeError(msg)
         if self.__recent_response.payload is None:
-            raise ValueError("Response does not contain payload")
+            msg = "Response does not contain payload"
+            raise ValueError(msg)
         if not isinstance(self.__recent_response.payload, list):
-            raise ValueError("Response does not contain a list")
+            msg = "Response does not contain a list"
+            raise ValueError(msg)
         if self.__recent_response.meta is None:
-            raise ValueError("Response does not contain meta")
+            msg = "Response does not contain meta"
+            raise ValueError(msg)
         if not isinstance(self.__recent_response.meta, PagingMetaMixin):
-            raise ValueError("Response does not contain paging meta")
+            msg = "Response does not contain paging meta"
+            raise ValueError(msg)
         return self.__recent_response.payload
 
     def get_paging_meta(self) -> PagingMeta:
@@ -152,7 +158,8 @@ class StreamingListResponse(Iterable[TOpenEpdObject], Generic[TOpenEpdObject]):
         """
         paging_meta = cast(PagingMetaMixin, self.get_meta()).paging
         if paging_meta is None:
-            raise ValueError("Response does not contain paging meta")
+            msg = "Response does not contain paging meta"
+            raise ValueError(msg)
         return paging_meta
 
     def get_meta(self) -> MetaCollectionDto:
@@ -206,8 +213,7 @@ class StreamingListResponse(Iterable[TOpenEpdObject], Generic[TOpenEpdObject]):
         self.goto_page(start_from_page)
         while True:
             items = self.goto_page(self.current_page)
-            for x in items:
-                yield x
+            yield from items
             if not self.has_next_page():
                 return  # no more pages
             else:

openepd/api/dto/common.py

@@ -82,7 +82,7 @@ class MetaCollectionDto(BaseOpenEpdApiModel, pyd_generics.GenericModel, Generic[
 
     It is generified by the extension type of similar structure (key-dict value), which should not be a part of OpenEPD
     spec. This allows to add custom meta objects to the response, which would be ignored by OpenEPD implementors.
-    """
+    """  # noqa: D404
 
     ext: TMetaExtension | None = None
 

openepd/api/epd/sync_api.py

@@ -173,7 +173,8 @@ class EpdApi(BaseApiMethodGroup):
         """
         epd_id = epd.id
         if not epd_id:
-            raise ValueError("The EPD ID must be set to edit an EPD.")
+            msg = "The EPD ID must be set to edit an EPD."
+            raise ValueError(msg)
         response = self._client.do_request(
             "put",
             f"/epds/{encode_path_param(epd_id)}",

openepd/bundle/base.py

@@ -14,8 +14,9 @@
 #  limitations under the License.
 #
 import abc
+from collections.abc import Callable, Iterator, Sequence
 import csv
-from typing import IO, Callable, Iterator, Self, Sequence, Type
+from typing import IO, Self
 
 from openepd.bundle.model import AssetInfo, AssetType, BundleManifest, RelType
 from openepd.model.base import TOpenEpdObject
@@ -70,7 +71,7 @@ class BaseBundleReader(BundleMixin, metaclass=abc.ABCMeta):
     def __enter__(self) -> Self:
         return self
 
-    def __exit__(self, type, value, traceback):
+    def __exit__(self, type, value, traceback):  # noqa: A002
         self.close()
 
     @abc.abstractmethod
@@ -133,7 +134,7 @@ class BaseBundleReader(BundleMixin, metaclass=abc.ABCMeta):
         pass
 
     @abc.abstractmethod
-    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 an object asset by given reference."""
         pass
 
@@ -171,7 +172,7 @@ class BaseBundleWriter(BundleMixin, metaclass=abc.ABCMeta):
     def __enter__(self) -> Self:
         return self
 
-    def __exit__(self, type, value, traceback):
+    def __exit__(self, type, value, traceback):  # noqa: A002
         self.close()
 
     @abc.abstractmethod

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
@@ -88,7 +89,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,
@@ -141,17 +143,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.parse_raw(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",
@@ -94,7 +95,8 @@ 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
         ref_str = self.__generate_entry_name(
@@ -133,14 +135,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.dict(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(self, asset_type: str, extension: str | None = None, file_name: str | None = None) -> str:
@@ -157,7 +161,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/compat/pydantic.py

@@ -27,4 +27,4 @@ except ImportError:
 
 pydantic = pyd
 
-__all__ = ["pyd", "pydantic", "pyd_generics", "functional_validators"]
+__all__ = ["functional_validators", "pyd", "pyd_generics", "pydantic"]

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

@@ -14,9 +14,10 @@
 #  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, TypeAlias, TypeVar
 
 from cqd import open_xpd_uuid  # type:ignore[import-untyped,ignore-not-found]
 
@@ -106,7 +107,7 @@ 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: TAnySerializable | None = None
     ) -> TAnySerializable:
         """
         Get an extension field from the model and convert it to the target type.
@@ -120,13 +121,14 @@ class BaseOpenEpdSchema(pyd.BaseModel):
             return target_type.parse_obj(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.construct(**{}))
 
@@ -174,7 +176,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):
@@ -218,23 +220,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(**data)
                 else:
-                    raise ValueError(
-                        f"Unsupported version: {version}. "
-                        f"The highest supported version from branch {x.major}.x is {x}"
+                    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):
@@ -252,7 +255,8 @@ class OpenXpdUUID(str):
             open_xpd_uuid.validate(open_xpd_uuid.sanitize(str(v)))
             return v
         except open_xpd_uuid.GuidValidationError as e:
-            raise ValueError("Invalid format") from e
+            msg = "Invalid format"
+            raise ValueError(msg) from e
 
     @classmethod
     def __get_validators__(cls):

openepd/model/common.py

@@ -31,7 +31,8 @@ class Amount(BaseOpenEpdSchema):
     def check_qty_or_unit(cls, values: dict[str, Any]):
         """Ensure that qty or unit is provided."""
         if values.get("qty") is None and values.get("unit") is None:
-            raise ValueError("Either qty or unit must be provided.")
+            msg = "Either qty or unit must be provided."
+            raise ValueError(msg)
         return values
 
     def to_quantity_str(self):
@@ -43,19 +44,19 @@ class Distribution(StrEnum):
     """
     Distribution of the measured value.
 
-     * log-normal: Probability distribution of any random parameter whose natural log is normally distributed (the
-       PDF is gaussian).
-     * normal: Probability distribution of any random parameter whose value is normally distributed around the mean
-       (the PDF is gaussian).
-     * Continuous uniform probability distribution between minimum value and maximum value and "0" probability beyond
-       these.
-     * Probability distribution of any random parameter between minimum value and maximum value with the highest
-       probability at the average value of minimum plus maximum value. Linear change of probability between minimum,
-       maximum and average value.
-     * Means Impact is not known, but with >95% certainty the true value is below the declared value.
-       So [1e-6,"kgCFC11e",0,"max"] means the ODP was not exactly measured, but it is guaranteed to be below
-       1E-6 kg CO2e.  It is acceptable to treat a 'max' distribution a normal or lognormal distribution with variation
-       0.1%.  This is conservative, because the 'max' value is usually much greater than the true impact.
+    * log-normal: Probability distribution of any random parameter whose natural log is normally distributed (the
+      PDF is gaussian).
+    * normal: Probability distribution of any random parameter whose value is normally distributed around the mean
+      (the PDF is gaussian).
+    * Continuous uniform probability distribution between minimum value and maximum value and "0" probability beyond
+      these.
+    * Probability distribution of any random parameter between minimum value and maximum value with the highest
+      probability at the average value of minimum plus maximum value. Linear change of probability between minimum,
+      maximum and average value.
+    * Means Impact is not known, but with >95% certainty the true value is below the declared value.
+      So [1e-6,"kgCFC11e",0,"max"] means the ODP was not exactly measured, but it is guaranteed to be below
+      1E-6 kg CO2e.  It is acceptable to treat a 'max' distribution a normal or lognormal distribution with variation
+      0.1%.  This is conservative, because the 'max' value is usually much greater than the true impact.
     """
 
     LOG_NORMAL = "log-normal"
@@ -102,8 +103,7 @@ class Ingredient(BaseOpenEpdSchema):
         description="Number of declared units of this consumed. Negative values indicate an outflow."
     )
     link: pyd.AnyUrl | None = pyd.Field(
-        description="Link to this object's OpenEPD declaration. "
-        "An OpenIndustryEPD or OpenLCI link is also acceptable.",
+        description="Link to this object's OpenEPD declaration. An OpenIndustryEPD or OpenLCI link is also acceptable.",
         default=None,
     )
 
@@ -123,9 +123,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
 
@@ -267,7 +269,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

@@ -43,11 +43,11 @@ class BaseDeclaration(RootDocument, abc.ABC):
         default=None,
     )
     date_of_issue: datetime.datetime | None = pyd.Field(
-        example=datetime.datetime(day=11, month=9, year=2019, tzinfo=datetime.timezone.utc),
+        example=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.",
     )
     valid_until: datetime.datetime | None = pyd.Field(
-        example=datetime.datetime(day=11, month=9, year=2028, tzinfo=datetime.timezone.utc),
+        example=datetime.datetime(day=11, month=9, year=2028, tzinfo=datetime.UTC),
         description="Last date the document is valid on, including any extensions.",
     )
 

openepd/model/epd.py

@@ -231,7 +231,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)