EPA-PM-API-Wrapper 0.3.0__py3-none-any.whl

epa_pm_api_wrapper/models/worship_facility_type_use_details.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from .ceiling_height import CeilingHeight
+from .cooking_facilities import CookingFacilities
+from .gross_floor_area_used_for_food_preparation import (
+    GrossFloorAreaUsedForFoodPreparation,
+)
+from .number_of_commercial_refrigeration_units import (
+    NumberOfCommercialRefrigerationUnits,
+)
+from .number_of_computers import NumberOfComputers
+from .number_of_weekdays_open import NumberOfWeekdaysOpen
+from .percent_cooled import PercentCooled
+from .percent_heated import PercentHeated
+from .seating_capacity import SeatingCapacity
+from .total_gross_floor_area import TotalGrossFloorArea
+from .weekly_operating_hours import WeeklyOperatingHours
+
+
+@dataclass(kw_only=True)
+class WorshipFacilityTypeUseDetails:
+    class Meta:
+        global_type = False
+
+    total_gross_floor_area: TotalGrossFloorArea = field(
+        metadata={
+            "name": "totalGrossFloorArea",
+            "type": "Element",
+        }
+    )
+    weekly_operating_hours: None | WeeklyOperatingHours = field(
+        default=None,
+        metadata={
+            "name": "weeklyOperatingHours",
+            "type": "Element",
+        },
+    )
+    seating_capacity: None | SeatingCapacity = field(
+        default=None,
+        metadata={
+            "name": "seatingCapacity",
+            "type": "Element",
+        },
+    )
+    ceiling_height: None | CeilingHeight = field(
+        default=None,
+        metadata={
+            "name": "ceilingHeight",
+            "type": "Element",
+        },
+    )
+    cooking_facilities: None | CookingFacilities = field(
+        default=None,
+        metadata={
+            "name": "cookingFacilities",
+            "type": "Element",
+        },
+    )
+    gross_floor_area_used_for_food_preparation: None | GrossFloorAreaUsedForFoodPreparation = field(
+        default=None,
+        metadata={
+            "name": "grossFloorAreaUsedForFoodPreparation",
+            "type": "Element",
+        },
+    )
+    number_of_weekdays_open: None | NumberOfWeekdaysOpen = field(
+        default=None,
+        metadata={
+            "name": "numberOfWeekdaysOpen",
+            "type": "Element",
+        },
+    )
+    number_of_computers: None | NumberOfComputers = field(
+        default=None,
+        metadata={
+            "name": "numberOfComputers",
+            "type": "Element",
+        },
+    )
+    number_of_commercial_refrigeration_units: None | NumberOfCommercialRefrigerationUnits = field(
+        default=None,
+        metadata={
+            "name": "numberOfCommercialRefrigerationUnits",
+            "type": "Element",
+        },
+    )
+    percent_heated: None | PercentHeated = field(
+        default=None,
+        metadata={
+            "name": "percentHeated",
+            "type": "Element",
+        },
+    )
+    percent_cooled: None | PercentCooled = field(
+        default=None,
+        metadata={
+            "name": "percentCooled",
+            "type": "Element",
+        },
+    )

epa_pm_api_wrapper/models/yes_no.py

@@ -0,0 +1,8 @@
+from __future__ import annotations
+
+from enum import Enum
+
+
+class YesNo(Enum):
+    YES = "Yes"
+    NO = "No"

epa_pm_api_wrapper/models/zoo.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .other_type import OtherType
+
+
+@dataclass(kw_only=True)
+class Zoo(OtherType):
+    """
+    Buildings used primarily to provide habitat to live animals and which
+    may include public or private viewing and educational programs.
+    """
+
+    class Meta:
+        name = "zoo"

epa_pm_api_wrapper/py.typed

@@ -0,0 +1 @@
+# Marker file for PEP 561

epa_pm_api_wrapper/resources/__init__.py

