openepd 7.0.0__tar.gz → 7.0.1__tar.gz

{openepd-7.0.0 → openepd-7.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: openepd
-Version: 7.0.0
+Version: 7.0.1
 Summary: Python library to work with OpenEPD format
 Home-page: https://github.com/cchangelabs/openepd
 License: Apache-2.0
@@ -21,7 +21,7 @@ Requires-Dist: email-validator (>=1.3.1)
 Requires-Dist: idna (>=3.7)
 Requires-Dist: open-xpd-uuid (>=0.2.1,<0.3.0)
 Requires-Dist: openlocationcode (>=1.0.1)
-Requires-Dist: pydantic (>=1.10,<3.0)
+Requires-Dist: pydantic (>=2.0,<3)
 Requires-Dist: requests (>=2.0) ; extra == "api-client"
 Project-URL: Repository, https://github.com/cchangelabs/openepd
 Description-Content-Type: text/markdown

{openepd-7.0.0 → openepd-7.0.1}/pyproject.toml

@@ -1,11 +1,11 @@
 [tool.ruff]
 line-length = 120
-target-version = "py312"
+target-version = "py311"
 exclude = [".*pyi"]
 
 [tool.poetry]
 name = "openepd"
-version = "7.0.0"
+version = "7.0.1"
 license = "Apache-2.0"
 description = "Python library to work with OpenEPD format"
 authors = ["C-Change Labs <support@c-change-labs.com>"]
@@ -26,7 +26,7 @@ exclude = ["**/test_*.py", "**/tests/**"]
 
 [tool.poetry.dependencies]
 python = "^3.11"
-pydantic = ">=1.10,<3.0"
+pydantic = ">=2.0,<3"
 email-validator = ">=1.3.1"
 requests = { version = ">=2.0", optional = true }
 idna = ">=3.7"

{openepd-7.0.0 → openepd-7.0.1}/src/openepd/__version__.py

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

{openepd-7.0.0 → openepd-7.0.1}/src/openepd/api/category/sync_api.py

@@ -28,7 +28,7 @@ class CategoryApi(BaseApiMethodGroup):
         :return: categories tree wrapped in OpenEpdApiResponse
         """
         response = self._client.do_request("get", "/v2/categories/tree")
-        return CategoryTreeResponse.model_validate(response.content)
+        return CategoryTreeResponse.model_validate_json(response.content)
 
     def get_tree(self) -> Category:
         """

{openepd-7.0.0 → openepd-7.0.1}/src/openepd/model/base.py

@@ -234,7 +234,7 @@ class BaseDocumentFactory(Generic[TRootDocument]):
         for x, doc_cls in cls.VERSION_MAP.items():
             if x.major == version.major:
                 if version.minor <= x.minor:
-                    return doc_cls(**data)
+                    return doc_cls.model_validate(data)
                 else:
                     raise ValueError(
                         f"Unsupported version: {version}. The highest supported version from branch {x.major}.x is {x}"

{openepd-7.0.0 → openepd-7.0.1}/src/openepd/model/common.py

@@ -14,7 +14,7 @@
 #  limitations under the License.
 #
 from enum import StrEnum
-from typing import Annotated, Any
+from typing import Annotated, Any, Self
 
 import pydantic
 import pydantic_core
@@ -32,12 +32,15 @@ class Amount(BaseOpenEpdSchema):
         default=None,
     )
 
-    @pydantic.model_validator(mode="before")
-    def check_qty_or_unit(cls, values: dict[str, Any]):
+    model_config = pydantic.ConfigDict(from_attributes=True)
+
+    @pydantic.model_validator(mode="after")
+    def check_qty_or_unit(self) -> Self:
         """Ensure that qty or unit is provided."""
-        if values.get("qty") is None and values.get("unit") is None:
+
+        if self.qty is None and self.unit is None:
             raise ValueError("Either qty or unit must be provided.")
-        return values
+        return self
 
     def to_quantity_str(self):
         """Return a string representation of the amount."""

{openepd-7.0.0 → openepd-7.0.1}/src/openepd/model/epd.py

@@ -282,10 +282,10 @@ class EpdWithDepsV0(EpdV0, title="EPD (with Dependencies)"):
     some required fields in Org (like web_domain), and WithDeps would not.
     """
 
-    manufacturer: Org | None = pydantic.Field(description=MANUFACTURER_DESCRIPTION)
-    epd_developer: Org | None = pydantic.Field(description=DEVELOPER_DESCRIPTION, default=None)
-    program_operator: Org | None = pydantic.Field(description=PROGRAM_OPERATOR_DESCRIPTION)
-    third_party_verifier: Org | None = pydantic.Field(description=THIRD_PARTY_VERIFIER_DESCRIPTION)
+    manufacturer: Org | None = pydantic.Field(description=MANUFACTURER_DESCRIPTION, default=None)  # type: ignore[assignment]
+    epd_developer: Org | None = pydantic.Field(description=DEVELOPER_DESCRIPTION, default=None)  # type: ignore[assignment]
+    program_operator: Org | None = pydantic.Field(description=PROGRAM_OPERATOR_DESCRIPTION, default=None)  # type: ignore[assignment]
+    third_party_verifier: Org | None = pydantic.Field(description=THIRD_PARTY_VERIFIER_DESCRIPTION, default=None)  # type: ignore[assignment]
 
 
 EpdWithDeps = EpdWithDepsV0

{openepd-7.0.0 → openepd-7.0.1}/src/openepd/model/generic_estimate.py

@@ -110,8 +110,8 @@ class GenericEstimateWithDepsV0(GenericEstimateV0, title="Generic Estimate (with
     Contains related entities - orgs - with full fields, to support object matching in implementations.
     """
 
-    publisher: Org | None = pydantic.Field(description="Organization that published the LCA results.")
-    reviewer: Org | None = pydantic.Field(description="Org that performed a critical review of the LCA.")
+    publisher: Org | None = pydantic.Field(description="Organization that published the LCA results.", default=None)  # type: ignore[assignment]
+    reviewer: Org | None = pydantic.Field(description="Org that performed a critical review of the LCA.", default=None)  # type: ignore[assignment]
 
 
 GenericEstimateWithDeps = GenericEstimateWithDepsV0

{openepd-7.0.0 → openepd-7.0.1}/src/openepd/model/lcia.py

@@ -18,6 +18,7 @@ from typing import Any, ClassVar
 
 import pydantic
 from pydantic import ConfigDict
+from typing_extensions import Self
 
 from openepd.model.base import BaseOpenEpdSchema
 from openepd.model.common import Measurement
@@ -200,15 +201,18 @@ class ScopeSet(BaseOpenEpdSchema):
         description="Potential net benefits from reuse, recycling, and/or energy recovery beyond the system boundary.",
     )
 
