openepd 6.24.0__tar.gz → 6.26.0__tar.gz

{openepd-6.24.0 → openepd-6.26.0}/PKG-INFO

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

{openepd-6.24.0 → openepd-6.26.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "openepd"
-version = "6.24.0"
+version = "6.26.0"
 license = "Apache-2.0"
 description = "Python library to work with OpenEPD format"
 authors = ["C-Change Labs <support@c-change-labs.com>"]
@@ -172,3 +172,7 @@ extend-ignore = [
     "D212", # We want to require second line for multiline docstrings
 ]
 extend-select = ["S", "E", "B", "A", "EM", "UP", "LOG", "G", "I", "D"]
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"

{openepd-6.24.0 → openepd-6.26.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.24.0"
+VERSION = "6.26.0"

openepd-6.26.0/src/openepd/constants/scope_phases.py

@@ -0,0 +1,168 @@
+#
+#  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__ = ["ScopePhases"]
+
+
+from enum import StrEnum
+
+from openepd.utils.functional import classproperty
+
+
+# noinspection PyMethodParameters
+class ScopePhases(StrEnum):
+    """Container of common way to specify known scope phases under OpenEPD standard."""
+
+    A1 = "A1"
+    A2 = "A2"
+    A3 = "A3"
+    A1A2A3 = "A1A2A3"
+    A4 = "A4"
+    A5 = "A5"
+
+    B1 = "B1"
+    B2 = "B2"
+    B3 = "B3"
+    B4 = "B4"
+    B5 = "B5"
+    B6 = "B6"
+    B7 = "B7"
+
+    C1 = "C1"
+    C2 = "C2"
+    C3 = "C3"
+    C4 = "C4"
+
+    D = "D"
+
+    @classproperty
+    def a1a2a3(cls) -> str:
+        return cls.A1A2A3.lower()
+
+    @classproperty
+    def a1(cls) -> str:
+        return cls.A1.lower()
+
+    @classproperty
+    def a2(cls) -> str:
+        return cls.A2.lower()
+
+    @classproperty
+    def a3(cls) -> str:
+        return cls.A3.lower()
+
+    @classproperty
+    def a4(cls) -> str:
+        return cls.A4.lower()
+
+    @classproperty
+    def a5(cls) -> str:
+        return cls.A5.lower()
+
+    @classproperty
+    def b1(cls) -> str:
+        return cls.B1.lower()
+
+    @classproperty
+    def b2(cls) -> str:
+        return cls.B2.lower()
+
+    @classproperty
+    def b3(cls) -> str:
+        return cls.B3.lower()
+
+    @classproperty
+    def b4(cls) -> str:
+        return cls.B4.lower()
+
+    @classproperty
+    def b5(cls) -> str:
+        return cls.B5.lower()
+
+    @classproperty
+    def b6(cls) -> str:
+        return cls.B6.lower()
+
+    @classproperty
+    def b7(cls) -> str:
+        return cls.B7.lower()
+
+    @classproperty
+    def c1(cls) -> str:
+        return cls.C1.lower()
+
+    @classproperty
+    def c2(cls) -> str:
+        return cls.C2.lower()
+
+    @classproperty
+    def c3(cls) -> str:
+        return cls.C3.lower()
+
+    @classproperty
+    def c4(cls) -> str:
+        return cls.C4.lower()
+
+    @classproperty
+    def d(cls) -> str:
+        return cls.D.lower()
+
+    @classmethod
+    def a_scopes(cls, *, lowercase: bool = False) -> tuple[str, ...]:
+        result = (ScopePhases.A1A2A3, ScopePhases.A1, ScopePhases.A2, ScopePhases.A3, ScopePhases.A4, ScopePhases.A5)
+        if lowercase:
+            return cls._lowercase(result)
+        return result
+
+    @classmethod
+    def b_scopes(cls, *, lowercase: bool = False) -> tuple[str, ...]:
+        result = (
+            ScopePhases.B1,
+            ScopePhases.B2,
+            ScopePhases.B3,
+            ScopePhases.B4,
+            ScopePhases.B5,
+            ScopePhases.B6,
+            ScopePhases.B7,
+        )
+        if lowercase:
+            return cls._lowercase(result)
+
+        return result
+
+    @classmethod
+    def c_scopes(cls, *, lowercase: bool = False) -> tuple[str, ...]:
+        result = (ScopePhases.C1, ScopePhases.C2, ScopePhases.C3, ScopePhases.C4)
+        if lowercase:
+            return cls._lowercase(result)
+        return result
+
+    @classmethod
+    def d_scopes(cls, *, lowercase: bool = False) -> tuple[str, ...]:
+        result = (ScopePhases.D,)
+        if lowercase:
+            return cls._lowercase(result)
+        return result
+
+    @classmethod
+    def all_scopes(cls, *, lowercase: bool = False) -> tuple[str, ...]:
+        result = cls.a_scopes() + cls.b_scopes() + cls.c_scopes() + cls.d_scopes()
+        if lowercase:
+            return cls._lowercase(result)
+        return result
+
+    @classmethod
+    def _lowercase(cls, scopes: tuple[str, ...]) -> tuple[str, ...]:
+        return tuple(scope.lower() for scope in scopes)

{openepd-6.24.0 → openepd-6.26.0}/src/openepd/model/declaration.py

@@ -203,6 +203,9 @@ class WithVerifierMixin(pyd.BaseModel):
     third_party_verifier_email: pyd.EmailStr | None = pyd.Field(
         description="Email address of the third party verifier", example="john.doe@example.com", default=None
     )
+    third_party_verifier_name: str | None = pyd.Field(
+        description="The publishable name of the third party verifier", example="John Doe", default=None
+    )
 
 
 class WithEpdDeveloperMixin(pyd.BaseModel):

{openepd-6.24.0 → openepd-6.26.0}/src/openepd/model/lcia.py

@@ -522,6 +522,7 @@ class LCIAMethod(StrEnum):
     CML_1992 = "CML 1992"
     RECIPE_2016 = "ReCiPe 2016"
     RECIPE_2008 = "ReCiPe 2008"
+    GWP_GHG = "GWP-GHG"
     LIME2 = "LIME2"
 
     @classmethod

{openepd-6.24.0 → openepd-6.26.0}/src/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-6.26.0/src/openepd/model/validation/__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-6.26.0/src/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-6.26.0/src/openepd/utils/functional.py

@@ -0,0 +1,36 @@
+#
+#  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.
+#
+
+# Portions of this file are sourced from https://github.com/django/django/blob/main/django/utils/functional.py
+# Copyright (c) Django Software Foundation and individual contributors.
+# Licensed under the BSD 3-Clause License.
+
+# noinspection PyPep8Naming
+class classproperty:
+    """
+    Decorator that converts a method with a single cls argument into a property
+    that can be accessed directly from the class.
+    """  # noqa: D205
+
+    def __init__(self, method=None):
+        self.fget = method
+
+    def __get__(self, instance, cls=None):
+        return self.fget(cls)
+
+    def getter(self, method):
+        self.fget = method
+        return self

openepd-6.26.0/src/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-6.26.0/src/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] = {}