openepd 5.1.0__tar.gz → 5.2.0__tar.gz

{openepd-5.1.0 → openepd-5.2.0}/PKG-INFO

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

{openepd-5.1.0 → openepd-5.2.0}/pyproject.toml

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

{openepd-5.1.0 → openepd-5.2.0}/src/openepd/__version__.py

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

{openepd-5.1.0 → openepd-5.2.0}/src/openepd/model/common.py

@@ -38,6 +38,32 @@ class Amount(BaseOpenEpdSchema):
         return f"{self.qty or ''} {self.unit or 'str'}".strip()
 
 
+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 = "log-normal"
+    NORMAL = "normal"
+    UNIFORM = "uniform"
+    TRIANGULAR = "triangular"
+    MAX = "max"
+
+
 class Measurement(BaseOpenEpdSchema):
     """A scientific value with units and uncertainty."""
 
@@ -46,7 +72,9 @@ class Measurement(BaseOpenEpdSchema):
     rsd: pyd.PositiveFloat | None = pyd.Field(
         description="Relative standard deviation, i.e. standard_deviation/mean", default=None
     )
-    dist: str | None = pyd.Field(description="Statistical distribution of the measurement error.", default=None)
+    dist: Distribution | None = pyd.Field(
+        description="Statistical distribution of the measurement error.", default=None
+    )
 
 
 class Ingredient(BaseOpenEpdSchema):
@@ -189,3 +217,17 @@ class RangeAmount(RangeFloat):
     """Structure representing a range of quantities."""
 
     unit: str | None = pyd.Field(default=None, description="Unit of the range.")
+
+
+class EnumGroupingAware:
+    """
+    Mixin for enums to support groups.
+
+    With the groups, enum can group its values into more than one groups, so that the validator higher in code can check
+    for mutual exclusivity, for example that only one value from the group is permitted at the same time.
+    """
+
+    @classmethod
+    def get_groupings(cls) -> list[list]:
+        """Return logical groupings of the values."""
+        return []

{openepd-5.1.0 → openepd-5.2.0}/src/openepd/model/org.py

@@ -69,7 +69,6 @@ class Plant(WithAttachmentsMixin, WithAltIdsMixin, BaseOpenEpdSchema):
         description="Plus code (aka Open Location Code) of plant's location and "
         "owner's web domain joined with `.`(dot).",
         example="865P2W3V+3W.interface.com",
-        alias="pluscode",
         default=None,
     )
     owner: Org | None = pyd.Field(description="Organization that owns the plant", default=None)

{openepd-5.1.0 → openepd-5.2.0}/src/openepd/model/specs/generated/concrete.py

@@ -19,6 +19,7 @@ from openepd.compat.pydantic import pyd
 from openepd.model.specs.base import BaseOpenEpdHierarchicalSpec, CodegenSpec
 from openepd.model.specs.concrete import Cementitious, ConcreteTypicalApplication
 from openepd.model.specs.generated.enums import AciExposureClass, CsaExposureClass, EnExposureClass