@@ -0,0 +1,172 @@
+"""Resource bindings for the EPA Portfolio Manager API.
+
+Each resource class wraps a logical group of endpoints. Resources are attached
+to ``EpaPmClient`` (sync) and ``EpaPmAsyncClient`` (async) as attributes
+(``client.property``, ``client.meter``, etc.) and share the underlying HTTP
+machinery via a back-reference to the client. The ``Async*`` variants mirror
+their sync counterparts with ``async def`` methods.
+"""
+
+from .account import AccountResource, AsyncAccountResource
+from .association import (
+    AssociationResource,
+    AsyncAssociationResource,
+    AsyncPropertyMeterAssociationResource,
+    AsyncPropertyUseMeterAssociationResource,
+    PropertyMeterAssociationResource,
+    PropertyUseMeterAssociationResource,
+)
+from .building import AsyncBuildingResource, BuildingResource
+from .consumption_data import AsyncConsumptionDataResource, ConsumptionDataResource
+from .custom_metric import AsyncCustomMetricResource, CustomMetricResource
+from .customer import AsyncCustomerResource, CustomerResource
+from .data_exchange import (
+    AsyncDataExchangeCustomFieldsResource,
+    AsyncDataExchangeResource,
+    DataExchangeCustomFieldsResource,
+    DataExchangeResource,
+)
+from .green_power import (
+    AsyncGreenPowerResource,
+    AsyncOffsiteGreenPowerResource,
+    AsyncOnsiteRenewableResource,
+    GreenPowerResource,
+    OffsiteGreenPowerResource,
+    OnsiteRenewableResource,
+)
+from .hey import AsyncHeyResource, HeyResource
+from .hierarchy import AsyncHierarchyResource, HierarchyResource
+from .identifier import AsyncIdentifierResource, IdentifierResource
+from .meter import (
+    AggregateMeterResource,
+    AsyncAggregateMeterResource,
+    AsyncMeterIdentifierResource,
+    AsyncMeterResource,
+    MeterIdentifierResource,
+    MeterResource,
+)
+from .metrics import AsyncMetricsResource, MetricsResource
+from .property import (
+    AsyncBillboardMetricResource,
+    AsyncEduResource,
+    AsyncEGridSubregionResource,
+    AsyncEnergyPerformanceProjectResource,
+    AsyncFederalAgencyResource,
+    AsyncInternationalWeatherStationResource,
+    AsyncPgpResource,
+    AsyncPropertyDesignResource,
+    AsyncPropertyResource,
+    BillboardMetricResource,
+    EduResource,
+    EGridSubregionResource,
+    EnergyPerformanceProjectResource,
+    FederalAgencyResource,
+    InternationalWeatherStationResource,
+    PgpResource,
+    PropertyDesignResource,
+    PropertyResource,
+)
+from .property_use import (
+    AsyncCustomUseResource,
+    AsyncPropertyUseResource,
+    AsyncUseDetailsResource,
+    CustomUseResource,
+    PropertyUseResource,
+    UseDetailsResource,
+)
+from .report import (
+    AsyncReportResource,
+    AsyncReportTemplatesResource,
+    ReportResource,
+    ReportTemplatesResource,
+)
+from .share import AsyncShareResource, ShareResource
+from .target_finder import AsyncTargetFinderResource, TargetFinderResource
+from .verification import (
+    AsyncVerificationDesignationsResource,
+    AsyncVerificationResource,
+    VerificationDesignationsResource,
+    VerificationResource,
+)
+from .waste_data import AsyncWasteDataResource, WasteDataResource
+
+__all__ = [
+    "AccountResource",
+    "AggregateMeterResource",
+    "AssociationResource",
+    "AsyncAccountResource",
+    "AsyncAggregateMeterResource",
+    "AsyncAssociationResource",
+    "AsyncBillboardMetricResource",
+    "AsyncBuildingResource",
+    "AsyncConsumptionDataResource",
+    "AsyncCustomMetricResource",
+    "AsyncCustomUseResource",
+    "AsyncCustomerResource",
+    "AsyncDataExchangeCustomFieldsResource",
+    "AsyncDataExchangeResource",
+    "AsyncEGridSubregionResource",
+    "AsyncEduResource",
+    "AsyncEnergyPerformanceProjectResource",
+    "AsyncFederalAgencyResource",
+    "AsyncGreenPowerResource",
+    "AsyncHeyResource",
+    "AsyncHierarchyResource",
+    "AsyncIdentifierResource",
+    "AsyncInternationalWeatherStationResource",
+    "AsyncMeterIdentifierResource",
+    "AsyncMeterResource",
+    "AsyncMetricsResource",
+    "AsyncOffsiteGreenPowerResource",
+    "AsyncOnsiteRenewableResource",
+    "AsyncPgpResource",
+    "AsyncPropertyDesignResource",
+    "AsyncPropertyMeterAssociationResource",
+    "AsyncPropertyResource",
+    "AsyncPropertyUseMeterAssociationResource",
+    "AsyncPropertyUseResource",
+    "AsyncReportResource",
+    "AsyncReportTemplatesResource",
+    "AsyncShareResource",
+    "AsyncTargetFinderResource",
+    "AsyncUseDetailsResource",
+    "AsyncVerificationDesignationsResource",
+    "AsyncVerificationResource",
+    "AsyncWasteDataResource",
+    "BillboardMetricResource",
+    "BuildingResource",
+    "ConsumptionDataResource",
+    "CustomMetricResource",
+    "CustomUseResource",
+    "CustomerResource",
+    "DataExchangeCustomFieldsResource",
+    "DataExchangeResource",
+    "EGridSubregionResource",
+    "EduResource",
+    "EnergyPerformanceProjectResource",
+    "FederalAgencyResource",
+    "GreenPowerResource",
+    "HeyResource",
+    "HierarchyResource",
+    "IdentifierResource",
+    "InternationalWeatherStationResource",
+    "MeterIdentifierResource",
+    "MeterResource",
+    "MetricsResource",
+    "OffsiteGreenPowerResource",
+    "OnsiteRenewableResource",
+    "PgpResource",
+    "PropertyDesignResource",
+    "PropertyMeterAssociationResource",
+    "PropertyResource",
+    "PropertyUseMeterAssociationResource",
+    "PropertyUseResource",
+    "ReportResource",
+    "ReportTemplatesResource",
+    "ShareResource",
+    "TargetFinderResource",
+    "UseDetailsResource",
+    "VerificationDesignationsResource",
+    "VerificationResource",
+    "WasteDataResource",
+]

