openepd 6.23.0__py3-none-any.whl → 6.25.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 = "6.23.0"
+VERSION = "6.25.0"

openepd/model/lcia.py

@@ -504,10 +504,12 @@ class LCIAMethod(StrEnum):
     """A list of available LCA methods."""
 
     UNKNOWN = "Unknown LCIA"
+    TRACI_2_2 = "TRACI 2.2"
     TRACI_2_1 = "TRACI 2.1"
     TRACI_2_0 = "TRACI 2.0"
     TRACI_1_0 = "TRACI 1.0"
     IPCC_AR5 = "IPCC AR5"
+    IPCC_AR6 = "IPCC AR6"
     EF_3_0 = "EF 3.0"
     EF_3_1 = "EF 3.1"
     EF_2_0 = "EF 2.0"

openepd/model/specs/singular/__init__.py

@@ -22,8 +22,6 @@ from collections.abc import Sequence
 import types
 from typing import Any, ClassVar, TypeVar
 
-from pydantic.v1.fields import FieldInfo
-
 from openepd.compat.pydantic import pyd
 from openepd.model.specs.base import BaseOpenEpdHierarchicalSpec
 from openepd.model.specs.singular.accessories import AccessoriesV1
@@ -208,9 +206,9 @@ class Specs(BaseOpenEpdHierarchicalSpec):
         """
         klass = self.__class__
 
-        fields: dict[str, FieldInfo] = klass.__fields__  # type: ignore[assignment]
+        fields: dict[str, pyd.fields.FieldInfo] = klass.__fields__  # type: ignore[assignment]
 
-        field: FieldInfo | None
+        field: pyd.fields.FieldInfo | None
         for i, key in enumerate(keys, start=1):
             field = fields.get(key)
             if field is None:

openepd/utils/__init__.py

@@ -0,0 +1,15 @@
+#
+#  Copyright 2025 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.
+#

openepd/utils/mapping/__init__.py

@@ -0,0 +1,15 @@
+#
+#  Copyright 2025 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.
+#

openepd/utils/mapping/common.py

@@ -0,0 +1,192 @@
+#
+#  Copyright 2025 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__ = (
+    "BaseDataMapper",
+    "KeyValueMapper",
+    "ReferenceMapper",
+    "RegexMapper",
+    "SimpleDataMapper",
+)
+
+import abc
+from collections.abc import Mapping
+import re
+from typing import Generic, TypeAlias, TypeVar, assert_never, cast
+
+T = TypeVar("T")
+K = TypeVar("K")
+
+
+class BaseDataMapper(Generic[T, K], abc.ABC):
+    """
+    Base class for all data mappers.
+
+    Data mappers are objects used to map some input values to output values of different types.
+
+    Typical use case is mapping between different aliases of impact names with OpenEpd naming conventions.
+    """
+
+    @abc.abstractmethod
+    def map(self, input_value: T, default_value: K | None, *, raise_if_missing: bool = False) -> K | None:
+        """
+        Map the input value to the output value.
+
+        :param input_value: The input value to map.
+        :param default_value: The default value to return if there is no mapping for the input value.
+        :param raise_if_missing: Whether to raise an exception if there is no mapping for the input value.
+
+        :raise ValueError: If there is no mapping for the input value and raise_if_missing is True.
+        """
+        pass
+
+
+class SimpleDataMapper(BaseDataMapper[T, T], Generic[T]):
+    """A data mapper that does not change the type of the input value."""
+
+    DATABASE: Mapping[T, T] = {}
+
+    def map(self, input_value: T, default_value: T | None, *, raise_if_missing: bool = False) -> T | None:
+        """
+        Map the input value to the output value.
+
+        :param input_value: The input value to map.
+        :param default_value: The default value to return if there is no mapping for the input value.
+        :param raise_if_missing: Whether to raise an exception if there is no mapping for the input value.
+
+        :raise ValueError: If there is no mapping for the input value and raise_if_missing is True.
+        """
+        if raise_if_missing and input_value not in self.DATABASE:
+            msg = f"No mapping for input value: {input_value}"
+            raise ValueError(msg)
+
+        return self.DATABASE.get(input_value, default_value)
+
+
+class KeyValueMapper(BaseDataMapper[str, T], Generic[T]):
+    """
+    A data mapper that maps input values to output values using keywords.
+
+    List of values is expected to be a list string object or a list of objects easily castable to string.
+    """
+
+    KV: Mapping[str, list[T]] = {}
+
+    def map(self, input_value: str, default_value: T | None, *, raise_if_missing: bool = False) -> T | None:
+        """
+        Map the input value to the output value using keywords.
+
+        :param input_value: The input value to map.
+        :param default_value: The default value to return if there is no mapping for input value.
+        :param raise_if_missing: Whether to raise an exception if there is no mapping for the input value.
+
+        :raise ValueError: If there is no mapping for the input value and raise_if_missing is True.
+        """
+        for impact_name, keywords in self.KV.items():
+            for keyword in keywords:
+                if str(keyword).strip().lower() in input_value.strip().lower():
+                    return cast(T, impact_name)
+
+        if raise_if_missing:
+            msg = f"No mapping for input value: {input_value}"
+            raise ValueError(msg)
+
+        return default_value
+
+
+class RegexMapper(BaseDataMapper[str, T], Generic[T]):
+    """A data mapper that maps input values to output values using regex."""
+
+    PATTERNS: dict[str, str] = {}
+    _compiled_patterns: dict[str, re.Pattern]
+
+    def __init__(self) -> None:
+        self._compiled_patterns: dict[str, re.Pattern] = {
+            key: re.compile(pattern, re.IGNORECASE) for key, pattern in self.PATTERNS.items()
+        }
+
+    def map(self, input_value: str, default_value: T | None, *, raise_if_missing: bool = False) -> T | None:
+        """
+        Map the input value to the output value using regex.
+
+        :param input_value: The input value to map.
+        :param default_value: The default value to return if there is no mapping for an input value.
+
+        :param raise_if_missing: Whether to raise an exception if there is no mapping for the input value.
+
+        :raise ValueError: If there is no mapping for the input value and raise_if_missing is True.
+        """
+        for impact_name, pattern in self._compiled_patterns.items():
+            if pattern.search(input_value.strip().lower()):
+                return cast(T, impact_name)
+
+        if raise_if_missing:
+            msg = f"No mapping for input value: {input_value}"
+            raise ValueError(msg)
+
+        return default_value
+
+
+_TRmRules: TypeAlias = str | re.Pattern | list[str | re.Pattern]
+
+
+class ReferenceMapper(BaseDataMapper[str, _TRmRules]):
+    """
+    A mapper that maps input values of any form to the expected value format.
+
+    Expected values may be a value or a list of values. Values are expected to be a string object, regular expressions,
+    or objects easily castable to string.
+    """
+
+    def map(self, input_value: str, default_value: str | None, *, raise_if_missing: bool = False) -> str | None:  # type: ignore[override]
+        """
+        Return specified key as a value if any of the values in the list matches the input value.
+
+        :param input_value: value to be checked against the list of specified rules
+        :param default_value: default value to return if no match is found
+        :param raise_if_missing: whether to raise an exception if no match is found
+
+        :return: mapped value if find any match, else default value
+
+        :raise ValueError: if no match is found and raise_if_missing is True
+        """
+        for key, value in self.MAPPING.items():
+            if not self._is_applied(input_value, value):
+                continue
+            return key
+
+        if raise_if_missing:
+            msg = f"No mapping for input value: {input_value}"
+            raise ValueError(msg)
+
+        return default_value
+
+    def _is_applied(self, input_value: str, rules: _TRmRules) -> bool:
+        if isinstance(rules, str | re.Pattern):
+            return self._is_applied_to_item(input_value, rules)
+        elif isinstance(rules, list):
+            return any(self._is_applied_to_item(input_value, rule) for rule in rules)
+        else:
+            assert_never(rules)
+
+    def _is_applied_to_item(self, input_value: str, rule: str | re.Pattern) -> bool:
+        if isinstance(rule, str):
+            return input_value.strip().lower() == rule.strip().lower()
+        elif isinstance(rule, re.Pattern):
+            return bool(rule.search(input_value.strip().lower()))
+        else:
+            assert_never(rule)
+
+    MAPPING: Mapping[str, _TRmRules] = {}

{openepd-6.23.0.dist-info → openepd-6.25.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: openepd
-Version: 6.23.0
+Version: 6.25.0
 Summary: Python library to work with OpenEPD format
 License: Apache-2.0
 Author: C-Change Labs

{openepd-6.23.0.dist-info → openepd-6.25.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
 openepd/__init__.py,sha256=fhxfEyEurLvSfvQci-vb3njzl_lvhcLXiZrecCOaMU8,794
-openepd/__version__.py,sha256=A1F4vtJZdjbFr6F3h4QgKFJUwgpNFQInneIXVmg2Vj8,639
+openepd/__version__.py,sha256=hDgSAJf2ChxmeWlgYCHYlntPXqIh3A42Hhy4RbDRnLc,639
 openepd/api/__init__.py,sha256=9THJcV3LT7JDBOMz1px-QFf_sdJ0LOqJ5dmA9Dvvtd4,620
 openepd/api/average_dataset/__init__.py,sha256=9THJcV3LT7JDBOMz1px-QFf_sdJ0LOqJ5dmA9Dvvtd4,620
 openepd/api/average_dataset/generic_estimate_sync_api.py,sha256=_eZt_jGVL1a3p9cr-EF39Ve9Vl5sB8zwzTc_slnRL50,7975
@@ -51,7 +51,7 @@ openepd/model/factory.py,sha256=UWSGpfCr3GiMTP4rzBkwqxzbXB6GKZ_5Okb1Dqa_4aA,2701
 openepd/model/generic_estimate.py,sha256=zLGTyf4Uzmp2C0m-J1ePWItSz2RGdZ0OiGPWC5nhKHk,3992
 openepd/model/geography.py,sha256=Jx7NIDdk_sIvwyh-7YxnIjAwIHW2HCQK7UtFGM2xKtw,42095
 openepd/model/industry_epd.py,sha256=QZr7OhgGkzqZ8H5p6dCIVk9zSHEYtK3y9Nk-DvkFMyk,4011
-openepd/model/lcia.py,sha256=jgxTVoY2gCgfPCLrV5xRYGHbxntellGTfgLUGU9J22Y,26152
+openepd/model/lcia.py,sha256=5SkiFdJKtza2fc2BBuepbl0TAi-UYsjSDR0ERj9ffmk,26206
 openepd/model/org.py,sha256=AAyXx42phVn3fZN0_Ga8CJb2iKh_dfVXsvO1lEtDovM,6832
 openepd/model/pcr.py,sha256=7nf6ATofdrlPt81vdU6p0E8n_ftFEuCEIKxtYlFwclw,5476
 openepd/model/specs/README.md,sha256=UGhSiFJ9hOxT1mZl-5ZrhkOrPKf1W_gcu5CI9hzV7LU,2430
@@ -98,7 +98,7 @@ openepd/model/specs/range/thermal_moisture_protection.py,sha256=aUpStISG2snc8aZ7
 openepd/model/specs/range/utility_piping.py,sha256=mQTrKbMTES_0Yta9DBnKehsmA2BAN_zYF_uPZCTKLPo,2665
 openepd/model/specs/range/wood.py,sha256=ZMStFsFOw5d6tCL2P7kksBnlYhwfvWJBZqoAdqSIUDg,6917
 openepd/model/specs/range/wood_joists.py,sha256=NCBHL0gdKwdKlGCP6up_Royl9BtWUUeuFfS1r2vIZ30,1785
-openepd/model/specs/singular/__init__.py,sha256=JuoXYIhyexFBY6gwCAa823CDT3XISSjjMBjQue7HTvM,11434
+openepd/model/specs/singular/__init__.py,sha256=YaySkDd4qgmHCk58TfMhgsiAnU_IY83xK847NEvOC60,11414
 openepd/model/specs/singular/accessories.py,sha256=xcuSJrG84oTm_w76_wlv_sItfK36gSyDmUD2TnpZnVE,2013
 openepd/model/specs/singular/aggregates.py,sha256=oSfArxvLUj63w_U0tZViRyiOpMRRjE72ncy2BimKxco,2934
 openepd/model/specs/singular/aluminium.py,sha256=7Z3WmuW22o92cPHfR6X_OBSoer0V5llwiNdQmWgKTx8,2408
@@ -150,7 +150,10 @@ openepd/model/validation/quantity.py,sha256=mP4gIkeOGZuHRhprsf_BX11Cic75NssYxOTk
 openepd/model/versioning.py,sha256=wBZdOVL3ND9FMIRU9PS3vx9M_7MBiO70xYPQvPez6po,4522
 openepd/patch_pydantic.py,sha256=bO7U5HqthFol0vfycb0a42UAGL3KOQ8-9MW4yCWOFP0,4150
 openepd/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-openepd-6.23.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-openepd-6.23.0.dist-info/METADATA,sha256=j0XNy77oTEnuCbaEbCxKnmA5INpLme5-OVoILoxKAUE,9827
-openepd-6.23.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-openepd-6.23.0.dist-info/RECORD,,
+openepd/utils/__init__.py,sha256=9THJcV3LT7JDBOMz1px-QFf_sdJ0LOqJ5dmA9Dvvtd4,620
+openepd/utils/mapping/__init__.py,sha256=9THJcV3LT7JDBOMz1px-QFf_sdJ0LOqJ5dmA9Dvvtd4,620
+openepd/utils/mapping/common.py,sha256=WphCzwQQlzX11tUk88Ubyq3QPBLvH0tBPSIuH0kmiug,7339
+openepd-6.25.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+openepd-6.25.0.dist-info/METADATA,sha256=sXZ1WJU-4BzBy9ZSCjbmL_cvd_44recegC2mmALLGlE,9827
+openepd-6.25.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+openepd-6.25.0.dist-info/RECORD,,