engie-nl 0.2.1__tar.gz

engie_nl-0.2.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AboveColin
+
+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.

engie_nl-0.2.1/PKG-INFO

@@ -0,0 +1,170 @@
+Metadata-Version: 2.4
+Name: engie-nl
+Version: 0.2.1
+Summary: Async Python client for the private API behind the ENGIE Energie NL app
+Author: AboveColin
+License: MIT
+Project-URL: Homepage, https://github.com/AboveColin/engie-nl
+Project-URL: Issues, https://github.com/AboveColin/engie-nl/issues
+Keywords: engie,energy,netherlands,home-assistant,smart-meter
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+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 :: Home Automation
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.9
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+Requires-Dist: pytest-cov>=5; extra == "dev"
+Requires-Dist: pylint>=3; extra == "dev"
+Requires-Dist: mypy>=1.8; extra == "dev"
+Dynamic: license-file
+
+# engie-nl
+
+Async Python client for the private API behind the **ENGIE Energie NL** app
+(`nl.engie.engieapp`). It covers the whole thing: all 148 endpoints the app
+declares, with 199 typed models.
+
+The reads a household actually polls are on the client itself: the customer
+record and EANs, daily consumption per meter, meter readings, the termijnbedrag
+advice, invoices, the smart-meter data mandate, outages, and day-ahead prices.
+The rest is grouped by area, `client.tariffs`, `client.assets`, `client.enode`
+and so on, listed below.
+
+ENGIE does not document or support this API. It can change without notice.
+The map it is built from, with the receipts, lives in
+`apk-reverse-engineering/docs/engie-nl/ENGIE_NL_API.md`.
+
+## How the login works
+
+The app logs in through Okta (`login.engie.nl`) and sends the Okta access token
+straight to the gateway as `Authorization: Bearer`. ENGIE's org runs Okta
+Identity Engine, so this package walks the interaction code flow: interact,
+introspect, identify, then the password.
+
+**ENGIE then emails a one-time code, and it is not optional.** `login()` asks
+Okta to send the mail and raises `EngieEmailCodeRequired`; hand the code to
+`submit_email_code()` to finish. Only the token pair is kept, never the
+password. The scope includes `offline_access`, so this happens once: the
+refresh token carries every later session without touching the mailbox.
+
+```python
+import asyncio
+from engie_nl import EngieClient, EngieEmailCodeRequired, OktaAuth
+
+async def main():
+    async with OktaAuth() as auth:
+        try:
+            tokens = await auth.login("you@example.com", "password")
+        except EngieEmailCodeRequired as err:
+            code = input("code from the email: ")
+            tokens = await auth.submit_email_code(err.challenge, code)
+
+        async with EngieClient(tokens, auth=auth) as client:
+            user = await client.get_user()
+            for series in await client.get_consumptions(user.eans, days=7):
+                for day in series.data:
+                    print(series.ean, day.day, day.total, "kWh/m3")
+
+asyncio.run(main())
+```
+
+Persist `tokens.to_dict()` and rebuild with `TokenSet.from_dict()`; losing the
+refresh token means another trip to the mailbox.
+
+Pass `on_tokens_updated=` to be told when the pair is refreshed, and persist
+`TokenSet.to_dict()`. Home Assistant passes its own `aiohttp` session via
+`session=`.
+
+## The whole surface
+
+| Group | What it covers |
+|---|---|
+| `client.get_*` | user, consumptions, meterstands, estimations, transactions, documents, mandates, outages, day-ahead prices, MER periods, opening hours |
+| `client.tariffs` | the contract's own rates, `GET /api/v1/tariffs` |
+| `client.meter` | filing and withdrawing meter readings, the P4 feed, dongle activation |
+| `client.billing` | invoice payment status, documents, the MER report, the termijnbedrag, iDEAL |
+| `client.account` | profile, settings cards, areas of interest, passwords, payment details |
+| `client.mandates` | granting and withdrawing the smart-meter mandate |
+| `client.assets` | declared solar panels, heat pumps, batteries, cars, chargers, aircos |
+| `client.enode` | linked vehicles and chargers, locations, charge policies, sessions |
+| `client.smart_charging` | ENGIE's own smart-charging programme |
+| `client.happy_hour` | announced Happy Hours, subscriptions, payouts |
+| `client.solar` | solar potential, quotes, home and energy scans |
+| `client.address` | postcode lookup, iDIN verification, moving the contract |
+| `client.support` | opening hours, waiting time, advice articles, feedback, chat |
+| `client.ev` | charge card and charging station lead forms |
+| `client.legacy` | pre-Okta authentication and account creation |
+| `Net2GridClient` | the P1 dongle, on Net2Grid's own host |
+
+`tools/check_coverage.py` compares the package against the APK map and is run by
+the test suite, so "all 148" stays true rather than being a claim in a README.
+
+## Writes are off unless you ask
+
+Every method that changes the account raises `EngieWriteBlocked` on a normal
+client. The endpoints behind them are not test fixtures: `POST
+/api/v1/meterstands` files a meter reading with the supplier who bills you, `PUT
+/api/v1/prepayment` changes a direct debit, and `POST /api/v1/contract/move`
+moves the contract to another address.
+
+```python
+async with EngieClient(tokens, auth=auth, allow_writes=True) as client:
+    await client.billing.set_prepayment(user.eans, amount=195)
+```
+
+Two POSTs are queries despite the verb, `/api/v1/readings` and
+`/api/v1/p4-errors`, and need no permission: both send a body to read P4 data
+back.
+
+## Scripts
+
+- `scripts/login.py`: interactive login. Prompts for the password, then for the
+  code ENGIE emails, and stores the token pair at
+  `~/.config/engie-nl/tokens.json` (mode 0600). `--check` runs the whole login
+  and saves nothing; `--browser` uses the browser flow instead.
+- `scripts/probe.py`: reads every supported endpoint once and writes the raw
+  responses to `~/.config/engie-nl/captures/` (mode 0600, override with
+  `ENGIE_CAPTURES`) for inspection. They land outside the repo because a real
+  `/user` answer carries the account holder's name, address, bank account and
+  both meter EANs.
+
+## Development
+
+```sh
+uv venv .venv && uv pip install -e '.[dev]'
+.venv/bin/pytest
+.venv/bin/pytest --cov          # line and branch coverage, gated at 100%
+.venv/bin/pylint engie_nl
+.venv/bin/mypy engie_nl
+```
+
+Tests run the client against a loopback aiohttp server that plays both Okta
+and the gateway; no network, no mocks of aiohttp internals.
+
+`tests/test_coverage.py` checks the package against the APK's `api-map.json`,
+which lives in a separate repo that is not published with this one. Point
+`ENGIE_NL_API_MAP` at that file, or check the repo out beside this one, and the
+two endpoint tests run. Without it they skip and name the path they looked for,
+so a skip is visible rather than a silent pass:
+
+```sh
+export ENGIE_NL_API_MAP=/path/to/apk-reverse-engineering/docs/engie-nl/api-map.json
+```
+
+`--cov` needs no other flags: the source list, branch coverage and the 100%
+gate are in `pyproject.toml`, so the number is the same wherever it is run.
+Every value in the tests is invented. Nothing in `tests/` came from a real
+account; `scripts/probe.py` writes real responses to
+`~/.config/engie-nl/captures/`, outside the working tree, and no test reads
+them. Keeping them out of the repo means no gitignore rule stands between a
+real bank account number and a public push.

