eswater 0.1.0__tar.gz

eswater-0.1.0/.gitignore

@@ -0,0 +1,27 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+.eggs/
+build/
+dist/
+.venv/
+venv/
+
+# Tooling
+.mypy_cache/
+.ruff_cache/
+.pytest_cache/
+.coverage
+htmlcov/
+
+# Editors / OS
+.vscode/
+.idea/
+.DS_Store
+
+# Secrets — never commit captured tokens or real credentials
+*.env
+.env
+secrets.*
+captures/

eswater-0.1.0/CHANGELOG.md

@@ -0,0 +1,26 @@
+# Changelog
+
+All notable changes to this project are documented here. Format loosely follows
+[Keep a Changelog](https://keepachangelog.com/); versioning is [SemVer](https://semver.org/).
+
+## [0.1.0] - 2026-07-22
+
+### Added
+- Initial project scaffold: `ESWaterClient`, data models, typed exceptions, CLI,
+  test harness, and CI.
+- Reverse-engineered the ESW/NWG portal API and documented it in `docs/api.md`.
+- Implemented cookie-based auth (`/api/Auth/Login` → `userProfile` cookie →
+  `GetSmartAuthToken` JWT), account/meter discovery, and usage retrieval
+  (`get_usage`/`get_meter_usage`) with litres + cost parsing and automatic JWT
+  refresh.
+- Tests parsing captured (redacted) fixtures; 100% line coverage, coverage
+  gate in CI.
+- **Verified end-to-end against the live API.** Corrected auth to read tokens
+  from the login response *body* (not a cookie), and to run the required
+  `SaveUserProfile` → `GetAccountSummary` sequence before `GetSmartAuthToken`
+  (usage endpoints 401 otherwise). Smart-auth refresh token now rotates
+  (single-use) on each refresh. CLI auto-loads `.env`.
+
+### TODO
+- Confirm `ReadingType` 0 vs 1 semantics and whether usage accepts date ranges.
+- Tariff endpoint (`get_tariff`) not yet captured/implemented.

eswater-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 mikezs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

eswater-0.1.0/PKG-INFO

@@ -0,0 +1,134 @@
+Metadata-Version: 2.4
+Name: eswater
+Version: 0.1.0
+Summary: Async Python client for Essex & Suffolk Water (Northumbrian Water Group) smart water meter data.
+Project-URL: Homepage, https://github.com/mikezs/python-eswater
+Project-URL: Repository, https://github.com/mikezs/python-eswater
+Project-URL: Issues, https://github.com/mikezs/python-eswater/issues
+Author: mikezs
+License-Expression: MIT
+License-File: LICENSE
+Keywords: essex,home-assistant,nwg,smart-meter,suffolk,water
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Home Automation
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: aiohttp>=3.9
+Provides-Extra: dev
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest-cov>=5.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.5; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# eswater
+
+Async Python client for **Essex & Suffolk Water** (Northumbrian Water Group)
+smart water meter data.
+
+Built to be consumed by a Home Assistant custom integration (see the companion
+`ha-essex-suffolk-water` repo), but usable standalone.
+
+> ⚠️ **Alpha.** The ESW/NWG API is private and undocumented; this library was
+> built by reverse-engineering the web portal — see [`docs/api.md`](docs/api.md).
+> Auth and usage retrieval are implemented and verified end-to-end against the
+> live API, but the API is unofficial and may change or break without notice.
+
+## Install
+
+```bash
+pip install eswater           # once published
+# or, for development:
+pip install -e ".[dev]"
+```
+
+## Usage
+
+Log in with the **email + password** of your ESW online account.
+
+```python
+import asyncio
+from datetime import datetime
+
+import aiohttp
+from eswater import ESWaterClient, Granularity
+
+
+async def main() -> None:
+    async with aiohttp.ClientSession() as session:
+        client = ESWaterClient(session, "you@example.com", "your-password")
+        await client.authenticate()
+
+        meter = (await client.get_meters())[0]
+        # Hourly for a specific day (returns ~24 readings):
+        usage = await client.get_usage(
+            meter.account_id, meter.serial, datetime(2026, 7, 18), Granularity.HOURLY
+        )
+        for reading in usage:
+            print(reading.timestamp, reading.consumption_litres, "L", reading.cost, "£")
+
+
+asyncio.run(main())
+```
+
+Consumption is in **litres** and cost in **GBP**, both provided by the API.
+The smart-usage JWT (~10 min) is refreshed automatically; the login session
+(~1 hour) is re-established on expiry.
+
+> **Timestamps are naive local (UK) time**, exactly as the API returns them —
+> `UsageReading.timestamp` carries no `tzinfo`. Convert to your own zone before
+> use (e.g. attach `ZoneInfo("Europe/London")`); don't assume UTC, or readings
+> will be off by up to an hour across BST/GMT.
+
+### CLI
+
+Handy for debugging against the live API without Home Assistant:
+
+```bash
+export ESW_USERNAME=you@example.com ESW_PASSWORD='…'
+eswater meters
+eswater usage --account-id 3799250100 --meter-serial 24LU083349 \
+    --start 2026-07-18 --granularity hourly
+```
+
+## Public API
+
+| Method | Description |
+| --- | --- |
+| `authenticate()` | Log in (cookie session) and fetch the first smart JWT |
+| `refresh()` | Re-fetch the short-lived smart-usage JWT (usually automatic) |
+| `get_accounts()` | List billing accounts, each populated with meters |
+| `get_meters()` | List all smart meters (each has `account_id` + `serial`) |
+| `get_usage(account_id, serial, start_date, granularity)` | Readings (litres + £) |
+| `get_meter_usage(meter, start_date, granularity)` | Same, taking a `Meter` |
+| `get_latest_reading(account_id, serial)` | Most recent daily reading |
+
+Errors are typed: `InvalidAuth`, `NotAuthenticated`, `ServiceUnavailable`,
+`ApiError` (all subclass `ESWaterError`).
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+ruff check .
+mypy src
+pytest
+```
+
+## Disclaimer
+
+Not affiliated with or endorsed by Essex & Suffolk Water or Northumbrian Water
+Group. Uses a private API that may change or restrict access at any time. For
+personal use with your own account.
+
+## License
+
+MIT

eswater-0.1.0/README.md

@@ -0,0 +1,103 @@
+# eswater
+
+Async Python client for **Essex & Suffolk Water** (Northumbrian Water Group)
+smart water meter data.
+
+Built to be consumed by a Home Assistant custom integration (see the companion
+`ha-essex-suffolk-water` repo), but usable standalone.
+
+> ⚠️ **Alpha.** The ESW/NWG API is private and undocumented; this library was
+> built by reverse-engineering the web portal — see [`docs/api.md`](docs/api.md).
+> Auth and usage retrieval are implemented and verified end-to-end against the
+> live API, but the API is unofficial and may change or break without notice.
+
+## Install
+
+```bash
+pip install eswater           # once published
+# or, for development:
+pip install -e ".[dev]"
+```
+
+## Usage
+
+Log in with the **email + password** of your ESW online account.
+
+```python
+import asyncio
+from datetime import datetime
+
+import aiohttp
+from eswater import ESWaterClient, Granularity
+
+
+async def main() -> None:
+    async with aiohttp.ClientSession() as session:
+        client = ESWaterClient(session, "you@example.com", "your-password")
+        await client.authenticate()
+
+        meter = (await client.get_meters())[0]
+        # Hourly for a specific day (returns ~24 readings):
+        usage = await client.get_usage(
+            meter.account_id, meter.serial, datetime(2026, 7, 18), Granularity.HOURLY
+        )
+        for reading in usage:
+            print(reading.timestamp, reading.consumption_litres, "L", reading.cost, "£")
+
+
+asyncio.run(main())
+```
+
+Consumption is in **litres** and cost in **GBP**, both provided by the API.
+The smart-usage JWT (~10 min) is refreshed automatically; the login session
+(~1 hour) is re-established on expiry.
+
+> **Timestamps are naive local (UK) time**, exactly as the API returns them —
+> `UsageReading.timestamp` carries no `tzinfo`. Convert to your own zone before
+> use (e.g. attach `ZoneInfo("Europe/London")`); don't assume UTC, or readings
+> will be off by up to an hour across BST/GMT.
+
+### CLI
+
+Handy for debugging against the live API without Home Assistant:
+
+```bash
+export ESW_USERNAME=you@example.com ESW_PASSWORD='…'
+eswater meters
+eswater usage --account-id 3799250100 --meter-serial 24LU083349 \
+    --start 2026-07-18 --granularity hourly
+```
+
+## Public API
+
+| Method | Description |
+| --- | --- |
+| `authenticate()` | Log in (cookie session) and fetch the first smart JWT |
+| `refresh()` | Re-fetch the short-lived smart-usage JWT (usually automatic) |
+| `get_accounts()` | List billing accounts, each populated with meters |
+| `get_meters()` | List all smart meters (each has `account_id` + `serial`) |
+| `get_usage(account_id, serial, start_date, granularity)` | Readings (litres + £) |
+| `get_meter_usage(meter, start_date, granularity)` | Same, taking a `Meter` |
+| `get_latest_reading(account_id, serial)` | Most recent daily reading |
+
+Errors are typed: `InvalidAuth`, `NotAuthenticated`, `ServiceUnavailable`,
+`ApiError` (all subclass `ESWaterError`).
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+ruff check .
+mypy src
+pytest
+```
+
+## Disclaimer
+
+Not affiliated with or endorsed by Essex & Suffolk Water or Northumbrian Water
+Group. Uses a private API that may change or restrict access at any time. For
+personal use with your own account.
+
+## License
+
+MIT

eswater-0.1.0/docs/api.md

@@ -0,0 +1,238 @@
+# Essex & Suffolk Water (NWG) API — reverse-engineered spec
+
+> Captured 22 Jul 2026 from the web portal at `https://www.eswater.co.uk`
+> (logged-in "My account" → My Usage → Smart Meter). All personal values below
+> are **redacted** with `<PLACEHOLDERS>`.
+
+Essex & Suffolk Water is part of **Northumbrian Water Group (NWG)**. The portal
+is a same-origin ASP.NET Core app fronted by **Cloudflare**; the JSON API lives
+under `https://www.eswater.co.uk/api/`. Identity is handled by **LoginRadius**
+(CIAM); smart-usage endpoints are gated by a LoginRadius-issued JWT.
+
+## Auth model (two layers)
+
+> **Verified end-to-end against the live API (22 Jul 2026).** The notes below
+> are what actually works, not just what the browser appeared to do.
+
+1. **Portal session** — `POST /api/Auth/Login` with `{email, password}` returns
+   the profile **in the response body** and sets cookies:
+   - `.AspNetCore.Session` — **the only cookie that matters for auth**; the
+     usage endpoints authorise off this server-side session (confirmed by
+     leave-one-out cookie bisection).
+   - `.AspNetCore.Antiforgery.*`, `ARRAffinity*`, `EPiStateMarker` (not needed).
+   - The browser *also* sets `userProfile` / `smartTokenInfo` /
+     `smartUserTokenInfo` cookies **client-side via JavaScript** — these are
+     **not** required by the API and the library does not set them.
+
+   The login **response body** carries the LoginRadius tokens the server
+   obtained on our behalf (this is the source of truth, not the cookie):
+   ```json
+   {
+     "RestException": null, "OtherException": null,
+     "Response": {
+       "access_token": "<uuid>",
+       "refresh_token": "<uuid>",           // seed for GetSmartAuthToken
+       "expires_in": "2026-07-22T16:02:45Z",  // ~1 hour
+       "Profile": { "CustomFields": { "PersonId": "PersonId" } }
+       /* + Email, FirstName, Surname, Roles … (PII — do not log/persist) */
+     }
+   }
+   ```
+   A cookie jar is mandatory (carries `.AspNetCore.Session`).
+
+2. **Smart JWT** — usage endpoints require a short-lived JWT from
+   `POST /api/Customer/GetSmartAuthToken`, sent in the usage request **body** as
+   `Authorization`. **But the JWT alone is not sufficient** — see the required
+   sequence below.
+
+### Required login sequence (order matters!)
+The usage endpoints return **401** unless the session is set up in this exact
+order *before* fetching the smart token:
+
+1. `POST /api/Auth/Login {email, password}` → read `Response.refresh_token`.
+2. `POST /api/Auth/SaveUserProfile` with the whole `Response` object — registers
+   the profile in the session. Without it, `GetAccountSummary` returns
+   `{"statusField": {"codeField": 400, "messageField": "PersonId is required"}}`.
+3. `GET /api/Customer/GetAccountSummary?personId=PersonId` — **binds the account
+   to the session**. This is the non-obvious step: skipping it makes usage 401
+   even with a valid JWT (`AddOrUpdateCustomerSession` does *not* substitute).
+4. `POST /api/Customer/GetSmartAuthToken {refresh_Token}` → `Id_token` (JWT).
+5. Usage calls now succeed.
+
+No LoginRadius apikey and **no call to `api.loginradius.com`** is needed — the
+server does that internally. (The JWT is LoginRadius-issued:
+`iss = cloud-api.loginradius.com/sso/oidc/northumbrianwater`,
+`aud = f62c1509-d0c0-4ebf-8f0d-ed2e71d5c3a3`, `PersonId`, **~10 min** lifetime.)
+
+### Token refresh & rotation (verified)
+- The `GetSmartAuthToken` **refresh token is single-use** and **rotates**: each
+  call returns a new `Refresh_token`; reusing a spent one returns `null`. Store
+  the returned `Refresh_token` for the next refresh.
+- Within a live session, a repeat `GetSmartAuthToken` (using the rotated token)
+  works **without** re-running steps 1–3, and its JWT authorises usage.
+- Lifetimes: login `refresh_token` ~1 hour (re-login after); JWT ~10 min
+  (re-fetch before expiry).
+
+## Common request conventions
+- `Content-Type: application/json`, `Accept: */*`
+- `X-Requested-With: XMLHttpRequest` (send this — likely enforced)
+- Cookies from step 1 on every call
+- Bodies are JSON; some responses are `text/plain` (e.g. token)
+
+---
+
+## Endpoints
+
+### `POST /api/Auth/Login`
+Request:
+```json
+{ "email": "<EMAIL>", "password": "<PASSWORD>" }
+```
+Response: empty body; sets session cookies.
+
+### `GET /api/Customer/GetAccountSummary?personId=<PERSON_ID>&_=<ts>`
+Account/premise discovery entry point.
+```json
+{
+  "Message": "",
+  "Accounts": [
+    {
+      "AccountID": "<ACCOUNT_ID>",
+      "PremiseID": "<PREMISE_ID>",
+      "PropertyAddress": "<ADDRESS>",
+      "AccountType": 1,
+      "AccountBalance": -27.19,
+      "MultiplePremises": false
+    }
+  ],
+  "Status": { "Code": "0", "Message": "<p>Success</p>" }
+}
+```
+> Note: the portal often sends `personId=PersonId` literally (a placeholder);
+> the server resolves the person from the session cookie.
+
+### `POST /api/Customer/GetAccountDetails`  ← meter discovery
+Request:
+```json
+{ "AccountId": "<ACCOUNT_ID>", "PremiseId": "<PREMISE_ID>", "PersonId": "PersonId" }
+```
+Response (trimmed to the useful bits): `AccountDetail.Meters[]` holds the meter,
+where **`BadgeNumber` is the `MeterSerial`** used by the usage calls:
+```json
+{
+  "AccountDetail": {
+    "Account": { "SmartMeter": true, "StartDate": "2017-01-30T00:00:00",
+                 "NumberOfOccupiers": 4, "LastBillAmount": 254.81 },
+    "Meters": [
+      {
+        "BadgeNumber": "<METER_SERIAL>",
+        "smartPoint": "<SMART_POINT>",
+        "smartStatus": "COMM",
+        "meterInstalledDate": "2024-03-20T00:00:00",
+        "LastRead": "231.000000",
+        "LastReadDate": "2026-07-14T00:00:00",
+        "NumberDials": 5
+      }
+    ],
+    "Premise": { "PropertyAddress": "<ADDRESS>", "Measured": true },
+    "AccountId": "<ACCOUNT_ID>", "PremiseId": "<PREMISE_ID>", "PersonId": "PersonId"
+  }
+}
+```
+> Also contains `Person` (name, DOB, email, phone) and `Payment` blocks — ignore
+> for usage; do not persist PII.
+
+### `POST /api/Customer/GetSmartAuthToken`  ← smart JWT
+Request:
+```json
+{ "refresh_Token": "<REFRESH_TOKEN>" }
+```
+Response (`text/plain` JSON):
+```json
+{
+  "Access_token": "<uuid>",
+  "Token_type": "Bearer",
+  "Refresh_token": "<uuid>",
+  "Expires_in": 3598,
+  "Id_token": "<JWT>",
+  "Status": null
+}
+```
+`Id_token` (the JWT) is what usage calls put in their `Authorization` field.
+Cache it and re-fetch when within ~30s of the 10-min expiry.
+
+### Usage — `POST /api/Customer/Get{Hourly,Daily,Weekly,Monthly,Yearly}WaterUsage`
+All five share the same request/response contract; only aggregation differs.
+
+Request:
+```json
+{
+  "AccountId": "<ACCOUNT_ID>",
+  "Authorization": "<JWT from GetSmartAuthToken>",
+  "MeterSerial": "<METER_SERIAL>",
+  "StartDate": "2026-07-18T00:00:00"
+}
+```
+Response — array of readings:
+```json
+[
+  { "Date": "2026-07-18T01:00:00", "LitreValue": 4, "MonetaryValue": 0.02,
+    "Key": "12:00\nam|1:00\nam", "ReadingType": 1, "Status": null }
+]
+```
+Field semantics:
+- **`LitreValue`** — consumption in **litres** for the interval (integer).
+- **`MonetaryValue`** — cost in **£** for the interval.
+- **`Date`** — interval timestamp (local, no tz). For hourly, `Date` is the
+  **end** of the hour (00:00→01:00 row has `Date=01:00`).
+- **`Key`** — display label (`\n`-separated); ignore for data purposes.
+- **`ReadingType`** — `1` vs `0`. Observed: older intervals = `1`, most recent
+  1–3 days = `0`. Best guess: `1 = actual/confirmed`, `0 = provisional/estimated`.
+  _TODO: confirm._
+- **`Status`** — null in all samples.
+
+Observed windowing behaviour:
+- **Hourly**: `StartDate` = the target day → returns ~24 rows for that day.
+- **Daily**: returned the most recent **7 days** (rolling), despite `StartDate`
+  being the account start date. _TODO: confirm whether a narrower `StartDate`
+  or an `EndDate` field narrows/extends it._
+- **Weekly / Monthly / Yearly**: same shape, coarser buckets (not re-captured;
+  assume identical contract). _TODO: confirm max range + whether `EndDate` is
+  supported._
+
+### Other endpoints seen (not needed for core usage)
+- `POST /api/Customer/GetMeterReadHistory` — manual/actual meter reads
+- `POST /api/Customer/GetWaterUsageEfficiency`
+- `POST /api/Customer/GetSmartMeterAlertStatus` — leak/alert status
+- `GET  /api/Customer/GetUsageComparison?noOfOccupiers=&lastYearAvgUsage=`
+- `POST /api/Customer/AddOrUpdateCustomerSession` — body `["PersonId:…","AccountId:…"]` → `true`
+- `POST /api/Auth/SaveUserProfile` — empty response
+- `POST /api/BillsPayments/GetBillsPayments`, `GET /api/BillsPayments/GetPaymentPlan?accountId=`
+
+### Minimal library flow (verified)
+1. `POST /api/Auth/Login` → read `Response.refresh_token` from the body
+2. `POST /api/Auth/SaveUserProfile` (whole `Response` object)
+3. `GET  /api/Customer/GetAccountSummary?personId=PersonId` (binds session)
+4. `POST /api/Customer/GetSmartAuthToken {refresh_Token}` → JWT (+ rotated token)
+5. `POST /api/Customer/GetAccountDetails` → meter `BadgeNumber` (serial)
+6. `POST /api/Customer/Get…WaterUsage` (JWT in body + serial) → readings
+
+`AddOrUpdateCustomerSession` and `GetAccountDetails` order-relative-to-token do
+not matter for auth; only steps 2 and 3 must precede step 4.
+
+## Gotchas
+- Cloudflare + reCAPTCHA sit on the **login page**; the LoginRadius API login
+  may avoid the browser reCAPTCHA, but watch for challenges / rate limits.
+- Send `X-Requested-With: XMLHttpRequest`.
+- JWT lifetime ~10 min — refresh proactively; the portal session cookie lasts
+  longer (re-login on 401).
+- `LitreValue` is already litres — no unit conversion needed.
+
+## Still TODO (minor; needs another short capture / test)
+1. `ReadingType` 0 vs 1 meaning (guess: 1 = actual/confirmed, 0 = provisional).
+2. Whether usage endpoints accept an `EndDate` / arbitrary historical ranges
+   (matters for HA long-term-statistics backfill).
+3. Weekly/Monthly/Yearly `StartDate` windowing (assumed same contract as daily).
+
+_Resolved: auth needs no LoginRadius apikey — the seed refresh_token is in the
+`userProfile` cookie from `/api/Auth/Login`._

eswater-0.1.0/pyproject.toml

@@ -0,0 +1,93 @@
+[build-system]
+requires = ["hatchling>=1.27"]
+build-backend = "hatchling.build"
+
+[project]
+name = "eswater"
+version = "0.1.0"
+description = "Async Python client for Essex & Suffolk Water (Northumbrian Water Group) smart water meter data."
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "mikezs" }]
+keywords = ["essex", "suffolk", "water", "smart-meter", "home-assistant", "nwg"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Framework :: AsyncIO",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Operating System :: OS Independent",
+    "Topic :: Home Automation",
+    "Typing :: Typed",
+]
+dependencies = [
+    "aiohttp>=3.9",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0",
+    "pytest-asyncio>=0.23",
+    "pytest-cov>=5.0",
+    "ruff>=0.5",
+    "mypy>=1.10",
+]
+
+[project.urls]
+Homepage = "https://github.com/mikezs/python-eswater"
+Repository = "https://github.com/mikezs/python-eswater"
+Issues = "https://github.com/mikezs/python-eswater/issues"
+
+[project.scripts]
+eswater = "eswater.__main__:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/eswater"]
+
+# This repo may not be under version control, so hatchling can't fall back to
+# VCS-ignore to prune the sdist. Enumerate exactly what ships so secrets
+# (.env), caches, and virtualenvs can never leak into the tarball.
+[tool.hatch.build.targets.sdist]
+include = [
+    "/src",
+    "/tests",
+    "/docs",
+    "/README.md",
+    "/CHANGELOG.md",
+    "/LICENSE",
+    "/pyproject.toml",
+]
+
+[tool.ruff]
+line-length = 100
+target-version = "py311"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B", "SIM", "ASYNC"]
+
+[tool.mypy]
+python_version = "3.11"
+strict = true
+warn_unused_ignores = true
+disallow_untyped_defs = true
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]
+
+[tool.coverage.run]
+source = ["eswater"]
+branch = true
+
+[tool.coverage.report]
+show_missing = true
+exclude_lines = [
+    "pragma: no cover",
+    "raise NotImplementedError",
+    "if __name__ == .__main__.:",
+    "\\.\\.\\.",
+]

eswater-0.1.0/src/eswater/__init__.py

@@ -0,0 +1,28 @@
+"""eswater: async client for Essex & Suffolk Water smart meter data."""
+
+from __future__ import annotations
+
+from .client import ESWaterClient
+from .exceptions import (
+    ApiError,
+    ESWaterError,
+    InvalidAuth,
+    NotAuthenticated,
+    ServiceUnavailable,
+)
+from .models import Account, Granularity, Meter, UsageReading
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "ESWaterClient",
+    "Account",
+    "Meter",
+    "UsageReading",
+    "Granularity",
+    "ESWaterError",
+    "InvalidAuth",
+    "NotAuthenticated",
+    "ServiceUnavailable",
+    "ApiError",
+]