openepd 5.1.1__py3-none-any.whl → 5.3.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 = "5.1.1"
+VERSION = "5.3.0"

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/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/api/utils.py

@@ -26,3 +26,43 @@ def encode_path_param(value: str) -> str:
     :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/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/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/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/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.dist-info → openepd-5.3.0.dist-info}/METADATA

@@ -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.dist-info → openepd-5.3.0.dist-info}/RECORD

@@ -1,8 +1,8 @@
 openepd/__init__.py,sha256=Shkfh0Kun0YRhmRDw7LkUj2eQL3X-HnP55u2THOEALw,794
-openepd/__version__.py,sha256=csd0FxZWJj24NtNlydwLhnKkBEILVXhOK-SxfTv8Uf0,638
+openepd/__version__.py,sha256=eEVqmdbsGDJ4vyFA7va4C2zZ4rWy5ZZzKevZvLZTPtQ,638
 openepd/api/__init__.py,sha256=UGmZGEyMnASrYwEBPHuXmVzHiuCUskUsJEPoHTIo-lg,620
 openepd/api/average_dataset/__init__.py,sha256=UGmZGEyMnASrYwEBPHuXmVzHiuCUskUsJEPoHTIo-lg,620
-openepd/api/average_dataset/generic_estimate_sync_api.py,sha256=DM7i8gugUIEAutEsakEUxFjwgtKmcytkjvNAvfhVYUs,7690
+openepd/api/average_dataset/generic_estimate_sync_api.py,sha256=5dWtdyzs9WGO5-liQGZd0o5q0tSjoJrx1RCtjSnRrrk,8110
 openepd/api/average_dataset/industry_epd_sync_api.py,sha256=xoicuZdclf4BTBa2ndG1K2Aog-iZd7_jOqdDPZSCLq4,6286
 openepd/api/base_sync_client.py,sha256=IX-q6JdWLMqYHC-hKLXUFRPs-DZZ9Co0NRZ5pSAipAs,20992
 openepd/api/category/__init__.py,sha256=UGmZGEyMnASrYwEBPHuXmVzHiuCUskUsJEPoHTIo-lg,620
@@ -17,13 +17,13 @@ openepd/api/dto/mf.py,sha256=tjsxF6yJhnOrcOepNVHBn18pF-kXkBoUYfTQwOTaY2g,1994
 openepd/api/dto/params.py,sha256=UGmZGEyMnASrYwEBPHuXmVzHiuCUskUsJEPoHTIo-lg,620
 openepd/api/epd/__init__.py,sha256=UGmZGEyMnASrYwEBPHuXmVzHiuCUskUsJEPoHTIo-lg,620
 openepd/api/epd/dto.py,sha256=NZ76vfUkCEkwDibQd2QCEQP5DZms_NFc9tjoP-mcw3o,4874
-openepd/api/epd/sync_api.py,sha256=5wuPiM_zVciVtTvsGaaRdf7T6q2CUp7QMZCW0DAjQng,7072
+openepd/api/epd/sync_api.py,sha256=EY9KVz8yDgmjgLzWWh2B3VobNswd9fZmfDFkiJTxog0,7522
 openepd/api/errors.py,sha256=Iipd0QW2tbhUu_UjUbmiFWgmrPVgOFHc3uxZN-SX-g4,2868
 openepd/api/pcr/__init__.py,sha256=UGmZGEyMnASrYwEBPHuXmVzHiuCUskUsJEPoHTIo-lg,620
 openepd/api/pcr/sync_api.py,sha256=Riu77h8uLJngKpITOiXYmO7mzjAHpYskUJ6ynyfNG78,1557
 openepd/api/sync_client.py,sha256=IurnhZrkBQoQIbbfon6TPuhjGpAV_CSTJNeXjIiN0QI,3105
 openepd/api/test/__init__.py,sha256=UGmZGEyMnASrYwEBPHuXmVzHiuCUskUsJEPoHTIo-lg,620
-openepd/api/utils.py,sha256=FSY2W8zTXGTvJAJACMi4nibpo-9m1HXkTCH8kdAYlzQ,875
+openepd/api/utils.py,sha256=9kdWbJ-m0IqsrkPQpGkILIQlR1WPd9rRlko-ymj9gtI,2092
 openepd/bundle/__init__.py,sha256=UGmZGEyMnASrYwEBPHuXmVzHiuCUskUsJEPoHTIo-lg,620
 openepd/bundle/base.py,sha256=mOt3h3MuQyc1yunp9u6_CVYDtSdWQHZcx8cNfbNkqoY,6869
 openepd/bundle/model.py,sha256=yICEHl7ZWDXHGx4rhFomCwa-ganjUtykyj_fpWw_6OI,2446
@@ -35,7 +35,7 @@ openepd/compat/pydantic.py,sha256=DOjSixsylLqMtFAIARu50sGcT4VPXN_c473q_2JwZQ0,11
 openepd/model/__init__.py,sha256=UGmZGEyMnASrYwEBPHuXmVzHiuCUskUsJEPoHTIo-lg,620
 openepd/model/base.py,sha256=OEYNFUTL4BivBNAt_LGowTlDuUjvKMHgf5U5ZBncZwQ,9805
 openepd/model/category.py,sha256=IQXNGQFQmFZ_H9PRONloX_UOSf1sTMDq1rM1yz8JR0Y,1639
