pybluecurrent 0.1.1__tar.gz → 0.2.0__tar.gz

pybluecurrent-0.2.0/CHANGELOG.md

@@ -0,0 +1,40 @@
+# Changelog
+
+All notable changes to this project are documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
+This project is pre-1.0: breaking changes may land in minor releases.
+
+## [Unreleased]
+
+## [0.2.0] - 2026-07-11
+
+### Added
+
+- API-token authentication: construct the client with `BlueCurrentClient(api_token=...)` instead of a username and password.
+- `get_api_token()` and `generate_api_token()` to fetch or rotate your account's API token (home automation key).
+
+### Changed
+
+- REST calls now use `api.bluecurrent.nl` instead of the legacy `bo.bluecurrent.nl` backoffice host (same `bc_api` v2.0 API and response shapes).
+- REST requests now use a 30-second timeout instead of httpx's 5-second default, so occasional slow backend responses no longer raise `httpx.ReadTimeout`; override with the `http_timeout` attribute.
+- Internal: added an offline websocket test harness (fake socket + recorded fixtures) so the auth/`_send`/`_receive`/`_handler` logic runs in CI without live credentials.
+
+### Fixed
+
+- Concurrent websocket calls are now safe: calls awaiting the same response type are serialized so overlapping same-type calls can no longer receive each other's replies (different-type calls still run concurrently). Errors the backend tags with a request id are routed to the originating call rather than failing every in-flight call.
+
+## [0.1.1] - 2026-07-04
+
+### Fixed
+
+- `get_account` no longer raises a `ValueError` on BlueCurrent's current date format; `first_login_app` now parses both the legacy (`01-JAN-20`) and ISO (`2020-01-15T13:33:52`) formats.
+
+### Changed
+
+- `get_account` returns `first_login_app` as a `datetime` (previously a `date`).
+- Internal: switched tooling to Ruff and ty, added a Python 3.10–3.13 CI matrix, and moved to PyPI trusted publishing (OIDC).
+
+[Unreleased]: https://github.com/rogiervandergeer/pybluecurrent/compare/0.2.0...HEAD
+[0.2.0]: https://github.com/rogiervandergeer/pybluecurrent/compare/0.1.1...0.2.0
+[0.1.1]: https://github.com/rogiervandergeer/pybluecurrent/compare/0.1.0...0.1.1

