loqedAPI 2.1.10__tar.gz → 2.1.11__tar.gz

loqedapi-2.1.11/PKG-INFO

@@ -0,0 +1,110 @@
+Metadata-Version: 2.4
+Name: loqedAPI
+Version: 2.1.11
+Summary: Python package to use the Loqed Smart Door Lock APIs in a local network. To be used by Home Assistant.
+Home-page: https://github.com/cpolhout/loqedAPI
+Author: Casper Polhout
+Author-email: cpolhout@gmail.com
+License: BSD 2-clause
+Project-URL: Bug Tracker, https://github.com/cpolhout/loqedAPI/issues
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp
+Requires-Dist: async-timeout
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: aioresponses; extra == "dev"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: summary
+
+# Loqed Touch Smart Lock — Python client
+
+This repository provides a small async-first Python client for the Loqed Touch smart lock. It wraps [the HTTP API used by Loqed devices](https://support.loqed.com/en/articles/6127856-loqed-local-bridge-api-integration) and exposes convenient helpers to read lock state, send lock/unlock commands, and manage webhooks.
+
+## Quick start
+
+1. Install the package (recommended: in a virtualenv):
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+pip install -e .
+```
+
+2. Install dev/test dependencies (optional):
+
+```bash
+pip install -e .[dev]
+```
+
+3. Use the client (async):
+
+```python
+import asyncio
+from loqedAPI.loqed import APIClient, LoqedAPI
+
+async def main():
+	client = APIClient(base_url="https://api.loqed.com", token="your-api-token")
+	api = LoqedAPI(client)
+
+	# fetch a lock by id
+	lock = await api.async_get_lock("lock-id")
+	print("state:", lock.bolt_state)
+
+	# send an unlock command
+	await lock.unlock()
+
+asyncio.run(main())
+```
+
+Notes:
+
+- The library is async-first and uses `aiohttp` for HTTP calls.
+- `APIClient` accepts `base_url` and an optional `token` (for authorization) or you can provide your own `aiohttp.ClientSession`.
+
+## Testing
+
+Run the test suite with pytest (the project uses `pytest-asyncio` and `aioresponses`):
+
+```bash
+source .venv/bin/activate
+pytest --cov=src/loqedAPI --cov-report=term-missing
+```
+
+## Development
+
+- The package follows standard Python packaging with `pyproject.toml`/`setup.py`.
+- Dev/test dependencies are available under the `dev` extra: `pip install -e .[dev]`.
+- When editing code, run the tests frequently. The tests are fast and designed to mock network calls.
+
+## Contributing
+
+If you want to contribute:
+
+1. Fork the repo, create a branch, and make your changes.
+2. Add or update tests for new behavior.
+3. Run the test suite and ensure all tests pass.
+4. Open a pull request with a short description of the change.
+
+## Where to find docs
+
+- Source code is under `src/loqedAPI`.
+- Sphinx documentation lives in `docs/`.
+
+## License
+
+See the `LICENSE` file in the project root.

loqedapi-2.1.11/README.md

@@ -0,0 +1,77 @@
+# Loqed Touch Smart Lock — Python client
+
+This repository provides a small async-first Python client for the Loqed Touch smart lock. It wraps [the HTTP API used by Loqed devices](https://support.loqed.com/en/articles/6127856-loqed-local-bridge-api-integration) and exposes convenient helpers to read lock state, send lock/unlock commands, and manage webhooks.
+
+## Quick start
+
+1. Install the package (recommended: in a virtualenv):
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+pip install -e .
+```
+
+2. Install dev/test dependencies (optional):
+
+```bash
+pip install -e .[dev]
+```
+
+3. Use the client (async):
+
+```python
+import asyncio
+from loqedAPI.loqed import APIClient, LoqedAPI
+
+async def main():
+	client = APIClient(base_url="https://api.loqed.com", token="your-api-token")
+	api = LoqedAPI(client)
+
+	# fetch a lock by id
+	lock = await api.async_get_lock("lock-id")
+	print("state:", lock.bolt_state)
+
+	# send an unlock command
+	await lock.unlock()
+
+asyncio.run(main())
+```
+
+Notes:
+
+- The library is async-first and uses `aiohttp` for HTTP calls.
+- `APIClient` accepts `base_url` and an optional `token` (for authorization) or you can provide your own `aiohttp.ClientSession`.
+
+## Testing
+
+Run the test suite with pytest (the project uses `pytest-asyncio` and `aioresponses`):
+
+```bash
+source .venv/bin/activate
+pytest --cov=src/loqedAPI --cov-report=term-missing
+```
+
+## Development
+
+- The package follows standard Python packaging with `pyproject.toml`/`setup.py`.
+- Dev/test dependencies are available under the `dev` extra: `pip install -e .[dev]`.
+- When editing code, run the tests frequently. The tests are fast and designed to mock network calls.
+
+## Contributing
+
+If you want to contribute:
+
+1. Fork the repo, create a branch, and make your changes.
+2. Add or update tests for new behavior.
+3. Run the test suite and ensure all tests pass.
+4. Open a pull request with a short description of the change.
+
+## Where to find docs
+
+- Source code is under `src/loqedAPI`.
+- Sphinx documentation lives in `docs/`.
+
+## License
+
+See the `LICENSE` file in the project root.

{loqedAPI-2.1.10 → loqedapi-2.1.11}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = loqedAPI
-version = 2.1.10
+version = 2.1.11
 author = Casper Polhout
 author_email = cpolhout@gmail.com
 description = Python package to use the Loqed Smart Door Lock APIs in a local network. To be used by Home Assistant.

{loqedAPI-2.1.10 → loqedapi-2.1.11}/setup.py

@@ -2,23 +2,29 @@ from setuptools import find_packages, setup
 
 setup(
     name="loqedAPI",
-    version="2.1.10",
+    version="2.1.11",
     description="Python package to use the Loqed Smart Door Lock APIs in a local network. To be used by Home Assistant.",
     url="https://github.com/cpolhout/loqedAPI",
     author="Casper Polhout",
     author_email="cpolhout@gmail.com",
     license="BSD 2-clause",
     packages=find_packages(exclude=["tests", "generator"]),
-    install_requires=["aiohttp", "async-timeout"],
+    install_requires=[
+        "aiohttp",
+        "async-timeout",
+    ],
+    extras_require={
+        "dev": [
+            "pytest",
+            "pytest-asyncio",
+            "pytest-cov",
+            "aioresponses",
+        ]
+    },
     classifiers=[
-        "Development Status :: 1 - Planning",
-        "Intended Audience :: Science/Research",
+        "Development Status :: 4 - Beta",
+        "Intended Audience :: Developers",
         "License :: OSI Approved :: BSD License",
-        "Operating System :: POSIX :: Linux",
-        "Programming Language :: Python :: 2",
-        "Programming Language :: Python :: 2.7",
         "Programming Language :: Python :: 3",
-        "Programming Language :: Python :: 3.4",
-        "Programming Language :: Python :: 3.5",
     ],
 )

{loqedAPI-2.1.10 → loqedapi-2.1.11}/src/loqedAPI/loqed.py

@@ -90,22 +90,22 @@ class Lock:
 
     @property
     def battery_voltage(self) -> str:
-        """Return the ID of the lock."""
+        """Return the battery voltage of the lock."""
         return self.raw_data["battery_voltage"]
 
     @property
     def wifi_strength(self) -> str:
-        """Return the ID of the lock."""
+        """Return the Wifi strength of the lock."""
         return self.raw_data["wifi_strength"]
 
     @property
     def ble_strength(self) -> str:
-        """Return the ID of the lock."""
+        """Return the BLE strength of the lock."""
         return self.raw_data["ble_strength"]
 
     @property
     def battery_type(self) -> str:
-        """Return the name of the lock."""
+        """Return the battery type of the lock."""
         return self.raw_data["battery_type"]
 
     def getcommand(self, action: Action) -> str:
@@ -166,7 +166,7 @@ class Lock:
         "Update status"
         resp = await self.apiclient.request("get", "status")
         resp.raise_for_status()
-        json_data = await resp.json(content_type="text/html")
+        json_data = await resp.json(content_type=None)
         self.raw_data = json_data
         self.bolt_state = self.raw_data["bolt_state"]
         return json_data
@@ -180,7 +180,7 @@ class Lock:
         headers = {"TIMESTAMP": str(now), "HASH": hash}
         resp = await self.apiclient.request("get", f"webhooks", headers=headers)
         resp.raise_for_status()
-        json_data = await resp.json(content_type="text/html")
+        json_data = await resp.json(content_type=None)
         _LOGGER.debug("get Webhooks Response: %s", str(json_data))
         self.webhooks = {}
         return json_data
@@ -322,7 +322,7 @@ class LoqedAPI:
         resp = await self.apiclient.request("get", "status")
         resp.raise_for_status()
         _LOGGER.debug("Response get lock details: %s", await resp.text())
-        json_data = await resp.json(content_type="text/html")
+        json_data = await resp.json(content_type=None)
         return json_data
 
     async def async_get_lock(
@@ -331,7 +331,7 @@ class LoqedAPI:
         """Return the locks with lock-data"""
         if not json_data:
             resp = await self.apiclient.request("get", "status")
-            json_data = await resp.json(content_type="text/html")
+            json_data = await resp.json(content_type=None)
         return Lock(json_data, secret, bridgekey, key_id, name, self.apiclient)
 
 

loqedapi-2.1.11/src/loqedAPI.egg-info/PKG-INFO

@@ -0,0 +1,110 @@
+Metadata-Version: 2.4
+Name: loqedAPI
+Version: 2.1.11
+Summary: Python package to use the Loqed Smart Door Lock APIs in a local network. To be used by Home Assistant.
+Home-page: https://github.com/cpolhout/loqedAPI
+Author: Casper Polhout
+Author-email: cpolhout@gmail.com
+License: BSD 2-clause
+Project-URL: Bug Tracker, https://github.com/cpolhout/loqedAPI/issues
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp
+Requires-Dist: async-timeout
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: aioresponses; extra == "dev"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: summary
+
+# Loqed Touch Smart Lock — Python client
+
+This repository provides a small async-first Python client for the Loqed Touch smart lock. It wraps [the HTTP API used by Loqed devices](https://support.loqed.com/en/articles/6127856-loqed-local-bridge-api-integration) and exposes convenient helpers to read lock state, send lock/unlock commands, and manage webhooks.
+
+## Quick start
+
+1. Install the package (recommended: in a virtualenv):
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+pip install -e .
+```
+
+2. Install dev/test dependencies (optional):
+
+```bash
+pip install -e .[dev]
+```
+
+3. Use the client (async):
+
+```python
+import asyncio
+from loqedAPI.loqed import APIClient, LoqedAPI
+
+async def main():
+	client = APIClient(base_url="https://api.loqed.com", token="your-api-token")
+	api = LoqedAPI(client)
+
+	# fetch a lock by id
+	lock = await api.async_get_lock("lock-id")
+	print("state:", lock.bolt_state)
+
+	# send an unlock command
+	await lock.unlock()
+
+asyncio.run(main())
+```
+
+Notes:
+
+- The library is async-first and uses `aiohttp` for HTTP calls.
+- `APIClient` accepts `base_url` and an optional `token` (for authorization) or you can provide your own `aiohttp.ClientSession`.
+
+## Testing
+
+Run the test suite with pytest (the project uses `pytest-asyncio` and `aioresponses`):
+
+```bash
+source .venv/bin/activate
+pytest --cov=src/loqedAPI --cov-report=term-missing
+```
+
+## Development
+
+- The package follows standard Python packaging with `pyproject.toml`/`setup.py`.
+- Dev/test dependencies are available under the `dev` extra: `pip install -e .[dev]`.
+- When editing code, run the tests frequently. The tests are fast and designed to mock network calls.
+
+## Contributing
+
+If you want to contribute:
+
+1. Fork the repo, create a branch, and make your changes.
+2. Add or update tests for new behavior.
+3. Run the test suite and ensure all tests pass.
+4. Open a pull request with a short description of the change.
+
+## Where to find docs
+
+- Source code is under `src/loqedAPI`.
+- Sphinx documentation lives in `docs/`.
+
+## License
+
+See the `LICENSE` file in the project root.

{loqedAPI-2.1.10 → loqedapi-2.1.11}/src/loqedAPI.egg-info/SOURCES.txt

@@ -15,4 +15,7 @@ src/loqedAPI.egg-info/SOURCES.txt
 src/loqedAPI.egg-info/dependency_links.txt
 src/loqedAPI.egg-info/requires.txt
 src/loqedAPI.egg-info/top_level.txt
-tests/test.py
+tests/test.py
+tests/test_cloud_loqed.py
+tests/test_local_loqed.py
+tests/test_loqed.py

loqedapi-2.1.11/src/loqedAPI.egg-info/requires.txt

@@ -0,0 +1,8 @@
+aiohttp
+async-timeout
+
+[dev]
+pytest
+pytest-asyncio
+pytest-cov
+aioresponses

loqedapi-2.1.11/tests/test_cloud_loqed.py

@@ -0,0 +1,18 @@
+
+import pytest
+from aioresponses import aioresponses
+import aiohttp
+from loqedAPI.cloud_loqed import LoqedCloudAPI, CloudAPIClient, CLOUD_BASE_URL
+
+@pytest.mark.asyncio
+async def test_loqedcloudapi_get_locks():
+    with aioresponses() as m:
+        url = f"{CLOUD_BASE_URL}/api/locks/"
+        m.get(url, payload={"data": [{"id": "cloudlock1", "name": "Cloud Door"}]}, status=200)
+        async with aiohttp.ClientSession() as session:
+            client = CloudAPIClient(session, token="dummy-token")
+            api = LoqedCloudAPI(client)
+            locks = await api.async_get_locks()
+            assert "data" in locks
+            assert locks["data"][0]["id"] == "cloudlock1"
+            assert locks["data"][0]["name"] == "Cloud Door"

loqedapi-2.1.11/tests/test_local_loqed.py

@@ -0,0 +1,60 @@
+import pytest
+from loqedAPI.local_loqed import Lock, APIClient, LoqedAPI
+from loqedAPI.exceptions import LoqedException, LoqedAuthenticationException
+
+class DummyAPIClient(APIClient):
+    def __init__(self):
+        pass
+    async def request(self, method, url, **kwargs):
+        class DummyResponse:
+            async def json(self):
+                return {"data": [{"id": "lock1", "name": "Front Door", "bolt_state": "locked", "battery_percentage": 80, "battery_type": "AA", "party_mode": False, "guest_access_mode": False, "twist_assist": True, "touch_to_connect": True, "lock_direction": "left", "mortise_lock_type": "euro", "supported_lock_states": "locked"}]}
+            async def text(self):
+                return "OK"
+            def raise_for_status(self):
+                pass
+        return DummyResponse()
+
+@pytest.mark.asyncio
+async def test_lock_properties():
+    raw_data = {
+        "id": "lock1",
+        "name": "Front Door",
+        "bolt_state": "locked",
+        "battery_percentage": 80,
+        "battery_type": "AA",
+        "party_mode": False,
+        "guest_access_mode": False,
+        "twist_assist": True,
+        "touch_to_connect": True,
+        "lock_direction": "left",
+        "mortise_lock_type": "euro",
+        "supported_lock_states": "locked"
+    }
+    lock = Lock(raw_data, DummyAPIClient())
+    assert lock.id == "lock1"
+    assert lock.name == "Front Door"
+    assert lock.battery_percentage == 80
+    assert lock.battery_type == "AA"
+    assert lock.party_mode is False
+    assert lock.guest_access_mode is False
+    assert lock.twist_assist is True
+    assert lock.touch_to_connect is True
+    assert lock.lock_direction == "left"
+    assert lock.mortise_lock_type == "euro"
+    assert lock.supported_lock_states == "locked"
+
+@pytest.mark.asyncio
+async def test_loqedapi_get_locks():
+    api = LoqedAPI(DummyAPIClient())
+    locks = await api.async_get_locks()
+    assert len(locks) == 1
+    assert locks[0].name == "Front Door"
+    assert locks[0].id == "lock1"
+
+# Exception tests
+def test_exceptions():
+    with pytest.raises(LoqedException):
+        raise LoqedException("Test exception")
+    with pytest.raises(LoqedAuthenticationException):
+        raise LoqedAuthenticationException("Auth exception")

loqedapi-2.1.11/tests/test_loqed.py

@@ -0,0 +1,286 @@
+import pytest
+import pytest_asyncio
+from aioresponses import aioresponses
+import aiohttp
+import base64
+import time
+import hashlib
+import re
+import types
+from loqedAPI.loqed import Lock, LoqedAPI, APIClient, Action
+
+# ---------------------------------------------------------------------------
+# Fixtures
+# ---------------------------------------------------------------------------
+
+@pytest.fixture
+def valid_base64():
+    # 44 chars -> 33 bytes when decoded; sufficient for HMAC key
+    return "U2VjcmV0U2VjcmV0U2VjcmV0U2VjcmV0U2VjcmV0U2VjcmU="
+
+@pytest.fixture
+def raw_data():
+    return {
+        "bolt_state": "locked",
+        "battery_percentage": 90,
+        "battery_type": "AA",
+        "bridge_mac_wifi": "lockid",
+        "wifi_strength": "good",
+        "ble_strength": "strong",
+        "battery_voltage": "3.7",
+    }
+
+@pytest_asyncio.fixture
+async def aiohttp_session():
+    async with aiohttp.ClientSession() as session:
+        yield session
+
+@pytest.fixture
+def base_url():
+    return "http://dummy"
+
+@pytest.fixture
+def client(aiohttp_session, base_url):
+    return APIClient(aiohttp_session, base_url)
+
+@pytest.fixture
+def lock(raw_data, valid_base64, client):
+    return Lock(raw_data.copy(), valid_base64, valid_base64, 1, "TestLock", client)
+
+
+# Helper to compute webhook hash
+def compute_webhook_hash(body: str, timestamp: int, bridgekey_b64: str) -> str:
+    return hashlib.sha256(
+        body.encode() + timestamp.to_bytes(8, "big", signed=False) + base64.b64decode(bridgekey_b64)
+    ).hexdigest()
+
+
+# ---------------------------------------------------------------------------
+# Command & property tests
+# ---------------------------------------------------------------------------
+@pytest.mark.asyncio
+async def test_lock_properties_and_commands(lock):
+    # Monkeypatch underlying apiclient.request to avoid complex URL matching
+    class DummyResp:
+        status = 200
+        async def text(self):
+            return "OK"
+        def raise_for_status(self):
+            return None
+    async def fake_request(self, method, url, **kwargs):
+        return DummyResp()
+    lock.apiclient.request = types.MethodType(fake_request, lock.apiclient)
+    for action in (lock.open, lock.lock, lock.unlock):
+        resp = await action()
+        assert await resp.text() == "OK"
+    assert lock.bolt_state == "locked"
+    assert lock.battery_percentage == 90
+    assert lock.battery_type == "AA"
+    assert lock.id == "lockid"
+    assert lock.wifi_strength == "good"
+    assert lock.ble_strength == "strong"
+
+
+@pytest.mark.asyncio
+async def test_loqedapi_get_lock(valid_base64, raw_data, client):
+    api = LoqedAPI(client)
+    with aioresponses() as m:
+        m.get(f"{client.host}/status", payload=raw_data, status=200, headers={"Content-Type": "text/html"})
+        lock = await api.async_get_lock(valid_base64, valid_base64, 1, "TestLock")
+    assert lock.name == "TestLock"
+    assert lock.id == "lockid"
+    assert lock.bolt_state == "locked"
+
+
+@pytest.mark.asyncio
+async def test_async_get_lock_details(client, raw_data):
+    """LoqedAPI.async_get_lock_details should return the parsed JSON from /status"""
+    api = LoqedAPI(client)
+    with aioresponses() as m:
+        m.get(f"{client.host}/status", payload=raw_data, status=200, headers={"Content-Type": "text/html"})
+        result = await api.async_get_lock_details()
+    assert result == raw_data
+
+
+# ---------------------------------------------------------------------------
+# receiveWebhook tests (no network activity required)
+# ---------------------------------------------------------------------------
+@pytest.mark.asyncio
+async def test_lock_receive_webhook_state_update(lock, valid_base64):
+    body = '{"battery_percentage": 80, "key_local_id": 1, "event_type": "STATE_CHANGED_NIGHT_LOCK"}'
+    timestamp = int(time.time())
+    hash_val = compute_webhook_hash(body, timestamp, valid_base64)
+    await lock.receiveWebhook(body, hash_val, str(timestamp))
+    assert lock.battery_percentage == 80
+
+
+@pytest.mark.asyncio
+async def test_lock_receive_webhook_invalid_hash(lock):
+    body = '{"battery_percentage": 80, "key_local_id": 1, "event_type": "STATE_CHANGED_NIGHT_LOCK"}'
+    timestamp = str(int(time.time()))
+    bad_hash = "deadbeef" * 8
+    result = await lock.receiveWebhook(body, bad_hash, timestamp)
+    assert result["error"] == "Hash incorrect"
+
+
+@pytest.mark.asyncio
+async def test_lock_receive_webhook_invalid_timestamp(lock, valid_base64):
+    body = '{"battery_percentage": 80, "key_local_id": 1, "event_type": "STATE_CHANGED_NIGHT_LOCK"}'
+    old_timestamp = int(time.time()) - 1000
+    hash_val = compute_webhook_hash(body, old_timestamp, valid_base64)
+    result = await lock.receiveWebhook(body, hash_val, str(old_timestamp))
+    assert result["error"] == "Timestamp incorrect, possible replaying"
+
+
+@pytest.mark.asyncio
+async def test_receive_webhook_empty_body(lock, valid_base64):
+    timestamp = int(time.time())
+    hash_val = compute_webhook_hash("", timestamp, valid_base64)
+    result = await lock.receiveWebhook("", hash_val, str(timestamp))
+    assert result["error"].startswith("Received invalid data from LOQED. Data needs to be formatted as JSON")
+
+
+@pytest.mark.asyncio
+async def test_receive_webhook_non_dict(lock, valid_base64):
+    body = '"notadict"'
+    timestamp = int(time.time())
+    hash_val = compute_webhook_hash(body, timestamp, valid_base64)
+    result = await lock.receiveWebhook(body, hash_val, str(timestamp))
+    assert result["error"].endswith("be a dictionary")
+
+
+@pytest.mark.asyncio
+async def test_receive_webhook_unknown_event(lock, valid_base64):
+    body = '{"key_local_id": 1, "event_type": "UNKNOWN_EVENT"}'
+    timestamp = int(time.time())
+    hash_val = compute_webhook_hash(body, timestamp, valid_base64)
+    await lock.receiveWebhook(body, hash_val, str(timestamp))
+    assert lock.last_event == "unknown_event"
+
+
+@pytest.mark.asyncio
+async def test_receive_webhook_ble_strength(lock, valid_base64):
+    body = '{"ble_strength": "weak", "key_local_id": 2, "event_type": "STATE_CHANGED_LATCH"}'
+    timestamp = int(time.time())
+    hash_val = compute_webhook_hash(body, timestamp, valid_base64)
+    await lock.receiveWebhook(body, hash_val, str(timestamp))
+    assert lock.raw_data["ble_strength"] == "weak"
+
+
+@pytest.mark.asyncio
+async def test_receive_webhook_bolt_state_change(lock, valid_base64):
+    body = '{"key_local_id": 3, "event_type": "STATE_CHANGED_NIGHT_LOCK"}'
+    timestamp = int(time.time())
+    hash_val = compute_webhook_hash(body, timestamp, valid_base64)
+    lock.bolt_state = "unlocked"
+    await lock.receiveWebhook(body, hash_val, str(timestamp))
+    assert lock.bolt_state == "night_lock"
+    assert lock.last_event == "state_changed_night_lock"
+    assert lock.last_key_id == 3
+
+
+@pytest.mark.asyncio
+async def test_receive_webhook_goto_state_night_lock(lock, valid_base64):
+    body = '{"key_local_id": 4, "event_type": "GOTO_STATE_NIGHT_LOCK"}'
+    timestamp = int(time.time())
+    hash_val = compute_webhook_hash(body, timestamp, valid_base64)
+    lock.bolt_state = "unlocked"
+    await lock.receiveWebhook(body, hash_val, str(timestamp))
+    assert lock.bolt_state == "locking"
+    assert lock.last_event == "goto_state_night_lock"
+    assert lock.last_key_id == 4
+
+
+@pytest.mark.asyncio
+async def test_receive_webhook_goto_state_open(lock, valid_base64):
+    body = '{"key_local_id": 5, "event_type": "GOTO_STATE_OPEN"}'
+    timestamp = int(time.time())
+    hash_val = compute_webhook_hash(body, timestamp, valid_base64)
+    lock.bolt_state = "locked"
+    await lock.receiveWebhook(body, hash_val, str(timestamp))
+    assert lock.bolt_state == "opening"
+    assert lock.last_event == "goto_state_open"
+    assert lock.last_key_id == 5
+
+
+@pytest.mark.asyncio
+async def test_receive_webhook_goto_state_latch(lock, valid_base64):
+    body = '{"key_local_id": 6, "event_type": "GOTO_STATE_LATCH"}'
+    timestamp = int(time.time())
+    hash_val = compute_webhook_hash(body, timestamp, valid_base64)
+    lock.bolt_state = "locked"
+    await lock.receiveWebhook(body, hash_val, str(timestamp))
+    assert lock.bolt_state == "unlocking"
+    assert lock.last_event == "goto_state_latch"
+    assert lock.last_key_id == 6
+
+
+# ---------------------------------------------------------------------------
+# Update & webhook management (network interactions via aioresponses)
+# ---------------------------------------------------------------------------
+@pytest.mark.asyncio
+async def test_update(lock, raw_data):
+    with aioresponses() as m:
+        raw_data_updated = raw_data.copy()
+        raw_data_updated["bolt_state"] = "locked"  # unchanged but explicit
+        m.get(f"{lock.apiclient.host}/status", payload=raw_data_updated, status=200, headers={"Content-Type": "text/html"})
+        result = await lock.update()
+    assert result["bolt_state"] == "locked"
+    assert lock.bolt_state == "locked"
+
+
+@pytest.mark.asyncio
+async def test_get_webhooks(lock):
+    with aioresponses() as m:
+        m.get(f"{lock.apiclient.host}/webhooks", payload=[{"url": "http://test.com"}], status=200, headers={"Content-Type": "text/html"})
+        webhooks = await lock.getWebhooks()
+    assert isinstance(webhooks, list)
+    assert webhooks[0]["url"] == "http://test.com"
+
+
+@pytest.mark.asyncio
+async def test_register_webhook_created(lock):
+    with aioresponses() as m:
+        # First call returns no webhooks -> triggers creation
+        m.get(f"{lock.apiclient.host}/webhooks", payload=[], status=200, headers={"Content-Type": "text/html"})
+        m.post(f"{lock.apiclient.host}/webhooks", payload={}, status=200)
+        result = await lock.registerWebhook("http://newwebhook.com")
+    assert result == "CREATED"
+
+
+@pytest.mark.asyncio
+async def test_register_webhook_exists_already(lock):
+    with aioresponses() as m:
+        m.get(f"{lock.apiclient.host}/webhooks", payload=[{"url": "http://test.com"}], status=200, headers={"Content-Type": "text/html"})
+        result = await lock.registerWebhook("http://test.com")
+    assert result == "EXISTS ALREADY"
+
+
+@pytest.mark.asyncio
+async def test_delete_webhook(lock):
+    with aioresponses() as m:
+        m.delete(re.compile(rf"{re.escape(lock.apiclient.host)}/webhooks/\d+"), status=200, body="OK")
+        await lock.deleteWebhook(123)
+
+
+@pytest.mark.asyncio
+async def test_update_state(lock):
+    await lock.updateState("unlocked")
+    assert lock.bolt_state == "unlocked"
+
+
+# ---------------------------------------------------------------------------
+# Additional: ensure command URL signature changes each call (basic sanity)
+# ---------------------------------------------------------------------------
+@pytest.mark.asyncio
+async def test_command_signature_varies(lock, base_url):
+    with aioresponses() as m:
+        pattern = re.compile(rf"{re.escape(base_url)}/to_lock\?command_signed_base64=.*")
+        m.get(pattern, status=200, body="OK")
+        cmd1 = lock.getcommand(Action.OPEN)
+        time.sleep(1)
+        cmd2 = lock.getcommand(Action.OPEN)
+        assert cmd1 != cmd2  # timestamp included makes them different
+        # Execute one to ensure mocked endpoint matches
+        await lock.open()
+

loqedAPI-2.1.10/PKG-INFO

@@ -1,25 +0,0 @@
-Metadata-Version: 2.1
-Name: loqedAPI
-Version: 2.1.10
-Summary: Python package to use the Loqed Smart Door Lock APIs in a local network. To be used by Home Assistant.
-Home-page: https://github.com/cpolhout/loqedAPI
-Author: Casper Polhout
-Author-email: cpolhout@gmail.com
-License: BSD 2-clause
-Project-URL: Bug Tracker, https://github.com/cpolhout/loqedAPI/issues
-Classifier: Development Status :: 1 - Planning
-Classifier: Intended Audience :: Science/Research
-Classifier: License :: OSI Approved :: BSD License
-Classifier: Operating System :: POSIX :: Linux
-Classifier: Programming Language :: Python :: 2
-Classifier: Programming Language :: Python :: 2.7
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.4
-Classifier: Programming Language :: Python :: 3.5
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: aiohttp
-Requires-Dist: async-timeout
-
-# Loqed Touch Smart Lock Python library

loqedAPI-2.1.10/README.md

@@ -1 +0,0 @@
-# Loqed Touch Smart Lock Python library

loqedAPI-2.1.10/src/loqedAPI.egg-info/PKG-INFO

@@ -1,25 +0,0 @@
-Metadata-Version: 2.1
-Name: loqedAPI
-Version: 2.1.10
-Summary: Python package to use the Loqed Smart Door Lock APIs in a local network. To be used by Home Assistant.
-Home-page: https://github.com/cpolhout/loqedAPI
-Author: Casper Polhout
-Author-email: cpolhout@gmail.com
-License: BSD 2-clause
-Project-URL: Bug Tracker, https://github.com/cpolhout/loqedAPI/issues
-Classifier: Development Status :: 1 - Planning
-Classifier: Intended Audience :: Science/Research
-Classifier: License :: OSI Approved :: BSD License
-Classifier: Operating System :: POSIX :: Linux
-Classifier: Programming Language :: Python :: 2
-Classifier: Programming Language :: Python :: 2.7
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.4
-Classifier: Programming Language :: Python :: 3.5
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: aiohttp
-Requires-Dist: async-timeout
-
-# Loqed Touch Smart Lock Python library

loqedAPI-2.1.10/src/loqedAPI.egg-info/requires.txt

@@ -1,2 +0,0 @@
-aiohttp
-async-timeout