-openepd/model/common.py,sha256=j-5bUMGoSJFkWzCTcX8pb8m9oMRKUyuplXWQSmfoRlw,6760
+openepd/model/common.py,sha256=kPN1MrFYCvnPNregds3CtFNvLxVrf0T-Y9nePdZspL4,8554
 openepd/model/declaration.py,sha256=Wh5Ni6AG903lmPTV5sS627lNjSazH7km3OIr2lkKKJE,11072
 openepd/model/epd.py,sha256=GU7OW6hp9GeLB9PUGqacDYMAJVWmAAHzGp3dZs2aGqo,7479
 openepd/model/factory.py,sha256=XP7eeQNW5tqwX_4hfuEb3lK6BFQDb4KB0fSN0r8-lCU,2656
@@ -60,12 +60,12 @@ openepd/model/specs/generated/cast_decks_and_underlayment.py,sha256=qZjryfTZc1lt
 openepd/model/specs/generated/cladding.py,sha256=NEY2taEzXJeIR08oimzfXrHAaJ-EojC4TPI5tG6Xfi8,6598
 openepd/model/specs/generated/cmu.py,sha256=Vv-aiT4Q7Zl5XTkSCnTeGOpE_ufTy63zt2Z5aXbv_Qo,1794
 openepd/model/specs/generated/common.py,sha256=iNeJmVYZURVQWewx3zskwnwy7DBuaggCHFWQBThtY2A,1048
-openepd/model/specs/generated/concrete.py,sha256=TzKy1h9mQvZk0CHqJKG-NGA1eZEu-w0t-a8FYLj1EUU,7116
+openepd/model/specs/generated/concrete.py,sha256=gk-ZFUTJni4l32FRYGnqD9Vv6lT-ACgIEY7RKM266k4,7728
 openepd/model/specs/generated/conveying_equipment.py,sha256=sQSnFccpTIw8sNGywW0KajE1lCHzbVBCISKyrYFW02U,3052
 openepd/model/specs/generated/electrical.py,sha256=vX3k_dYRmFCQG0Rh4g8rYZ_hAiAE3Hxfk217jgsrz4g,11093
 openepd/model/specs/generated/electrical_transmission_and_distribution_equipment.py,sha256=h6UQixACOHrquhQ2GFqqYWel_zqOXT-vAkI0o_RLf0A,1978
 openepd/model/specs/generated/electricity.py,sha256=iGtN21K1MRVwoRfO6friVgiXc2b6cVdITbvnXqLmW3k,823
-openepd/model/specs/generated/enums.py,sha256=DD9eQbkSVkV4b8F10rn6_2k8Sn8H01mZmZX5aBnPtuc,61524
+openepd/model/specs/generated/enums.py,sha256=rh35d0CZUIp1GDYopldu-dUJ3YQtXlKzJuMpyFLKT2w,63602
 openepd/model/specs/generated/finishes.py,sha256=1nqZs2B2VRIt553ezCJSLT4qF8nJmfg457duNb1sxlI,22503
 openepd/model/specs/generated/fire_and_smoke_protection.py,sha256=zkOlnNCnAZ9MUWk2sDqUX14YxNEDU3MGfUlePG3su0Q,3068
 openepd/model/specs/generated/furnishings.py,sha256=QY_FDsFZaqjCiw2xHsD3kmyBGJA7jCHlSIvaw4TmqXI,2581
@@ -127,12 +127,13 @@ openepd/model/specs/range/wood_joists.py,sha256=jSOP5s0sYVR4tqk0l8rYARDPHQE8UsbM
 openepd/model/standard.py,sha256=QhGpWN3U27fDcS0Yy1Dk8ElJfD0etet6i_PzoTD6B48,1318
 openepd/model/validation/__init__.py,sha256=UGmZGEyMnASrYwEBPHuXmVzHiuCUskUsJEPoHTIo-lg,620
 openepd/model/validation/common.py,sha256=FLYqK8gYFagx08LCkS0jy3qo4-Zq9VAv5i8ZwF2svkc,2435
+openepd/model/validation/enum.py,sha256=06Fi2_sdjVhOElavtgvNXvkKU0NQ-bcAFx5_5MiDzdU,1793
 openepd/model/validation/numbers.py,sha256=J2rVMwJTPr8uC1DrU80xpq2SZGMXvVKx7v74SgOVi0U,851
 openepd/model/validation/quantity.py,sha256=8LbSn-Gfo6r1j6AKDjzPnt_9dwyXMFmN5Uaoxa6LIEU,16953
 openepd/model/versioning.py,sha256=R_zm6rCrgF3vlJQYbpyWhirdS_Oek16cv_mvZmpuE8I,4473
 openepd/patch_pydantic.py,sha256=xrkzblatmU9HBzukWkp1cPq9ZSuohoz1p0pQqVKSlKs,4122
 openepd/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-openepd-5.1.1.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-openepd-5.1.1.dist-info/METADATA,sha256=cbSHMpaZO00Scz14xXnkzZsm6Hkb9LbnxlEyJ-G22Ew,8996
-openepd-5.1.1.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
-openepd-5.1.1.dist-info/RECORD,,
+openepd-5.3.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+openepd-5.3.0.dist-info/METADATA,sha256=twGr4uGcA4Rn0osNRGYw0IdWeC53yVy5NlbzhZNLZ6c,8996
+openepd-5.3.0.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
+openepd-5.3.0.dist-info/RECORD,,