openepd 4.13.1__py3-none-any.whl → 5.1.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 = "4.13.1"
+VERSION = "5.1.0"

openepd/model/common.py

@@ -42,7 +42,7 @@ class Measurement(BaseOpenEpdSchema):
     """A scientific value with units and uncertainty."""
 
     mean: float = pyd.Field(description="Mean (expected) value of the measurement")
-    unit: str = pyd.Field(description="Measurement unit")
+    unit: str | None = pyd.Field(description="Measurement unit")
     rsd: pyd.PositiveFloat | None = pyd.Field(
         description="Relative standard deviation, i.e. standard_deviation/mean", default=None
     )
@@ -150,3 +150,42 @@ class OpenEPDUnit(StrEnum):
     degree_c = "°C"
     kg_co2 = "kgCO2e"
     hour = "hour"
+
+
+class RangeBase(BaseOpenEpdSchema):
+    """Base class for range types having min and max and order between them."""
+
+    @pyd.root_validator
+    def _validate_range_bounds(cls, values: dict[str, Any]) -> dict[str, Any]:
+        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")
+        return values
+
+
+class RangeFloat(RangeBase):
+    """Structure representing a range of floats."""
+
+    min: float | None = pyd.Field(default=None, example=3.1)
+    max: float | None = pyd.Field(default=None, example=5.8)
+
+
+class RangeInt(RangeBase):
+    """Structure representing a range of ints1."""
+
+    min: int | None = pyd.Field(default=None, example=2)
+    max: int | None = pyd.Field(default=None, example=3)
+
+
+class RangeRatioFloat(RangeFloat):
+    """Range of ratios (0-1 to 0-10)."""
+
+    min: float | None = pyd.Field(default=None, example=0.2, ge=0, le=1)
+    max: float | None = pyd.Field(default=None, example=0.65, ge=0, le=1)
+
+
+class RangeAmount(RangeFloat):
+    """Structure representing a range of quantities."""
+
+    unit: str | None = pyd.Field(default=None, description="Unit of the range.")

openepd/model/declaration.py

@@ -22,6 +22,7 @@ from openepd.model.common import Amount
 from openepd.model.geography import Geography
 from openepd.model.org import Org
 from openepd.model.pcr import Pcr
+from openepd.model.specs.range import SpecsRange
 from openepd.model.standard import Standard
 from openepd.model.validation.common import ReferenceStr
 from openepd.model.validation.quantity import AmountGWP, AmountMass
@@ -141,14 +142,14 @@ class BaseDeclaration(RootDocument, abc.ABC):
         description="Mass of elemental carbon, per declared unit, contained in the product itself at the manufacturing "
         "facility gate.  Used (among other things) to check a carbon balance or calculate incineration "
         "emissions.  The source of carbon (e.g. biogenic) is not relevant in this field.",
-        example=Amount(qty=8.76, unit="kgCO2e"),
+        example=Amount(qty=8.76, unit="kgCO2e").to_serializable(exclude_unset=True),
     )
     kg_C_biogenic_per_declared_unit: AmountGWP | None = pyd.Field(
         default=None,
         description="Mass of elemental carbon from biogenic sources, per declared unit, contained in the product "
         "itself at the manufacturing facility gate.  It may be presumed that any biogenic carbon content "
         "has been accounted for as -44/12 kgCO2e per kg C in stages A1-A3, per EN15804 and ISO 21930.",
-        example=Amount(qty=8.76, unit="kgCO2e"),
+        example=Amount(qty=8.76, unit="kgCO2e").to_serializable(exclude_unset=True),
     )
     product_service_life_years: float | None = pyd.Field(
         gt=0.0009,
@@ -173,6 +174,10 @@ class AverageDatasetMixin(pyd.BaseModel, title="Average Dataset"):
         "implies global applicability.",
     )
 