epa_pm_api_wrapper/resources/_base.py

@@ -0,0 +1,22 @@
+"""Resource base classes — shared back-reference to the underlying client."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from epa_pm_api_wrapper.client import EpaPmAsyncClient, EpaPmClient
+
+
+class Resource:
+    """Holds a back-reference to the sync client so resources can share `_request`."""
+
+    def __init__(self, client: EpaPmClient) -> None:
+        self._client = client
+
+
+class AsyncResource:
+    """Holds a back-reference to the async client so resources can share `_arequest`."""
+
+    def __init__(self, client: EpaPmAsyncClient) -> None:
+        self._client = client

epa_pm_api_wrapper/resources/account.py

@@ -0,0 +1,37 @@
+"""Account resource — `/account` endpoints."""
+
+from __future__ import annotations
+
+from epa_pm_api_wrapper.models import Account, CustomFieldList, Response
+
+from ._base import AsyncResource, Resource
+
+
+class AccountResource(Resource):
+    def get(self) -> Account:
+        """Get the account details for the authenticated user."""
+        return self._client._request("GET", "account", response_type=Account)
+
+    def update(self, account_data: Account) -> Response:
+        """Update the authenticated user's account."""
+        return self._client._request("PUT", "account", data=account_data, response_type=Response)
+
+    def custom_fields(self, account_id: int) -> CustomFieldList:
+        """List custom field values stored on a customer account."""
+        return self._client._request("GET", f"account/{account_id}/customFieldList", response_type=CustomFieldList)
+
+
+class AsyncAccountResource(AsyncResource):
+    async def get(self) -> Account:
+        """Get the account details for the authenticated user."""
+        return await self._client._arequest("GET", "account", response_type=Account)
+
+    async def update(self, account_data: Account) -> Response:
+        """Update the authenticated user's account."""
+        return await self._client._arequest("PUT", "account", data=account_data, response_type=Response)
+
+    async def custom_fields(self, account_id: int) -> CustomFieldList:
+        """List custom field values stored on a customer account."""
+        return await self._client._arequest(
+            "GET", f"account/{account_id}/customFieldList", response_type=CustomFieldList
+        )

epa_pm_api_wrapper/resources/association.py

