aionanit 1.0.0__tar.gz

aionanit-1.0.0/PKG-INFO

@@ -0,0 +1,78 @@
+Metadata-Version: 2.4
+Name: aionanit
+Version: 1.0.0
+Summary: Async Python client for Nanit baby cameras
+License-Expression: MIT
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: aiohttp>=3.9.0
+Requires-Dist: betterproto>=2.0.0b7
+Provides-Extra: dev
+Requires-Dist: grpcio-tools; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+Requires-Dist: aioresponses; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+
+# aionanit
+
+Async Python client library for Nanit baby cameras.
+
+## Features
+
+- **Authentication**: Email/password login, MFA verification, automatic token refresh.
+- **WebSocket**: Protobuf-over-WebSocket communication with cameras (cloud and local).
+- **REST API**: Baby metadata, cloud events, snapshots.
+- **Streaming**: RTMPS URL construction for live video.
+- **Push-based**: Subscribe to real-time camera state changes (sensors, settings, controls).
+
+## Installation
+
+```bash
+pip install aionanit
+```
+
+## Quick Start
+
+```python
+import aiohttp
+from aionanit import NanitClient
+
+async with aiohttp.ClientSession() as session:
+    client = NanitClient(session)
+
+    # Login
+    tokens = await client.async_login("you@example.com", "password")
+
+    # Get babies
+    babies = await client.async_get_babies()
+    baby = babies[0]
+
+    # Connect to camera
+    camera = client.camera(baby.camera_uid, baby.uid)
+    await camera.async_start()
+
+    # Subscribe to state changes
+    def on_event(event):
+        print(f"Sensors: {event.state.sensors}")
+
+    unsub = camera.subscribe(on_event)
+
+    # Get RTMPS stream URL
+    url = await camera.async_get_stream_rtmps_url()
+    print(f"Stream: {url}")
+
+    # Cleanup
+    unsub()
+    await client.async_close()
+```
+
+## Requirements
+
+- Python 3.12+
+- aiohttp >= 3.9.0
+- betterproto >= 2.0.0b7
+
+## License
+
+MIT

aionanit-1.0.0/README.md

@@ -0,0 +1,62 @@
+# aionanit
+
+Async Python client library for Nanit baby cameras.
+
+## Features
+
+- **Authentication**: Email/password login, MFA verification, automatic token refresh.
+- **WebSocket**: Protobuf-over-WebSocket communication with cameras (cloud and local).
+- **REST API**: Baby metadata, cloud events, snapshots.
+- **Streaming**: RTMPS URL construction for live video.
+- **Push-based**: Subscribe to real-time camera state changes (sensors, settings, controls).
+
+## Installation
+
+```bash
+pip install aionanit
+```
+
+## Quick Start
+
+```python
+import aiohttp
+from aionanit import NanitClient
+
+async with aiohttp.ClientSession() as session:
+    client = NanitClient(session)
+
+    # Login
+    tokens = await client.async_login("you@example.com", "password")
+
+    # Get babies
+    babies = await client.async_get_babies()
+    baby = babies[0]
+
+    # Connect to camera
+    camera = client.camera(baby.camera_uid, baby.uid)
+    await camera.async_start()
+
+    # Subscribe to state changes
+    def on_event(event):
+        print(f"Sensors: {event.state.sensors}")
+
+    unsub = camera.subscribe(on_event)
+
+    # Get RTMPS stream URL
+    url = await camera.async_get_stream_rtmps_url()
+    print(f"Stream: {url}")
+
+    # Cleanup
+    unsub()
+    await client.async_close()
+```
+
+## Requirements
+
+- Python 3.12+
+- aiohttp >= 3.9.0
+- betterproto >= 2.0.0b7
+
+## License
+
+MIT

aionanit-1.0.0/aionanit/__init__.py