+    specs: SpecsRange | None = pyd.Field(
+        default=None, description="Average dataset material performance specifications."
+    )
+
 
 class WithProgramOperatorMixin(pyd.BaseModel):
     """Object which has a connection to ProgramOperator."""

openepd/model/geography.py

@@ -279,7 +279,7 @@ class Geography(StrEnum):
      * ZM: Zambia
      * ZW: Zimbabwe
 
-    USA and Canada subdivisions, see https://en.wikipedia.org/wiki/ISO_3166-1:
+    USA states and Canada provinces, see https://en.wikipedia.org/wiki/ISO_3166-1:
 
      * CA-AB: Alberta, Canada
      * CA-BC: British Columbia, Canada

openepd/model/lcia.py

@@ -14,10 +14,12 @@
 #  limitations under the License.
 #
 from enum import StrEnum
+from typing import Any, ClassVar
 
 from openepd.compat.pydantic import pyd
 from openepd.model.base import BaseOpenEpdSchema
 from openepd.model.common import Measurement
+from openepd.model.validation.quantity import ExternalValidationConfig
 
 
 class EolScenario(BaseOpenEpdSchema):
@@ -70,6 +72,8 @@ class ScopeSet(BaseOpenEpdSchema):
     The 'unit' field must be consistent across all scopes in a single scopeset.
     """
 
+    allowed_units: ClassVar[str | tuple[str, ...] | None] = None
+
     A1A2A3: Measurement | None = pyd.Field(
         description="Sum of A1..A3",
         default=None,
@@ -194,17 +198,56 @@ class ScopeSet(BaseOpenEpdSchema):
         description="Potential net benefits from reuse, recycling, and/or energy recovery beyond the system boundary.",
     )
 
+    @pyd.root_validator
+    def _unit_validator(cls, values: dict[str, Any]) -> dict[str, Any]:
+        all_units = set()
+
+        for k, v in values.items():
+            if isinstance(v, Measurement):
+                all_units.add(v.unit)
+
+        # 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.")
+
+        # can correctly validate unit
+        if cls.allowed_units is not None and len(all_units) == 1 and ExternalValidationConfig.QUANTITY_VALIDATOR:
+            unit = next(iter(all_units))
+            allowed_units = cls.allowed_units if isinstance(cls.allowed_units, tuple) else (cls.allowed_units,)
 
-class ScopesetByNameBase(BaseOpenEpdSchema):
+            matched_unit = False
+            for allowed_unit in allowed_units:
+                try:
+                    ExternalValidationConfig.QUANTITY_VALIDATOR.validate_same_dimensionality(unit, allowed_unit)
+                    matched_unit = True
+                except ValueError:
+                    ...
+            if not matched_unit:
+                raise ValueError(
+                    f"'{', '.join(allowed_units)}' is only allowed unit for this scopeset. Provided '{unit}'"
+                )
+
+        return values
+
+
+class ScopesetByNameBase(BaseOpenEpdSchema, extra="allow"):
     """Base class for the data structures presented as typed name:scopeset mapping ."""
 
     def get_scopeset_names(self) -> list[str]:
         """
         Get the names of scopesets which have been set by model (not defaults).
 