{pybluecurrent-0.1.1 → pybluecurrent-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pybluecurrent
-Version: 0.1.1
+Version: 0.2.0
 Summary: Python client for BlueCurrent charge points.
 Author-email: Rogier van der Geer <rogier@vander-geer.nl>
 License: MIT
@@ -52,6 +52,8 @@ async with client:
 The `BlueCurrentClient` exposes the following methods:
   
 - [`get_account`](#getaccount---get-your-account-information)
+- [`get_api_token`](#getapitoken---get-your-api-token)
+- [`generate_api_token`](#generateapitoken---generate-a-new-api-token)
 - [`get_charge_cards`](#getchargecards---get-your-charge-cards)
 - [`get_charge_points`](#getchargepoints---get-your-charge-points)
 - [`get_charge_point_settings`](#getchargepointsettings---get-the-settings-of-a-charge-point)
@@ -76,6 +78,14 @@ async with client:
 ```
 Entering the async context will automatically login.
 
+Instead of a username and password, you can authenticate with an API token:
+```python
+client = BlueCurrentClient(api_token="your_api_token")
+```
+Retrieve or rotate the token with [`get_api_token`](#getapitoken---get-your-api-token) and
+[`generate_api_token`](#generateapitoken---generate-a-new-api-token), or from the
+[BlueCurrent website](https://my.bluecurrent.nl).
+
 #### `get_account` - Get your account information.
 
 ```python
@@ -94,11 +104,29 @@ A dictionary describing your account:
     "developer_mode_enabled": False,
     "tel": "",
     "marketing_target": "bluecurrent",
-    "first_login_app": date(2020, 1, 1),
+    "first_login_app": datetime(2020, 1, 15, 13, 33, 52),
     "hubspot_user_identity": "a_very_long_string"
 }
 ```
 
+#### `get_api_token` - Get your API token.
+
+```python
+async def get_api_token(self) -> str
+```
+
+Returns the API token (home automation key) for your account. This token can be used to authenticate
+instead of a username and password, by constructing the client with `BlueCurrentClient(api_token=...)`.
+
+#### `generate_api_token` - Generate a new API token.
+
+```python
+async def generate_api_token(self) -> str
+```
+
+Generates a new API token and returns it. **Warning:** this rotates the token — any previously issued
+token is invalidated, which will break anything still using the old one (for example a Home Assistant integration).
+
 #### `get_charge_cards` - Get your charge cards.
 
 ```python

{pybluecurrent-0.1.1 → pybluecurrent-0.2.0}/README.md

@@ -25,6 +25,8 @@ async with client:
 The `BlueCurrentClient` exposes the following methods:
   
 - [`get_account`](#getaccount---get-your-account-information)
+- [`get_api_token`](#getapitoken---get-your-api-token)
+- [`generate_api_token`](#generateapitoken---generate-a-new-api-token)
 - [`get_charge_cards`](#getchargecards---get-your-charge-cards)
 - [`get_charge_points`](#getchargepoints---get-your-charge-points)
 - [`get_charge_point_settings`](#getchargepointsettings---get-the-settings-of-a-charge-point)
@@ -49,6 +51,14 @@ async with client:
 ```
 Entering the async context will automatically login.
 
+Instead of a username and password, you can authenticate with an API token:
+```python
+client = BlueCurrentClient(api_token="your_api_token")
+```
+Retrieve or rotate the token with [`get_api_token`](#getapitoken---get-your-api-token) and
+[`generate_api_token`](#generateapitoken---generate-a-new-api-token), or from the
+[BlueCurrent website](https://my.bluecurrent.nl).
+
 #### `get_account` - Get your account information.
 
 ```python
@@ -67,11 +77,29 @@ A dictionary describing your account:
     "developer_mode_enabled": False,
     "tel": "",
     "marketing_target": "bluecurrent",
-    "first_login_app": date(2020, 1, 1),
+    "first_login_app": datetime(2020, 1, 15, 13, 33, 52),
     "hubspot_user_identity": "a_very_long_string"
 }
 ```
 
+#### `get_api_token` - Get your API token.
+
+```python
+async def get_api_token(self) -> str
+```
+
+Returns the API token (home automation key) for your account. This token can be used to authenticate
+instead of a username and password, by constructing the client with `BlueCurrentClient(api_token=...)`.
+
+#### `generate_api_token` - Generate a new API token.
+
+```python
+async def generate_api_token(self) -> str
+```
+
+Generates a new API token and returns it. **Warning:** this rotates the token — any previously issued
+token is invalidated, which will break anything still using the old one (for example a Home Assistant integration).
+
 #### `get_charge_cards` - Get your charge cards.
 
 ```python

{pybluecurrent-0.1.1 → pybluecurrent-0.2.0}/src/pybluecurrent/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.1.1'
-__version_tuple__ = version_tuple = (0, 1, 1)
+__version__ = version = '0.2.0'
+__version_tuple__ = version_tuple = (0, 2, 0)
 
-__commit_id__ = commit_id = 'g10ca35774'
+__commit_id__ = commit_id = 'ge8d24aba3'

{pybluecurrent-0.1.1 → pybluecurrent-0.2.0}/src/pybluecurrent/client.py

@@ -1,8 +1,11 @@
-from asyncio import Task, create_task, wait_for
+from asyncio import Lock, Task, create_task, wait_for
+from asyncio import TimeoutError as AsyncTimeoutError
+from collections import defaultdict
+from contextlib import asynccontextmanager
 from datetime import date, datetime
 from json import dumps, loads
 from logging import getLogger
-from typing import Any, AsyncIterable
+from typing import Any, AsyncIterable, AsyncIterator
 from uuid import uuid4
 
 from asyncio_multisubscriber_queue import MultisubscriberQueue
@@ -16,16 +19,22 @@ from pybluecurrent.utilities import parse_datetime_keys, parse_list_datetime_key
 
 
 class BlueCurrentClient:
-    api_url: str = "https://bo.bluecurrent.nl/app/bc_api/api/v2.0"
+    api_url: str = "https://api.bluecurrent.nl/app/bc_api/api/v2.0"
     psk: str = "d9ab2352a935be4ade182ce4921044f8"
     socket_url: str = "wss://motown.bluecurrent.nl/appserver/2.0"
+    http_timeout: float = 30.0
 
-    def __init__(self, username: str, password: str):
+    def __init__(self, username: str | None = None, password: str | None = None, api_token: str | None = None):
+        if api_token is None and (username is None or password is None):
+            raise ValueError("Provide either username and password, or api_token.")
         self.consumer: Task | None = None
-        self.credentials: tuple[str, str] = (username, password)
+        self.credentials: tuple[str | None, str | None] = (username, password)
+        self.api_token: str | None = api_token
+        self.customer_id: str | None = None
         self.logger = getLogger("BlueCurrentClient")
         self.httpx_client: AsyncClient | None = None
         self.queue = MultisubscriberQueue()
+        self.locks: defaultdict[str, Lock] = defaultdict(Lock)
         self.socket: ClientConnection | None = None
         self.token: str | None = None
 
@@ -34,7 +43,7 @@ class BlueCurrentClient:
         self.connection = connect(self.socket_url, user_agent_header=self._user_agent)
         self.socket = await self.connection.__aenter__()
         self.consumer = create_task(self._handler())
-        self.httpx_client = AsyncClient()
+        self.httpx_client = AsyncClient(timeout=self.http_timeout)
         await self.httpx_client.__aenter__()
         if self.token is None:
             await self._login()
@@ -68,11 +77,42 @@ class BlueCurrentClient:
                 "hubspot_user_identity": "a_very_long_string"
             }
         """
-        await self._send(dict(command="GET_ACCOUNT"), token=True)
-        result = await self._receive("ACCOUNT")
+        result = await self._request(dict(command="GET_ACCOUNT"), "ACCOUNT")
         del result["object"]
         return parse_datetime_keys(result, formats={"first_login_app": (("%d-%b-%y", "%Y-%m-%dT%H:%M:%S"), False)})
 
+    async def get_api_token(self) -> str:
+        """
+        Get the API token (home automation key) for your account.
+
+        The token can be used to authenticate instead of a username and password, by constructing
+        the client with ``BlueCurrentClient(api_token=...)``.
+        """
+        if self.httpx_client is None:
+            raise RuntimeError(f"{self.__class__.__name__} is not connected.")
+        response = await self.httpx_client.get(
+            f"{self.api_url}/gethomeautomationkey",
+            headers={"Authorization": f"Token {self.token}", "User-Agent": self._user_agent},
+        )
+        response.raise_for_status()
+        return response.json()["key"]
+
+    async def generate_api_token(self) -> str:
+        """
+        Generate a new API token (home automation key) and return it.
+
+        Warning: this rotates the token. Any previously issued token is invalidated, which will
+        break anything still using the old one (for example a Home Assistant integration).
+        """
+        if self.httpx_client is None:
+            raise RuntimeError(f"{self.__class__.__name__} is not connected.")
+        response = await self.httpx_client.post(
+            f"{self.api_url}/generatehomeautomationkey",
+            headers={"Authorization": f"Token {self.token}", "User-Agent": self._user_agent},
+        )
+        response.raise_for_status()
+        return await self.get_api_token()
+
     async def get_charge_cards(self) -> list[dict[str, date | int | str | None]]:
         """
         Get your charge cards:
@@ -82,7 +122,7 @@ class BlueCurrentClient:
             {
                 "uid": "A1B2C3D4E5F6",
                 "id": "NL-ABC-123456-0",
-                "name": "My Charge Cards",
+                "name": "My Charge Card",
                 "customer_name": "Your Name",
                 "valid": 1,
                 "date_created": date(2023, 6, 27),
@@ -90,8 +130,7 @@ class BlueCurrentClient:
                 "date_became_invalid": None
             }
         """
-        await self._send(dict(command="GET_CHARGE_CARDS"), token=True)
-        result = (await self._receive("CHARGE_CARDS"))["cards"]
+        result = (await self._request(dict(command="GET_CHARGE_CARDS"), "CHARGE_CARDS"))["cards"]
         return parse_list_datetime_keys(
             result,
             formats={
@@ -134,8 +173,7 @@ class BlueCurrentClient:
                 "delayed_charging": {"value": False, "permission": "none"}
             }
         """
-        await self._send(dict(command="GET_CHARGE_POINTS"), token=True)
-        return (await self._receive("CHARGE_POINTS"))["data"]
+        return (await self._request(dict(command="GET_CHARGE_POINTS"), "CHARGE_POINTS"))["data"]
 
     async def get_charge_point_settings(self, evse_id: str) -> dict[str, bool | dict[str, Any] | str]:
         """
@@ -168,8 +206,7 @@ class BlueCurrentClient:
                 "led_interaction": {"value": False, "permission": "none"}
             }
         """
-        await self._send(dict(command="GET_CH_SETTINGS", evse_id=evse_id), token=True)
-        return (await self._receive("CH_SETTINGS"))["data"]
+        return (await self._request(dict(command="GET_CH_SETTINGS", evse_id=evse_id), "CH_SETTINGS"))["data"]
 
     async def get_grid_status(self, evse_id: str) -> dict[str, int | str]:
         """
@@ -189,13 +226,11 @@ class BlueCurrentClient:
                 "grid_max_reserved": 25
             }
         """
-        await self._send(dict(command="GET_GRID_STATUS", evse_id=evse_id), token=True)
-        return (await self._receive("GRID_STATUS"))["data"]
+        return (await self._request(dict(command="GET_GRID_STATUS", evse_id=evse_id), "GRID_STATUS"))["data"]
 
     async def get_sessions(self, evse_id: str):
         """Does not work"""
-        await self._send(dict(command="GET_SESSIONS"), token=True)
-        return await self._receive("SESSIONS")
+        return await self._request(dict(command="GET_SESSIONS"), "SESSIONS")
 
     async def get_sustainability_status(self) -> dict[str, float | int]:
         """
@@ -205,8 +240,7 @@ class BlueCurrentClient:
             A dictionary with two keys:
             {"trees": 1, "co2": 12.345}
         """
-        await self._send(dict(command="GET_SUSTAINABILITY_STATUS"), token=True)
-        result = await self._receive("SUSTAINABILITY_STATUS")
+        result = await self._request(dict(command="GET_SUSTAINABILITY_STATUS"), "SUSTAINABILITY_STATUS")
         result.pop("object")
         return result
 
@@ -224,11 +258,10 @@ class BlueCurrentClient:
                 as setting it to None.
         """
         token_uid = "BCU-APP" if uid is None or uid == "BCU_HOME_USE" else uid
-        await self._send(
+        result = await self._request(
             dict(command="SET_PLUG_AND_CHARGE_CHARGE_CARD", evse_id=evse_id, token_uid=token_uid),
-            token=True,
+            "STATUS_SET_PLUG_AND_CHARGE_CHARGE_CARD",
         )
-        result = await self._receive("STATUS_SET_PLUG_AND_CHARGE_CHARGE_CARD")
         if not result.get("success"):
             raise BlueCurrentException(result)
 
@@ -240,32 +273,26 @@ class BlueCurrentClient:
             evse_id: The ID of the charge point.
             enabled: Boolean that indicates the desired status.
         """
-        if enabled:
-            await self._send(dict(command="SET_OPERATIVE", evse_id=evse_id, flow_id=str(uuid4())), token=True)
-            await self._receive("RECEIVED_SET_OPERATIVE")
-            await self._receive("STATUS_SET_OPERATIVE", timeout=30)
-        else:
-            await self._send(dict(command="SET_INOPERATIVE", evse_id=evse_id, flow_id=str(uuid4())), token=True)
-            await self._receive("RECEIVED_SET_INOPERATIVE")
-            await self._receive("STATUS_SET_INOPERATIVE", timeout=30)
+        command = "SET_OPERATIVE" if enabled else "SET_INOPERATIVE"
+        flow_id = str(uuid4())
+        async with self._command(command):
+            await self._send(dict(command=command, evse_id=evse_id, flow_id=flow_id), token=True)
+            await self._receive(f"RECEIVED_{command}", flow_id=flow_id)
+            await self._receive(f"STATUS_{command}", timeout=30, flow_id=flow_id)
 
     async def unlock_connector(self, evse_id: str):
-        # TODO: test
-        await self._send(
-            dict(
-                command="UNLOCK_CONNECTOR",
-                evse_id=evse_id,
-            ),
-            token=True,
-        )
-        await self._receive("RECEIVED_UNLOCK_CONNECTOR")
-        return await self._receive("STATUS_UNLOCK_CONNECTOR", timeout=30)
+        flow_id = str(uuid4())
+        async with self._command("UNLOCK_CONNECTOR"):
+            await self._send(dict(command="UNLOCK_CONNECTOR", evse_id=evse_id, flow_id=flow_id), token=True)
+            await self._receive("RECEIVED_UNLOCK_CONNECTOR", flow_id=flow_id)
+            return await self._receive("STATUS_UNLOCK_CONNECTOR", timeout=30, flow_id=flow_id)
 
     async def soft_reset(self, evse_id: str):
-        # TODO: verify flow id
-        await self._send(dict(command="SOFT_RESET", evse_id=evse_id, flow_id=str(uuid4())), token=True)
-        await self._receive("RECEIVED_SOFT_RESET")
-        return await self._receive("STATUS_SOFT_RESET", timeout=30)
+        flow_id = str(uuid4())
+        async with self._command("SOFT_RESET"):
+            await self._send(dict(command="SOFT_RESET", evse_id=evse_id, flow_id=flow_id), token=True)
+            await self._receive("RECEIVED_SOFT_RESET", flow_id=flow_id)
+            return await self._receive("STATUS_SOFT_RESET", timeout=30, flow_id=flow_id)
 
     async def get_charge_point_status(self, evse_id: str) -> dict[str, datetime | float | int | str | None]:
         """
@@ -448,6 +475,12 @@ class BlueCurrentClient:
             next_page = transactions["next_page"]
 
     async def _login(self) -> None:
+        if self.api_token is not None:
+            await self._login_with_token()
+        else:
+            await self._login_with_password()
+
+    async def _login_with_password(self) -> None:
         await self._send(
             dict(
                 command="VALIDATE_PASSWORD",
@@ -462,15 +495,28 @@ class BlueCurrentClient:
         self.token = message["token"]
         self.logger.info("Successfully authenticated")
 
+    async def _login_with_token(self) -> None:
+        await self._send(dict(command="VALIDATE_API_TOKEN", token=self.api_token))
+        message = await self._receive("STATUS_API_TOKEN")
+        if not message.get("success"):
+            self.logger.error("Authentication failed")
+            raise AuthenticationFailed(message)
+        self.token = message["token"]
+        self.customer_id = message.get("customer_id")
+        self.logger.info("Successfully authenticated")
+
     async def _hello(self) -> None:
         await self._send(dict(command="HELLO"), token=True)
         await self._receive("HELLO")
 
     def _encrypt_password(self) -> str:
+        password = self.credentials[1]
+        if password is None:
+            raise RuntimeError("No password configured.")
         return dumps(
             {
                 key: (value.decode("utf-8") if isinstance(value, bytes) else value)
-                for key, value in SJCL().encrypt(self.credentials[1].encode("utf-8"), self.psk).items()
+                for key, value in SJCL().encrypt(password.encode("utf-8"), self.psk).items()
             },
             ensure_ascii=False,
         )
@@ -486,12 +532,24 @@ class BlueCurrentClient:
     def _user_agent(self) -> str:
         return f"pybluecurrent {__version__.split('+')[0]}"
 
-    async def _receive(self, obj: str, timeout: int = 10) -> dict[str, Any]:
+    async def _receive(self, obj: str, timeout: int = 10, flow_id: str | None = None) -> dict[str, Any]:
         with self.queue.queue() as q:
             while True:
-                message = await wait_for(q.get(), timeout=timeout)
+                try:
+                    message = await wait_for(q.get(), timeout=timeout)
+                except AsyncTimeoutError as exc:
+                    # On Python 3.10 asyncio.TimeoutError is a distinct class from the
+                    # builtin TimeoutError; normalise so callers can catch the builtin.
+                    raise TimeoutError from exc
                 if message.get("object") == "ERROR":
-                    raise BlueCurrentException(message)
+                    # Attribute errors by flow_id when the backend echoes one, so a correlated
+                    # error doesn't poison other concurrent calls. Not every error carries a
+                    # flow_id (e.g. "forbidden" has none), so an uncorrelated error still raises
+                    # for whoever is waiting — falling back to the old broadcast behaviour.
+                    error_flow_id = message.get("flow_id")
+                    if error_flow_id in (flow_id, None):
+                        raise BlueCurrentException(message)
+                    continue
                 if message.get("object") == obj:
                     return message
 
@@ -501,3 +559,16 @@ class BlueCurrentClient:
         if self.socket is None:
             raise RuntimeError(f"{self.__class__.__name__} is not connected.")
         await self.socket.send(dumps(data, ensure_ascii=False))
+
+    @asynccontextmanager
+    async def _command(self, key: str) -> AsyncIterator[None]:
+        # Serialise calls that await the same response object so concurrent same-type calls
+        # can't consume each other's replies. Different keys keep running concurrently, so a
+        # slow command (e.g. soft_reset) doesn't block a quick read.
+        async with self.locks[key]:
+            yield
+
+    async def _request(self, data: dict[str, Any], response_object: str, timeout: int = 10) -> dict[str, Any]:
+        async with self._command(response_object):
+            await self._send(data, token=True)
+            return await self._receive(response_object, timeout=timeout)

{pybluecurrent-0.1.1 → pybluecurrent-0.2.0}/src/pybluecurrent.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pybluecurrent
-Version: 0.1.1
+Version: 0.2.0
 Summary: Python client for BlueCurrent charge points.
 Author-email: Rogier van der Geer <rogier@vander-geer.nl>
 License: MIT
@@ -52,6 +52,8 @@ async with client:
 The `BlueCurrentClient` exposes the following methods:
   
 - [`get_account`](#getaccount---get-your-account-information)
+- [`get_api_token`](#getapitoken---get-your-api-token)
+- [`generate_api_token`](#generateapitoken---generate-a-new-api-token)
 - [`get_charge_cards`](#getchargecards---get-your-charge-cards)
 - [`get_charge_points`](#getchargepoints---get-your-charge-points)
 - [`get_charge_point_settings`](#getchargepointsettings---get-the-settings-of-a-charge-point)
@@ -76,6 +78,14 @@ async with client:
 ```
 Entering the async context will automatically login.
 
+Instead of a username and password, you can authenticate with an API token:
+```python
+client = BlueCurrentClient(api_token="your_api_token")
+```
+Retrieve or rotate the token with [`get_api_token`](#getapitoken---get-your-api-token) and
+[`generate_api_token`](#generateapitoken---generate-a-new-api-token), or from the
+[BlueCurrent website](https://my.bluecurrent.nl).
+
 #### `get_account` - Get your account information.
 
 ```python
@@ -94,11 +104,29 @@ A dictionary describing your account:
     "developer_mode_enabled": False,
     "tel": "",
     "marketing_target": "bluecurrent",
-    "first_login_app": date(2020, 1, 1),
+    "first_login_app": datetime(2020, 1, 15, 13, 33, 52),
     "hubspot_user_identity": "a_very_long_string"
 }
 ```
 
+#### `get_api_token` - Get your API token.
+
+```python
+async def get_api_token(self) -> str
+```
+
+Returns the API token (home automation key) for your account. This token can be used to authenticate
+instead of a username and password, by constructing the client with `BlueCurrentClient(api_token=...)`.
+
+#### `generate_api_token` - Generate a new API token.
+
+```python
+async def generate_api_token(self) -> str
+```
+
+Generates a new API token and returns it. **Warning:** this rotates the token — any previously issued
+token is invalidated, which will break anything still using the old one (for example a Home Assistant integration).
+
 #### `get_charge_cards` - Get your charge cards.
 
 ```python

{pybluecurrent-0.1.1 → pybluecurrent-0.2.0}/src/pybluecurrent.egg-info/SOURCES.txt

@@ -1,5 +1,6 @@
 .gitignore
 .pre-commit-config.yaml
+CHANGELOG.md
 LICENSE
 README.md
 pyproject.toml
@@ -19,5 +20,14 @@ src/pybluecurrent.egg-info/scm_file_list.json
 src/pybluecurrent.egg-info/scm_version.json
 src/pybluecurrent.egg-info/top_level.txt
 tests/conftest.py
+tests/fake_socket.py
 tests/test_client.py
-tests/test_utilities.py
+tests/test_offline.py
+tests/test_utilities.py
+tests/fixtures/account.json
+tests/fixtures/charge_cards.json
+tests/fixtures/charge_point_settings.json
+tests/fixtures/charge_points.json
+tests/fixtures/error_forbidden.json
+tests/fixtures/grid_status.json
+tests/fixtures/sustainability_status.json

{pybluecurrent-0.1.1 → pybluecurrent-0.2.0}/src/pybluecurrent.egg-info/scm_file_list.json

@@ -4,15 +4,25 @@
     "README.md",
     "LICENSE",
     "pyproject.toml",
+    "CHANGELOG.md",
     ".gitignore",
     "src/pybluecurrent/utilities.py",
     "src/pybluecurrent/py.typed",
     "src/pybluecurrent/__init__.py",
     "src/pybluecurrent/exceptions.py",
     "src/pybluecurrent/client.py",
+    "tests/test_offline.py",
     "tests/test_client.py",
     "tests/test_utilities.py",
+    "tests/fake_socket.py",
     "tests/conftest.py",
+    "tests/fixtures/charge_point_settings.json",
+    "tests/fixtures/error_forbidden.json",
+    "tests/fixtures/sustainability_status.json",
+    "tests/fixtures/account.json",
+    "tests/fixtures/charge_points.json",
+    "tests/fixtures/grid_status.json",
+    "tests/fixtures/charge_cards.json",
     ".github/workflows/publish.yaml",
     ".github/workflows/test.yaml"
   ]

pybluecurrent-0.2.0/src/pybluecurrent.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.2.0",
+  "distance": 0,
+  "node": "ge8d24aba3c4114cbd37656dde2ddb1c7a03bdc79",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-07-11"
+}

{pybluecurrent-0.1.1 → pybluecurrent-0.2.0}/tests/conftest.py

@@ -1,7 +1,8 @@
 from os import environ
 from typing import AsyncGenerator
 
-from pytest import fixture, skip
+from fake_socket import FakeSocket, make_fake_connect
+from pytest import MonkeyPatch, fixture, skip
 
 from pybluecurrent import BlueCurrentClient
 
@@ -11,6 +12,20 @@ def client() -> BlueCurrentClient:
     return BlueCurrentClient("username", "password")
 
 
+@fixture(scope="function")
+def fake_socket() -> FakeSocket:
+    """A fresh offline websocket with the default auth + HELLO handshake scripted."""
+    return FakeSocket()
+
+
+@fixture(scope="function")
+async def offline_client(monkeypatch: MonkeyPatch, fake_socket: FakeSocket) -> AsyncGenerator[BlueCurrentClient, None]:
+    """A connected client backed by ``fake_socket`` — no credentials, no network."""
+    monkeypatch.setattr("pybluecurrent.client.connect", make_fake_connect(fake_socket))
+    async with BlueCurrentClient("username", "password") as client:
+        yield client
+
+
 @fixture(scope="session")
 def client_with_auth() -> BlueCurrentClient | None:
     try:

pybluecurrent-0.2.0/tests/fake_socket.py

@@ -0,0 +1,130 @@
+"""Offline fake for the BlueCurrent websocket transport.
+
+Replaces ``websockets.asyncio.client.connect`` in tests so the client can run without a
+live backend. Patch it in with::
+
+    monkeypatch.setattr("pybluecurrent.client.connect", make_fake_connect(fake_socket))
+
+The client only uses the socket in a handful of ways (async iteration in ``_handler``,
+``send`` in ``_send``, and the ``connect(...)`` async context manager in ``__aenter__``),
+so ``FakeSocket`` duck-types just those.
+
+Two ways to drive responses:
+
+* **Scripted** — a ``responder`` maps a command name to the frames the server sends back.
+  A default responder scripts the auth handshake and ``HELLO`` so ``async with client``
+  completes offline. Register more with :meth:`FakeSocket.on`.
+* **Manual** — a command with no script feeds nothing; the test injects frames itself with
+  :meth:`FakeSocket.feed` (in any order, duplicated, as ``ERROR``, or as raw non-JSON).
+"""
+
+from asyncio import Queue
+from json import dumps, loads
+from pathlib import Path
+from typing import Any, Callable
+
+Responder = Callable[[dict[str, Any]], list[dict[str, Any]]]
+
+_FIXTURE_DIR = Path(__file__).parent / "fixtures"
+
+
+def load_fixture(name: str) -> dict[str, Any]:
+    """Load a recorded server frame from ``tests/fixtures`` (``.json`` optional)."""
+    path = _FIXTURE_DIR / (name if name.endswith(".json") else f"{name}.json")
+    return loads(path.read_text())
+
+
+# Token the default handshake hands back; tests can assert against it.
+FAKE_TOKEN = "fake-token-123"
+FAKE_CUSTOMER_ID = "fake-customer-1"
+
+# Sentinel enqueued by close() to end the ``async for`` loop in ``_handler``.
+_DISCONNECT = object()
+
+
+def default_responder() -> dict[str, Responder]:
+    """A responder scripting the auth handshake and ``HELLO`` (enough for ``__aenter__``)."""
+    return {
+        "VALIDATE_PASSWORD": lambda msg: [{"object": "STATUS_PASSWORD", "accepted": True, "token": FAKE_TOKEN}],
+        "VALIDATE_API_TOKEN": lambda msg: [
+            {"object": "STATUS_API_TOKEN", "success": True, "token": FAKE_TOKEN, "customer_id": FAKE_CUSTOMER_ID}
+        ],
+        "HELLO": lambda msg: [{"object": "HELLO"}],
+    }
+
+
+class FakeSocket:
+    """Duck-typed stand-in for a ``websockets`` client connection."""
+
+    def __init__(self, responder: dict[str, Responder] | None = None) -> None:
+        self._outbound: Queue[Any] = Queue()
+        self.sent: list[dict[str, Any]] = []
+        self.responder: dict[str, Responder] = default_responder() if responder is None else responder
+        self.closed = False
+
+    # -- server -> client -------------------------------------------------
+    def feed(self, frame: dict[str, Any] | str) -> None:
+        """Push a server->client frame. A dict is JSON-encoded; a str is sent verbatim.
+
+        Raw strings let tests exercise the non-JSON-frame path (``_handler`` calls ``loads``).
+        """
+        self._outbound.put_nowait(frame if isinstance(frame, str) else dumps(frame, ensure_ascii=False))
+
+    def close(self) -> None:
+        """Signal a disconnect so the ``async for`` in ``_handler`` ends cleanly."""
+        self.closed = True
+        self._outbound.put_nowait(_DISCONNECT)
+
+    def __aiter__(self) -> "FakeSocket":
+        return self
+
+    async def __anext__(self) -> str:
+        frame = await self._outbound.get()
+        if frame is _DISCONNECT:
+            raise StopAsyncIteration
+        return frame
+
+    # -- client -> server -------------------------------------------------
+    async def send(self, raw: str) -> None:
+        """Record the outgoing message and feed any scripted responses.
+
+        Uses ``put_nowait`` and never suspends, so the caller resumes synchronously and
+        subscribes to the response queue before the handler task runs — mirroring the fact
+        that real network latency keeps ``send`` ahead of the reply.
+        """
+        message = loads(raw)
+        self.sent.append(message)
+        handler = self.responder.get(message.get("command"))
+        if handler is not None:
+            for frame in handler(message):
+                self.feed(frame)
+
+    def on(self, command: str, *frames: dict[str, Any]) -> None:
+        """Script the frames returned when ``command`` is sent."""
+        self.responder[command] = lambda msg: list(frames)
+
+
+class FakeConnection:
+    """Async context manager returned by :func:`make_fake_connect`, yielding a FakeSocket."""
+
+    def __init__(self, socket: FakeSocket) -> None:
+        self.socket = socket
+
+    async def __aenter__(self) -> FakeSocket:
+        return self.socket
+
+    async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
+        self.socket.close()
+
+
+def make_fake_connect(socket: FakeSocket) -> Callable[..., FakeConnection]:
+    """Build a drop-in replacement for ``connect`` bound to ``socket``.
+
+    The returned callable accepts (and ignores) the ``url`` / ``user_agent_header`` args the
+    client passes, and returns a :class:`FakeConnection`.
+    """
+
+    def fake_connect(*args: Any, **kwargs: Any) -> FakeConnection:
+        return FakeConnection(socket)
+
+    return fake_connect

pybluecurrent-0.2.0/tests/fixtures/account.json

@@ -0,0 +1,12 @@
+{
+  "developer_mode_enabled": false,
+  "email": "your@email.address",
+  "first_login_app": "2020-01-15T13:33:52",
+  "full_name": "Your Full Name",
+  "hubspot_user_identity": "a_very_long_string",
+  "login": "your@email.address",
+  "marketing_target": "bluecurrent",
+  "object": "ACCOUNT",
+  "should_reset_password": false,
+  "tel": ""
+}

pybluecurrent-0.2.0/tests/fixtures/charge_cards.json

@@ -0,0 +1,15 @@
+{
+  "cards": [
+    {
+      "customer_name": "Your Name",
+      "date_became_invalid": null,
+      "date_created": "2023-06-27",
+      "date_modified": "2023-07-11",
+      "id": "NL-ABC-123456-0",
+      "name": "My Charge Card",
+      "uid": "A1B2C3D4E5F6",
+      "valid": 1
+    }
+  ],
+  "object": "CHARGE_CARDS"
+}

pybluecurrent-0.2.0/tests/fixtures/charge_point_settings.json

@@ -0,0 +1,50 @@
+{
+  "data": {
+    "chargepoint_type": "HIDDEN",
+    "default_card": {
+      "customer_name": "Your Name",
+      "id": "NL-ABC-123456-0",
+      "name": "Your Card",
+      "uid": "A1B2C3D4E5F6",
+      "valid": 1
+    },
+    "evse_id": "BCU123456",
+    "is_cable": true,
+    "led_intensity": {
+      "permission": "none",
+      "value": 0
+    },
+    "led_interaction": {
+      "permission": "none",
+      "value": false
+    },
+    "model_type": "H:MOVE-C32T2",
+    "plug_and_charge": {
+      "permission": "write",
+      "value": true
+    },
+    "plug_and_charge_card": {
+      "customer_name": "Your Name",
+      "id": "NL-ABC-123456-0",
+      "name": "Your Card",
+      "uid": "A1B2C3D4E5F6",
+      "valid": 1
+    },
+    "plug_and_charge_notification": false,
+    "preferred_card": {
+      "customer_name": "Your Name",
+      "id": "NL-ABC-123456-0",
+      "name": "Your Card",
+      "uid": "A1B2C3D4E5F6",
+      "valid": 1
+    },
+    "public_charging": {
+      "permission": "write",
+      "value": false
+    },
+    "smart_charging": true,
+    "smart_charging_dynamic": true
+  },
+  "evse_id": "BCU123456",
+  "object": "CH_SETTINGS"
+}

pybluecurrent-0.2.0/tests/fixtures/charge_points.json

@@ -0,0 +1,75 @@
+{
+  "data": [
+    {
+      "activity": "available",
+      "chargepoint_type": "HIDDEN",
+      "default_card": {
+        "customer_name": "Your Name",
+        "id": "NL-ABC-123456-0",
+        "name": "Your Card",
+        "uid": "A1B2C3D4E5F6",
+        "valid": 1
+      },
+      "delayed_charging": {
+        "permission": "none",
+        "value": false
+      },
+      "evse_id": "BCU123456",
+      "is_cable": true,
+      "led_interaction": {
+        "permission": "read",
+        "value": false
+      },
+      "location": {
+        "city": "Utrecht",
+        "country": "NL",
+        "housenumber": "100",
+        "street": "Europalaan",
+        "x_coord": 50.1234,
+        "y_coord": 5.01234,
+        "zipcode": "3526KS"
+      },
+      "model_type": "H:MOVE-C32T2",
+      "name": "",
+      "plug_and_charge": {
+        "permission": "write",
+        "value": true
+      },
+      "plug_and_charge_card": {
+        "customer_name": "Your Name",
+        "id": "NL-ABC-123456-0",
+        "name": "Your Card",
+        "uid": "A1B2C3D4E5F6",
+        "valid": 1
+      },
+      "plug_and_charge_notification": false,
+      "preferred_card": {
+        "customer_name": "Your Name",
+        "id": "NL-ABC-123456-0",
+        "name": "Your Card",
+        "uid": "A1B2C3D4E5F6",
+        "valid": 1
+      },
+      "public_charging": {
+        "permission": "write",
+        "value": false
+      },
+      "publish_location": {
+        "permission": "write",
+        "value": false
+      },
+      "smart_charging": true,
+      "smart_charging_dynamic": true,
+      "tariff": {
+        "currency": "EUR",
+        "price_ex_vat": 0.2,
+        "price_in_vat": 0.242,
+        "start_price_ex_vat": 0,
+        "start_price_in_vat": 0,
+        "tariff_id": "NLBCUT58",
+        "vat_percentage": 21
+      }
+    }
+  ],
+  "object": "CHARGE_POINTS"
+}

pybluecurrent-0.2.0/tests/fixtures/error_forbidden.json

@@ -0,0 +1,5 @@
+{
+  "error": 2,
+  "message": "forbidden",
+  "object": "ERROR"
+}

pybluecurrent-0.2.0/tests/fixtures/grid_status.json

@@ -0,0 +1,11 @@
+{
+  "data": {
+    "grid_actual_p1": 1,
+    "grid_actual_p2": 2,
+    "grid_actual_p3": 3,
+    "grid_max_install": 25,
+    "grid_max_reserved": 25,
+    "id": "GRID-BCU123456"
+  },
+  "object": "GRID_STATUS"
+}

pybluecurrent-0.2.0/tests/fixtures/sustainability_status.json

@@ -0,0 +1,5 @@
+{
+  "co2": 12.345,
+  "object": "SUSTAINABILITY_STATUS",
+  "trees": 1
+}

{pybluecurrent-0.1.1 → pybluecurrent-0.2.0}/tests/test_client.py

@@ -20,9 +20,12 @@ class TestAuthentication:
         async with client_with_auth:
             assert client_with_auth.token is not None
 
-    async def test_authentication_failed(self, client: BlueCurrentClient):
+    async def test_authentication_rejected_live(self, connected_client: BlueCurrentClient):
+        # Guards the rejection *contract* against backend drift: the offline test in test_offline.py
+        # scripts our assumption of how rejection looks, so this hits the real backend with bad
+        # credentials to confirm the client still raises. connected_client skips it without creds.
         with raises(AuthenticationFailed):
-            async with client:
+            async with BlueCurrentClient(username="invalid", password="invalid"):
                 pass
 
 
@@ -165,3 +168,14 @@ class TestRestApi:
             if n_transactions >= 30:
                 break
         assert len(unique_transactions) == 30
+
+    async def test_get_api_token(self, connected_client: BlueCurrentClient):
+        token = await connected_client.get_api_token()
+        assert isinstance(token, str)
+        assert token
+
+    async def test_api_token_auth(self, connected_client: BlueCurrentClient):
+        token = await connected_client.get_api_token()
+        async with BlueCurrentClient(api_token=token) as token_client:
+            assert isinstance(await token_client.get_charge_points(), list)
+            assert token_client.customer_id is not None

pybluecurrent-0.2.0/tests/test_offline.py

@@ -0,0 +1,225 @@
+from asyncio import CancelledError, create_task, gather, sleep
+from contextlib import suppress
+from datetime import date, datetime
+from json import JSONDecodeError
+
+from fake_socket import FAKE_CUSTOMER_ID, FAKE_TOKEN, FakeSocket, load_fixture, make_fake_connect
+from pytest import MonkeyPatch, raises
+
+from pybluecurrent import BlueCurrentClient
+from pybluecurrent.exceptions import AuthenticationFailed, BlueCurrentException
+
+
+async def _expect_auth_failure(monkeypatch: MonkeyPatch, socket: FakeSocket, **client_kwargs) -> None:
+    """Connect a client backed by ``socket`` and assert ``__aenter__`` fails authentication.
+
+    Cleans up the leaked handler task / httpx client itself, since ``__aexit__`` never runs when
+    ``__aenter__`` raises (a lifecycle gap tracked separately in #9).
+    """
+    monkeypatch.setattr("pybluecurrent.client.connect", make_fake_connect(socket))
+    client = BlueCurrentClient(**client_kwargs)
+    try:
+        with raises(AuthenticationFailed):
+            await client.__aenter__()
+    finally:
+        if client.consumer is not None:
+            client.consumer.cancel()
+        if client.httpx_client is not None:
+            await client.httpx_client.__aexit__(None, None, None)
+
+
+class TestOfflineAuth:
+    """Auth handshake against the offline fake — no credentials, no network."""
+
+    async def test_password_auth_success(self, offline_client: BlueCurrentClient):
+        assert offline_client.token == FAKE_TOKEN
+
+    async def test_password_auth_failed(self, monkeypatch: MonkeyPatch, fake_socket: FakeSocket):
+        fake_socket.on("VALIDATE_PASSWORD", {"object": "STATUS_PASSWORD", "accepted": False})
+        await _expect_auth_failure(monkeypatch, fake_socket, username="username", password="password")
+
+    async def test_token_auth_success(self, monkeypatch: MonkeyPatch, fake_socket: FakeSocket):
+        monkeypatch.setattr("pybluecurrent.client.connect", make_fake_connect(fake_socket))
+        async with BlueCurrentClient(api_token="some-token") as client:
+            assert client.token == FAKE_TOKEN
+            assert client.customer_id == FAKE_CUSTOMER_ID
+
+    async def test_token_auth_failed(self, monkeypatch: MonkeyPatch, fake_socket: FakeSocket):
+        fake_socket.on("VALIDATE_API_TOKEN", {"object": "STATUS_API_TOKEN", "success": False})
+        await _expect_auth_failure(monkeypatch, fake_socket, api_token="bad-token")
+
+
+class TestOfflineTransport:
+    """Exercise ``_send`` / ``_receive`` / ``_handler`` directly against the fake."""
+
+    async def test_send_injects_authorization(self, offline_client: BlueCurrentClient, fake_socket: FakeSocket):
+        fake_socket.sent.clear()
+        await offline_client._send({"command": "PING"}, token=True)
+        assert fake_socket.sent[-1]["Authorization"] == f"Token {FAKE_TOKEN}"
+
+    async def test_send_without_token(self, offline_client: BlueCurrentClient, fake_socket: FakeSocket):
+        fake_socket.sent.clear()
+        await offline_client._send({"command": "PING"})
+        assert "Authorization" not in fake_socket.sent[-1]
+
+    async def test_receive_matches_object(self, offline_client: BlueCurrentClient, fake_socket: FakeSocket):
+        task = create_task(offline_client._receive("PONG"))
+        await sleep(0)
+        fake_socket.feed({"object": "PONG", "value": 1})
+        assert (await task) == {"object": "PONG", "value": 1}
+
+    async def test_receive_discards_nonmatching(self, offline_client: BlueCurrentClient, fake_socket: FakeSocket):
+        task = create_task(offline_client._receive("WANTED"))
+        await sleep(0)
+        fake_socket.feed({"object": "NOISE", "value": 0})
+        fake_socket.feed({"object": "WANTED", "value": 1})
+        assert (await task)["value"] == 1
+
+    async def test_receive_raises_on_error(self, offline_client: BlueCurrentClient, fake_socket: FakeSocket):
+        task = create_task(offline_client._receive("WANTED"))
+        await sleep(0)
+        fake_socket.feed(load_fixture("error_forbidden"))
+        with raises(BlueCurrentException) as exc:
+            await task
+        assert exc.value.args[0]["message"] == "forbidden"
+
+    async def test_receive_timeout(self, offline_client: BlueCurrentClient):
+        with raises(TimeoutError):
+            await offline_client._receive("NEVER_ARRIVES", timeout=0)
+
+    async def test_handler_fans_out_to_all_waiters(self, offline_client: BlueCurrentClient, fake_socket: FakeSocket):
+        # A single frame reaches every concurrent waiter — the broadcast behaviour that #8 hardens.
+        first = create_task(offline_client._receive("PING"))
+        second = create_task(offline_client._receive("PING"))
+        await sleep(0)
+        fake_socket.feed({"object": "PING", "value": 1})
+        assert (await first)["value"] == 1
+        assert (await second)["value"] == 1
+
+    async def test_non_json_frame_kills_consumer(self, offline_client: BlueCurrentClient, fake_socket: FakeSocket):
+        # Documents current behaviour: a malformed frame kills the handler task (a seam #9 will address).
+        consumer = offline_client.consumer
+        assert consumer is not None
+        fake_socket.feed("this is not json")
+        for _ in range(5):
+            await sleep(0)
+            if consumer.done():
+                break
+        assert consumer.done()
+        assert isinstance(consumer.exception(), JSONDecodeError)
+
+
+class TestOfflineCommands:
+    """Command round-trips driven by recorded fixtures."""
+
+    async def test_get_charge_points(self, offline_client: BlueCurrentClient, fake_socket: FakeSocket):
+        fake_socket.on("GET_CHARGE_POINTS", load_fixture("charge_points"))
+        charge_points = await offline_client.get_charge_points()
+        assert charge_points[0]["evse_id"] == "BCU123456"
+
+    async def test_get_grid_status(self, offline_client: BlueCurrentClient, fake_socket: FakeSocket):
+        fake_socket.on("GET_GRID_STATUS", load_fixture("grid_status"))
+        status = await offline_client.get_grid_status("BCU123456")
+        assert status["id"] == "GRID-BCU123456"
+        assert status["grid_actual_p1"] == 1
+
+    async def test_get_charge_point_settings(self, offline_client: BlueCurrentClient, fake_socket: FakeSocket):
+        fake_socket.on("GET_CH_SETTINGS", load_fixture("charge_point_settings"))
+        settings = await offline_client.get_charge_point_settings("BCU123456")
+        assert settings["evse_id"] == "BCU123456"
+
+    async def test_get_charge_cards(self, offline_client: BlueCurrentClient, fake_socket: FakeSocket):
+        fake_socket.on("GET_CHARGE_CARDS", load_fixture("charge_cards"))
+        cards = await offline_client.get_charge_cards()
+        assert cards[0]["uid"] == "A1B2C3D4E5F6"
+        assert cards[0]["date_created"] == date(2023, 6, 27)
+        assert cards[0]["date_became_invalid"] is None
+
+    async def test_get_account(self, offline_client: BlueCurrentClient, fake_socket: FakeSocket):
+        fake_socket.on("GET_ACCOUNT", load_fixture("account"))
+        account = await offline_client.get_account()
+        assert account["full_name"] == "Your Full Name"
+        assert account["first_login_app"] == datetime(2020, 1, 15, 13, 33, 52)
+
+    async def test_get_sustainability_status(self, offline_client: BlueCurrentClient, fake_socket: FakeSocket):
+        fake_socket.on("GET_SUSTAINABILITY_STATUS", load_fixture("sustainability_status"))
+        status = await offline_client.get_sustainability_status()
+        assert status == {"trees": 1, "co2": 12.345}
+
+    async def test_error_is_raised(self, offline_client: BlueCurrentClient, fake_socket: FakeSocket):
+        fake_socket.on("GET_GRID_STATUS", load_fixture("error_forbidden"))
+        with raises(BlueCurrentException) as exc:
+            await offline_client.get_grid_status("BOGUS")
+        assert exc.value.args[0]["message"] == "forbidden"
+
+
+class TestOfflineConcurrency:
+    """Concurrency safety: same-type serialization (C1) and error attribution (C2)."""
+
+    async def test_same_type_calls_do_not_cross_consume(
+        self, offline_client: BlueCurrentClient, fake_socket: FakeSocket
+    ):
+        # Give each GET_GRID_STATUS a distinct response. Without the per-object lock both waiters
+        # (subscribed at once) would grab the first reply; with it, each call gets its own.
+        sent = []
+
+        def responder(msg):
+            sent.append(msg)
+            return [{"object": "GRID_STATUS", "data": {"id": f"GRID-{len(sent)}"}}]
+
+        fake_socket.responder["GET_GRID_STATUS"] = responder
+        first, second = await gather(
+            offline_client.get_grid_status("A"),
+            offline_client.get_grid_status("B"),
+        )
+        assert {first["id"], second["id"]} == {"GRID-1", "GRID-2"}
+
+    async def test_read_ignores_an_async_commands_error(
+        self, offline_client: BlueCurrentClient, fake_socket: FakeSocket
+    ):
+        # A read (flow_id=None) must not be poisoned by an error carrying a flow_id (someone else's).
+        task = create_task(offline_client._receive("WANTED"))
+        await sleep(0)
+        fake_socket.feed({"object": "ERROR", "flow_id": "other", "message": "not mine"})
+        fake_socket.feed({"object": "WANTED", "value": 1})
+        assert (await task)["value"] == 1
+
+    async def test_async_command_ignores_another_commands_error(
+        self, offline_client: BlueCurrentClient, fake_socket: FakeSocket
+    ):
+        # An async waiter (flow_id="F") ignores an error correlated to a different flow and
+        # raises only on the one bearing its own flow_id.
+        task = create_task(offline_client._receive("STATUS_X", flow_id="F"))
+        await sleep(0)
+        fake_socket.feed({"object": "ERROR", "flow_id": "other", "message": "another command"})
+        fake_socket.feed({"object": "ERROR", "flow_id": "F", "message": "mine"})
+        with raises(BlueCurrentException) as exc:
+            await task
+        assert exc.value.args[0]["message"] == "mine"
+
+    async def test_async_command_claims_uncorrelated_error(
+        self, offline_client: BlueCurrentClient, fake_socket: FakeSocket
+    ):
+        # Not every error carries a flow_id ("forbidden" has none); the waiting async command
+        # still surfaces such an uncorrelated error rather than hanging on it.
+        task = create_task(offline_client._receive("STATUS_X", flow_id="F"))
+        await sleep(0)
+        fake_socket.feed({"object": "ERROR", "message": "forbidden"})
+        with raises(BlueCurrentException) as exc:
+            await task
+        assert exc.value.args[0]["message"] == "forbidden"
+
+    async def test_different_type_calls_run_concurrently(
+        self, offline_client: BlueCurrentClient, fake_socket: FakeSocket
+    ):
+        # A slow two-phase command holds only its own lock: stall soft_reset after its RECEIVED_ ack
+        # (no STATUS_ fed) and show a grid read on a different key still completes.
+        fake_socket.on("SOFT_RESET", {"object": "RECEIVED_SOFT_RESET"})
+        reset = create_task(offline_client.soft_reset("A"))
+        await sleep(0)
+        fake_socket.on("GET_GRID_STATUS", {"object": "GRID_STATUS", "data": {"id": "GRID-1"}})
+        status = await offline_client.get_grid_status("A")
+        assert status["id"] == "GRID-1"
+        reset.cancel()
+        with suppress(CancelledError):
+            await reset

pybluecurrent-0.1.1/src/pybluecurrent.egg-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "0.1.1",
-  "distance": 0,
-  "node": "g10ca3577491631fafa5e8030701eff3c4854f9b4",
-  "dirty": false,
-  "branch": "HEAD",
-  "node_date": "2026-07-04"
-}