+from openepd.model.validation.enum import exclusive_groups_validator_factory
 from openepd.model.validation.numbers import RatioFloat
 from openepd.model.validation.quantity import (
     LengthInchStr,
@@ -172,3 +173,13 @@ class ConcreteV1(BaseOpenEpdHierarchicalSpec):
     OilPatch: OilPatchV1 | None = None
     ReadyMix: ReadyMixV1 | None = None
     Shotcrete: ShotcreteV1 | None = None
+
+    _aci_exposure_classes_exclusive_groups_validator = pyd.validator("aci_exposure_classes", allow_reuse=True)(
+        exclusive_groups_validator_factory(AciExposureClass)
+    )
+    _en_exposure_classes_exclusive_groups_validator = pyd.validator("en_exposure_classes", allow_reuse=True)(
+        exclusive_groups_validator_factory(EnExposureClass)
+    )
+    _csa_exposure_classes_exclusive_groups_validator = pyd.validator("csa_exposure_classes", allow_reuse=True)(
+        exclusive_groups_validator_factory(CsaExposureClass)
+    )

{openepd-5.1.0 → openepd-5.2.0}/src/openepd/model/specs/generated/enums.py

@@ -15,6 +15,8 @@
 #
 from enum import StrEnum
 
+from openepd.model.common import EnumGroupingAware
+
 # Enums used
 
 
@@ -2182,7 +2184,7 @@ class FloorBoxFloorMaterial(StrEnum):
     OTHER = "Other"
 
 
-class AciExposureClass(StrEnum):
+class AciExposureClass(EnumGroupingAware, StrEnum):
     """
     American Concrete Institute concrete exposure classes.
 
@@ -2196,6 +2198,7 @@ class AciExposureClass(StrEnum):
       * `aci.S2` - Exposed to <10000 ppm of SO4 in water and <2% SO4 in soil
       * `aci.S3` - Exposed to >10000 ppm of SO4 in water or >2% SO4 in soil
 
+      * `aci.C0` - Concrete dry or protected from moisture.
       * `aci.C1` - Concrete in contact with moisture, but the external source of chloride does not reach it.
       * `aci.C2` - Concrete subjected to moisture and an external source of chlorides such as deicing chemicals,
                     salt, brackish water, seawater, or spray from these sources.
@@ -2212,14 +2215,25 @@ class AciExposureClass(StrEnum):
     S1 = "aci.S1"
     S2 = "aci.S2"
     S3 = "aci.S3"
+    C0 = "aci.C1"
     C1 = "aci.C1"
     C2 = "aci.C2"
     W0 = "aci.W0"
     W1 = "aci.W1"
     W2 = "aci.W2"
 
+    @classmethod
+    def get_groupings(cls) -> list[list]:
+        """Return logical groupings of the values."""
+        return [
+            [AciExposureClass.F0, AciExposureClass.F1, AciExposureClass.F2, AciExposureClass.F3],
+            [AciExposureClass.S0, AciExposureClass.S1, AciExposureClass.S2, AciExposureClass.S3],
+            [AciExposureClass.W0, AciExposureClass.W1],
+            [AciExposureClass.C0, AciExposureClass.C1, AciExposureClass.C2],
+        ]
+
 
-class CsaExposureClass(StrEnum):
+class CsaExposureClass(EnumGroupingAware, StrEnum):
     """
     Canadian Standard Association concrete exposure classes.
 
@@ -2286,8 +2300,20 @@ class CsaExposureClass(StrEnum):
     A_3 = "csa.A-3"
     A_4 = "csa.A-4"
 
+    @classmethod
+    def get_groupings(cls) -> list[list]:
+        """Return logical groupings of the values."""
+        return [
+            [CsaExposureClass.C_XL],
+            [CsaExposureClass.C_1, CsaExposureClass.C_2, CsaExposureClass.C_3, CsaExposureClass.C_4],
+            [CsaExposureClass.F_1, CsaExposureClass.F2],
+            [CsaExposureClass.N],
+            [CsaExposureClass.A_1, CsaExposureClass.A_2, CsaExposureClass.A_3, CsaExposureClass.A_4],
+            [CsaExposureClass.S_1, CsaExposureClass.S_2, CsaExposureClass.S_3],
+        ]
 
-class EnExposureClass(StrEnum):
+
+class EnExposureClass(EnumGroupingAware, StrEnum):
     """
     EN 206 Class (Europe).
 
@@ -2348,6 +2374,28 @@ class EnExposureClass(StrEnum):
     en206_XA2 = "en206.XA2"
     en206_XA3 = "en206.XA3"
 
+    @classmethod
+    def get_groupings(cls) -> list[list]:
+        """Return logical groupings of the values."""
+        return [
+            [EnExposureClass.en206_X0],
+            [
+                EnExposureClass.en206_XC1,
+                EnExposureClass.en206_XC2,
+                EnExposureClass.en206_XC3,
+                EnExposureClass.en206_XC4,
+            ],
+            [EnExposureClass.en206_XD1, EnExposureClass.en206_XD2, EnExposureClass.en206_XD3],
+            [EnExposureClass.en206_XS1, EnExposureClass.en206_XS2, EnExposureClass.en206_XS3],
+            [
+                EnExposureClass.en206_XF1,
+                EnExposureClass.en206_XF2,
+                EnExposureClass.en206_XF3,
+                EnExposureClass.en206_XF4,
+            ],
+            [EnExposureClass.en206_XA1, EnExposureClass.en206_XA2, EnExposureClass.en206_XA3],
+        ]
+
 
 class AggregateWeightClassification(StrEnum):
     """

openepd-5.2.0/src/openepd/model/validation/enum.py

@@ -0,0 +1,42 @@
+#
+#  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, Callable
+
+from openepd.model.common import EnumGroupingAware
+
+
+def exclusive_groups_validator_factory(enum_type: type[EnumGroupingAware]) -> Callable[[type, Any], Any]:
+    """
+    Create an exclusive groups validator.
+
+    If we have a certain enum TheEnum, and a field of list[TheEnum], where list can contain only one value of each of
+    the groups, this validator should be used. For example, ACI exposure classes for concrete specify various
+    parameters such as water resistance, chemical resistance, etc., and the list of classes can have 0 or 1 from each
+    group.
+
+    :param enum_type:Enum type which supports groupings.
+    :return:value, or raises ValueError if not allowed combination is given.
+    """
+
+    def enum_exclusive_grouping_validator(cls, value: list | None) -> list | None:
+        for grouping in enum_type.get_groupings():
+            matching_from_group = [v for v in (value or []) if v in grouping]
+            if len(matching_from_group) > 1:
+                raise ValueError(f"Values {', '.join(matching_from_group)} are not allowed together.")
+
+        return value
+
+    return enum_exclusive_grouping_validator