engie_nl-0.2.1/README.md

@@ -0,0 +1,140 @@
+# engie-nl
+
+Async Python client for the private API behind the **ENGIE Energie NL** app
+(`nl.engie.engieapp`). It covers the whole thing: all 148 endpoints the app
+declares, with 199 typed models.
+
+The reads a household actually polls are on the client itself: the customer
+record and EANs, daily consumption per meter, meter readings, the termijnbedrag
+advice, invoices, the smart-meter data mandate, outages, and day-ahead prices.
+The rest is grouped by area, `client.tariffs`, `client.assets`, `client.enode`
+and so on, listed below.
+
+ENGIE does not document or support this API. It can change without notice.
+The map it is built from, with the receipts, lives in
+`apk-reverse-engineering/docs/engie-nl/ENGIE_NL_API.md`.
+
+## How the login works
+
+The app logs in through Okta (`login.engie.nl`) and sends the Okta access token
+straight to the gateway as `Authorization: Bearer`. ENGIE's org runs Okta
+Identity Engine, so this package walks the interaction code flow: interact,
+introspect, identify, then the password.
+
+**ENGIE then emails a one-time code, and it is not optional.** `login()` asks
+Okta to send the mail and raises `EngieEmailCodeRequired`; hand the code to
+`submit_email_code()` to finish. Only the token pair is kept, never the
+password. The scope includes `offline_access`, so this happens once: the
+refresh token carries every later session without touching the mailbox.
+
+```python
+import asyncio
+from engie_nl import EngieClient, EngieEmailCodeRequired, OktaAuth
+
+async def main():
+    async with OktaAuth() as auth:
+        try:
+            tokens = await auth.login("you@example.com", "password")
+        except EngieEmailCodeRequired as err:
+            code = input("code from the email: ")
+            tokens = await auth.submit_email_code(err.challenge, code)
+
+        async with EngieClient(tokens, auth=auth) as client:
+            user = await client.get_user()
+            for series in await client.get_consumptions(user.eans, days=7):
+                for day in series.data:
+                    print(series.ean, day.day, day.total, "kWh/m3")
+
+asyncio.run(main())
+```
+
+Persist `tokens.to_dict()` and rebuild with `TokenSet.from_dict()`; losing the
+refresh token means another trip to the mailbox.
+
+Pass `on_tokens_updated=` to be told when the pair is refreshed, and persist
+`TokenSet.to_dict()`. Home Assistant passes its own `aiohttp` session via
+`session=`.
+
+## The whole surface
+
+| Group | What it covers |
+|---|---|
+| `client.get_*` | user, consumptions, meterstands, estimations, transactions, documents, mandates, outages, day-ahead prices, MER periods, opening hours |
+| `client.tariffs` | the contract's own rates, `GET /api/v1/tariffs` |
+| `client.meter` | filing and withdrawing meter readings, the P4 feed, dongle activation |
+| `client.billing` | invoice payment status, documents, the MER report, the termijnbedrag, iDEAL |
+| `client.account` | profile, settings cards, areas of interest, passwords, payment details |
+| `client.mandates` | granting and withdrawing the smart-meter mandate |
+| `client.assets` | declared solar panels, heat pumps, batteries, cars, chargers, aircos |
+| `client.enode` | linked vehicles and chargers, locations, charge policies, sessions |
+| `client.smart_charging` | ENGIE's own smart-charging programme |
+| `client.happy_hour` | announced Happy Hours, subscriptions, payouts |
+| `client.solar` | solar potential, quotes, home and energy scans |
+| `client.address` | postcode lookup, iDIN verification, moving the contract |
+| `client.support` | opening hours, waiting time, advice articles, feedback, chat |
+| `client.ev` | charge card and charging station lead forms |
+| `client.legacy` | pre-Okta authentication and account creation |
+| `Net2GridClient` | the P1 dongle, on Net2Grid's own host |
+
+`tools/check_coverage.py` compares the package against the APK map and is run by
+the test suite, so "all 148" stays true rather than being a claim in a README.
+
+## Writes are off unless you ask
+
+Every method that changes the account raises `EngieWriteBlocked` on a normal
+client. The endpoints behind them are not test fixtures: `POST
+/api/v1/meterstands` files a meter reading with the supplier who bills you, `PUT
+/api/v1/prepayment` changes a direct debit, and `POST /api/v1/contract/move`
+moves the contract to another address.
+
+```python
+async with EngieClient(tokens, auth=auth, allow_writes=True) as client:
+    await client.billing.set_prepayment(user.eans, amount=195)
+```
+
+Two POSTs are queries despite the verb, `/api/v1/readings` and
+`/api/v1/p4-errors`, and need no permission: both send a body to read P4 data
+back.
+
+## Scripts
+
+- `scripts/login.py`: interactive login. Prompts for the password, then for the
+  code ENGIE emails, and stores the token pair at
+  `~/.config/engie-nl/tokens.json` (mode 0600). `--check` runs the whole login
+  and saves nothing; `--browser` uses the browser flow instead.
+- `scripts/probe.py`: reads every supported endpoint once and writes the raw
+  responses to `~/.config/engie-nl/captures/` (mode 0600, override with
+  `ENGIE_CAPTURES`) for inspection. They land outside the repo because a real
+  `/user` answer carries the account holder's name, address, bank account and
+  both meter EANs.
+
+## Development
+
+```sh
+uv venv .venv && uv pip install -e '.[dev]'
+.venv/bin/pytest
+.venv/bin/pytest --cov          # line and branch coverage, gated at 100%
+.venv/bin/pylint engie_nl
+.venv/bin/mypy engie_nl
+```
+
+Tests run the client against a loopback aiohttp server that plays both Okta
+and the gateway; no network, no mocks of aiohttp internals.
+
+`tests/test_coverage.py` checks the package against the APK's `api-map.json`,
+which lives in a separate repo that is not published with this one. Point
+`ENGIE_NL_API_MAP` at that file, or check the repo out beside this one, and the
+two endpoint tests run. Without it they skip and name the path they looked for,
+so a skip is visible rather than a silent pass:
+
+```sh
+export ENGIE_NL_API_MAP=/path/to/apk-reverse-engineering/docs/engie-nl/api-map.json
+```
+
+`--cov` needs no other flags: the source list, branch coverage and the 100%
+gate are in `pyproject.toml`, so the number is the same wherever it is run.
+Every value in the tests is invented. Nothing in `tests/` came from a real
+account; `scripts/probe.py` writes real responses to
+`~/.config/engie-nl/captures/`, outside the working tree, and no test reads
+them. Keeping them out of the repo means no gitignore rule stands between a
+real bank account number and a public push.

