openepd 5.1.1__tar.gz → 5.3.0__tar.gz

{openepd-5.1.1 → openepd-5.3.0}/PKG-INFO

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

{openepd-5.1.1 → openepd-5.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "openepd"
-version = "5.1.1"
+version = "5.3.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.1 → openepd-5.3.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.1"
+VERSION = "5.3.0"

{openepd-5.1.1 → openepd-5.3.0}/src/openepd/api/average_dataset/generic_estimate_sync_api.py

@@ -21,7 +21,7 @@ from openepd.api.base_sync_client import BaseApiMethodGroup
 from openepd.api.common import StreamingListResponse, paging_meta_from_v1_api
 from openepd.api.dto.common import BaseMeta, OpenEpdApiResponse
 from openepd.api.dto.meta import PagingMetaMixin
-from openepd.api.utils import encode_path_param
+from openepd.api.utils import encode_path_param, remove_none_id_fields
 from openepd.model.generic_estimate import (
     GenericEstimate,
     GenericEstimatePreview,
@@ -57,26 +57,33 @@ class GenericEstimateApi(BaseApiMethodGroup):
 
     @overload
     def post_with_refs(
-        self, ge: GenericEstimateWithDeps, with_response: Literal[True]
+        self, ge: GenericEstimateWithDeps, with_response: Literal[True], exclude_defaults: bool = True
     ) -> tuple[GenericEstimate, Response]: ...
 
     @overload
-    def post_with_refs(self, ge: GenericEstimateWithDeps, with_response: Literal[False] = False) -> GenericEstimate: ...
+    def post_with_refs(
+        self, ge: GenericEstimateWithDeps, with_response: Literal[False] = False, exclude_defaults: bool = True
+    ) -> GenericEstimate: ...
 
     def post_with_refs(
-        self, ge: GenericEstimateWithDeps, with_response: bool = False
+        self, ge: GenericEstimateWithDeps, with_response: bool = False, exclude_defaults: bool = True
     ) -> GenericEstimate | tuple[GenericEstimate, Response]:
         """
         Post an GenericEstimate with references.
 
         :param ge: GenericEstimate
         :param with_response: return the response object togather with the GenericEstimate
+        :param exclude_defaults: If True, fields with default values are excluded from the payload
         :return: GenericEstimate alone, or GenericEstimate with HTTP Response object depending on parameter
         """
+        data = ge.to_serializable(exclude_unset=True, exclude_defaults=exclude_defaults, by_alias=True)
+        if exclude_defaults is False:
+            # Remove 'id' fields with None values, as 'id' cannot be None
+            data = remove_none_id_fields(data)
         response = self._client.do_request(
             "patch",
             "/generic_estimates/post_with_refs",
-            json=ge.to_serializable(exclude_unset=True, exclude_defaults=True, by_alias=True),
+            json=data,
         )
         content = response.json()
         if with_response:

{openepd-5.1.1 → openepd-5.3.0}/src/openepd/api/epd/sync_api.py

@@ -20,7 +20,7 @@ from requests import Response
 from openepd.api.base_sync_client import BaseApiMethodGroup
 from openepd.api.common import StreamingListResponse
 from openepd.api.epd.dto import EpdSearchResponse, EpdStatisticsResponse, StatisticsDto
-from openepd.api.utils import encode_path_param
+from openepd.api.utils import encode_path_param, remove_none_id_fields
 from openepd.model.epd import Epd
 
 
@@ -106,23 +106,32 @@ class EpdApi(BaseApiMethodGroup):
         return self.get_statistics_raw(omf).payload
 
     @overload
-    def post_with_refs(self, epd: Epd, with_response: Literal[True]) -> tuple[Epd, Response]: ...
+    def post_with_refs(
+        self, epd: Epd, with_response: Literal[True], exclude_defaults: bool = True
+    ) -> tuple[Epd, Response]: ...
 
     @overload
-    def post_with_refs(self, epd: Epd, with_response: Literal[False] = False) -> Epd: ...
+    def post_with_refs(self, epd: Epd, with_response: Literal[False] = False, exclude_defaults: bool = True) -> Epd: ...
 
-    def post_with_refs(self, epd: Epd, with_response: bool = False) -> Epd | tuple[Epd, Response]:
+    def post_with_refs(
+        self, epd: Epd, with_response: bool = False, exclude_defaults: bool = True
+    ) -> Epd | tuple[Epd, Response]:
         """
         Post an EPD with references.
 
         :param epd: EPD
         :param with_response: return the response object togather with the EPD
+        :param exclude_defaults: If True, fields with default values are excluded from the payload
         :return: EPD or EPD with HTTP Response object depending on parameter
         """
+        epd_data = epd.to_serializable(exclude_unset=True, exclude_defaults=exclude_defaults, by_alias=True)
+        if exclude_defaults is False:
+            # Remove 'id' fields with None values, as 'id' cannot be None
+            epd_data = remove_none_id_fields(epd_data)
         response = self._client.do_request(
             "patch",
             "/epds/post-with-refs",
-            json=epd.to_serializable(exclude_unset=True, exclude_defaults=True, by_alias=True),
+            json=epd_data,
         )
         content = response.json()
         if with_response:

openepd-5.3.0/src/openepd/api/utils.py

@@ -0,0 +1,68 @@
+#
+#  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.
+#
+__all__ = ("encode_path_param",)
+
+from urllib.parse import quote
+
+
+def encode_path_param(value: str) -> str:
+    """
+    Encode a path parameter value.
+
+    :param value: parameter value
+    :return: encoded value
+    """
+    return quote(value, safe="")
+
+
+def remove_none_id_fields(d: dict) -> dict:
+    """
+    Remove any key 'id' with a None value from the dictionary, including nested dicts.
+
+    :param d: the dict which may contain 'id' keys with None values.
+    :return: a new dict with 'id' keys that have None values removed.
+
+    :note:
+        - This function does not modify the original dictionary (no side effects).
+        - It returns a new dictionary with the necessary modifications applied.
+
+    :example:
+        >>> data = {
+        ...     "id": None,
+        ...     "name": "item1",
+        ...     "details": {
+        ...         "id": None,
+        ...         "category": "tools",
+        ...         "nested": {
+        ...             "id": None,
+        ...             "value": 42
+        ...         }
+        ...     }
+        ... }
+        >>> remove_none_id_fields(data)
+        {'name': 'item1', 'details': {'category': 'tools', 'nested': {'value': 42}}}
+    """
+    if not isinstance(d, dict):
+        return d
+
+    cleaned_dict = {}
+    for k, v in d.items():
+        if isinstance(v, dict):
+            v = remove_none_id_fields(v)
+        if not (k == "id" and v is None):
+            cleaned_dict[k] = v
+
+    return cleaned_dict

{openepd-5.1.1 → openepd-5.3.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.1 → openepd-5.3.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.1 → openepd-5.3.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.3.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

openepd-5.1.1/src/openepd/api/utils.py

@@ -1,28 +0,0 @@
-#
-#  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.
-#
-__all__ = ("encode_path_param",)
-
-from urllib.parse import quote
-
-
-def encode_path_param(value: str) -> str:
-    """
-    Encode a path parameter value.
-
-    :param value: parameter value
-    :return: encoded value
-    """
-    return quote(value, safe="")