@@ -0,0 +1,69 @@
+"""aionanit — async Python client for Nanit baby cameras."""
+
+from .auth import TokenManager
+from .camera import NanitCamera
+from .client import NanitClient
+from .exceptions import (
+    NanitAuthError,
+    NanitCameraUnavailable,
+    NanitConnectionError,
+    NanitError,
+    NanitMfaRequiredError,
+    NanitProtocolError,
+    NanitRequestTimeout,
+    NanitTransportError,
+)
+from .models import (
+    Baby,
+    CameraEvent,
+    CameraEventKind,
+    CameraState,
+    CloudEvent,
+    ConnectionInfo,
+    ConnectionState,
+    ControlState,
+    NightLightState,
+    SensorReading,
+    SensorState,
+    SensorType,
+    SettingsState,
+    StatusState,
+    TransportKind,
+)
+from .rest import NanitRestClient
+
+__all__ = [
+    # auth
+    "TokenManager",
+    # camera
+    "NanitCamera",
+    # client
+    "NanitClient",
+    # rest
+    "NanitRestClient",
+    # models
+    "Baby",
+    "CameraEvent",
+    "CameraEventKind",
+    "CameraState",
+    "CloudEvent",
+    "ConnectionInfo",
+    "ConnectionState",
+    "ControlState",
+    "NightLightState",
+    "SensorReading",
+    "SensorState",
+    "SensorType",
+    "SettingsState",
+    "StatusState",
+    "TransportKind",
+    # exceptions
+    "NanitAuthError",
+    "NanitCameraUnavailable",
+    "NanitConnectionError",
+    "NanitError",
+    "NanitMfaRequiredError",
+    "NanitProtocolError",
+    "NanitRequestTimeout",
+    "NanitTransportError",
+]

aionanit-1.0.0/aionanit/auth.py

@@ -0,0 +1,96 @@
+"""Token management with proactive refresh for the Nanit API."""
+
+from __future__ import annotations
+
+import asyncio
+import time
+from collections.abc import Callable
+from typing import TYPE_CHECKING
+
+from .exceptions import NanitAuthError
+
+if TYPE_CHECKING:
+    from .rest import NanitRestClient
+
+
+class TokenManager:
+    """Manages access/refresh tokens with automatic proactive renewal.
+
+    Does not own the REST client — caller provides it. Acquires an
+    asyncio.Lock around refresh operations to prevent concurrent refreshes.
+    """
+
+    def __init__(
+        self,
+        rest: NanitRestClient,
+        access_token: str,
+        refresh_token: str,
+        expires_in: float = 3600.0,
+    ) -> None:
+        self._rest: NanitRestClient = rest
+        self._access_token: str = access_token
+        self._refresh_token: str = refresh_token
+        self._expires_at: float = time.monotonic() + expires_in
+        self._lock: asyncio.Lock = asyncio.Lock()
+        self._callbacks: list[Callable[[str, str], None]] = []
+
+    @property
+    def access_token(self) -> str:
+        return self._access_token
+
+    @property
+    def refresh_token(self) -> str:
+        return self._refresh_token
+
+    def update_tokens(
+        self,
+        access_token: str,
+        refresh_token: str,
+        expires_in: float = 3600.0,
+    ) -> None:
+        self._access_token = access_token
+        self._refresh_token = refresh_token
+        self._expires_at = time.monotonic() + expires_in
+
+    async def async_get_access_token(
+        self, min_ttl: float = 60.0
+    ) -> str:
+        async with self._lock:
+            if time.monotonic() + min_ttl >= self._expires_at:
+                await self._async_refresh()
+            return self._access_token
+
+    async def async_force_refresh(self) -> None:
+        async with self._lock:
+            await self._async_refresh()
+
+    async def _async_refresh(self) -> None:
+        try:
+            tokens = await self._rest.async_refresh_token(
+                self._access_token, self._refresh_token
+            )
+        except NanitAuthError:
+            raise
+        except Exception as err:
+            raise NanitAuthError(f"Token refresh failed: {err}") from err
+
+        self._access_token = tokens["access_token"]
+        self._refresh_token = tokens["refresh_token"]
+        self._expires_at = time.monotonic() + 3600.0
+
+        for callback in self._callbacks:
+            callback(self._access_token, self._refresh_token)
+
+    def on_tokens_refreshed(
+        self, callback: Callable[[str, str], None]
+    ) -> Callable[[], None]:
+        """Register a callback invoked with (access_token, refresh_token) after refresh.
+
+        Returns an unsubscribe function that removes the callback.
+        """
+        self._callbacks.append(callback)
+
+        def _unsubscribe() -> None:
+            self._callbacks.remove(callback)
+
+        return _unsubscribe