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

epa_pm_api_wrapper/resources/verification.py

@@ -0,0 +1,201 @@
+"""Verification resource — `/property/{propertyId}/verification` endpoints
+plus the nested `verification.designations` sub-namespace for professional
+designation management.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from epa_pm_api_wrapper.models import (
+    ProfessionalDesignationList,
+    Response,
+    Verification,
+)
+
+from ._base import AsyncResource, Resource
+
+if TYPE_CHECKING:
+    from epa_pm_api_wrapper.client import EpaPmAsyncClient, EpaPmClient
+
+
+class VerificationDesignationsResource(Resource):
+    def list(self, property_id: int) -> Verification:
+        """Get the verification record (which carries the designation list)."""
+        return self._client._request(
+            "GET",
+            f"property/{property_id}/verification/professionalDesignation",
+            response_type=Verification,
+        )
+
+    def delete_all(self, property_id: int) -> Response:
+        """Remove all professional designations from a property's verification."""
+        return self._client._request(
+            "DELETE",
+            f"property/{property_id}/verification/professionalDesignation",
+            response_type=Response,
+        )
+
+    def add(self, property_id: int, designation_type_id: int, data: ProfessionalDesignationList) -> Response:
+        """Add a professional designation entry."""
+        return self._client._request(
+            "POST",
+            f"property/{property_id}/verification/professionalDesignation/{designation_type_id}",
+            data=data,
+            response_type=Response,
+        )
+
+    def update(self, property_id: int, designation_type_id: int, data: ProfessionalDesignationList) -> Response:
+        """Update licenses for a designation type."""
+        return self._client._request(
+            "PUT",
+            f"property/{property_id}/verification/professionalDesignation/{designation_type_id}",
+            data=data,
+            response_type=Response,
+        )
+
+    def delete_type(self, property_id: int, designation_type_id: int) -> Response:
+        """Remove all entries of a single designation type."""
+        return self._client._request(
+            "DELETE",
+            f"property/{property_id}/verification/professionalDesignation/{designation_type_id}",
+            response_type=Response,
+        )
+
+    def update_license(
+        self,
+        property_id: int,
+        designation_type_id: int,
+        index: int,
+        data: ProfessionalDesignationList,
+    ) -> Response:
+        """Update a specific license entry within a designation type."""
+        return self._client._request(
+            "PUT",
+            f"property/{property_id}/verification/professionalDesignation/{designation_type_id}/{index}",
+            data=data,
+            response_type=Response,
+        )
+
+    def delete_license(self, property_id: int, designation_type_id: int, index: int) -> Response:
+        """Remove a specific license entry within a designation type."""
+        return self._client._request(
+            "DELETE",
+            f"property/{property_id}/verification/professionalDesignation/{designation_type_id}/{index}",
+            response_type=Response,
+        )
+
+    def types(self) -> ProfessionalDesignationList:
+        """List the EPA-defined professional designation types (catalog)."""
+        return self._client._request(
+            "GET", "property/professionalDesignation/list", response_type=ProfessionalDesignationList
+        )
+
+
+class VerificationResource(Resource):
+    def __init__(self, client: EpaPmClient) -> None:
+        super().__init__(client)
+        self.designations = VerificationDesignationsResource(client)
+
+    def get(self, property_id: int) -> Verification:
+        """Get verification (verifier) information for a property."""
+        return self._client._request("GET", f"property/{property_id}/verification", response_type=Verification)
+
+    def create(self, property_id: int, data: Verification) -> Response:
+        """Create verification information for a property."""
+        return self._client._request("POST", f"property/{property_id}/verification", data=data, response_type=Response)
+
+    def update(self, property_id: int, data: Verification) -> Response:
+        """Update verification information for a property."""
+        return self._client._request("PUT", f"property/{property_id}/verification", data=data, response_type=Response)
+
+    def delete(self, property_id: int) -> Response:
+        """Remove verification information from a property."""
+        return self._client._request("DELETE", f"property/{property_id}/verification", response_type=Response)
+
+
+class AsyncVerificationDesignationsResource(AsyncResource):
+    async def list(self, property_id: int) -> Verification:
+        return await self._client._arequest(
+            "GET",
+            f"property/{property_id}/verification/professionalDesignation",
+            response_type=Verification,
+        )
+
+    async def delete_all(self, property_id: int) -> Response:
+        return await self._client._arequest(
+            "DELETE",
+            f"property/{property_id}/verification/professionalDesignation",
+            response_type=Response,
+        )
+
+    async def add(self, property_id: int, designation_type_id: int, data: ProfessionalDesignationList) -> Response:
+        return await self._client._arequest(
+            "POST",
+            f"property/{property_id}/verification/professionalDesignation/{designation_type_id}",
+            data=data,
+            response_type=Response,
+        )
+
+    async def update(self, property_id: int, designation_type_id: int, data: ProfessionalDesignationList) -> Response:
+        return await self._client._arequest(
+            "PUT",
+            f"property/{property_id}/verification/professionalDesignation/{designation_type_id}",
+            data=data,
+            response_type=Response,
+        )
+
+    async def delete_type(self, property_id: int, designation_type_id: int) -> Response:
+        return await self._client._arequest(
+            "DELETE",
+            f"property/{property_id}/verification/professionalDesignation/{designation_type_id}",
+            response_type=Response,
+        )
+
+    async def update_license(
+        self,
+        property_id: int,
+        designation_type_id: int,
+        index: int,
+        data: ProfessionalDesignationList,
+    ) -> Response:
+        return await self._client._arequest(
+            "PUT",
+            f"property/{property_id}/verification/professionalDesignation/{designation_type_id}/{index}",
+            data=data,
+            response_type=Response,
+        )
+
+    async def delete_license(self, property_id: int, designation_type_id: int, index: int) -> Response:
+        return await self._client._arequest(
+            "DELETE",
+            f"property/{property_id}/verification/professionalDesignation/{designation_type_id}/{index}",
+            response_type=Response,
+        )
+
+    async def types(self) -> ProfessionalDesignationList:
+        return await self._client._arequest(
+            "GET", "property/professionalDesignation/list", response_type=ProfessionalDesignationList
+        )
+
+
+class AsyncVerificationResource(AsyncResource):
+    def __init__(self, client: EpaPmAsyncClient) -> None:
+        super().__init__(client)
+        self.designations = AsyncVerificationDesignationsResource(client)
+
+    async def get(self, property_id: int) -> Verification:
+        return await self._client._arequest("GET", f"property/{property_id}/verification", response_type=Verification)
+
+    async def create(self, property_id: int, data: Verification) -> Response:
+        return await self._client._arequest(
+            "POST", f"property/{property_id}/verification", data=data, response_type=Response
+        )
+
+    async def update(self, property_id: int, data: Verification) -> Response:
+        return await self._client._arequest(
+            "PUT", f"property/{property_id}/verification", data=data, response_type=Response
+        )
+
+    async def delete(self, property_id: int) -> Response:
+        return await self._client._arequest("DELETE", f"property/{property_id}/verification", response_type=Response)