engie_nl-0.2.1/engie_nl/__init__.py

@@ -0,0 +1,83 @@
+"""engie-nl: async client for the private API behind the ENGIE Energie NL app."""
+
+from .auth import BrowserLogin, EmailChallenge, OktaAuth, TokenSet, make_pkce_pair
+from .client import EngieClient
+from .exceptions import (
+    EngieApiError,
+    EngieAuthError,
+    EngieEmailCodeRequired,
+    EngieError,
+    EngieMfaRequiredError,
+    EngieNetworkError,
+    EngieRateLimited,
+    EngieWriteBlocked,
+)
+from .net2grid import Net2GridClient, P1Client
+from .models import (
+    Consumption,
+    ConsumptionSeries,
+    DayAheadPrice,
+    DeliveryAddress,
+    DocumentRef,
+    EnergyType,
+    EstimationCosts,
+    Mandate,
+    MerPeriod,
+    MeteringPoint,
+    MeterReadings,
+    OutageMessage,
+    ProductInfo,
+    Reading,
+    Register,
+    Tariffs,
+    Transaction,
+    TransactionStatus,
+    User,
+)
+
+# The 180 dataclasses generated from the APK's api-map.json are not re-exported
+# one by one: import them from engie_nl.generated. The 19 below are the curated
+# ones, which carry behaviour the generator cannot infer.
+from . import generated  # noqa: E402  pylint: disable=wrong-import-position
+
+__version__ = "0.2.1"
+
+__all__ = [
+    "__version__",
+    "generated",
+    "BrowserLogin",
+    "EmailChallenge",
+    "OktaAuth",
+    "TokenSet",
+    "make_pkce_pair",
+    "EngieClient",
+    "EngieApiError",
+    "EngieAuthError",
+    "EngieEmailCodeRequired",
+    "EngieError",
+    "EngieMfaRequiredError",
+    "EngieNetworkError",
+    "EngieRateLimited",
+    "EngieWriteBlocked",
+    "Net2GridClient",
+    "P1Client",
+    "Consumption",
+    "ConsumptionSeries",
+    "DayAheadPrice",
+    "DeliveryAddress",
+    "DocumentRef",
+    "EnergyType",
+    "EstimationCosts",
+    "Mandate",
+    "MerPeriod",
+    "MeteringPoint",
+    "MeterReadings",
+    "OutageMessage",
+    "ProductInfo",
+    "Reading",
+    "Register",
+    "Tariffs",
+    "Transaction",
+    "TransactionStatus",
+    "User",
+]

