openepd 4.10.0__tar.gz → 4.11.0__tar.gz

{openepd-4.10.0 → openepd-4.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: openepd
-Version: 4.10.0
+Version: 4.11.0
 Summary: Python library to work with OpenEPD format
 Home-page: https://github.com/cchangelabs/openepd
 License: Apache-2.0
@@ -164,6 +164,11 @@ The geography and country enums are generated from several sources, including py
 codes, UN m49 codification, and special regions. To update the enums, first update any of these sources, then use
 `make codegen`. See 'tools/openepd/codegen' for details.
 
+## Development
+
+Windows is not supported for development. You can use WSL2 with Ubuntu 20.04 or higher.
+Instructions are the same as for regular GNU/Linux installation.
+
 # Credits
 
 This library has been written and maintained by [C-Change Labs](https://c-change-labs.com/).

{openepd-4.10.0 → openepd-4.11.0}/README.md

@@ -138,6 +138,11 @@ The geography and country enums are generated from several sources, including py
 codes, UN m49 codification, and special regions. To update the enums, first update any of these sources, then use
 `make codegen`. See 'tools/openepd/codegen' for details.
 
+## Development
+
+Windows is not supported for development. You can use WSL2 with Ubuntu 20.04 or higher.
+Instructions are the same as for regular GNU/Linux installation.
+
 # Credits
 
 This library has been written and maintained by [C-Change Labs](https://c-change-labs.com/).

{openepd-4.10.0 → openepd-4.11.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "openepd"
-version = "4.10.0"
+version = "4.11.0"
 license = "Apache-2.0"
 description = "Python library to work with OpenEPD format"
 authors = ["C-Change Labs <support@c-change-labs.com>"]

{openepd-4.10.0 → openepd-4.11.0}/src/openepd/__version__.py

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

openepd-4.11.0/src/openepd/api/average_dataset/generic_estimate_sync_api.py

@@ -0,0 +1,200 @@
+#
+#  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 Literal, TypeAlias, overload
+
+from requests import Response
+
+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.model.generic_estimate import (
+    GenericEstimate,
+    GenericEstimatePreview,
+    GenericEstimateRef,
+    GenericEstimateWithDeps,
+)
+
+
+class GenericEstimateApi(BaseApiMethodGroup):
+    """API methods for Generic Estimates."""
+
+    @overload
+    def get_by_open_xpd_uuid(self, uuid: str, with_response: Literal[True]) -> tuple[GenericEstimate, Response]: ...
+
+    @overload
+    def get_by_open_xpd_uuid(self, uuid: str, with_response: Literal[False] = False) -> GenericEstimate: ...
+
+    def get_by_open_xpd_uuid(
+        self, uuid: str, with_response: bool = False
+    ) -> GenericEstimate | tuple[GenericEstimate, Response]:
+        """
+        Get Generic Estimate by OpenEPD UUID.
+
+        :param uuid: Open xPD UUID
+        :param with_response: whether to return just object or with response
+        :return: GE or GE with response depending on param with_response
+        :raise ObjectNotFound: if Generic Estimate is not found
+        """
+        response = self._client.do_request("get", f"/generic_estimates/{uuid}")
+        if with_response:
+            return GenericEstimate.parse_obj(response.json()), response
+        return GenericEstimate.parse_obj(response.json())
+
+    @overload
+    def post_with_refs(
+        self, ge: GenericEstimateWithDeps, with_response: Literal[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: bool = False
+    ) -> GenericEstimate | tuple[GenericEstimate, Response]:
+        """
+        Post an GenericEstimate with references.
+
+        :param ge: GenericEstimate
+        :param with_response: return the response object togather with the GenericEstimate
+        :return: GenericEstimate alone, or GenericEstimate with HTTP Response object depending on parameter
+        """
+        response = self._client.do_request(
+            "patch",
+            "/generic_estimates/post_with_refs",
+            json=ge.to_serializable(exclude_unset=True, exclude_defaults=True, by_alias=True),
+        )
+        content = response.json()
+        if with_response:
+            return GenericEstimate.parse_obj(content), response
+        return GenericEstimate.parse_obj(content)
+
+    @overload
+    def create(self, ge: GenericEstimate, with_response: Literal[True]) -> tuple[GenericEstimateRef, Response]: ...
+
+    @overload
+    def create(self, ge: GenericEstimate, with_response: Literal[False] = False) -> GenericEstimateRef: ...
+
+    def create(
+        self, ge: GenericEstimate, with_response: bool = False
+    ) -> GenericEstimateRef | tuple[GenericEstimateRef, Response]:
+        """
+        Create a Generic Estimate.
+
+        :param ge: Generic Estimate
+        :param with_response: return the response object together with the EPD
+        :return: Generic Estimate or Generic Estimate with HTTP Response object depending on parameter
+        """
+        response = self._client.do_request(
+            "post",
+            "/generic_estimates",
+            json=ge.to_serializable(exclude_unset=True, exclude_defaults=True, by_alias=True),
+        )
+        content = response.json()
+        if with_response:
+            return GenericEstimateRef.parse_obj(content), response
+        return GenericEstimateRef.parse_obj(content)
+
+    @overload
+    def edit(self, ge: GenericEstimate, with_response: Literal[True]) -> tuple[GenericEstimateRef, Response]: ...
+
+    @overload
+    def edit(self, ge: GenericEstimate, with_response: Literal[False] = False) -> GenericEstimateRef: ...
+
+    def edit(
+        self, ge: GenericEstimate, with_response: bool = False
+    ) -> GenericEstimateRef | tuple[GenericEstimateRef, Response]:
+        """
+        Edit a Generic Estimate.
+
+        :param ge: GenericEstimate
+        :param with_response: return the response object together with the GE
+        :return: GE or GE with HTTP Response object depending on parameter
+        """
+        ge_id = ge.id
+        if not ge_id:
+            raise ValueError("The ID must be set to edit a GenericEstimate.")
+
+        response = self._client.do_request(
+            "put",
+            f"/generic_estimates/{encode_path_param(ge_id)}",
+            json=ge.to_serializable(exclude_unset=True, exclude_defaults=True, by_alias=True),
+        )
+        content = response.json()
+        if with_response:
+            return GenericEstimateRef.parse_obj(content), response
+        return GenericEstimateRef.parse_obj(content)
+
+    @overload
+    def list_raw(
+        self, page_num: int, page_size: int, with_response: Literal[False] = False
+    ) -> list[GenericEstimatePreview]: ...
+
+    @overload
+    def list_raw(
+        self, page_num: int, page_size: int, with_response: Literal[True]
+    ) -> tuple[list[GenericEstimatePreview], Response]: ...
+
+    def list_raw(
+        self, page_num: int = 1, page_size: int = 10, with_response: bool = False
+    ) -> list[GenericEstimatePreview] | tuple[list[GenericEstimatePreview], Response]:
+        """
+        List generic estimates.
+
+        :param page_num: page number
+        :param page_size: page size
+        :param with_response: whether to return just object or with response
+
+        :return: GE or GE with HTTP Response object depending on parameter
+        """
+        response = self._client.do_request(
+            "get",
+            "/generic_estimates",
+            params=dict(
+                page_number=page_num,
+                page_size=page_size,
+            ),
+        )
+        data = [GenericEstimatePreview.parse_obj(o) for o in response.json()]
+        if with_response:
+            return data, response
+        return data
+
+    def list(self, page_size: int | None = None) -> StreamingListResponse[GenericEstimatePreview]:
+        """
+        List GenericEstimates.
+
+        :param page_size: page size, None for default
+        :return: streaming list of GEs
+        """
+
+        def _get_page(p_num: int, p_size: int) -> GenericEstimateListResponse:
+            data_list, response = self.list_raw(page_num=p_num, page_size=p_size, with_response=True)
+            return GenericEstimateListResponse(
+                payload=data_list, meta=GenericEstimateSearchMeta(paging=paging_meta_from_v1_api(response))
+            )
+
+        return StreamingListResponse[GenericEstimatePreview](_get_page, page_size=page_size)
+
+
+class GenericEstimateSearchMeta(PagingMetaMixin, BaseMeta):
+    """Metadata for EPD Search endpoint."""
+
+    pass
+
+
+GenericEstimateListResponse: TypeAlias = OpenEpdApiResponse[list[GenericEstimatePreview], GenericEstimateSearchMeta]

openepd-4.11.0/src/openepd/api/average_dataset/industry_epd_sync_api.py

@@ -0,0 +1,164 @@
+#
+#  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 Literal, TypeAlias, overload
+
+from requests import Response
+
+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.model.industry_epd import IndustryEpd, IndustryEpdPreview, IndustryEpdRef
+
+
+class IndustryEpdApi(BaseApiMethodGroup):
+    """API methods for Industry EPD."""
+
+    @overload
+    def get_by_open_xpd_uuid(self, uuid: str, with_response: Literal[True]) -> tuple[IndustryEpd, Response]: ...
+
+    @overload
+    def get_by_open_xpd_uuid(self, uuid: str, with_response: Literal[False] = False) -> IndustryEpd: ...
+
+    def get_by_open_xpd_uuid(
+        self, uuid: str, with_response: bool = False
+    ) -> IndustryEpd | tuple[IndustryEpd, Response]:
+        """
+        Get Industry EPD by OpenEPD UUID.
+
+        :param uuid: OpenEPD UUID
+        :param with_response: whether to return just object or with response
+        :return: IEPD or IEPD with response depending on param with_response
+        :raise ObjectNotFound: if Industry EPD is not found
+        """
+        response = self._client.do_request("get", f"/industry_epds/{uuid}")
+        if with_response:
+            return IndustryEpd.parse_obj(response.json()), response
+        return IndustryEpd.parse_obj(response.json())
+
+    @overload
+    def create(self, iepd: IndustryEpd, with_response: Literal[True]) -> tuple[IndustryEpdRef, Response]: ...
+
+    @overload
+    def create(self, iepd: IndustryEpd, with_response: Literal[False] = False) -> IndustryEpdRef: ...
+
+    def create(
+        self, iepd: IndustryEpd, with_response: bool = False
+    ) -> IndustryEpdRef | tuple[IndustryEpdRef, Response]:
+        """
+        Create an Industry EPD.
+
+        :param iepd: Industry EPD
+        :param with_response: return the response object together with the EPD
+        :return: Industry EPD or Industry EPD with HTTP Response object depending on parameter
+        """
+        response = self._client.do_request(
+            "post",
+            "/industry_epds",
+            json=iepd.to_serializable(exclude_unset=True, exclude_defaults=True, by_alias=True),
+        )
+        content = response.json()
+        if with_response:
+            return IndustryEpdRef.parse_obj(content), response
+        return IndustryEpdRef.parse_obj(content)
+
+    @overload
+    def edit(self, iepd: IndustryEpd, with_response: Literal[True]) -> tuple[IndustryEpdRef, Response]: ...
+
+    @overload
+    def edit(self, iepd: IndustryEpd, with_response: Literal[False] = False) -> IndustryEpdRef: ...
+
+    def edit(self, iepd: IndustryEpd, with_response: bool = False) -> IndustryEpdRef | tuple[IndustryEpdRef, Response]:
+        """
+        Edit an Industr EPD.
+
+        :param iepd: IndustryEpd
+        :param with_response: return the response object together with the IEPD
+        :return: IEPD or IEPD with HTTP Response object depending on parameter
+        """
+        iepd_id = iepd.id
+        if not iepd_id:
+            raise ValueError("The ID must be set to edit a IndustryEpd.")
+
+        response = self._client.do_request(
+            "put",
+            f"/industry_epds/{encode_path_param(iepd_id)}",
+            json=iepd.to_serializable(exclude_unset=True, exclude_defaults=True, by_alias=True),
+        )
+        content = response.json()
+        if with_response:
+            return IndustryEpdRef.parse_obj(content), response
+        return IndustryEpdRef.parse_obj(content)
+
+    @overload
+    def list_raw(
+        self, page_num: int, page_size: int, with_response: Literal[False] = False
+    ) -> list[IndustryEpdPreview]: ...
+
+    @overload
+    def list_raw(
+        self, page_num: int, page_size: int, with_response: Literal[True]
+    ) -> tuple[list[IndustryEpdPreview], Response]: ...
+
+    def list_raw(
+        self, page_num: int = 1, page_size: int = 10, with_response: bool = False
+    ) -> list[IndustryEpdPreview] | tuple[list[IndustryEpdPreview], Response]:
+        """
+        List industry epds.
+
+        :param page_num: page number
+        :param page_size: page size
+        :param with_response: whether to return just object or with response
+        :return: list of IEPDs or list of IEPDs with response depending on param with_response
+        """
+        response = self._client.do_request(
+            "get",
+            "/industry_epds",
+            params=dict(
+                page_number=page_num,
+                page_size=page_size,
+            ),
+        )
+        data = [IndustryEpdPreview.parse_obj(o) for o in response.json()]
+        if with_response:
+            return data, response
+        return data
+
+    def list(self, page_size: int | None = None) -> StreamingListResponse[IndustryEpdPreview]:
+        """
+        List IndustryEpds.
+
+        :param page_size: page size, None for default
+        :return: streaming list of IEPDs
+        """
+
+        def _get_page(p_num: int, p_size: int) -> IndustryEpdListResponse:
+            data_list, response = self.list_raw(page_num=p_num, page_size=p_size, with_response=True)
+            return IndustryEpdListResponse(
+                payload=data_list, meta=IndustryEpdSearchMeta(paging=paging_meta_from_v1_api(response))
+            )
+
+        return StreamingListResponse[IndustryEpdPreview](_get_page, page_size=page_size)
+
+
+class IndustryEpdSearchMeta(PagingMetaMixin, BaseMeta):
+    """Metadata for EPD Search endpoint."""
+
+    pass
+
+
+IndustryEpdListResponse: TypeAlias = OpenEpdApiResponse[list[IndustryEpdPreview], IndustryEpdSearchMeta]

{openepd-4.10.0 → openepd-4.11.0}/src/openepd/api/common.py

@@ -20,6 +20,8 @@ import threading
 from time import sleep
 from typing import Callable, Generic, Iterator, cast
 
+from requests import Response
+
 from openepd.api.dto.common import DEFAULT_PAGE_SIZE, MetaCollectionDto, OpenEpdApiResponse
 from openepd.api.dto.meta import PagingMeta, PagingMetaMixin
 from openepd.model.base import TOpenEpdObject
@@ -233,3 +235,12 @@ def no_trailing_slash(val: str) -> str:
     while val.endswith("/"):
         val = val[:-1]
     return val
+
+
+def paging_meta_from_v1_api(r: Response) -> PagingMeta:
+    """Return a PagingMeta dto from v1 API format with data in headers."""
+    return PagingMeta(
+        total_count=int(r.headers["X-Total-Count"]),
+        total_pages=int(r.headers["X-Total-Pages"]),
+        page_size=int(r.headers["X-Page-Size"]),
+    )

{openepd-4.10.0 → openepd-4.11.0}/src/openepd/api/sync_client.py

@@ -17,6 +17,8 @@ __all__ = ("OpenEpdApiClientSync",)
 
 from requests.auth import AuthBase
 
+from openepd.api.average_dataset.generic_estimate_sync_api import GenericEstimateApi
+from openepd.api.average_dataset.industry_epd_sync_api import IndustryEpdApi
 from openepd.api.base_sync_client import SyncHttpClient, TokenAuth
 from openepd.api.category.sync_api import CategoryApi
 from openepd.api.epd.sync_api import EpdApi
@@ -40,6 +42,8 @@ class OpenEpdApiClientSync:
         self.__epd_api: EpdApi | None = None
         self.__pcr_api: PcrApi | None = None
         self.__category_api: CategoryApi | None = None
+        self.__generic_estimate_api: GenericEstimateApi | None = None
+        self.__industry_epd_api: IndustryEpdApi | None = None
 
     @property
     def epds(self) -> EpdApi:
@@ -61,3 +65,17 @@ class OpenEpdApiClientSync:
         if self.__category_api is None:
             self.__category_api = CategoryApi(self._http_client)
         return self.__category_api
+
+    @property
+    def industry_epds(self) -> IndustryEpdApi:
+        """Get the Category API."""
+        if self.__industry_epd_api is None:
+            self.__industry_epd_api = IndustryEpdApi(self._http_client)
+        return self.__industry_epd_api
+
+    @property
+    def generic_estimates(self) -> GenericEstimateApi:
+        """Get the GE API."""
+        if self.__generic_estimate_api is None:
+            self.__generic_estimate_api = GenericEstimateApi(self._http_client)
+        return self.__generic_estimate_api

{openepd-4.10.0 → openepd-4.11.0}/src/openepd/model/declaration.py

@@ -57,7 +57,7 @@ class BaseDeclaration(RootDocument, abc.ABC):
     kg_per_declared_unit: Amount | None = pyd.Field(
         default=None,
         description="Mass of the product, in kilograms, per declared unit",
-        example=Amount(qty=12.5, unit="kg"),
+        example=Amount(qty=12.5, unit="kg").to_serializable(exclude_unset=True),
     )
     compliance: list[Standard] = pyd.Field(
         description="Standard(s) to which this document is compliant.", default_factory=list
@@ -129,7 +129,8 @@ class AverageDatasetMixin(pyd.BaseModel, title="Average Dataset"):
     )
 
     geography: list[Geography] | None = pyd.Field(
-        "Jurisdiction(s) in which the LCA result is applicable.  An empty array, or absent properties, implies global applicability."
+        description="Jurisdiction(s) in which the LCA result is applicable.  An empty array, or absent properties, "
+        "implies global applicability.",
     )
 
 

{openepd-4.10.0 → openepd-4.11.0}/src/openepd/model/generic_estimate.py

@@ -58,6 +58,8 @@ class GenericEstimatePreviewV0(
     Excludes LCIA data.
     """
 
+    _FORMAT_VERSION = OpenEpdVersions.Version0.as_str()
+
     doctype: str = pyd.Field(
         description='Describes the type and schema of the document. Must always be "openGenericEstimate"',
         default="openGenericEstimate",
@@ -79,15 +81,7 @@ GenericEstimatePreview = GenericEstimatePreviewV0
 
 
 class GenericEstimateV0(GenericEstimatePreviewV0, WithLciaMixin, WithAltIdsMixin, title="Generic Estimate (Full)"):
-    """
-    Full Generic Estimate object.
-
-    This is considered the most complete valid openEPD object for GenericEstimate. In addition to it, several related
-    models are defined, either with fewer fields (to be used in APIs for list requests) or with more relaxed structure
-    to support related entities matching.
-    """
-
-    _FORMAT_VERSION = OpenEpdVersions.Version0.as_str()
+    """Full Generic Estimate object."""
 
 
 GenericEstimate = GenericEstimateV0
@@ -98,10 +92,6 @@ class GenericEstimateWithDepsV0(GenericEstimateV0, title="Generic Estimate (with
     Expanded version of the GenericEstimate.
 
     Contains related entities - orgs - with full fields, to support object matching in implementations.
-
-    For now the implementation matches the above GenericEstimate entity, but they will diverge as normal GE would have
-    some required fields in Org (like web_domain), and WithDeps would not.
-
     """
 
     publisher: Org | None = pyd.Field(description="Organization that published the LCA results.")

{openepd-4.10.0 → openepd-4.11.0}/src/openepd/model/geography.py

@@ -279,7 +279,7 @@ class Geography(StrEnum):
      * ZM: Zambia
      * ZW: Zimbabwe
 
-    USA states and Canada provinces, see https://en.wikipedia.org/wiki/ISO_3166-1:
+    USA and Canada subdivisions, see https://en.wikipedia.org/wiki/ISO_3166-1:
 
      * CA-AB: Alberta, Canada
      * CA-BC: British Columbia, Canada

{openepd-4.10.0 → openepd-4.11.0}/src/openepd/model/lcia.py

@@ -322,6 +322,16 @@ class LCIAMethod(StrEnum):
 class Impacts(pyd.BaseModel):
     """List of environmental impacts, compiled per one of the standard Impact Assessment methods."""
 
+    class Config:
+        # pydantic schema generator gets lost in this structure, so we need to re-establish it manually for openapi
+        schema_extra = {
+            "properties": {
+                str(lm): {"description": str(lm), "allOf": [{"$ref": "#/components/schemas/ImpactSet"}]}
+                for lm in LCIAMethod
+            },
+            "additionalProperties": None,
+        }
+
     __root__: dict[LCIAMethod, ImpactSet]
 
     def set_unknown_lcia(self, impact_set: ImpactSet):

openepd-4.11.0/src/openepd/model/validation/__init__.py

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

{openepd-4.10.0 → openepd-4.11.0}/src/openepd/model/industry_epd.py

@@ -49,6 +49,8 @@ class IndustryEpdPreviewV0(
     Used in lists and other cases where full LCIA data is not required.
     """
 
+    _FORMAT_VERSION = OpenEpdVersions.Version0.as_str()
+
     doctype: str = pyd.Field(
         description='Describes the type and schema of the document. Must always be "openIndustryEpd"',
         default="openIndustryEpd",
@@ -70,8 +72,6 @@ class IndustryEpdV0(IndustryEpdPreviewV0, WithLciaMixin, WithAltIdsMixin, title=
     to support related entities matching.
     """
 
-    _FORMAT_VERSION = OpenEpdVersions.Version0.as_str()
-
 
 IndustryEpd = IndustryEpdV0