epa_pm_api_wrapper/resources/waste_data.py

@@ -0,0 +1,124 @@
+"""Waste data resource — `/meter/{meterId}/wasteData` and `/wasteData/{id}` endpoints."""
+
+from __future__ import annotations
+
+from collections.abc import AsyncIterator, Iterator
+
+from epa_pm_api_wrapper.models import Response, WasteData, WasteDataList
+
+from ._base import AsyncResource, Resource
+
+
+class WasteDataResource(Resource):
+    def list(
+        self,
+        meter_id: int,
+        page: int | None = None,
+        start_date: str | None = None,
+        end_date: str | None = None,
+    ) -> WasteDataList:
+        """Get waste data for a meter (up to 120 records per page)."""
+        params = {"page": page, "startDate": start_date, "endDate": end_date}
+        return self._client._request("GET", f"meter/{meter_id}/wasteData", params=params, response_type=WasteDataList)
+
+    def add(self, meter_id: int, data: WasteData) -> Response:
+        """Add a waste data record to a meter."""
+        return self._client._request("POST", f"meter/{meter_id}/wasteData", data=data, response_type=Response)
+
+    def delete_range(self, meter_id: int, start_date: str, end_date: str) -> Response:
+        """Delete waste data records on a meter within a date range."""
+        return self._client._request(
+            "DELETE",
+            f"meter/{meter_id}/wasteData",
+            params={"startDate": start_date, "endDate": end_date},
+            response_type=Response,
+        )
+
+    def update(self, waste_data_id: int, data: WasteData) -> Response:
+        """Update a single waste data record."""
+        return self._client._request("PUT", f"wasteData/{waste_data_id}", data=data, response_type=Response)
+
+    def delete(self, waste_data_id: int) -> Response:
+        """Delete a single waste data record."""
+        return self._client._request("DELETE", f"wasteData/{waste_data_id}", response_type=Response)
+
+    def what_changed(self, customer_id: int, date: str) -> Response:
+        """List meters under a connected customer with waste data modified on/after ``date``."""
+        return self._client._request(
+            "GET",
+            f"customer/{customer_id}/meter/wasteData/whatChanged",
+            params={"date": date},
+            response_type=Response,
+        )
+
+    def iter(
+        self,
+        meter_id: int,
+        start_date: str | None = None,
+        end_date: str | None = None,
+    ) -> Iterator[WasteData]:
+        """Iterate over every waste record for a meter, paging internally (120/page)."""
+        page = 1
+        while True:
+            data = self.list(meter_id, page=page, start_date=start_date, end_date=end_date)
+            records = data.waste_data or []
+            if not records:
+                return
+            yield from records
+            page += 1
+
+
+class AsyncWasteDataResource(AsyncResource):
+    async def list(
+        self,
+        meter_id: int,
+        page: int | None = None,
+        start_date: str | None = None,
+        end_date: str | None = None,
+    ) -> WasteDataList:
+        params = {"page": page, "startDate": start_date, "endDate": end_date}
+        return await self._client._arequest(
+            "GET", f"meter/{meter_id}/wasteData", params=params, response_type=WasteDataList
+        )
+
+    async def add(self, meter_id: int, data: WasteData) -> Response:
+        return await self._client._arequest("POST", f"meter/{meter_id}/wasteData", data=data, response_type=Response)
+
+    async def delete_range(self, meter_id: int, start_date: str, end_date: str) -> Response:
+        return await self._client._arequest(
+            "DELETE",
+            f"meter/{meter_id}/wasteData",
+            params={"startDate": start_date, "endDate": end_date},
+            response_type=Response,
+        )
+
+    async def update(self, waste_data_id: int, data: WasteData) -> Response:
+        return await self._client._arequest("PUT", f"wasteData/{waste_data_id}", data=data, response_type=Response)
+
+    async def delete(self, waste_data_id: int) -> Response:
+        return await self._client._arequest("DELETE", f"wasteData/{waste_data_id}", response_type=Response)
+
+    async def what_changed(self, customer_id: int, date: str) -> Response:
+        return await self._client._arequest(
+            "GET",
+            f"customer/{customer_id}/meter/wasteData/whatChanged",
+            params={"date": date},
+            response_type=Response,
+        )
+
+    async def iter(
+        self,
+        meter_id: int,
+        start_date: str | None = None,
+        end_date: str | None = None,
+    ) -> AsyncIterator[WasteData]:
+        """Async equivalent of :meth:`WasteDataResource.iter`."""
+        page = 1
+        while True:
+            data = await self.list(meter_id, page=page, start_date=start_date, end_date=end_date)
+            records = data.waste_data or []
+            if not records:
+                return
+            for record in records:
+                yield record
+            page += 1