-    @pydantic.model_validator(mode="before")
-    def _unit_validator(cls, values: dict[str, Any]) -> dict[str, Any]:
+    model_config = pydantic.ConfigDict(from_attributes=True)
+
+    @pydantic.model_validator(mode="after")
+    def _unit_validator(self) -> Self:
         all_units = set()
 
-        for k, v in values.items():
+        for k in self.model_fields:
+            v = getattr(self, k, None)
             if isinstance(v, Measurement):
                 all_units.add(v.unit)
 
-        if not cls.allowed_units:
+        if not self.allowed_units:
             # For unknown units - only units should be the same across all measurements (textually)
             if len(all_units) > 1:
                 raise ValueError("All scopes and measurements should be expressed in the same unit.")
@@ -221,9 +225,9 @@ class ScopeSet(BaseOpenEpdSchema):
                     ExternalValidationConfig.QUANTITY_VALIDATOR.validate_same_dimensionality(first, unit)
 
         # can correctly validate unit
-        if cls.allowed_units is not None and len(all_units) == 1 and ExternalValidationConfig.QUANTITY_VALIDATOR:
+        if self.allowed_units is not None and len(all_units) == 1 and ExternalValidationConfig.QUANTITY_VALIDATOR:
             unit = next(iter(all_units))
-            allowed_units = cls.allowed_units if isinstance(cls.allowed_units, tuple) else (cls.allowed_units,)
+            allowed_units = self.allowed_units if isinstance(self.allowed_units, tuple) else (self.allowed_units,)
 
             matched_unit = False
             for allowed_unit in allowed_units:
@@ -237,7 +241,7 @@ class ScopeSet(BaseOpenEpdSchema):
                     f"'{', '.join(allowed_units)}' is only allowed unit for this scopeset. Provided '{unit}'"
                 )
 
-        return values
+        return self
 
 
 class ScopesetByNameBase(BaseOpenEpdSchema, extra="allow"):
@@ -279,7 +283,7 @@ class ScopesetByNameBase(BaseOpenEpdSchema, extra="allow"):
     def _extra_scopeset_validator(cls, values: dict[str, Any]) -> dict[str, Any]:
         for f in values:
             # only interested in validating the extra fields
-            if f in cls.__fields__:
+            if f in cls.model_fields:
                 continue
 
             # extra impact of an unknown type - engage validation of ScopeSet
@@ -298,97 +302,97 @@ class ScopesetByNameBase(BaseOpenEpdSchema, extra="allow"):
 class ScopeSetGwp(ScopeSet):
     """ScopeSet measured in kgCO2e."""
 
-    allowed_units = "kgCO2e"
+    allowed_units: ClassVar[str | tuple[str, ...] | None] = "kgCO2e"
 
 
 class ScopeSetOdp(ScopeSet):
     """ScopeSet measured in kgCFC11e."""
 
-    allowed_units = "kgCFC11e"
+    allowed_units: ClassVar[str | tuple[str, ...] | None] = "kgCFC11e"
 
 
 class ScopeSetAp(ScopeSet):
     """ScopeSet measured in kgSO2e."""
 
-    allowed_units = ("kgSO2e", "molHe")
+    allowed_units: ClassVar[str | tuple[str, ...] | None] = ("kgSO2e", "molHe")
 
 
 class ScopeSetEpNe(ScopeSet):
     """ScopeSet measured in kgNe."""
 
-    allowed_units = "kgNe"
+    allowed_units: ClassVar[str | tuple[str, ...] | None] = "kgNe"
 
 
 class ScopeSetPocp(ScopeSet):
     """ScopeSet measured in kgO3e."""
 
-    allowed_units = ("kgO3e", "kgNMVOCe")
+    allowed_units: ClassVar[str | tuple[str, ...] | None] = ("kgO3e", "kgNMVOCe")
 
 
 class ScopeSetEpFresh(ScopeSet):
     """ScopeSet measured in kgPO4e."""
 
-    allowed_units = "kgPO4e"
+    allowed_units: ClassVar[str | tuple[str, ...] | None] = "kgPO4e"
 
 
 class ScopeSetEpTerr(ScopeSet):
     """ScopeSet measured in molNe."""
 
-    allowed_units = "molNe"
+    allowed_units: ClassVar[str | tuple[str, ...] | None] = "molNe"
 
 
 class ScopeSetIrp(ScopeSet):
     """ScopeSet measured in kilo Becquerel equivalent of u235."""
 
-    allowed_units = "kBqU235e"
+    allowed_units: ClassVar[str | tuple[str, ...] | None] = "kBqU235e"
 
 
 class ScopeSetCTUh(ScopeSet):
     """ScopeSet measured in CTUh."""
 