engie_nl-0.2.1/engie_nl/_http.py

@@ -0,0 +1,84 @@
+"""Shared aiohttp session handling for the auth and gateway clients.
+
+Home Assistant passes its own session; scripts pass none and get one that is
+closed with the owner. Both classes need that same rule, so it lives once.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Any
+
+import aiohttp
+
+from .exceptions import EngieNetworkError
+
+
+class SessionOwner:
+    """Holds an aiohttp session, creating one lazily and closing only what it created."""
+
+    def __init__(self, session: aiohttp.ClientSession | None, timeout: float) -> None:
+        self._session: aiohttp.ClientSession | None = session
+        self._owns_session: bool = session is None
+        self._timeout: aiohttp.ClientTimeout = aiohttp.ClientTimeout(total=timeout)
+
+    async def _get_session(self) -> aiohttp.ClientSession:
+        if self._session is None or self._session.closed:
+            self._session = aiohttp.ClientSession(timeout=self._timeout)
+            self._owns_session = True
+        return self._session
+
+    async def close(self) -> None:
+        """Close the session if this object created it. A borrowed session is left alone."""
+        if self._owns_session and self._session is not None and not self._session.closed:
+            await self._session.close()
+
+    async def __aenter__(self) -> "SessionOwner":
+        return self
+
+    async def __aexit__(self, *exc: object) -> None:
+        await self.close()
+
+
+async def json_or_text(resp: aiohttp.ClientResponse) -> Any:
+    """Decode a response as JSON when it is, otherwise return the text; empty body -> ``{}``."""
+    text = await resp.text()
+    if not text:
+        return {}
+    try:
+        return await resp.json(content_type=None)
+    except (aiohttp.ContentTypeError, ValueError):
+        return text
+
+
+async def send(
+    session: aiohttp.ClientSession,
+    verb: str,
+    url: str,
+    *,
+    params: list[tuple[str, str]] | None = None,
+    form: list[tuple[str, str]] | None = None,
+    json_body: Any = None,
+    headers: dict[str, str] | None = None,
+    timeout: aiohttp.ClientTimeout | None = None,
+) -> tuple[int, Any]:
+    """One request, returning ``(status, body)``.
+
+    Both the gateway client and the Net2Grid client need exactly this, down to
+    turning every transport failure into :class:`EngieNetworkError` so callers
+    can retry on one type. The status is returned rather than raised on, because
+    what a 4xx means differs per host.
+    """
+    try:
+        async with session.request(
+            verb,
+            url,
+            params=params,
+            data=form,
+            json=json_body,
+            headers=headers,
+            timeout=timeout,
+        ) as resp:
+            return resp.status, await json_or_text(resp)
+    except (aiohttp.ClientError, asyncio.TimeoutError) as err:
+        raise EngieNetworkError(f"{verb} {url} failed: {err or type(err).__name__}") from err

engie_nl-0.2.1/engie_nl/_parse.py

@@ -0,0 +1,41 @@
+"""Turning a decoded response into models.
+
+Both the client's own reads and the endpoint groups need these, and importing
+one from the other would tie them together in a circle, so they live here.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Iterable
+from typing import Any, TypeVar
+
+T = TypeVar("T")
+
+Params = list[tuple[str, str]]
+
+
+def eans_param(eans: Iterable[str] | str) -> Params:
+    """``eans[]`` is one query key per value; a comma-joined string is rejected."""
+    values = [eans] if isinstance(eans, str) else list(eans)
+    if not values:
+        raise ValueError("at least one EAN is required")
+    return [("eans[]", ean) for ean in values]
+
+
+def as_dicts(data: Any) -> list[dict[str, Any]]:
+    """The list of objects in a response, whether it is bare or wrapped in ``data``."""
+    if isinstance(data, list):
+        return [d for d in data if isinstance(d, dict)]
+    if isinstance(data, dict) and isinstance(data.get("data"), list):
+        return [d for d in data["data"] if isinstance(d, dict)]
+    return []
+
+
+def parse_list(data: Any, model: Callable[[dict[str, Any]], T]) -> list[T]:
+    """Every object in a list response, as models. A non-list gives an empty list."""
+    return [model(d) for d in as_dicts(data)]
+
+
+def parse_one(data: Any, model: Callable[[dict[str, Any]], T]) -> T | None:
+    """One object response as a model, or None when the body was not an object."""
+    return model(data) if isinstance(data, dict) else None