epa_pm_api_wrapper/retry.py

@@ -0,0 +1,219 @@
+"""Retry transport for transient HTTP failures.
+
+Wraps an underlying ``httpx`` transport with retry/backoff for the responses
+EPA most commonly returns when the system is under stress: 429 (rate limited),
+502/503/504 (gateway/upstream errors), and connection-level failures
+(``httpx.ConnectError`` / ``httpx.ReadTimeout``). Auth (401) and client-side
+4xx errors are *not* retried — they will not change on retry.
+
+Two transports, sync and async, share the same :class:`RetryConfig` and the
+same backoff math. The default schedule is exponential with full jitter:
+``delay = uniform(0, base * 2**attempt)`` clamped to ``max_delay``. The HTTP
+``Retry-After`` header (numeric seconds form) overrides the computed delay
+when present.
+
+Transports are stacked: the user-supplied ``transport`` (or the default
+``httpx.HTTPTransport`` httpx builds for us) sits inside the retry transport.
+This means proxies and other transport-layer customizations still apply.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import random
+import time
+from dataclasses import dataclass, field
+
+import httpx
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_RETRY_STATUS_CODES = frozenset({429, 502, 503, 504})
+
+
+@dataclass(frozen=True)
+class RetryConfig:
+    """Retry behavior for the client transport layer.
+
+    Pass to ``EpaPmClient(retry=...)`` / ``EpaPmAsyncClient(retry=...)`` to
+    override the defaults. Pass ``retries=0`` on the client to disable.
+
+    :ivar max_retries: How many times to retry after the initial attempt
+        (default 3 → up to 4 total requests).
+    :ivar base_delay: Base for the exponential backoff in seconds.
+    :ivar max_delay: Cap on a single backoff sleep, in seconds.
+    :ivar retry_status_codes: HTTP status codes treated as transient.
+    :ivar respect_retry_after: Honor ``Retry-After`` headers (numeric form)
+        when the server provides them, capped at ``max_delay``.
+    """
+
+    max_retries: int = 3
+    base_delay: float = 0.5
+    max_delay: float = 30.0
+    retry_status_codes: frozenset[int] = field(default_factory=lambda: DEFAULT_RETRY_STATUS_CODES)
+    respect_retry_after: bool = True
+
+
+def _retryable_status(response: httpx.Response, cfg: RetryConfig) -> bool:
+    return response.status_code in cfg.retry_status_codes
+
+
+def _retry_after_seconds(response: httpx.Response, cfg: RetryConfig) -> float | None:
+    """Return the server-suggested delay in seconds, or ``None``.
+
+    Only the numeric form of ``Retry-After`` is honored; HTTP-date form falls
+    back to client-side backoff (it requires clock-correlation we'd rather
+    not assume).
+    """
+    if not cfg.respect_retry_after:
+        return None
+    raw = response.headers.get("retry-after")
+    if not raw:
+        return None
+    try:
+        return min(float(raw), cfg.max_delay)
+    except ValueError:
+        return None
+
+
+def _backoff_seconds(attempt: int, cfg: RetryConfig) -> float:
+    """Exponential backoff with full jitter, capped at ``max_delay``.
+
+    ``attempt`` is 0-indexed (first retry → attempt=0).
+    """
+    upper = min(cfg.max_delay, cfg.base_delay * (2**attempt))
+    return random.uniform(0, upper)
+
+
+def _delay_for(response: httpx.Response | None, attempt: int, cfg: RetryConfig) -> float:
+    """Server-hint delay if available, else backoff."""
+    if response is not None:
+        hinted = _retry_after_seconds(response, cfg)
+        if hinted is not None:
+            return hinted
+    return _backoff_seconds(attempt, cfg)
+
+
+_RETRYABLE_EXCEPTIONS: tuple[type[Exception], ...] = (
+    httpx.ConnectError,
+    httpx.ReadTimeout,
+    httpx.WriteTimeout,
+    httpx.PoolTimeout,
+    httpx.RemoteProtocolError,
+)
+
+
+class RetryTransport(httpx.BaseTransport):
+    """Sync retry transport. Wrap an existing transport (or omit for the default)."""
+
+    def __init__(self, wrapped: httpx.BaseTransport | None = None, config: RetryConfig | None = None):
+        self._wrapped = wrapped if wrapped is not None else httpx.HTTPTransport()
+        self._config = config or RetryConfig()
+
+    def handle_request(self, request: httpx.Request) -> httpx.Response:
+        cfg = self._config
+        last_exc: Exception | None = None
+        for attempt in range(cfg.max_retries + 1):
+            try:
+                response = self._wrapped.handle_request(request)
+            except _RETRYABLE_EXCEPTIONS as exc:
+                last_exc = exc
+                if attempt >= cfg.max_retries:
+                    logger.warning("request to %s failed after %d attempts: %s", request.url, attempt + 1, exc)
+                    raise
+                delay = _delay_for(None, attempt, cfg)
+                logger.info(
+                    "retrying %s after %s (attempt %d/%d, sleep %.2fs)",
+                    request.url,
+                    type(exc).__name__,
+                    attempt + 1,
+                    cfg.max_retries,
+                    delay,
+                )
+                time.sleep(delay)
+                continue
+
+            if attempt >= cfg.max_retries or not _retryable_status(response, cfg):
+                return response
+
+            # Drain the body so the connection can be released to the pool.
+            response.read()
+            response.close()
+            delay = _delay_for(response, attempt, cfg)
+            logger.info(
+                "retrying %s after HTTP %d (attempt %d/%d, sleep %.2fs)",
+                request.url,
+                response.status_code,
+                attempt + 1,
+                cfg.max_retries,
+                delay,
+            )
+            time.sleep(delay)
+
+        # Should not be reachable — the loop returns or raises — but mypy/ty
+        # want a definite outcome.
+        if last_exc is not None:
+            raise last_exc
+        raise RuntimeError("RetryTransport: unreachable")  # pragma: no cover
+
+    def close(self) -> None:
+        self._wrapped.close()
+
+
+class AsyncRetryTransport(httpx.AsyncBaseTransport):
+    """Async retry transport. Wrap an existing transport (or omit for the default)."""
+
+    def __init__(
+        self,
+        wrapped: httpx.AsyncBaseTransport | None = None,
+        config: RetryConfig | None = None,
+    ):
+        self._wrapped = wrapped if wrapped is not None else httpx.AsyncHTTPTransport()
+        self._config = config or RetryConfig()
+
+    async def handle_async_request(self, request: httpx.Request) -> httpx.Response:
+        cfg = self._config
+        last_exc: Exception | None = None
+        for attempt in range(cfg.max_retries + 1):
+            try:
+                response = await self._wrapped.handle_async_request(request)
+            except _RETRYABLE_EXCEPTIONS as exc:
+                last_exc = exc
+                if attempt >= cfg.max_retries:
+                    logger.warning("request to %s failed after %d attempts: %s", request.url, attempt + 1, exc)
+                    raise
+                delay = _delay_for(None, attempt, cfg)
+                logger.info(
+                    "retrying %s after %s (attempt %d/%d, sleep %.2fs)",
+                    request.url,
+                    type(exc).__name__,
+                    attempt + 1,
+                    cfg.max_retries,
+                    delay,
+                )
+                await asyncio.sleep(delay)
+                continue
+
+            if attempt >= cfg.max_retries or not _retryable_status(response, cfg):
+                return response
+
+            await response.aread()
+            await response.aclose()
+            delay = _delay_for(response, attempt, cfg)
+            logger.info(
+                "retrying %s after HTTP %d (attempt %d/%d, sleep %.2fs)",
+                request.url,
+                response.status_code,
+                attempt + 1,
+                cfg.max_retries,
+                delay,
+            )
+            await asyncio.sleep(delay)
+
+        if last_exc is not None:
+            raise last_exc
+        raise RuntimeError("AsyncRetryTransport: unreachable")  # pragma: no cover
+
+    async def aclose(self) -> None:
+        await self._wrapped.aclose()

epa_pm_api_wrapper-0.3.0.dist-info/METADATA

@@ -0,0 +1,137 @@
+Metadata-Version: 2.4
+Name: EPA-PM-API-Wrapper
+Version: 0.3.0
+Summary: Client wrapper for the EPA Portfolio Manager API.
+Project-URL: bugs, https://github.com/harryw1/EPA-PM-API-Wrapper/issues
+Project-URL: changelog, https://github.com/harryw1/EPA-PM-API-Wrapper/releases
+Project-URL: documentation, https://harryw1.github.io/EPA-PM-API-Wrapper/
+Project-URL: homepage, https://github.com/harryw1/EPA-PM-API-Wrapper
+Author-email: Harrison Weiss <haweiss@dcas.nyc.gov>
+Maintainer-email: Harrison Weiss <haweiss@dcas.nyc.gov>
+License: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: python-dotenv>=1.2.2
+Requires-Dist: rich>=13.7
+Requires-Dist: typer>=0.12
+Requires-Dist: xsdata>=26.2
+Description-Content-Type: text/markdown
+
+# EPA PM API Wrapper
+
+[![PyPI version](https://img.shields.io/pypi/v/EPA-PM-API-Wrapper.svg)](https://pypi.org/project/EPA-PM-API-Wrapper/)
+[![CI](https://github.com/harryw1/EPA-PM-API-Wrapper/actions/workflows/ci.yml/badge.svg)](https://github.com/harryw1/EPA-PM-API-Wrapper/actions/workflows/ci.yml)
+[![Python versions](https://img.shields.io/pypi/pyversions/EPA-PM-API-Wrapper.svg)](https://pypi.org/project/EPA-PM-API-Wrapper/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+Client wrapper for the EPA Portfolio Manager API.
+
+* [GitHub](https://github.com/harryw1/EPA-PM-API-Wrapper/) | [PyPI](https://pypi.org/project/EPA-PM-API-Wrapper/) | [Documentation](https://harryw1.github.io/EPA-PM-API-Wrapper/)
+* Created by [Harrison Weiss](https://publicpresence.org) | GitHub [@harryw1](https://github.com/harryw1) | PyPI [@harryw1](https://pypi.org/user/harryw1/)
+* MIT License
+
+## Features
+
+*   **Full API coverage:** Every public endpoint in the ENERGY STAR Portfolio Manager web services API is bound — account, property, propertyUse, building, meter, consumption, waste, reporting, target finder, HEY, and the various catalogs (federal agencies, eGrid, weather stations, EDU/PGP).
+*   **Sync and async clients:** `EpaPmClient` and `EpaPmAsyncClient` share the same resource-namespaced surface; pick whichever fits your runtime.
+*   **Typed XML models:** Request and response payloads are dataclasses generated from the EPA XSDs (via `xsdata`), so IDE autocomplete and type checkers work out of the box.
+*   **Structured error handling:** `EpaPmApiError` carries `status_code`, a parsed `errors` list, and an `error_number` accessor for branching without regexing the message; `EpaPmAuthError` covers 401s.
+*   **Production-ready transport:** Configurable timeout/transport/`httpx.Client` injection, context-manager lifecycle, and built-in retry/backoff for 429 + 5xx + connection-level errors with `Retry-After` support.
+*   **Pagination iterators:** `client.consumption_data.iter(meter_id)` and `client.waste_data.iter(meter_id)` walk pages internally.
+*   **Live and test environments:** Switch between production and `wstest` with a single flag.
+*   **CLI included:** A `typer`-based CLI (`epa_pm_api_wrapper`) for ad-hoc lookups across the most common resources.
+
+## Usage
+
+The CLI will prompt for credentials or read them from environment variables.
+
+### Environment Variables
+
+You can set the following environment variables:
+
+*   `EPA_PM_USERNAME`
+*   `EPA_PM_PASSWORD`
+*   `EPA_PM_TEST`: Set to `true` to target the test environment instead of live.
+
+### Using a `.env` file
+
+Copy the example file and fill in your credentials:
+
+```bash
+cp .env.example .env
+# Edit .env with your credentials
+```
+
+The CLI will automatically detect and load this file.
+
+## Documentation
+
+Documentation is built with [Zensical](https://zensical.org/) and deployed to GitHub Pages.
+
+* **Live site:** https://harryw1.github.io/EPA-PM-API-Wrapper/
+* **Preview locally:** `just docs-serve` (serves at http://localhost:8000)
+* **Build:** `just docs-build`
+
+API documentation is auto-generated from docstrings using [mkdocstrings](https://mkdocstrings.github.io/).
+
+Docs deploy automatically on push to `main` via GitHub Actions. To enable this, go to your repo's Settings > Pages and set the source to **GitHub Actions**.
+
+## Development
+
+To set up for local development:
+
+```bash
+# Clone your fork
+git clone git@github.com:your_username/EPA-PM-API-Wrapper.git
+cd EPA-PM-API-Wrapper
+
+# Install in editable mode with live updates
+uv tool install --editable .
+```
+
+This installs the CLI globally but with live updates - any changes you make to the source code are immediately available when you run `epa_pm_api_wrapper`.
+
+Run tests:
+
+```bash
+uv run pytest
+```
+
+Run quality checks (format, lint, type check, test):
+
+```bash
+just qa
+```
+
+## Versioning
+
+This project follows [Semantic Versioning](https://semver.org/). The public
+API is everything exported from `epa_pm_api_wrapper.__all__` plus the
+attribute-namespaced resource methods on `EpaPmClient` / `EpaPmAsyncClient`.
+Anything in a private module (leading underscore) or the internal
+`_request` / `_arequest` plumbing is implementation detail and may change
+in any release.
+
+Pin to a compatible release range when depending on this library:
+
+```
+EPA-PM-API-Wrapper>=0.3,<0.4
+```
+
+## Author
+
+EPA PM API Wrapper was created in 2026 by Harrison Weiss.
+
+Built with [Cookiecutter](https://github.com/cookiecutter/cookiecutter) and the [audreyfeldroy/cookiecutter-pypackage](https://github.com/audreyfeldroy/cookiecutter-pypackage) project template.