@@ -0,0 +1,145 @@
+"""Association resource — `/association/property/...` and `/association/propertyUse/...`.
+
+Two flavors of meter associations: by property and by property use. Each flavor
+exposes the same shape (``list``, ``set_many``, ``add_one``, ``remove_one``).
+The building↔property associations live on :class:`BuildingResource` for
+historical reasons (``client.building.associate`` / ``.disassociate``).
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from epa_pm_api_wrapper.models import (
+    MeterPropertyAssociationList,
+    MeterPropertyUseAssociationList,
+    Response,
+)
+
+from ._base import AsyncResource, Resource
+
+if TYPE_CHECKING:
+    from epa_pm_api_wrapper.client import EpaPmAsyncClient, EpaPmClient
+
+
+class PropertyMeterAssociationResource(Resource):
+    def list(self, property_id: int) -> MeterPropertyAssociationList:
+        """List meters associated with a property."""
+        return self._client._request(
+            "GET", f"association/property/{property_id}/meter", response_type=MeterPropertyAssociationList
+        )
+
+    def set_many(self, property_id: int, data: MeterPropertyAssociationList) -> Response:
+        """Associate a batch of meters with a property in one call."""
+        return self._client._request(
+            "POST", f"association/property/{property_id}/meter", data=data, response_type=Response
+        )
+
+    def add_one(self, property_id: int, meter_id: int) -> Response:
+        """Associate a single meter with a property."""
+        return self._client._request(
+            "POST", f"association/property/{property_id}/meter/{meter_id}", response_type=Response
+        )
+
+    def remove_one(self, property_id: int, meter_id: int) -> Response:
+        """Remove a single meter↔property association."""
+        return self._client._request(
+            "DELETE", f"association/property/{property_id}/meter/{meter_id}", response_type=Response
+        )
+
+
+class PropertyUseMeterAssociationResource(Resource):
+    def list(self, property_use_id: int) -> MeterPropertyUseAssociationList:
+        """List meters associated with a property use."""
+        return self._client._request(
+            "GET", f"association/propertyUse/{property_use_id}/meter", response_type=MeterPropertyUseAssociationList
+        )
+
+    def set_many(self, property_use_id: int, data: MeterPropertyUseAssociationList) -> Response:
+        """Associate a batch of meters with a property use."""
+        return self._client._request(
+            "POST", f"association/propertyUse/{property_use_id}/meter", data=data, response_type=Response
+        )
+
+    def add_one(self, property_use_id: int, meter_id: int) -> Response:
+        """Associate a single meter with a property use."""
+        return self._client._request(
+            "POST", f"association/propertyUse/{property_use_id}/meter/{meter_id}", response_type=Response
+        )
+
+    def remove_one(self, property_use_id: int, meter_id: int) -> Response:
+        """Remove a single meter↔propertyUse association."""
+        return self._client._request(
+            "DELETE", f"association/propertyUse/{property_use_id}/meter/{meter_id}", response_type=Response
+        )
+
+
+class AssociationResource(Resource):
+    """Top-level association namespace.
+
+    ``client.association.property_meters`` covers property↔meter;
+    ``client.association.property_use_meters`` covers propertyUse↔meter.
+    """
+
+    def __init__(self, client: EpaPmClient) -> None:
+        super().__init__(client)
+        self.property_meters = PropertyMeterAssociationResource(client)
+        self.property_use_meters = PropertyUseMeterAssociationResource(client)
+
+
+class AsyncPropertyMeterAssociationResource(AsyncResource):
+    async def list(self, property_id: int) -> MeterPropertyAssociationList:
+        return await self._client._arequest(
+            "GET", f"association/property/{property_id}/meter", response_type=MeterPropertyAssociationList
+        )
+
+    async def set_many(self, property_id: int, data: MeterPropertyAssociationList) -> Response:
+        return await self._client._arequest(
+            "POST", f"association/property/{property_id}/meter", data=data, response_type=Response
+        )
+
+    async def add_one(self, property_id: int, meter_id: int) -> Response:
+        return await self._client._arequest(
+            "POST", f"association/property/{property_id}/meter/{meter_id}", response_type=Response
+        )
+
+    async def remove_one(self, property_id: int, meter_id: int) -> Response:
+        return await self._client._arequest(
+            "DELETE", f"association/property/{property_id}/meter/{meter_id}", response_type=Response
+        )
+
+
+class AsyncPropertyUseMeterAssociationResource(AsyncResource):
+    async def list(self, property_use_id: int) -> MeterPropertyUseAssociationList:
+        return await self._client._arequest(
+            "GET", f"association/propertyUse/{property_use_id}/meter", response_type=MeterPropertyUseAssociationList
+        )
+
+    async def set_many(self, property_use_id: int, data: MeterPropertyUseAssociationList) -> Response:
+        return await self._client._arequest(
+            "POST",
+            f"association/propertyUse/{property_use_id}/meter",
+            data=data,
+            response_type=Response,
+        )
+
+    async def add_one(self, property_use_id: int, meter_id: int) -> Response:
+        return await self._client._arequest(
+            "POST",
+            f"association/propertyUse/{property_use_id}/meter/{meter_id}",
+            response_type=Response,
+        )
+
+    async def remove_one(self, property_use_id: int, meter_id: int) -> Response:
+        return await self._client._arequest(
+            "DELETE",
+            f"association/propertyUse/{property_use_id}/meter/{meter_id}",
+            response_type=Response,
+        )
+
+
+class AsyncAssociationResource(AsyncResource):
+    def __init__(self, client: EpaPmAsyncClient) -> None:
+        super().__init__(client)
+        self.property_meters = AsyncPropertyMeterAssociationResource(client)
+        self.property_use_meters = AsyncPropertyUseMeterAssociationResource(client)

epa_pm_api_wrapper/resources/building.py

@@ -0,0 +1,89 @@
+"""Building resource — `/building` and `/property/{propertyId}/building` endpoints."""
+
+from __future__ import annotations
+
+from epa_pm_api_wrapper.models import Building, Response
+
+from ._base import AsyncResource, Resource
+
+
+class BuildingResource(Resource):
+    def list(self, property_id: int) -> Response:
+        """List buildings belonging to a property."""
+        return self._client._request("GET", f"property/{property_id}/building/list", response_type=Response)
+
+    def get(self, building_id: int) -> Building:
+        """Get details for a specific building."""
+        return self._client._request("GET", f"building/{building_id}", response_type=Building)
+
+    def create(self, property_id: int, building_data: Building) -> Response:
+        """Create a new building under a property."""
+        return self._client._request(
+            "POST", f"property/{property_id}/building", data=building_data, response_type=Response
+        )
+
+    def update(self, building_id: int, building_data: Building) -> Response:
+        """Update an existing building."""
+        return self._client._request("PUT", f"building/{building_id}", data=building_data, response_type=Response)
+
+    def delete(self, building_id: int) -> Response:
+        """Delete a building (and all of its meters)."""
+        return self._client._request("DELETE", f"building/{building_id}", response_type=Response)
+
+    def list_parents(self, building_id: int) -> Response:
+        """List parent properties connected to a building."""
+        return self._client._request("GET", f"building/{building_id}/property/list", response_type=Response)
+
+    def associate(self, property_id: int, building_id: int) -> Response:
+        """Associate an existing building with a property (both must already be shared)."""
+        return self._client._request(
+            "POST",
+            f"association/property/{property_id}/building/{building_id}",
+            response_type=Response,
+        )
+
+    def disassociate(self, property_id: int, building_id: int) -> Response:
+        """Remove the association between a building and a property."""
+        return self._client._request(
+            "DELETE",
+            f"association/property/{property_id}/building/{building_id}",
+            response_type=Response,
+        )
+
+
+class AsyncBuildingResource(AsyncResource):
+    async def list(self, property_id: int) -> Response:
+        return await self._client._arequest("GET", f"property/{property_id}/building/list", response_type=Response)
+
+    async def get(self, building_id: int) -> Building:
+        return await self._client._arequest("GET", f"building/{building_id}", response_type=Building)
+
+    async def create(self, property_id: int, building_data: Building) -> Response:
+        return await self._client._arequest(
+            "POST", f"property/{property_id}/building", data=building_data, response_type=Response
+        )
+
+    async def update(self, building_id: int, building_data: Building) -> Response:
+        return await self._client._arequest(
+            "PUT", f"building/{building_id}", data=building_data, response_type=Response
+        )
+
+    async def delete(self, building_id: int) -> Response:
+        return await self._client._arequest("DELETE", f"building/{building_id}", response_type=Response)
+
+    async def list_parents(self, building_id: int) -> Response:
+        return await self._client._arequest("GET", f"building/{building_id}/property/list", response_type=Response)
+
+    async def associate(self, property_id: int, building_id: int) -> Response:
+        return await self._client._arequest(
+            "POST",
+            f"association/property/{property_id}/building/{building_id}",
+            response_type=Response,
+        )
+
+    async def disassociate(self, property_id: int, building_id: int) -> Response:
+        return await self._client._arequest(
+            "DELETE",
+            f"association/property/{property_id}/building/{building_id}",
+            response_type=Response,
+        )