engie_nl-0.2.1/engie_nl/api/__init__.py

@@ -0,0 +1,49 @@
+"""The rest of the gateway, grouped by what it is for.
+
+:class:`~engie_nl.client.EngieClient` carries the reads a household actually
+polls: user, consumption, meter readings, costs, day-ahead prices. Everything
+else the app can reach lives here, one module per area, reachable as
+``client.assets``, ``client.enode`` and so on.
+
+Paths are written out at the call site rather than pulled from constants.py.
+There are 148 of them and each is used once, so a constant would only add a
+name to look up.
+
+Every method that changes the account goes through
+:meth:`~engie_nl.client.EngieClient._write`, which refuses unless the client was
+built with ``allow_writes=True``.
+"""
+
+from __future__ import annotations
+
+from .account import AccountApi
+from .address import AddressApi
+from .assets import AssetsApi
+from .billing import BillingApi
+from .enode import EnodeApi
+from .ev import EvApi
+from .happy_hour import HappyHourApi
+from .legacy import LegacyApi
+from .mandates import MandatesApi
+from .meter import MeterApi
+from .smart_charging import SmartChargingApi
+from .solar import SolarApi
+from .support import SupportApi
+from .tariffs import TariffsApi
+
+__all__ = [
+    "AccountApi",
+    "AddressApi",
+    "AssetsApi",
+    "BillingApi",
+    "EnodeApi",
+    "EvApi",
+    "HappyHourApi",
+    "LegacyApi",
+    "MandatesApi",
+    "MeterApi",
+    "SmartChargingApi",
+    "SolarApi",
+    "SupportApi",
+    "TariffsApi",
+]

engie_nl-0.2.1/engie_nl/api/_base.py

@@ -0,0 +1,29 @@
+"""Shared plumbing for the endpoint groups."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from .._parse import Params, as_dicts, eans_param, parse_list, parse_one
+
+if TYPE_CHECKING:  # pragma: no cover - the import is a cycle at runtime
+    from ..client import EngieClient
+
+__all__ = ["ApiGroup", "Params", "as_dicts", "eans_param", "parse_list", "parse_one"]
+
+
+class ApiGroup:  # pylint: disable=too-few-public-methods
+    """One area of the gateway, bound to the client that owns the session."""
+
+    def __init__(self, client: "EngieClient") -> None:
+        self._client = client
+
+    async def _get(self, path: str, params: Params | None = None) -> Any:
+        return await self._client._get(path, params)  # pylint: disable=protected-access
+
+    async def _query(self, verb: str, path: str, **kwargs: Any) -> Any:
+        """A request that reads despite not being a GET, so no write gate."""
+        return await self._client._request(verb, path, **kwargs)  # pylint: disable=protected-access
+
+    async def _write(self, verb: str, path: str, **kwargs: Any) -> Any:
+        return await self._client._write(verb, path, **kwargs)  # pylint: disable=protected-access