-        :return: set of names, for example ['gwp', 'odp]
+        :return: set of names, for example ['gwp', 'odp']
         """
-        return [self.__fields__[f].alias or f for f in self.__fields_set__ if f not in ("ext",)]
+        result = []
+        for f in self.__fields_set__:
+            if f in ("ext",):
+                continue
+            field = self.__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)
+
+        return result
 
     def get_scopeset_by_name(self, name: str) -> ScopeSet | None:
         """
@@ -213,39 +256,133 @@ class ScopesetByNameBase(BaseOpenEpdSchema):
         :param name: The name of the scopeset.
         :return: A scopeset if found, None otherwise
         """
+        # check known impacts first
         for f_name, f in self.__fields__.items():
             if f.alias == name:
                 return getattr(self, f_name)
             if f_name == name:
                 return getattr(self, f_name)
+        # probably unknown impact, coming from 'extra' fields
+        return getattr(self, name, None)
+
+    @pyd.root_validator(skip_on_failure=True)
+    def _extra_scopeset_validator(cls, values: dict[str, Any]) -> dict[str, Any]:
+        for f in values:
+            # only interested in validating the extra fields
+            if f in cls.__fields__:
+                continue
+
+            # extra impact of an unknown type - engage validation of ScopeSet
+            extra_scopeset = values.get(f)
+            match extra_scopeset:
+                case ScopeSet():
+                    continue
+                case dict():
+                    values[f] = ScopeSet(**extra_scopeset)
+                case _:
+                    raise ValueError(f"{f} must be a ScopeSet schema")
+
+        return values
+
+
+class ScopeSetGwp(ScopeSet):
+    """ScopeSet measured in kgCO2e."""
+
+    allowed_units = "kgCO2e"
+
+
+class ScopeSetOdp(ScopeSet):
+    """ScopeSet measured in kgCFC11e."""
+
+    allowed_units = "kgCFC11e"
+
+
+class ScopeSetAp(ScopeSet):
+    """ScopeSet measured in kgSO2e."""
+
+    allowed_units = ("kgSO2e", "molHe")
+
+
+class ScopeSetEpNe(ScopeSet):
+    """ScopeSet measured in kgNe."""
+
+    allowed_units = "kgNe"
+
+
+class ScopeSetPocp(ScopeSet):
+    """ScopeSet measured in kgO3e."""
+
+    allowed_units = ("kgO3e", "kgNMVOCe")
+
+
+class ScopeSetEpFresh(ScopeSet):
+    """ScopeSet measured in kgPO4e."""
+
+    allowed_units = "kgPO4e"
+
+
+class ScopeSetEpTerr(ScopeSet):
+    """ScopeSet measured in molNe."""
 
-        return None
+    allowed_units = "molNe"
+
+
+class ScopeSetIrp(ScopeSet):
+    """ScopeSet measured in kilo Becquerel equivalent of u235."""
+
+    allowed_units = "kBqU235e"
+
+
+class ScopeSetCTUh(ScopeSet):
+    """ScopeSet measured in CTUh."""
+
+    allowed_units = "CTUh"
+
+
+class ScopeSetM3Aware(ScopeSet):
+    """ScopeSet measured in m3AWARE Water consumption by AWARE method."""
+
+    allowed_units = "m3AWARE"
+
+
+class ScopeSetCTUe(ScopeSet):
+    """ScopeSet measured in CTUe."""
+
+    allowed_units = "CTUe"
+
+
+class ScopeSetDiseaseIncidence(ScopeSet):
+    """ScopeSet measuring disease incidence measured in AnnualPerCapita (cases)."""
+
+    allowed_units = "AnnualPerCapita"
 
 
 class ImpactSet(ScopesetByNameBase):
     """A set of impacts, such as GWP, ODP, AP, EP, POCP, EP-marine, EP-terrestrial, EP-freshwater, etc."""
 
-    gwp: ScopeSet | None = pyd.Field(
+    gwp: ScopeSetGwp | None = pyd.Field(
         default=None,
         description="GWP100, calculated per IPCC guidelines.  If any CO2 removals are "
         "part of this figure, the gwp-fossil, gwp-bioganic, gwp-luluc, an "
         "gwp-nonCO2 fields are required, as is "
         "kg_C_biogenic_per_declared_unit.",
     )
-    odp: ScopeSet | None = pyd.Field(default=None, description="Ozone Depletion Potential")
-    ap: ScopeSet | None = pyd.Field(default=None, description="Acidification Potential")
-    ep: ScopeSet | None = pyd.Field(
+    odp: ScopeSetOdp | None = pyd.Field(default=None, description="Ozone Depletion Potential")
+    ap: ScopeSetAp | None = pyd.Field(default=None, description="Acidification Potential")
+    ep: ScopeSetEpNe | None = pyd.Field(
         default=None, description="Eutrophication Potential in Marine Ecosystems. Has the same meaning as ep-marine."
     )
-    pocp: ScopeSet | None = pyd.Field(default=None, description="Photochemical Smog (Ozone) creation potential")
-    ep_marine: ScopeSet | None = pyd.Field(alias="ep-marine", default=None, description="Has the same meaning as 'ep'")
-    ep_fresh: ScopeSet | None = pyd.Field(
+    pocp: ScopeSetPocp | None = pyd.Field(default=None, description="Photochemical Smog (Ozone) creation potential")
+    ep_marine: ScopeSetEpNe | None = pyd.Field(
+        alias="ep-marine", default=None, description="Has the same meaning as 'ep'"
+    )
+    ep_fresh: ScopeSetEpFresh | None = pyd.Field(
         alias="ep-fresh", default=None, description="Eutrophication Potential in Freshwater Ecosystems"
     )
-    ep_terr: ScopeSet | None = pyd.Field(
+    ep_terr: ScopeSetEpTerr | None = pyd.Field(
         alias="ep-terr", default=None, description="Eutrophication Potential in Terrestrial Ecosystems"
     )
-    gwp_biogenic: ScopeSet | None = pyd.Field(
+    gwp_biogenic: ScopeSetGwp | None = pyd.Field(
         alias="gwp-biogenic",
         default=None,
         description="Net GWP from removals of atmospheric CO2 into biomass and  emissions of CO2 from biomass sources. "
@@ -254,7 +391,7 @@ class ImpactSet(ScopesetByNameBase):
         "space (similar biome).  They must not have been sold, committed, or credited to any other "
         "product.  Harvesting from native forests is handled under GWP_luluc for EN15804.",
     )
-    gwp_luluc: ScopeSet | None = pyd.Field(
+    gwp_luluc: ScopeSetGwp | None = pyd.Field(
         alias="gwp-luluc",
         default=None,
         description="Climate change effects related to land use and land use change, for example biogenic carbon "
@@ -262,17 +399,49 @@ class ImpactSet(ScopesetByNameBase):
         "emissions). All related emissions for native forests are included under this category. "
         "Uptake for native forests is set to 0 kgCO2 for EN15804.",
     )
-    gwp_nonCO2: ScopeSet | None = pyd.Field(
+    gwp_nonCO2: ScopeSetGwp | None = pyd.Field(
         alias="gwp-nonCO2",
         default=None,
         description="GWP from non-CO2, non-fossil sources, such as livestock-sourced CH4 and agricultural N2O.",
     )
-    gwp_fossil: ScopeSet | None = pyd.Field(
+    gwp_fossil: ScopeSetGwp | None = pyd.Field(
         alias="gwp-fossil",
         default=None,
         description="Climate change effects due to greenhouse gas emissions originating from the oxidation or "
         "reduction of fossil fuels or materials containing fossil carbon. [Source: EN15804]",
     )
+    WDP: ScopeSetM3Aware | None = pyd.Field(
+        default=None,
+        description="Deprivation-weighted water consumption, calculated by the AWARE method "
+        "(https://wulca-waterlca.org/aware/what-is-aware)",
+    )
+    PM: ScopeSetDiseaseIncidence | None = pyd.Field(
+        default=None,
+        description="Potential incidence of disease due to particulate matter emissions.",
+    )
+    IRP: ScopeSetIrp | None = pyd.Field(
+        default=None,
+        description="Potential ionizing radiation effect on human health, relative to U235.",
+    )
+    ETP_fw: ScopeSetCTUe | None = pyd.Field(
+        alias="ETP-fw",
+        default=None,
+        description="Ecotoxicity in freshwater, in potential Comparative Toxic Unit for ecosystems.",
+    )
+    HTP_c: ScopeSetCTUh | None = pyd.Field(
+        alias="HTP-c",
+        default=None,
+        description="Human toxicity, cancer effects in potential Comparative Toxic Units for humans.",
+    )
+    HTP_nc: ScopeSetCTUh | None = pyd.Field(
+        alias="HTP-nc",
+        default=None,
+        description="Human toxicity, noncancer effects in potential Comparative Toxic Units for humans.",
+    )
+    SQP: ScopeSet | None = pyd.Field(
+        default=None,
+        description="Land use related impacts / Soil quality, in potential soil quality parameters.",
+    )
 
 
 class LCIAMethod(StrEnum):
@@ -512,12 +681,15 @@ class WithLciaMixin(BaseOpenEpdSchema):
     """Mixin for LCIA data."""
 
     impacts: Impacts | None = pyd.Field(
-        description="List of environmental impacts, compiled per one of the standard Impact Assessment methods"
+        description="List of environmental impacts, compiled per one of the standard Impact Assessment methods",
+        example={"TRACI 2.1": {"gwp": {"A1A2A3": {"mean": 22.4, "unit": "kgCO2e"}}}},
     )
     resource_uses: ResourceUseSet | None = pyd.Field(
-        description="Set of Resource Use Indicators, over various LCA scopes"
+        description="Set of Resource Use Indicators, over various LCA scopes",
+        example={"RPRe": {"A1A2A3": {"mean": 12, "unit": "MJ", "rsd": 0.12}}},
     )
     output_flows: OutputFlowSet | None = pyd.Field(
         description="Set of Waste and Output Flow indicators which describe the waste categories "
-        "and other material output flows derived from the LCI."
+        "and other material output flows derived from the LCI.",
+        example={"hwd": {"A1A2A3": {"mean": 2300, "unit": "kg", "rsd": 0.22}}},
     )

openepd/model/pcr.py

@@ -91,12 +91,12 @@ class Pcr(WithAttachmentsMixin, WithAltIdsMixin, BaseOpenEpdSchema):
         default=None,
     )
     date_of_issue: datetime.datetime | None = pyd.Field(
-        example=datetime.date(day=11, month=2, year=2022),
+        example=datetime.datetime(day=11, month=9, year=2019, tzinfo=datetime.timezone.utc),
         default=None,
         description="First day on which the document is valid",
     )
     valid_until: datetime.datetime | None = pyd.Field(
-        example=datetime.date(day=11, month=2, year=2024),
+        example=datetime.datetime(day=11, month=9, year=2019, tzinfo=datetime.timezone.utc),
         default=None,
         description="Last day on which the document is valid",
     )

openepd/model/specs/README.md

@@ -1,19 +1,45 @@
 # Material Extensions
 
-This package contains openEPD material extensions. They are used to represent the material properties of the openEPD 
-materials, and are a more dynamic, frequently changing part of the standard. 
+This package contains openEPD material extensions. They are used to represent the material properties of the openEPD
+materials, and are a more dynamic, frequently changing part of the standard.
 
 ## Versioning
 
-Extensions are versioned separately from the openEPD standard or openEPD API. 
+Extensions are versioned separately from the openEPD standard or openEPD API.
 
-Each material extension is named after the corresponding EC3 product class, and is located in the relevant place 
-in the specs tree. For example, `RebarSteel` is nested under `Steel`. 
+Each material extension is named after the corresponding EC3 product class, and is located in the relevant place
+in the specs tree. For example, `RebarSteel` is nested under `Steel`.
 
-Extensions are versioned as Major.Minor, for example "2.4". 
+Extensions are versioned as Major.Minor, for example "2.4".
+
+Rules:
 
-Rules: 
 1. Minor versions for the same major version should be backwards compatible.
-2. Major versions are not compatible between themselves. 
+2. Major versions are not compatible between themselves.
 3. Pydantic models representing versions are named in a pattern SpecNameV1, where 1 is major version and SpecName is
    the name of the material extension.
+
+## Range specs
+
+Normal EPDs get singular specs (e.g. `SteelV1`). Single specs can express performance parameters of one concrete
+material/EPD. However, the IndustryEDPs and Generic Estimates often cover a specific segment of the market, and
+include a range of products under the hood, thus demanding for ranges. For example, a single EPD has one `strength_28d`
+of `4000 psi`, but an industry EPD can be applicable to certain concretes in the range of `4000 psi` to `5000 psi`.
+
+Range specs are used to express that. Range specs are located in `specs.range` package, and are auto-generated from the
+single specs, please see `make codegen` command and `tools/openepd/codegen/generate_range_spec_models.py`
+
+Range specs are created by following general rules:
+
+1. A QuantityStr (such as `QuantityMassKg`) becomes an `AmountRange` of certain type - `AmountRangeMass`
+2. Float -> RangeFloat, Ratio -> RatioRange, int -> IntRange
+3. Enums become lists of enums, for example: `cable_trays_material: enums.CableTrayMaterial` in normal spec becomes a
+   `cable_trays_material: list[enums.CabeTrayMaterial]` in the range spec.
+4. Complex objects, strings remain unchanged.
+
+This is, however, not always desired. For example, `recarbonation: float` and `recarbonation_z: float` property of CMU
+should not be converted to ranges as these do not make sense.
+
+The default rule-base behaviour can be overridden with the
+`CodeGenSpec` class annotation like this: `recarbonation: Annotated[float, CodeGenSpec(override_type=float)]` in single
+spec to make RangeSpec have normal `float` type.

openepd/model/specs/asphalt.py

@@ -19,7 +19,7 @@ from openepd.compat.pydantic import pyd
 from openepd.model.common import OpenEPDUnit
 from openepd.model.specs.base import BaseOpenEpdHierarchicalSpec
 from openepd.model.validation.numbers import RatioFloat
-from openepd.model.validation.quantity import LengthMmStr, TemperatureCStr, validate_unit_factory
+from openepd.model.validation.quantity import LengthMmStr, TemperatureCStr, validate_quantity_unit_factory
 
 
 class AsphaltMixType(StrEnum):
@@ -79,5 +79,5 @@ class AsphaltV1(BaseOpenEpdHierarchicalSpec):
     asphalt_pmb: bool | None = pyd.Field(default=None, description="Polymer modified bitumen (PMB)")
 
     _aggregate_size_max_validator = pyd.validator("asphalt_aggregate_size_max", allow_reuse=True)(
-        validate_unit_factory(OpenEPDUnit.m)
+        validate_quantity_unit_factory(OpenEPDUnit.m)
     )

openepd/model/specs/base.py

@@ -13,12 +13,13 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 #
+import dataclasses
 from typing import Any
 
 from openepd.compat.pydantic import pyd
 from openepd.model.base import BaseOpenEpdSchema, Version
 from openepd.model.validation.common import validate_version_compatibility, validate_version_format
-from openepd.model.validation.quantity import QuantityValidator
+from openepd.model.validation.quantity import ExternalValidationConfig, QuantityValidator
 from openepd.model.versioning import WithExtVersionMixin
 
 
@@ -32,9 +33,6 @@ class BaseOpenEpdSpec(BaseOpenEpdSchema):
 class BaseOpenEpdHierarchicalSpec(BaseOpenEpdSpec, WithExtVersionMixin):
     """Base class for new specs (hierarchical, versioned)."""
 
-    # external validator for quantities (e.g. length, mass, etc.) which should be setup by the user of the library.
-    _QUANTITY_VALIDATOR: QuantityValidator | None = None
-
     def __init__(self, **data: Any) -> None:
         # ensure that all the concrete spec objects fail on creations if they dont have _EXT_VERSION declared to
         # something meaningful
@@ -53,4 +51,16 @@ class BaseOpenEpdHierarchicalSpec(BaseOpenEpdSpec, WithExtVersionMixin):
 
 def setup_external_validators(quantity_validator: QuantityValidator):
     """Set the implementation unit validator for specs."""
-    BaseOpenEpdHierarchicalSpec._QUANTITY_VALIDATOR = quantity_validator
+    ExternalValidationConfig.QUANTITY_VALIDATOR = quantity_validator
+
+
+@dataclasses.dataclass(kw_only=True)
+class CodegenSpec:
+    """
+    Specification for codegen when generating RangeSpecs from normal specs.
+
+    See openepd.mode.specs.README.md for details.
+    """
+
+    exclude_from_codegen: bool = False
+    override_type: type

openepd/model/specs/generated/__init__.py

@@ -13,3 +13,83 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 #
+
+from openepd.model.specs.base import BaseOpenEpdHierarchicalSpec
+from openepd.model.specs.generated.accessories import AccessoriesV1
+from openepd.model.specs.generated.aggregates import AggregatesV1
+from openepd.model.specs.generated.aluminium import AluminiumV1
+from openepd.model.specs.generated.asphalt import AsphaltV1
+from openepd.model.specs.generated.bulk_materials import BulkMaterialsV1
+from openepd.model.specs.generated.cast_decks_and_underlayment import CastDecksAndUnderlaymentV1
+from openepd.model.specs.generated.cladding import CladdingV1
+from openepd.model.specs.generated.cmu import CMUV1
+from openepd.model.specs.generated.concrete import ConcreteV1
+from openepd.model.specs.generated.conveying_equipment import ConveyingEquipmentV1
+from openepd.model.specs.generated.electrical import ElectricalV1
+from openepd.model.specs.generated.electrical_transmission_and_distribution_equipment import (
+    ElectricalTransmissionAndDistributionEquipmentV1,
+)
+from openepd.model.specs.generated.electricity import ElectricityV1
+from openepd.model.specs.generated.finishes import FinishesV1
+from openepd.model.specs.generated.fire_and_smoke_protection import FireAndSmokeProtectionV1
+from openepd.model.specs.generated.furnishings import FurnishingsV1
+from openepd.model.specs.generated.grouting import GroutingV1
+from openepd.model.specs.generated.manufacturing_inputs import ManufacturingInputsV1
+from openepd.model.specs.generated.masonry import MasonryV1
+from openepd.model.specs.generated.material_handling import MaterialHandlingV1
+from openepd.model.specs.generated.mechanical import MechanicalV1
+from openepd.model.specs.generated.mechanical_insulation import MechanicalInsulationV1
+from openepd.model.specs.generated.network_infrastructure import NetworkInfrastructureV1
+from openepd.model.specs.generated.openings import OpeningsV1
+from openepd.model.specs.generated.other_electrical_equipment import OtherElectricalEquipmentV1
+from openepd.model.specs.generated.other_materials import OtherMaterialsV1
+from openepd.model.specs.generated.plumbing import PlumbingV1
+from openepd.model.specs.generated.precast_concrete import PrecastConcreteV1
+from openepd.model.specs.generated.sheathing import SheathingV1
+from openepd.model.specs.generated.steel import SteelV1
+from openepd.model.specs.generated.thermal_moisture_protection import ThermalMoistureProtectionV1
+from openepd.model.specs.generated.utility_piping import UtilityPipingV1
+from openepd.model.specs.generated.wood import WoodV1
+from openepd.model.specs.generated.wood_joists import WoodJoistsV1
+
+
+class Specs(BaseOpenEpdHierarchicalSpec):
+    """Material specific specs."""
+
+    _EXT_VERSION = "1.0"
+
+    # Nested specs:
+    CMU: CMUV1 | None = None
+    Masonry: MasonryV1 | None = None
+    Steel: SteelV1 | None = None
+    NetworkInfrastructure: NetworkInfrastructureV1 | None = None
+    Finishes: FinishesV1 | None = None
+    ManufacturingInputs: ManufacturingInputsV1 | None = None
+    Accessories: AccessoriesV1 | None = None
+    ElectricalTransmissionAndDistributionEquipment: ElectricalTransmissionAndDistributionEquipmentV1 | None = None
+    Aggregates: AggregatesV1 | None = None
+    ThermalMoistureProtection: ThermalMoistureProtectionV1 | None = None
+    Mechanical: MechanicalV1 | None = None
+    Aluminium: AluminiumV1 | None = None
+    Cladding: CladdingV1 | None = None
+    FireAndSmokeProtection: FireAndSmokeProtectionV1 | None = None
+    PrecastConcrete: PrecastConcreteV1 | None = None
+    Asphalt: AsphaltV1 | None = None
+    OtherMaterials: OtherMaterialsV1 | None = None
+    Plumbing: PlumbingV1 | None = None
+    Electrical: ElectricalV1 | None = None
+    UtilityPiping: UtilityPipingV1 | None = None
+    BulkMaterials: BulkMaterialsV1 | None = None
+    CastDecksAndUnderlayment: CastDecksAndUnderlaymentV1 | None = None
+    Concrete: ConcreteV1 | None = None
+    Sheathing: SheathingV1 | None = None
+    Furnishings: FurnishingsV1 | None = None
+    Wood: WoodV1 | None = None
+    ConveyingEquipment: ConveyingEquipmentV1 | None = None
+    MaterialHandling: MaterialHandlingV1 | None = None
+    Openings: OpeningsV1 | None = None
+    Electricity: ElectricityV1 | None = None
+    Grouting: GroutingV1 | None = None
+    MechanicalInsulation: MechanicalInsulationV1 | None = None
+    OtherElectricalEquipment: OtherElectricalEquipmentV1 | None = None
+    WoodJoists: WoodJoistsV1 | None = None

openepd/model/specs/generated/cladding.py

@@ -16,7 +16,7 @@
 from openepd.compat.pydantic import pyd
 from openepd.model.specs.base import BaseOpenEpdHierarchicalSpec
 from openepd.model.specs.generated.enums import CladdingFacingMaterial, CladdingInsulatingMaterial, SidingFormFactor
-from openepd.model.validation.quantity import LengthMmStr, LengthMStr, RValueStr, validate_unit_factory
+from openepd.model.validation.quantity import LengthMmStr, LengthMStr, RValueStr, validate_quantity_unit_factory
 
 
 class AluminiumSidingV1(BaseOpenEpdHierarchicalSpec):
@@ -75,7 +75,7 @@ class InsulatedVinylSidingV1(BaseOpenEpdHierarchicalSpec):
     thickness: LengthMmStr | None = pyd.Field(default=None, description="", example="1 mm")
 
     _vinyl_siding_thickness_is_quantity_validator = pyd.validator("thickness", allow_reuse=True)(
-        validate_unit_factory("m")
+        validate_quantity_unit_factory("m")
     )
 
 
@@ -109,7 +109,7 @@ class VinylSidingV1(BaseOpenEpdHierarchicalSpec):
     thickness: LengthMmStr | None = pyd.Field(default=None, description="", example="5 mm")
 
     _vinyl_siding_thickness_is_quantity_validator = pyd.validator("thickness", allow_reuse=True)(
-        validate_unit_factory("m")
+        validate_quantity_unit_factory("m")
     )
 
 
@@ -191,7 +191,7 @@ class CladdingV1(BaseOpenEpdHierarchicalSpec):
     thickness: LengthMStr | None = pyd.Field(default=None, description="", example="10 mm")
     facing_material: CladdingFacingMaterial | None = pyd.Field(default=None, description="", example="Steel")
 
-    _thickness_is_quantity_validator = pyd.validator("thickness", allow_reuse=True)(validate_unit_factory("m"))
+    _thickness_is_quantity_validator = pyd.validator("thickness", allow_reuse=True)(validate_quantity_unit_factory("m"))
 
     # Nested specs:
     Siding: SidingV1 | None = None