-    allowed_units = "CTUh"
+    allowed_units: ClassVar[str | tuple[str, ...] | None] = "CTUh"
 
 
 class ScopeSetM3Aware(ScopeSet):
     """ScopeSet measured in m3AWARE Water consumption by AWARE method."""
 
-    allowed_units = "m3AWARE"
+    allowed_units: ClassVar[str | tuple[str, ...] | None] = "m3AWARE"
 
 
 class ScopeSetCTUe(ScopeSet):
     """ScopeSet measured in CTUe."""
 
-    allowed_units = "CTUe"
+    allowed_units: ClassVar[str | tuple[str, ...] | None] = "CTUe"
 
 
 class ScopeSetDiseaseIncidence(ScopeSet):
     """ScopeSet measuring disease incidence measured in AnnualPerCapita (cases)."""
 
-    allowed_units = "AnnualPerCapita"
+    allowed_units: ClassVar[str | tuple[str, ...] | None] = "AnnualPerCapita"
 
 
 class ScopeSetMass(ScopeSet):
     """ScopeSet measuring mass in kg."""
 
-    allowed_units = "kg"
+    allowed_units: ClassVar[str | tuple[str, ...] | None] = "kg"
 
 
 class ScopeSetVolume(ScopeSet):
     """ScopeSet measuring mass in kg."""
 
-    allowed_units = "m3"
+    allowed_units: ClassVar[str | tuple[str, ...] | None] = "m3"
 
 
 class ScopeSetMassOrVolume(ScopeSet):
     """ScopeSet measuring mass in kg OR volume in m3, example: radioactive waste."""
 
-    allowed_units = ("kg", "m3")
+    allowed_units: ClassVar[str | tuple[str, ...] | None] = ("kg", "m3")
 
 
 class ScopeSetEnergy(ScopeSet):
     """ScopeSet measuring mass in kg."""
 
-    allowed_units = "MJ"
+    allowed_units: ClassVar[str | tuple[str, ...] | None] = "MJ"
 
 
 class ImpactSet(ScopesetByNameBase):
@@ -484,6 +488,8 @@ class ImpactSet(ScopesetByNameBase):
         description="Land use related impacts / Soil quality, in potential soil quality parameters.",
     )
 
+    model_config = pydantic.ConfigDict(from_attributes=True)
+
 
 class LCIAMethod(StrEnum):
     """A list of available LCA methods."""

{openepd-7.0.0 → openepd-7.0.1}/src/openepd/model/org.py

@@ -13,11 +13,11 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 #
-from typing import Annotated, List, Optional
+from typing import Any, Optional
 
 from openlocationcode import openlocationcode
 import pydantic
-from pydantic import ConfigDict, Field, StringConstraints
+from pydantic import ConfigDict
 
 from openepd.model.base import BaseOpenEpdSchema
 from openepd.model.common import Location, WithAltIdsMixin, WithAttachmentsMixin
@@ -47,36 +47,46 @@ class OrgRef(BaseOpenEpdSchema):
 class Org(WithAttachmentsMixin, WithAltIdsMixin, OrgRef):
     """Represent an organization."""
 
