nuki-web-api 0.1.0__tar.gz

nuki_web_api-0.1.0/PKG-INFO

@@ -0,0 +1,34 @@
+Metadata-Version: 2.4
+Name: nuki-web-api
+Version: 0.1.0
+Summary: A Python wrapper for the Nuki Web API
+Author-email: barghest89 <blachosf@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/barghest89/nuki-web-api
+Project-URL: Bug Tracker, https://github.com/barghest89/nuki-web-api/issues
+Keywords: nuki,api,smartlock
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3.11
+Description-Content-Type: text/markdown
+Requires-Dist: requests==2.32.5
+
+# nukiwebapi
+
+A Python wrapper for the [Nuki Web API](https://developer.nuki.io/).
+
+## Installation
+
+```bash
+pip install nukiwebapi
+```
+
+## Usage
+```Python
+from nukiwebapi import NukiWebAPI
+
+client = NukiWebAPI("YOUR_ACCESS_TOKEN")
+
+for lock_id, lock in client.smartlocks():
+    print(lock_id, lock.name)
+    lock.unlock()
+```

nuki_web_api-0.1.0/README.md

@@ -0,0 +1,20 @@
+# nukiwebapi
+
+A Python wrapper for the [Nuki Web API](https://developer.nuki.io/).
+
+## Installation
+
+```bash
+pip install nukiwebapi
+```
+
+## Usage
+```Python
+from nukiwebapi import NukiWebAPI
+
+client = NukiWebAPI("YOUR_ACCESS_TOKEN")
+
+for lock_id, lock in client.smartlocks():
+    print(lock_id, lock.name)
+    lock.unlock()
+```

nuki_web_api-0.1.0/nuki_web_api.egg-info/PKG-INFO

@@ -0,0 +1,34 @@
+Metadata-Version: 2.4
+Name: nuki-web-api
+Version: 0.1.0
+Summary: A Python wrapper for the Nuki Web API
+Author-email: barghest89 <blachosf@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/barghest89/nuki-web-api
+Project-URL: Bug Tracker, https://github.com/barghest89/nuki-web-api/issues
+Keywords: nuki,api,smartlock
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3.11
+Description-Content-Type: text/markdown
+Requires-Dist: requests==2.32.5
+
+# nukiwebapi
+
+A Python wrapper for the [Nuki Web API](https://developer.nuki.io/).
+
+## Installation
+
+```bash
+pip install nukiwebapi
+```
+
+## Usage
+```Python
+from nukiwebapi import NukiWebAPI
+
+client = NukiWebAPI("YOUR_ACCESS_TOKEN")
+
+for lock_id, lock in client.smartlocks():
+    print(lock_id, lock.name)
+    lock.unlock()
+```

nuki_web_api-0.1.0/nuki_web_api.egg-info/SOURCES.txt

@@ -0,0 +1,23 @@
+README.md
+pyproject.toml
+nuki_web_api.egg-info/PKG-INFO
+nuki_web_api.egg-info/SOURCES.txt
+nuki_web_api.egg-info/dependency_links.txt
+nuki_web_api.egg-info/requires.txt
+nuki_web_api.egg-info/top_level.txt
+nukiwebapi/__init__.py
+nukiwebapi/account.py
+nukiwebapi/account_user.py
+nukiwebapi/address.py
+nukiwebapi/address_reservation.py
+nukiwebapi/address_token.py
+nukiwebapi/advanced_api.py
+nukiwebapi/api_key.py
+nukiwebapi/company.py
+nukiwebapi/notification.py
+nukiwebapi/nuki_web_api.py
+nukiwebapi/opener.py
+nukiwebapi/service.py
+nukiwebapi/smartlock.py
+nukiwebapi/smartlock_auth.py
+nukiwebapi/smartlock_log.py

nuki_web_api-0.1.0/nuki_web_api.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

nuki_web_api-0.1.0/nuki_web_api.egg-info/requires.txt

@@ -0,0 +1 @@
+requests==2.32.5

nuki_web_api-0.1.0/nuki_web_api.egg-info/top_level.txt

@@ -0,0 +1 @@
+nukiwebapi

nuki_web_api-0.1.0/nukiwebapi/__init__.py

@@ -0,0 +1,3 @@
+from .nuki_web_api import NukiWebAPI
+
+__all__ = ["NukiWebAPI"]

nuki_web_api-0.1.0/nukiwebapi/account.py

@@ -0,0 +1,84 @@
+# ---------------------------
+# Account sub-class
+# ---------------------------
+from typing import Any, Dict
+
+class Account:
+    def __init__(self, client):
+        self.client = client  # reference to the parent NukiClient
+
+    # GET /account
+    def get(self) -> Dict[str, Any]:
+        return self.client._request("GET", "/account")
+
+    # POST /account
+    def update(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        return self.client._request("POST", "/account", json=data)
+
+    # DELETE /account
+    def delete(self) -> Dict[str, Any]:
+        return self.client._request("DELETE", "/account")
+
+    # POST /account/email/change
+    def change_email(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        return self.client._request("POST", "/account/email/change", json=data)
+
+    # POST /account/email/verify
+    def verify_email(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        return self.client._request("POST", "/account/email/verify", json=data)
+
+    # GET /account/integration
+    def list_integrations(self) -> Dict[str, Any]:
+        return self.client._request("GET", "/account/integration")
+
+    # DELETE /account/integration
+    def delete_integration(self, integration_id: str) -> Dict[str, Any]:
+        return self.client._request("DELETE", "/account/integration", json={"id": integration_id})
+
+    # POST /account/otp
+    def enable_otp(self) -> Dict[str, Any]:
+        return self.client._request("POST", "/account/otp")
+
+    # PUT /account/otp
+    def create_otp(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        return self.client._request("PUT", "/account/otp", json=data)
+
+    # DELETE /account/otp
+    def disable_otp(self) -> Dict[str, Any]:
+        return self.client._request("DELETE", "/account/otp")
+
+    # POST /account/password/reset
+    def reset_password(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        return self.client._request("POST", "/account/password/reset", json=data)
+
+    # GET /account/setting
+    def get_setting(self) -> Dict[str, Any]:
+        return self.client._request("GET", "/account/setting")
+
+    # PUT /account/setting
+    def update_setting(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        return self.client._request("PUT", "/account/setting", json=data)
+
+    # DELETE /account/setting
+    def delete_setting(self, key: str) -> Dict[str, Any]:
+        return self.client._request("DELETE", "/account/setting", json={"key": key})
+
+    # GET /account/sub
+    def list_sub_accounts(self) -> Dict[str, Any]:
+        return self.client._request("GET", "/account/sub")
+
+    # PUT /account/sub
+    def create_sub_account(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        return self.client._request("PUT", "/account/sub", json=data)
+
+    # GET /account/sub/{accountId}
+    def get_sub_account(self, account_id: str) -> Dict[str, Any]:
+        return self.client._request("GET", f"/account/sub/{account_id}")
+
+    # POST /account/sub/{accountId}
+    def update_sub_account(self, account_id: str, data: Dict[str, Any]) -> Dict[str, Any]:
+        return self.client._request("POST", f"/account/sub/{account_id}", json=data)
+
+    # DELETE /account/sub/{accountId}
+    def delete_sub_account(self, account_id: str) -> Dict[str, Any]:
+        return self.client._request("DELETE", f"/account/sub/{account_id}")

nuki_web_api-0.1.0/nukiwebapi/account_user.py

@@ -0,0 +1,20 @@
+class AccountUser:
+    """Sub-client for managing account users."""
+
+    def __init__(self, client):
+        self.client = client
+
+    def list_account_users(self):
+        return self.client._request("GET", "/account/user")
+
+    def create_account_user(self, user_data):
+        return self.client._request("PUT", "/account/user", json=user_data)
+
+    def get_account_user(self, account_user_id):
+        return self.client._request("GET", f"/account/user/{account_user_id}")
+
+    def update_account_user(self, account_user_id, user_data):
+        return self.client._request("POST", f"/account/user/{account_user_id}", json=user_data)
+
+    def delete_account_user(self, account_user_id):
+        return self.client._request("DELETE", f"/account/user/{account_user_id}")

nuki_web_api-0.1.0/nukiwebapi/address.py

@@ -0,0 +1,31 @@
+class Address:
+    """Sub-client for managing addresses and address units."""
+
+    def __init__(self, client):
+        self.client = client
+
+    # ---- Address CRUD ----
+    def list_addresses(self):
+        return self.client._request("GET", "/address")
+
+    def create_address(self, address_data):
+        return self.client._request("PUT", "/address", json=address_data)
+
+    def update_address(self, address_id, address_data):
+        return self.client._request("POST", f"/address/{address_id}", json=address_data)
+
+    def delete_address(self, address_id):
+        return self.client._request("DELETE", f"/address/{address_id}")
+
+    # ---- Address Units ----
+    def list_address_units(self, address_id):
+        return self.client._request("GET", f"/address/{address_id}/unit")
+
+    def create_address_unit(self, address_id, unit_data):
+        return self.client._request("PUT", f"/address/{address_id}/unit", json=unit_data)
+
+    def delete_address_units(self, address_id):
+        return self.client._request("DELETE", f"/address/{address_id}/unit")
+
+    def delete_address_unit(self, address_id, unit_id):
+        return self.client._request("DELETE", f"/address/{address_id}/unit/{unit_id}")

nuki_web_api-0.1.0/nukiwebapi/address_reservation.py

@@ -0,0 +1,25 @@
+class AddressReservation:
+    """Sub-client for managing address reservations."""
+
+    def __init__(self, client):
+        self.client = client
+
+    def list_reservations(self, address_id):
+        """Get a list of address reservations for a specific address."""
+        return self.client._request("GET", f"/address/{address_id}/reservation")
+
+    def issue_reservation(self, address_id, reservation_id):
+        """Issue authorizations for an address reservation."""
+        return self.client._request("POST", f"/address/{address_id}/reservation/{reservation_id}/issue")
+
+    def revoke_reservation(self, address_id, reservation_id):
+        """Revoke authorizations for an address reservation."""
+        return self.client._request("POST", f"/address/{address_id}/reservation/{reservation_id}/revoke")
+
+    def update_reservation_access_times(self, address_id, reservation_id, access_times):
+        """Update access times of a reservation."""
+        return self.client._request(
+            "POST",
+            f"/address/{address_id}/reservation/{reservation_id}/update/accesstimes",
+            json=access_times,
+        )

nuki_web_api-0.1.0/nukiwebapi/address_token.py

@@ -0,0 +1,25 @@
+class AddressToken:
+    """Sub-client for managing address tokens."""
+
+    def __init__(self, client):
+        self.client = client
+
+    def get_token_info(self, token_id):
+        """Get info about a specific address token."""
+        return self.client._request("GET", f"/address/token/{token_id}")
+
+    def get_redeemed_token(self, token_id):
+        """Get info about a redeemed address token."""
+        return self.client._request("GET", f"/address/token/{token_id}/redeem")
+
+    def redeem_token(self, token_id, payload=None):
+        """Redeem an address token."""
+        return self.client._request(
+            "POST",
+            f"/address/token/{token_id}/redeem",
+            json=payload or {}
+        )
+
+    def list_tokens(self, address_id):
+        """Get a list of tokens for a specific address."""
+        return self.client._request("GET", f"/address/{address_id}/token")

nuki_web_api-0.1.0/nukiwebapi/advanced_api.py

@@ -0,0 +1,45 @@
+class AdvancedApi:
+    """Sub-client for managing advanced API functionality."""
+
+    def __init__(self, client):
+        self.client = client
+
+    # ---- Decentralized Webhooks ----
+    def list_decentral_webhooks(self):
+        """Get all registered decentral webhooks."""
+        return self.client._request("GET", "/api/decentralWebhook")
+
+    def create_decentral_webhook(self, webhook_data):
+        """Create a new decentral webhook."""
+        return self.client._request("PUT", "/api/decentralWebhook", json=webhook_data)
+
+    def delete_decentral_webhook(self, webhook_id):
+        """Unregister a decentral webhook."""
+        return self.client._request("DELETE", f"/api/decentralWebhook/{webhook_id}")
+
+    def get_webhook_logs(self, api_key_id):
+        """Get a list of webhook logs for a given API key (descending)."""
+        return self.client._request("GET", f"/api/key/{api_key_id}/webhook/logs")
+
+    # ---- Smartlock Advanced Authorizations ----
+    def create_smartlock_auth_advanced(self, auth_data):
+        """Creates asynchronous smartlock authorizations."""
+        return self.client._request("PUT", "/smartlock/auth/advanced", json=auth_data)
+
+    def action_smartlock_advanced(self, smartlock_id, action_data):
+        """Smartlock action with callback."""
+        return self.client._request(
+            "POST", f"/smartlock/{smartlock_id}/action/advanced", json=action_data
+        )
+
+    def lock_smartlock_advanced(self, smartlock_id, lock_data=None):
+        """Lock a smartlock (advanced)."""
+        return self.client._request(
+            "POST", f"/smartlock/{smartlock_id}/action/lock/advanced", json=lock_data or {}
+        )
+
+    def unlock_smartlock_advanced(self, smartlock_id, unlock_data=None):
+        """Unlock a smartlock (advanced)."""
+        return self.client._request(
+            "POST", f"/smartlock/{smartlock_id}/action/unlock/advanced", json=unlock_data or {}
+        )

nuki_web_api-0.1.0/nukiwebapi/api_key.py

@@ -0,0 +1,47 @@
+class ApiKey:
+    """Sub-client for managing API keys, advanced keys, and tokens."""
+
+    def __init__(self, client):
+        self.client = client
+
+    # ---- API Keys ----
+    def list_api_keys(self):
+        return self.client._request("GET", "/api/key")
+
+    def create_api_key(self, key_data):
+        return self.client._request("PUT", "/api/key", json=key_data)
+
+    def update_api_key(self, api_key_id, key_data):
+        return self.client._request("POST", f"/api/key/{api_key_id}", json=key_data)
+
+    def delete_api_key(self, api_key_id):
+        return self.client._request("DELETE", f"/api/key/{api_key_id}")
+
+    # ---- Advanced API Keys ----
+    def get_advanced_api_key(self, api_key_id):
+        return self.client._request("GET", f"/api/key/{api_key_id}/advanced")
+
+    def update_advanced_api_key(self, api_key_id, key_data):
+        return self.client._request("POST", f"/api/key/{api_key_id}/advanced", json=key_data)
+
+    def create_advanced_api_key(self, api_key_id, key_data):
+        return self.client._request("PUT", f"/api/key/{api_key_id}/advanced", json=key_data)
+
+    def delete_advanced_api_key(self, api_key_id):
+        return self.client._request("DELETE", f"/api/key/{api_key_id}/advanced")
+
+    def reactivate_advanced_api_key(self, api_key_id):
+        return self.client._request("POST", f"/api/key/{api_key_id}/advanced/reactivate")
+
+    # ---- API Key Tokens ----
+    def list_api_key_tokens(self, api_key_id):
+        return self.client._request("GET", f"/api/key/{api_key_id}/token")
+
+    def create_api_key_token(self, api_key_id, token_data):
+        return self.client._request("PUT", f"/api/key/{api_key_id}/token", json=token_data)
+
+    def update_api_key_token(self, api_key_id, token_id, token_data):
+        return self.client._request("POST", f"/api/key/{api_key_id}/token/{token_id}", json=token_data)
+
+    def delete_api_key_token(self, api_key_id, token_id):
+        return self.client._request("DELETE", f"/api/key/{api_key_id}/token/{token_id}")

nuki_web_api-0.1.0/nukiwebapi/company.py

@@ -0,0 +1,10 @@
+class Company:
+    """Sub-client for managing companies."""
+
+    def __init__(self, client):
+        self.client = client
+
+    def list_companies(self):
+        """Get a list of companies."""
+        return self.client._request("GET", "/company")
+        

nuki_web_api-0.1.0/nukiwebapi/notification.py

@@ -0,0 +1,26 @@
+class Notification:
+    """Sub-client for managing notifications."""
+
+    def __init__(self, client):
+        self.client = client
+
+    # ---- Notification CRUD ----
+    def list_notifications(self):
+        """Get all notifications attached to your account."""
+        return self.client._request("GET", "/notification")
+
+    def create_notification(self, notification_data):
+        """Create a notification configuration."""
+        return self.client._request("PUT", "/notification", json=notification_data)
+
+    def get_notification(self, notification_id):
+        """Get a specific notification configuration."""
+        return self.client._request("GET", f"/notification/{notification_id}")
+
+    def update_notification(self, notification_id, notification_data):
+        """Update a notification configuration."""
+        return self.client._request("POST", f"/notification/{notification_id}", json=notification_data)
+
+    def delete_notification(self, notification_id):
+        """Delete a notification configuration."""
+        return self.client._request("DELETE", f"/notification/{notification_id}")

nuki_web_api-0.1.0/nukiwebapi/nuki_web_api.py

@@ -0,0 +1,78 @@
+import requests
+
+from nukiwebapi.account import Account
+from nukiwebapi.account_user import AccountUser
+from nukiwebapi.address import Address
+from nukiwebapi.address_reservation import AddressReservation
+from nukiwebapi.address_token import AddressToken
+from nukiwebapi.advanced_api import AdvancedApi
+from nukiwebapi.api_key import ApiKey
+from nukiwebapi.company import Company
+from nukiwebapi.notification import Notification
+from nukiwebapi.opener import Opener
+from nukiwebapi.service import Service
+from nukiwebapi.smartlock import Smartlock
+from nukiwebapi.smartlock_auth import SmartlockAuth
+from nukiwebapi.smartlock_log import SmartlockLog
+
+
+class NukiWebAPI:
+    """Main Nuki Web API client."""
+
+    def __init__(self, access_token: str, base_url: str = "https://api.nuki.io", smartlock_ids: list[str] = None):
+        self.base_url = base_url.rstrip("/")
+        self.access_token = access_token
+        self.account = Account(self)
+        self.account_user = AccountUser(self)
+        self.address = Address(self)
+        self.address_reservation = AddressReservation(self)
+        self.address_token = AddressToken(self)
+        self.api_key = ApiKey(self)
+        self.smartlocks = self._fetch_smartlocks()
+        self.advanced_api = AdvancedApi(self)
+        self.company = Company(self)
+        self.notification = Notification(self)
+        self.opener = Opener(self)
+        self.service = Service(self)
+        self.smartlock_auth = SmartlockAuth(self)
+        self.smartlock_log = SmartlockLog(self)
+        
+        
+    def _fetch_smartlocks(self):
+        """Fetch all smartlocks and create Smartlock objects mapped by ID."""
+        response = self._request("GET", "/smartlock")
+        smartlocks = {}
+        if not isinstance(response, list):
+            raise ValueError(f"Expected list from /smartlock, got {type(response)}: {response}")
+
+        for item in response:
+            smartlock_id = item.get("smartlockId")
+            if not smartlock_id:
+                continue  # skip invalid entries
+            smartlock = Smartlock(
+                client=self,
+                smartlock_id=smartlock_id,
+                data=item
+            )
+            
+            smartlocks[smartlock_id] = smartlock
+
+        return smartlocks
+        
+    def _request(self, method: str, endpoint: str, **kwargs):
+        url = f"{self.base_url}{endpoint}"
+        headers = kwargs.pop("headers", {})
+        headers["Authorization"] = f"Bearer {self.access_token}"
+        headers["Accept"] = "application/json"
+
+        response = requests.request(method, url, headers=headers, **kwargs)
+        response.raise_for_status()
+
+    # Try parsing JSON only if content is non-empty
+        if response.text.strip():
+            try:
+                return response.json()
+            except ValueError:
+                return response.text  # raw text fallback
+        return None  # empty response body
+        

nuki_web_api-0.1.0/nukiwebapi/opener.py

@@ -0,0 +1,23 @@
+class Opener:
+    """Sub-client for managing intercom/openers."""
+
+    def __init__(self, client):
+        self.client = client
+
+    # ---- Intercom Brands ----
+    def list_brands(self):
+        """Get all intercom brands."""
+        return self.client._request("GET", "/opener/brand")
+
+    def get_brand(self, brand_id):
+        """Get a specific intercom brand."""
+        return self.client._request("GET", f"/opener/brand/{brand_id}")
+
+    # ---- Intercom Models ----
+    def list_intercoms(self):
+        """Get a list of intercom models."""
+        return self.client._request("GET", "/opener/intercom")
+
+    def get_intercom(self, intercom_id):
+        """Get a specific intercom model."""
+        return self.client._request("GET", f"/opener/intercom/{intercom_id}")

nuki_web_api-0.1.0/nukiwebapi/service.py

@@ -0,0 +1,32 @@
+class Service:
+    """Sub-client for managing services."""
+
+    def __init__(self, client):
+        self.client = client
+
+    # ---- Services ----
+    def list_services(self):
+        """Get a list of services."""
+        return self.client._request("GET", "/service")
+
+    def get_service(self, service_id):
+        """Get a specific service."""
+        return self.client._request("GET", f"/service/{service_id}")
+
+    def link_service(self, service_id, data=None):
+        """Link a service."""
+        return self.client._request(
+            "POST", f"/service/{service_id}/link", json=data or {}
+        )
+
+    def sync_service(self, service_id, data=None):
+        """Sync a service."""
+        return self.client._request(
+            "POST", f"/service/{service_id}/sync", json=data or {}
+        )
+
+    def unlink_service(self, service_id, data=None):
+        """Unlink a service."""
+        return self.client._request(
+            "POST", f"/service/{service_id}/unlink", json=data or {}
+        )

nuki_web_api-0.1.0/nukiwebapi/smartlock.py

@@ -0,0 +1,166 @@
+from typing import Any, Dict, Optional
+
+
+class Smartlock:
+    """Sub-client for managing smartlocks."""
+    
+    def __init__(self, client, smartlock_id, data=None):
+        self.client = client
+        self.smartlock_id = smartlock_id
+
+        """The hexadecimal representation of the smartlock ID.
+        It prepends 1-5 depending on the type of the lock.
+        Nuki Web API shows only the actual hex ID, omitting the first digit of the Hex ID.
+        
+        E.g. smartlock ID 21913877581 = hex 51A2B3C4D = hex ID 1A2B3C4D
+        
+        The hex_id is to be seen merely as a helper to identify a smartlock more easily,
+        the API only relies on the smartlock_id in decimal format as the identifier of
+        the smartlock.
+        """
+        self.smartlock_hex_id = f'{smartlock_id:x}'[1:].upper()
+        self._data = data or {}
+
+
+    # --- Metadata properties ---
+
+    @property
+    def name(self) -> Optional[str]:
+        return self._data.get("name") or self._data.get("config", {}).get("name")
+
+    @property
+    def state(self) -> Optional[Dict[str, Any]]:
+        return self._data.get("state")
+
+    @property
+    def battery_charge(self) -> Optional[int]:
+        state = self._data.get("state", {})
+        return state.get("batteryCharge")
+
+    @property
+    def is_locked(self) -> Optional[bool]:
+        """State=1 means locked, 0 unlocked (per API docs)."""
+        state = self._data.get("state", {})
+        return state.get("state") == 1
+
+    # --- Data sync ---
+
+    def refresh(self) -> Dict[str, Any]:
+        """Fetch the latest smartlock data from the API and update object."""
+        data = self.client._request("GET", f"/smartlock/{self.smartlock_id}")
+        self._data = data
+        return data
+    # ------------------------
+    # Convenience methods (bound instance)
+    # ------------------------
+    
+   
+    def _action(self, smartlock_id: str, action: int) -> Dict[str, Any]:
+       
+        payload = {"action": action}
+        return self.client._request(
+            "POST",
+            f"/smartlock/{smartlock_id}/action",
+            json=payload
+        )
+
+
+    def lock(self, full: bool = False) -> Dict[str, Any]:
+        """Lock or full lock the smartlock."""
+        if not self.smartlock_id:
+            raise ValueError("smartlock_id not set")
+        return self._action(self.smartlock_id, 6 if full else 2)
+
+    def unlock(self) -> Dict[str, Any]:
+        """Unlock the smartlock."""
+        if not self.smartlock_id:
+            raise ValueError("smartlock_id not set")
+        return self._action(self.smartlock_id, "1")
+
+    def unlatch(self) -> Dict[str, Any]:
+        """Unlatch the smartlock."""
+        if not self.smartlock_id:
+            raise ValueError("smartlock_id not set")
+        return self._action(self.smartlock_id, 3)
+
+    def lock_and_go(self, unlatch: bool = False) -> Dict[str, Any]:
+        """Lock ’n’ Go, optionally with unlatch."""
+        if not self.smartlock_id:
+            raise ValueError("smartlock_id not set")
+        return self._action(self.smartlock_id, 5 if unlatch else 4)
+
+    # ------------------------
+    # General API methods (for any smartlock)
+    # ------------------------
+    def bulk_web_config(self, config_data: Dict[str, Any]) -> Dict[str, Any]:
+        return self.client._request("POST", "/bulk-web-config", json=config_data)
+
+    def list_smartlocks(self) -> Dict[str, Any]:
+        return self.client._request("GET", "/smartlock")
+
+    def get_smartlock(self, smartlock_id) -> Dict[str, Any]:
+        sid = smartlock_id or self.smartlock_id
+        if not sid:
+            raise ValueError("smartlock_id not provided")
+        return self.client._request("GET", f"/smartlock/{sid}")
+
+    def update_smartlock(self, smartlock_id, data: Dict[str, Any] = None) -> Dict[str, Any]:
+        sid = smartlock_id or self.smartlock_id
+        if not sid:
+            raise ValueError("smartlock_id not provided")
+        return self.client._request("POST", f"/smartlock/{sid}", json=data or {})
+
+    def delete_smartlock(self, smartlock_id) -> Dict[str, Any]:
+        sid = smartlock_id or self.smartlock_id
+        if not sid:
+            raise ValueError("smartlock_id not provided")
+        return self.client._request("DELETE", f"/smartlock/{sid}")
+
+    def action_smartlock(self, smartlock_id, action_data: Dict[str, Any] = None) -> Dict[str, Any]:
+        """Generic action for any smartlock ID."""
+        sid = smartlock_id or self.smartlock_id
+        if not sid:
+            raise ValueError("smartlock_id not provided")
+        return self.client._request("POST", f"/smartlock/{sid}/action", json=action_data or {})
+
+    def update_admin_pin(self, smartlock_id, data: Dict[str, Any] = None) -> Dict[str, Any]:
+        sid = smartlock_id or self.smartlock_id
+        if not sid:
+            raise ValueError("smartlock_id not provided")
+        return self.client._request("POST", f"/smartlock/{sid}/admin/pin", json=data or {})
+
+    def update_advanced_config(self, smartlock_id: Optional[str] = None, data: Dict[str, Any] = None) -> Dict[str, Any]:
+        sid = smartlock_id or self.smartlock_id
+        if not sid:
+            raise ValueError("smartlock_id not provided")
+        return self.client._request("POST", f"/smartlock/{sid}/advanced/config", json=data or {})
+
+    def update_opener_advanced_config(self, smartlock_id: Optional[str] = None, data: Dict[str, Any] = None) -> Dict[str, Any]:
+        sid = smartlock_id or self.smartlock_id
+        if not sid:
+            raise ValueError("smartlock_id not provided")
+        return self.client._request("POST", f"/smartlock/{sid}/advanced/openerconfig", json=data or {})
+
+    def update_smartdoor_advanced_config(self, smartlock_id: Optional[str] = None, data: Dict[str, Any] = None) -> Dict[str, Any]:
+        sid = smartlock_id or self.smartlock_id
+        if not sid:
+            raise ValueError("smartlock_id not provided")
+        return self.client._request("POST", f"/smartlock/{sid}/advanced/smartdoorconfig", json=data or {})
+
+    def update_config(self, smartlock_id: Optional[str] = None, data: Dict[str, Any] = None) -> Dict[str, Any]:
+        sid = smartlock_id or self.smartlock_id
+        if not sid:
+            raise ValueError("smartlock_id not provided")
+        return self.client._request("POST", f"/smartlock/{sid}/config", json=data or {})
+
+    def sync_smartlock(self, smartlock_id: Optional[str] = None) -> Dict[str, Any]:
+        sid = smartlock_id or self.smartlock_id
+        if not sid:
+            raise ValueError("smartlock_id not provided")
+        return self.client._request("POST", f"/smartlock/{sid}/sync")
+
+    def update_web_config(self, smartlock_id: Optional[str] = None, data: Dict[str, Any] = None) -> Dict[str, Any]:
+        sid = smartlock_id or self.smartlock_id
+        if not sid:
+            raise ValueError("smartlock_id not provided")
+        return self.client._request("POST", f"/smartlock/{sid}/web/config", json=data or {})

nuki_web_api-0.1.0/nukiwebapi/smartlock_auth.py

@@ -0,0 +1,58 @@
+from typing import Any, Dict, Optional
+
+
+class SmartlockAuth:
+    """Sub-client for managing smartlock authorizations."""
+
+    def __init__(self, client):
+        self.client = client
+
+    # ---- Account-level authorizations ----
+    def list_auths(self) -> Dict[str, Any]:
+        """Get a list of smartlock authorizations for your smartlocks."""
+        return self.client._request("GET", "/smartlock/auth")
+
+    def create_auth(self, auth_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Creates asynchronous smartlock authorizations."""
+        return self.client._request("PUT", "/smartlock/auth", json=auth_data)
+
+    def update_auth(self, auth_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Updates smartlock authorizations asynchronously."""
+        return self.client._request("POST", "/smartlock/auth", json=auth_data)
+
+    def delete_auth(self, auth_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Deletes smartlock authorizations asynchronously."""
+        return self.client._request("DELETE", "/smartlock/auth", json=auth_data)
+
+    def list_auths_paged(self, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Get a paginated list of smartlock authorizations for your smartlocks."""
+        return self.client._request("GET", "/smartlock/auth/paged", params=params)
+
+    # ---- Smartlock-specific authorizations ----
+    def list_auths_for_smartlock(self, smartlock_id: str) -> Dict[str, Any]:
+        """Get a list of smartlock authorizations for a specific smartlock."""
+        return self.client._request("GET", f"/smartlock/{smartlock_id}/auth")
+
+    def create_auth_for_smartlock(self, smartlock_id: str, auth_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Creates an asynchronous smartlock authorization for a specific smartlock."""
+        return self.client._request("PUT", f"/smartlock/{smartlock_id}/auth", json=auth_data)
+
+    def generate_shared_key_auth(self, smartlock_id: str, auth_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Generate a new smartlock auth with a shared key."""
+        return self.client._request(
+            "POST", f"/smartlock/{smartlock_id}/auth/advanced/sharedkey", json=auth_data
+        )
+
+    def get_auth(self, smartlock_id: str, auth_id: str) -> Dict[str, Any]:
+        """Get a specific smartlock authorization."""
+        return self.client._request("GET", f"/smartlock/{smartlock_id}/auth/{auth_id}")
+
+    def update_auth_for_smartlock(self, smartlock_id: str, auth_id: str, auth_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Updates a specific smartlock authorization asynchronously."""
+        return self.client._request(
+            "POST", f"/smartlock/{smartlock_id}/auth/{auth_id}", json=auth_data
+        )
+
+    def delete_auth_for_smartlock(self, smartlock_id: str, auth_id: str) -> Dict[str, Any]:
+        """Deletes a specific smartlock authorization asynchronously."""
+        return self.client._request("DELETE", f"/smartlock/{smartlock_id}/auth/{auth_id}")

nuki_web_api-0.1.0/nukiwebapi/smartlock_log.py

@@ -0,0 +1,18 @@
+from typing import Any, Dict, Optional
+
+
+class SmartlockLog:
+    """Sub-client for retrieving smartlock logs."""
+
+    def __init__(self, client):
+        self.client = client
+
+    # ---- Account-level logs ----
+    def list_logs(self, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Get a list of smartlock logs for all smartlocks."""
+        return self.client._request("GET", "/smartlock/log", params=params)
+
+    # ---- Smartlock-specific logs ----
+    def list_logs_for_smartlock(self, smartlock_id: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Get a list of smartlock logs for a specific smartlock."""
+        return self.client._request("GET", f"/smartlock/{smartlock_id}/log", params=params)

nuki_web_api-0.1.0/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "nuki-web-api"
+version = "0.1.0"
+description = "A Python wrapper for the Nuki Web API"
+readme = "README.md"
+license = "MIT"
+authors = [
+  {name="barghest89", email="blachosf@gmail.com"}
+]
+keywords = ["nuki", "api", "smartlock"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Programming Language :: Python :: 3.11",
+]
+
+dependencies = [
+  "requests==2.32.5"
+]
+
+[project.urls]
+Homepage = "https://github.com/barghest89/nuki-web-api"
+"Bug Tracker" = "https://github.com/barghest89/nuki-web-api/issues"

nuki_web_api-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+