openepd 6.4.1__tar.gz → 6.5.0__tar.gz

{openepd-6.4.1 → openepd-6.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: openepd
-Version: 6.4.1
+Version: 6.5.0
 Summary: Python library to work with OpenEPD format
 Home-page: https://github.com/cchangelabs/openepd
 License: Apache-2.0

{openepd-6.4.1 → openepd-6.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "openepd"
-version = "6.4.1"
+version = "6.5.0"
 license = "Apache-2.0"
 description = "Python library to work with OpenEPD format"
 authors = ["C-Change Labs <support@c-change-labs.com>"]

{openepd-6.4.1 → openepd-6.5.0}/src/openepd/__version__.py

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

{openepd-6.4.1 → openepd-6.5.0}/src/openepd/model/lcia.py

@@ -206,9 +206,17 @@ class ScopeSet(BaseOpenEpdSchema):
             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.")
+        if not cls.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.")
+        else:
+            # might be multiple variations of the same unit (kgCFC-11e, kgCFC11e)
+            if len(all_units) > 1 and ExternalValidationConfig.QUANTITY_VALIDATOR:
+                all_units_list = list(all_units)
+                first = all_units_list[0]
+                for unit in all_units_list[1:]:
+                    ExternalValidationConfig.QUANTITY_VALIDATOR.validate_same_dimensionality(first, unit)
 
         # can correctly validate unit
         if cls.allowed_units is not None and len(all_units) == 1 and ExternalValidationConfig.QUANTITY_VALIDATOR:

{openepd-6.4.1 → openepd-6.5.0}/src/openepd/model/specs/concrete.py

@@ -13,7 +13,6 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 #
-from enum import StrEnum
 
 from openepd.compat.pydantic import pyd
 from openepd.model.base import BaseOpenEpdSchema
@@ -21,56 +20,6 @@ from openepd.model.specs.base import BaseOpenEpdSpec
 from openepd.model.validation.numbers import RatioFloat
 
 
-class CmuWeightClassification(StrEnum):
-    """Concrete Masonry Unit weight classification."""
-
-    Normal = "Normal"
-    """Normal weight CMU has a density of 125 lbs/cu. ft."""
-    Medium = "Medium"
-    """Medium weight CMU has a density of 105-125 lbs/cu. ft."""
-    Light = "Light"
-    """Lightweight CMU has a density less than 105 lbs/cu. ft."""
-
-
-class CmuOptions(BaseOpenEpdSchema):
-    """Concrete Masonry Unit options."""
-
-    load_bearing: bool | None = pyd.Field(
-        description="Load-Bearing. CMUs intended to be loadbearing, rather than simply cosmetic",
-        example=True,
-        default=None,
-    )
-    aerated_concrete: bool | None = pyd.Field(
-        description="AAC Aerated Concrete. Aerated Autoclaved Concrete, a foam concrete.", example=True, default=None
-    )
-    insulated: bool | None = pyd.Field(
-        description="Insulated. CMUs with integral insulation", example=True, default=None
-    )
-    sound_absorbing: bool | None = pyd.Field(
-        description="Sound Absorbing. CMUs structured for sound absorbtion", example=True, default=None
-    )
-    white: bool | None = pyd.Field(
-        description="White. CMU using white cement and light-colored aggregate", example=True, default=None
-    )
-    recycled_aggregate: bool | None = pyd.Field(
-        description="Recycled aggregate. CMU using primarily reycled aggregates", example=True, default=None
-    )
-    groundface: bool | None = pyd.Field(
-        description="Ground Face. Ground or Honed facing, typically for improved appearance", example=True, default=None
-    )
-    splitface: bool | None = pyd.Field(
-        description="Splitface. Rough surface texture via splitting; aggregate can be seen", example=True, default=None
-    )
-    smoothface: bool | None = pyd.Field(
-        description="Smooth Face. Standard smooth-faced blocks", example=True, default=None
-    )
-    slumpstone: bool | None = pyd.Field(
-        description="Slumpstone. A slightly rounded, random distortion with the look of rustic adobe.",
-        example=True,
-        default=None,
-    )
-
-
 class ConcreteTypicalApplication(BaseOpenEpdSpec):
     """Typical Application for Concrete."""
 
@@ -138,15 +87,6 @@ class ConcreteTypicalApplication(BaseOpenEpdSpec):
     )
 
 
-class CmuSpec(BaseOpenEpdSpec):
-    """Standardized Concrete Masonry Unit-specific extension for OpenEPD."""
-
-    strength: str = pyd.Field(description="Compressive strength", example="4000 psi")
-    options: CmuOptions = pyd.Field(
-        description="Options for CMU. List of true/false properties", default_factory=CmuOptions
-    )
-
-
 class Cementitious(BaseOpenEpdSchema):
     """List of cementitious materials, and proportion by mass."""
 
@@ -168,34 +108,3 @@ class Cementitious(BaseOpenEpdSchema):
     mk: RatioFloat | None = pyd.Field(default=None, description="Metakaolin", example=0.5, ge=0, le=1)
     CaCO3: RatioFloat | None = pyd.Field(default=None, description="Limestone", example=0.5, ge=0, le=1)
     other: RatioFloat | None = pyd.Field(default=None, description="Other SCMs", example=0.5, ge=0, le=1)
-
-
-class TypicalApplication(BaseOpenEpdSchema):
-    """Concrete typical application."""
-
-    fnd: bool | None = pyd.Field(description="Foundation", default=None)
-    sog: bool | None = pyd.Field(description="Slab on Grade", default=None)
-    hrz: bool | None = pyd.Field(description="Elevated Horizontal", default=None)
-    vrt_wall: bool | None = pyd.Field(description="Vertical Wall", default=None)
-    vrt_column: bool | None = pyd.Field(description="Vertical Column", default=None)
-    vrt_other: bool | None = pyd.Field(description="Vertical Other", default=None)
-    sht: bool | None = pyd.Field(description="Shotcrete", default=None)
-    cdf: bool | None = pyd.Field(description="Flowable Fill (CDF,default=None)", default=None)
-    sac: bool | None = pyd.Field(description="Sidewalk and Curb", default=None)
-    pav: bool | None = pyd.Field(description="Paving", default=None)
-    oil: bool | None = pyd.Field(description="Oil Patch", default=None)
-    grt: bool | None = pyd.Field(description="Cement Grout", default=None)
-    ota: bool | None = pyd.Field(description="Other", default=None)
-
-
-class ConcreteV1Options(BaseOpenEpdSchema):
-    """Concrete options."""
-
-    lightweight: bool | None = pyd.Field(description="Lightweight", default=None)
-    plc: bool | None = pyd.Field(description="Portland Limestone Cement", default=None)
-    scc: bool | None = pyd.Field(description="Self Compacting", default=None)
-    finishable: bool | None = pyd.Field(description="Finishable", default=None)
-    air: bool | None = pyd.Field(description="Air Entrainment", default=None)
-    co2: bool | None = pyd.Field(description="CO2 Curing", default=None)
-    white: bool | None = pyd.Field(description="White Cement", default=None)
-    fiber_reinforced: bool | None = pyd.Field(description="Fiber reinforced", default=None)

{openepd-6.4.1 → openepd-6.5.0}/src/openepd/model/specs/singular/__init__.py

@@ -13,7 +13,9 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 #
-from openepd.model.base import BaseOpenEpdSchema
+from typing import Any, ClassVar
+
+from openepd.compat.pydantic import pyd
 from openepd.model.specs.base import BaseOpenEpdHierarchicalSpec
 from openepd.model.specs.singular.accessories import AccessoriesV1
 from openepd.model.specs.singular.aggregates import AggregatesV1
@@ -25,6 +27,9 @@ from openepd.model.specs.singular.cladding import CladdingV1
 from openepd.model.specs.singular.cmu import CMUV1
 from openepd.model.specs.singular.concrete import ConcreteV1
 from openepd.model.specs.singular.conveying_equipment import ConveyingEquipmentV1
+from openepd.model.specs.singular.deprecated import BaseCompatibilitySpec, get_safely, set_safely
+from openepd.model.specs.singular.deprecated.concrete import ConcreteOldSpec
+from openepd.model.specs.singular.deprecated.steel import SteelOldSpec
 from openepd.model.specs.singular.electrical import ElectricalV1
 from openepd.model.specs.singular.electrical_transmission_and_distribution_equipment import (
     ElectricalTransmissionAndDistributionEquipmentV1,
@@ -58,6 +63,8 @@ __all__ = ("Specs",)
 class Specs(BaseOpenEpdHierarchicalSpec):
     """Material specific specs."""
 
+    COMPATIBILITY_SPECS: ClassVar[list[type[BaseCompatibilitySpec]]] = [ConcreteOldSpec, SteelOldSpec]
+
     _EXT_VERSION = "1.0"
 
     # Nested specs:
@@ -95,3 +102,38 @@ class Specs(BaseOpenEpdHierarchicalSpec):
     MechanicalInsulation: MechanicalInsulationV1 | None = None
     OtherElectricalEquipment: OtherElectricalEquipmentV1 | None = None
     WoodJoists: WoodJoistsV1 | None = None
+
+    # historical backward-compatible specs
+    concrete: ConcreteOldSpec | None = None
+    steel: SteelOldSpec | None = None
+
+    @pyd.root_validator(pre=True)
+    def _ensure_backward_compatibiltiy(cls, values: dict[str, Any]) -> dict[str, Any]:
+        """
+        Restore the functionality for backward-compatible specs.
+
+        Originally, we used to have 'concrete' and 'steel' specs non-hierarchical and manually maintained. Since we
+        introduced hierarchical specs, there is a need to retain the key mapping to the old structure.
+
+        :return: modified values
+        """
+        for compat_spec in cls.COMPATIBILITY_SPECS:
+            if (
+                compat_spec.COMPATIBILITY_SPECS_KEY_OLD not in values
+                and compat_spec.COMPATIBILITY_SPECS_KEY_NEW not in values
+            ):
+                continue
+            for old_key_spec, new_key_spec in compat_spec.COMPATIBILITY_MAPPING.items():
+                has_new_spec, new_value = get_safely(values, new_key_spec)
+
+                # new value is set, we should not override it but should return it in old spec
+                if has_new_spec:
+                    set_safely(values, old_key_spec, new_value)
+                    continue
+
+                has_old_spec, old_value = get_safely(values, old_key_spec)
+                # nothing to back
+                if not has_old_spec:
+                    continue
+                set_safely(values, new_key_spec, old_value)
+        return values

openepd-6.5.0/src/openepd/model/specs/singular/deprecated/__init__.py

@@ -0,0 +1,79 @@
+#
+#  Copyright 2024 by C Change Labs Inc. www.c-change-labs.com
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+from typing import Any, ClassVar
+
+from openepd.compat.pydantic import pyd
+from openepd.model.base import BaseOpenEpdSchema
+
+
+class BaseCompatibilitySpec(BaseOpenEpdSchema):
+    """
+    Base class for compatibility (legacy) specs.
+
+    See Specs model for implementation.
+    """
+
+    COMPATIBILITY_SPECS_KEY_OLD: ClassVar[str]
+    COMPATIBILITY_SPECS_KEY_NEW: ClassVar[str]
+    COMPATIBILITY_MAPPING: ClassVar[dict[str, str]]
+
+
+def get_safely(d: dict, path: str) -> tuple[bool, Any]:
+    """
+    Get a value from a mixed object via dotted path.
+
+    Mixed object can be a combination of dicts and pydatnic Models on any hierarchy.
+    :param d: source dict/object to search in
+    :param path: dotted path in object like specs.Concrete.strength_28d
+    :return: tuple (WasFound, Value). First element tells if value was found, second - the value itself.
+    """
+    path_elements = path.split(".")
+    current: Any = d
+    for p in path_elements:
+        match current:
+            case dict():
+                if p not in current:
+                    return False, None
+                current = current.get(p)
+            case pyd.BaseModel() as model:
+                if not hasattr(current, p) or p not in model.__fields_set__:
+                    return False, None
+                current = getattr(current, p)
+            case _:
+                return False, None
+
+    return True, current
+
+
+def set_safely(d: dict, path: str, value: Any) -> None:
+    """
+    Safely set an element in a dict.
+
+    Warning: this is asymmetric compared to get_safely, since it sets value in a dict, not in pydantic model object.
+
+    :param d: source dict/object to set value in
+    :param path: dotted path in object like specs.Concrete.strength_28d
+    :param value: value to set
+    :return: None
+    """
+    path_elements = path.split(".")
+    current = d
+    for p in path_elements[:-1]:
+        if current.get(p) is None:
+            current[p] = {}
+        current = current[p]
+
+    current[path_elements[-1]] = value

openepd-6.5.0/src/openepd/model/specs/singular/deprecated/concrete.py

@@ -0,0 +1,100 @@
+#
+#  Copyright 2024 by C Change Labs Inc. www.c-change-labs.com
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+from typing import ClassVar, Literal
+
+from openepd.compat.pydantic import pyd
+from openepd.model.base import BaseOpenEpdSchema
+from openepd.model.specs.concrete import Cementitious, ConcreteTypicalApplication
+from openepd.model.specs.enums import AciExposureClass, CsaExposureClass, EnExposureClass
+from openepd.model.specs.singular import BaseCompatibilitySpec
+from openepd.model.validation.numbers import RatioFloat
+from openepd.model.validation.quantity import LengthInchStr, PressureMPaStr
+
+
+class ConcreteOptions(BaseOpenEpdSchema):
+    """Legacy Concrete options model."""
+
+    lightweight: bool | None = pyd.Field(
+        default=None, description="Lightweight. True if < 120lb/ft3 or 1900 kg/m3", example=True
+    )
+    scc: bool | None = pyd.Field(default=None, description="Self Compacting", example=True)
+    finishable: bool | None = pyd.Field(default=None, description="Finishable", example=True)
+    air: bool | None = pyd.Field(default=None, description="Air Entrainment", example=True)
+    co2_entrain: bool | None = pyd.Field(
+        default=None, description="CO2 Curing. Uses intentionally entrained CO2.", example=True
+    )
+    white_cement: bool | None = pyd.Field(default=None, description="White Cement", example=True)
+    plc: bool | None = pyd.Field(default=None, description="Portland Limestone Cement", example=True)
+    fiber_reinforced: bool | None = pyd.Field(default=None, description="fiber_reinforced", example=True)
+
+
+class ConcreteOldSpec(BaseCompatibilitySpec):
+    """Old version of the Concrete spec, please use Concrete hierarchical version instead."""
+
+    COMPATIBILITY_SPECS_KEY_OLD: ClassVar[str] = "concrete"
+    COMPATIBILITY_SPECS_KEY_NEW: ClassVar[str] = "Concrete"
+    COMPATIBILITY_MAPPING: ClassVar[dict[str, str]] = {
+        "concrete.strength_28d": "Concrete.strength_28d",
+        "concrete.slump": "Concrete.min_slump",
+        "concrete.strength_other": "Concrete.strength_other",
+        "concrete.strength_other_d": "Concrete.strength_other_d",
+        "concrete.w_c_ratio": "Concrete.w_c_ratio",
+        "concrete.aci_exposure_classes": "Concrete.aci_exposure_classes",
+        "concrete.csa_exposure_classes": "Concrete.csa_exposure_classes",
+        "concrete.en_exposure_classes": "Concrete.en_exposure_classes",
+        "concrete.application": "Concrete.typical_application",
+        "concrete.options.lightweight": "Concrete.lightweight",
+        "concrete.options.scc": "Concrete.self_consolidating",
+        "concrete.options.finishable": "Concrete.finishable",
+        "concrete.options.air": "Concrete.air_entrain",
+        "concrete.options.co2_entrain": "Concrete.co2_entrain",
+        "concrete.options.white_cement": "Concrete.white_cement",
+        "concrete.options.plc": "Concrete.plc",
+        "concrete.options.fiber_reinforced": "Concrete.fiber_reinforced",
+        "concrete.cementitious": "Concrete.cementitious",
+    }
+
+    strength_28d: PressureMPaStr | None = pyd.Field(
+        default=None, description="Compressive Strength at 28 days", example="1 MPa"
+    )
+    slump: LengthInchStr | None = pyd.Field(default=None, description="Minimum test slump", example="2 in")
+    strength_other: PressureMPaStr | None = pyd.Field(
+        default=None,
+        description="One additional strength, which can be early (e.g. 3d) or late (e.g. 96d)",
+        example="30 MPa",
+    )
+    strength_other_d: Literal[3, 7, 14, 42, 56, 72, 96, 120] | None = pyd.Field(
+        default=None,
+        description="Days for the strength field above. Required IF strength_other is provided.",
+        example=42,
+    )
+    w_c_ratio: RatioFloat | None = pyd.Field(
+        default=None, description="Ratio of water to cement", example=0.5, ge=0, le=1
+    )
+    aci_exposure_classes: list[AciExposureClass] | None = pyd.Field(
+        default=None, description="List of ACI318-19 exposure classes this product meets", example=["aci.F0"]
+    )
+    csa_exposure_classes: list[CsaExposureClass] | None = pyd.Field(
+        default=None, description="List of CSA A23.1 exposure classes this product meets", example=["csa.C-2"]
+    )
+    en_exposure_classes: list[EnExposureClass] | None = pyd.Field(
+        default=None, description="List of EN206 exposure classes this product meets", example=["en206.X0"]
+    )
+    application: ConcreteTypicalApplication | None = pyd.Field(default=None, description="Typical Application")
+    options: ConcreteOptions | None = pyd.Field(default=None, description="List of true/false properties")
+    cementitious: Cementitious | None = pyd.Field(
+        default=None, description="List of cementitious materials, and proportion by mass"
+    )

openepd-6.5.0/src/openepd/model/specs/singular/deprecated/steel.py

@@ -0,0 +1,75 @@
+#
+#  Copyright 2024 by C Change Labs Inc. www.c-change-labs.com
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+from typing import ClassVar
+
+from openepd.compat.pydantic import pyd
+from openepd.model.base import BaseOpenEpdSchema
+from openepd.model.specs.enums import SteelComposition
+from openepd.model.specs.singular import BaseCompatibilitySpec
+from openepd.model.specs.singular.steel import SteelMakingRoute
+from openepd.model.standard import Standard
+from openepd.model.validation.quantity import PressureMPaStr
+
+
+class SteelOldOptions(BaseOpenEpdSchema):
+    """Legacy Steel options model."""
+
+    cold_finished: bool | None = pyd.Field(default=None, description="Cold Finished", example=True)
+    galvanized: bool | None = pyd.Field(default=None, description="Galvanized", example=True)
+    epoxy: bool | None = pyd.Field(default=None, description="Epoxy Coated", example=True)
+    steel_fabricated: bool | None = pyd.Field(default=None, example=True, description="Fabricated")
+
+
+class SteelOldSpec(BaseCompatibilitySpec):
+    """Legacy Steel spec."""
+
+    COMPATIBILITY_SPECS_KEY_OLD: ClassVar[str] = "steel"
+    COMPATIBILITY_SPECS_KEY_NEW: ClassVar[str] = "Steel"
+    COMPATIBILITY_MAPPING: ClassVar[dict[str, str]] = {
+        "steel.steel_composition": "Steel.composition",
+        "steel.Fy": "Steel.yield_tensile_str",
+        "steel.making_route": "Steel.making_route",
+        "steel.ASTM": "Steel.astm_standards",
+        "steel.EN": "Steel.en_standards",
+        "steel.SAE": "Steel.sae_standards",
+        "steel.options.cold_finished": "Steel.cold_finished",
+        "steel.options.galvanized": "Steel.galvanized",
+        "steel.options.epoxy": "Steel.RebarSteel.epoxy_coated",  # moved to sub-spec
+        "steel.options.steel_fabricated": "Steel.RebarSteel.fabricated",
+        # last one is tricky as fabricated might be in multiple cases; thus limited support
+    }
+    form_factor: str | None = pyd.Field(default=None, description="Product's form factor, read-only.")
+    steel_composition: SteelComposition | None = pyd.Field(
+        default=None,
+        description="Basic chemical composition. Generally the ASTM or EN grade is a subcategory of one of these.",
+        example="Carbon",
+    )
+    Fy: PressureMPaStr | None = pyd.Field(
+        default=None,
+        description="Minimum Yield Strength",
+        example="2000 psi",
+    )
+    making_route: SteelMakingRoute | None = pyd.Field(
+        default=None, description="List of true/false properties for steelmaking route"
+    )
+    ASTM: list[Standard] | None = pyd.Field(
+        default=None, description="ASTM standard(s) to which this product complies."
+    )
+    SAE: list[Standard] | None = pyd.Field(
+        default=None, description="AISA/SAE standard(s) to which this product complies."
+    )
+    EN: list[Standard] | None = pyd.Field(default=None, description="EN 10027 number(s).")
+    options: SteelOldOptions | None = pyd.Field(default=None, description="List of true/false properties")

{openepd-6.4.1 → openepd-6.5.0}/src/openepd/model/validation/quantity.py

@@ -33,7 +33,7 @@ class QuantityValidator(ABC):
     """
 
     @abstractmethod
-    def validate_same_dimensionality(self, unit: str | None, dimensionality_unit: str) -> None:
+    def validate_same_dimensionality(self, unit: str | None, dimensionality_unit: str | None) -> None:
         """
         Validate that a given unit ('kg') has the same dimesnionality as provided dimensionality_unit ('g').