-    alt_names: (
-        Annotated[
-            list[str],
-            Annotated[
-                List[Annotated[str, StringConstraints(max_length=200)]],
-                Field(max_length=255),
-            ],
-        ]
-        | None
-    ) = pydantic.Field(
+    alt_names: list[str] | None = pydantic.Field(
         description="List of other names for organization",
         examples=[["C-Change Labs", "C-Change Labs inc."]],
         default=None,
+        max_length=255,
     )
     # TODO: NEW field, not in the spec
 
+    @pydantic.field_validator("alt_names", mode="before")
+    def _validate_alt_names(cls, value: Any) -> list[str] | None:
+        if value is None:
+            return value
+
+        if not isinstance(value, list):
+            raise TypeError(f"Expected type list or None, got {type(value)}")
+
+        if any((len(item) > 200) for item in value):
+            raise ValueError("One or more alt_names are longer than 200 characters")
+
+        return value
+
     owner: Optional["OrgRef"] = pydantic.Field(description="Organization that controls this organization", default=None)
-    subsidiaries: (
-        Annotated[
-            list["OrgRef"],
-            Annotated[
-                List[Annotated[str, StringConstraints(max_length=200)]],
-                Field(max_length=255),
-            ],
-        ]
-        | None
-    ) = pydantic.Field(
-        description="Organizations controlled by this organization",
-        default=None,
+    subsidiaries: list["OrgRef"] | None = pydantic.Field(
+        description="Organizations controlled by this organization", default=None, max_length=255
     )
+
+    @pydantic.field_validator("subsidiaries", mode="before")
+    def _validate_subsidiaries(cls, value: Any) -> list[str] | None:
+        if value is None:
+            return value
+
+        if not isinstance(value, list):
+            raise TypeError(f"Expected type list or None, got {type(value)}")
+
+        for item in value:
+            if len(item.name) > 200:
+                raise ValueError("One or more subsidiaries name are longer than 200 characters")
+
+        return value
+
     hq_location: Location | None = pydantic.Field(
         default=None,
         description="Location of a place of business, preferably the corporate headquarters.",
@@ -111,8 +121,10 @@ class Plant(PlantRef, WithAttachmentsMixin, WithAltIdsMixin):
     pluscode: str | None = pydantic.Field(
         default=None,
         description="(deprecated) Plus code (aka Open Location Code) of plant's location",
-        deprecated="Pluscode field is deprecated. If users need a pluscode they can obtain it from "
-        "`id` like this: `id.spit('.', maxsplit=1)[0]`",
+        json_schema_extra={
+            "deprecated": "Pluscode field is deprecated. If users need a pluscode they can obtain it from "
+            "`id` like this: `id.spit('.', maxsplit=1)[0]`",
+        },
     )
     latitude: float | None = pydantic.Field(
         default=None,

{openepd-7.0.0 → openepd-7.0.1}/src/openepd/model/specs/base.py

@@ -20,10 +20,10 @@ from typing import Any
 import pydantic
 from pydantic import ConfigDict
 
-from openepd.model.base import BaseOpenEpdSchema, Version
+from openepd.model.base import BaseOpenEpdSchema
 from openepd.model.validation.common import validate_version_compatibility, validate_version_format
 from openepd.model.validation.quantity import ExternalValidationConfig, QuantityValidator
-from openepd.model.versioning import WithExtVersionMixin
+from openepd.model.versioning import Version, WithExtVersionMixin
 
 
 class BaseOpenEpdSpec(BaseOpenEpdSchema):
@@ -35,6 +35,7 @@ class BaseOpenEpdSpec(BaseOpenEpdSchema):
 class BaseOpenEpdHierarchicalSpec(BaseOpenEpdSpec, WithExtVersionMixin):
     """Base class for new specs (hierarchical, versioned)."""
 
+    # TODO: Refactor work with class-based and instance-based _EXT_VERSION
     def __init__(self, **data: Any) -> None:
         # ensure that all the concrete spec objects fail on creations if they dont have _EXT_VERSION declared to
         # something meaningful

{openepd-7.0.0 → openepd-7.0.1}/src/openepd/model/specs/range/steel.py

@@ -35,6 +35,8 @@ __all__ = (
     "SteelRangeV1",
 )
 
+from typing import ClassVar
+
 import pydantic
 
 from openepd.model.common import RangeFloat, RangeRatioFloat
@@ -313,7 +315,7 @@ class SteelRangeV1(BaseOpenEpdHierarchicalSpec):
     Range version.
     """
 
-    _EXT_VERSION = "1.1"
+    _EXT_VERSION: ClassVar[str] = "1.1"
 
     yield_tensile_str: AmountRangePressureMpa | None = pydantic.Field(
         default=None,