openepd 7.0.1__py3-none-any.whl → 7.2.0__py3-none-any.whl

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",
@@ -96,7 +97,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(
@@ -139,14 +141,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 +172,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
 
@@ -365,6 +365,12 @@ class ScopeSetCTUe(ScopeSet):
     allowed_units: ClassVar[str | tuple[str, ...] | None] = "CTUe"
 
 
+class ScopeSetKgSbe(ScopeSet):
+    """ScopeSet measured in kgSbe."""
+
+    allowed_units: ClassVar[str | tuple[str, ...] | None] = "kgSbe"
+
+
 class ScopeSetDiseaseIncidence(ScopeSet):
     """ScopeSet measuring disease incidence measured in AnnualPerCapita (cases)."""
 
@@ -487,6 +493,17 @@ class ImpactSet(ScopesetByNameBase):
         default=None,
         description="Land use related impacts / Soil quality, in potential soil quality parameters.",
     )
+    ADP_mineral: ScopeSetKgSbe | None = pydantic.Field(
+        alias="ADP-mineral",
+        default=None,
+        description='Abiotic depletion potential for non-fossil resources. EN15804 calls this "ADP - minerals and metals".',
+    )
+
+    ADP_fossil: ScopeSetEnergy | None = pydantic.Field(
+        alias="ADP-fossil",
+        default=None,
+        description="Abiotic depletion potential for fossil resources",
+    )
 
     model_config = pydantic.ConfigDict(from_attributes=True)
 

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",
     )

openepd/model/specs/__init__.py

@@ -14,6 +14,43 @@
 #  limitations under the License.
 #
 
+__all__ = [
+    "CMUV1",
+    "AccessoriesV1",
+    "AggregatesV1",
+    "AluminiumV1",
+    "AsphaltV1",
+    "BulkMaterialsV1",
+    "CastDecksAndUnderlaymentV1",
+    "CladdingV1",
+    "ConcreteV1",
+    "ConveyingEquipmentV1",
+    "ElectricalTransmissionAndDistributionEquipmentV1",
+    "ElectricalV1",
+    "ElectricityV1",
+    "FinishesV1",
+    "FireAndSmokeProtectionV1",
+    "FurnishingsV1",
+    "GroutingV1",
+    "ManufacturingInputsV1",
+    "MasonryV1",
+    "MaterialHandlingV1",
+    "MechanicalInsulationV1",
+    "MechanicalV1",
+    "NetworkInfrastructureV1",
+    "OpeningsV1",
+    "OtherElectricalEquipmentV1",
+    "OtherMaterialsV1",
+    "PlumbingV1",
+    "PrecastConcreteV1",
+    "SheathingV1",
+    "SteelV1",
+    "ThermalMoistureProtectionV1",
+    "UtilityPipingV1",
+    "WoodJoistsV1",
+    "WoodV1",
+]
+
 from openepd.model.specs.singular.accessories import AccessoriesV1
 from openepd.model.specs.singular.aggregates import AggregatesV1
 from openepd.model.specs.singular.aluminium import AluminiumV1

openepd/model/specs/asphalt.py

@@ -51,19 +51,19 @@ class AsphaltV1(BaseOpenEpdHierarchicalSpec):
 
     asphalt_rap: float | None = pydantic.Field(
         default=None,
-        description="Percent of mixture that has been replaced by recycled " "asphalt pavement (RAP).",
+        description="Percent of mixture that has been replaced by recycled asphalt pavement (RAP).",
         ge=0,
         le=1,
     )
     asphalt_ras: float | None = pydantic.Field(
         default=None,
-        description="Percent of mixture that has been replaced by recycled " "asphalt shingles (RAS).",
+        description="Percent of mixture that has been replaced by recycled asphalt shingles (RAS).",
         ge=0,
         le=1,
     )
     asphalt_ground_tire_rubber: float | None = pydantic.Field(
         default=None,
-        description="Percent of mixture that has been replaced " "by ground tire rubber (GTR).",
+        description="Percent of mixture that has been replaced by ground tire rubber (GTR).",
         ge=0,
         le=1,
     )

openepd/model/specs/base.py

@@ -40,7 +40,8 @@ class BaseOpenEpdHierarchicalSpec(BaseOpenEpdSpec, WithExtVersionMixin):
         # ensure that all the concrete spec objects fail on creations if they dont have _EXT_VERSION declared to
         # something meaningful
         if not hasattr(self, "_EXT_VERSION") or self._EXT_VERSION is None:
-            raise ValueError(f"Class {self.__class__} must declare an extension version")
+            msg = f"Class {self.__class__} must declare an extension version"
+            raise ValueError(msg)
         Version.parse_version(self._EXT_VERSION)  # validate format correctness
         super().__init__(**{"ext_version": self._EXT_VERSION, **data})
 

openepd/model/specs/enums.py

@@ -2017,7 +2017,8 @@ class InsulatingMaterial(StrEnum):
      - Polyisocyanurate: Polyisocyanurate
      - Expanded Polyethylene: Expanded Polyethylene
      - EPS: EPS
-     - Other: Other
+     - Wood Fiber = Wood Fiber
+    - Other: Other
 
     """
 
@@ -2029,6 +2030,8 @@ class InsulatingMaterial(StrEnum):
     POLYISOCYANURATE = "Polyisocyanurate"
     EXPANDED_POLYETHYLENE = "Expanded Polyethylene"
     EPS = "EPS"
+    WOOD_FIBER = "Wood Fiber"
+    POLYURETHANE = "Polyurethane"
     OTHER = "Other"
 
 
@@ -2439,13 +2442,18 @@ class CementBoardThickness(StrEnum):
     INCH_3_8 = '3/8"'
     INCH_1_2 = '1/2"'
     INCH_5_8 = '5/8"'
+    MM_4 = "4 mm"
+    MM_6 = "6 mm"
     MM_6_5 = "6.5 mm"
     MM_8_0 = "8.0 mm"
     MM_9_0 = "9.0 mm"
     MM_9_5 = "9.5 mm"
+    MM_10 = "10 mm"
+    MM_12 = "12 mm"
     MM_12_5 = "12.5 mm"
     MM_13 = "13 mm"
     MM_15 = "15 mm"
+    MM_16 = "16 mm"
     MM_18 = "18 mm"
 
 

openepd/model/specs/range/__init__.py

@@ -13,9 +13,9 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 #
-__all__ = ("SpecsRange",)
-
-# NB! This is a generated code. Do not edit it manually. Please see src/openepd/model/specs/README.md
+__all__ = [
+    "SpecsRange",
+]
 
 
 from openepd.model.specs.base import BaseOpenEpdHierarchicalSpec
@@ -33,6 +33,7 @@ from .conveying_equipment import ConveyingEquipmentRangeV1
 from .electrical import ElectricalRangeV1
 from .electrical_transmission_and_distribution_equipment import ElectricalTransmissionAndDistributionEquipmentRangeV1
 from .electricity import ElectricityRangeV1
+from .exterior_improvements import ExteriorImprovementsRangeV1
 from .finishes import FinishesRangeV1
 from .fire_and_smoke_protection import FireAndSmokeProtectionRangeV1
 from .furnishings import FurnishingsRangeV1
@@ -99,3 +100,4 @@ class SpecsRange(BaseOpenEpdHierarchicalSpec):
     MechanicalInsulation: MechanicalInsulationRangeV1 | None = None
     OtherElectricalEquipment: OtherElectricalEquipmentRangeV1 | None = None
     WoodJoists: WoodJoistsRangeV1 | None = None
+    ExteriorImprovements: ExteriorImprovementsRangeV1 | None = None