notte-sdk 0.0.dev0__py3-none-any.whl

notte_sdk/vault.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+import traceback
+from typing import final
+
+from loguru import logger
+from notte_core.credentials.base import (
+    BaseVault,
+    CredentialField,
+    VaultCredentials,
+)
+from notte_core.utils.url import get_root_domain
+from typing_extensions import override
+
+from notte_sdk.endpoints.personas import PersonasClient
+
+
+@final
+class NotteVault(BaseVault):
+    """Vault that fetches credentials stored using the sdk"""
+
+    def __init__(self, persona_client: PersonasClient, persona_id: str):
+        self.persona_client = persona_client
+        self.persona_id = persona_id
+
+    @property
+    def vault_id(self):
+        return self.persona_id
+
+    @override
+    def _set_singleton_credentials(self, creds: list[CredentialField]) -> None:
+        for cred in creds:
+            if not cred.singleton:
+                raise ValueError(f"{cred.__class__} can't be set as singleton credential: url-specific only")
+
+        creds_dict = BaseVault.credential_fields_to_dict(creds)
+        _ = self.persona_client.add_credentials(self.persona_id, url=None, **creds_dict)
+
+    @override
+    def get_singleton_credentials(self) -> list[CredentialField]:
+        try:
+            return self.persona_client.get_credentials(self.persona_id, url=None).credentials
+        except Exception as e:
+            logger.warning(f"Could not get singleton credentials: {e} {traceback.format_exc()}")
+            return []
+
+    @override
+    def _add_credentials(self, creds: VaultCredentials) -> None:
+        for cred in creds.creds:
+            if cred.singleton:
+                raise ValueError(f"{cred.__class__} can't be set as url specific credential: singleton only")
+
+        domain = get_root_domain(creds.url)
+        creds_dict = BaseVault.credential_fields_to_dict(creds.creds)
+        _ = self.persona_client.add_credentials(self.persona_id, url=domain, **creds_dict)
+
+    @override
+    def _get_credentials_impl(self, url: str) -> VaultCredentials | None:
+        try:
+            domain = get_root_domain(url)
+            creds = self.persona_client.get_credentials(self.persona_id, url=domain).credentials
+            return VaultCredentials(url=url, creds=creds)
+        except Exception:
+            logger.warning(f"Failed to get creds: {traceback.format_exc()}")
+
+    @override
+    def remove_credentials(self, url: str | None) -> None:
+        _ = self.persona_client.delete_credentials(self.persona_id, url=url)

notte_sdk/websockets/recording.py

@@ -0,0 +1,106 @@
+import asyncio
+import threading
+from collections.abc import AsyncIterator
+from pathlib import Path
+from typing import Callable
+
+import websockets.client
+from loguru import logger
+from notte_core.common.resource import SyncResource
+from pydantic import BaseModel, Field, PrivateAttr
+from typing_extensions import override
+
+# def save_frames_to_video(frames: list[bytes], output_path: Path, fps: int = 10):
+#     import numpy as np
+#     import imagio
+#     with imageio.get_writer('output.mp4', fps=fps) as writer:
+#         for img in frames:
+#             writer.append_data(np.array(img))
+
+
+class JupyterKernelViewer:
+    @staticmethod
+    def display_image(image_data: bytes):
+        from IPython.display import clear_output, display  # type: ignore
+        from notte_core.utils.image import image_from_bytes
+
+        image = image_from_bytes(image_data)
+        clear_output(wait=True)
+        return display(image)
+
+
+class SessionRecordingWebSocket(BaseModel, SyncResource):  # type: ignore
+    """WebSocket client for receiving session recording data in binary format."""
+
+    wss_url: str
+    fps: int = 10
+    max_frames: int = 300
+    frames: list[bytes] = Field(default_factory=list)
+    on_frame: Callable[[bytes], None] | None = None
+    output_path: Path | None = None
+    _thread: threading.Thread | None = PrivateAttr(default=None)
+    _stop_event: threading.Event | None = PrivateAttr(default=None)
+    display_image: bool = True
+
+    def _run_async_loop(self) -> None:
+        """Run the async event loop in a separate thread."""
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        try:
+            loop.run_until_complete(self.watch())
+        finally:
+            loop.close()
+
+    @override
+    def start(self) -> None:
+        """Start recording in a separate thread."""
+        self._stop_event = threading.Event()
+        self._thread = threading.Thread(target=self._run_async_loop)
+        self._thread.start()
+
+    @override
+    def stop(self) -> None:
+        """Stop the recording thread."""
+        if self._stop_event:
+            self._stop_event.set()
+        if self._thread:
+            self._thread.join()
+            self._thread = None
+            self._stop_event = None
+
+    async def connect(self) -> AsyncIterator[bytes]:
+        """Connect to the WebSocket and yield binary recording data.
+
+        Yields:
+            Binary data chunks from the recording stream
+        """
+        try:
+            async with websockets.client.connect(self.wss_url) as websocket:
+                async for message in websocket:
+                    if isinstance(message, bytes):
+                        if len(self.frames) >= self.max_frames:
+                            break
+                        self.frames.append(message)
+                        yield message
+                    else:
+                        logger.warning(f"[Session Recording] Received non-binary message: {message}")
+        except websockets.exceptions.WebSocketException as e:
+            logger.error(f"[Session Recording] WebSocket error: {e}")
+            raise
+
+    async def watch(self) -> None:
+        """Save the recording stream to a file."""
+        output_path = self.output_path or Path(".recordings/{dt.strftime('%Y-%m-%d_%H-%M-%S')}/")
+        output_path = Path(output_path)
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+
+        with output_path.open("wb") as f:
+            async for chunk in self.connect():
+                if self._stop_event and self._stop_event.is_set():
+                    break
+                _ = f.write(chunk)
+                if self.on_frame:
+                    self.on_frame(chunk)
+                if self.display_image:
+                    _ = JupyterKernelViewer.display_image(chunk)
+        logger.info(f"[Session Recording] Recording saved to {output_path}")

notte_sdk-0.0.dev0.dist-info/METADATA

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: notte-sdk
+Version: 0.0.dev0
+Summary: The SDK for Notte
+Author-email: Notte Team  <hello@notte.cc>
+Requires-Python: >=3.11
+Requires-Dist: notte-core==0.0.dev
+Requires-Dist: websockets>=13.1

notte_sdk-0.0.dev0.dist-info/RECORD

@@ -0,0 +1,18 @@
+notte_sdk/__init__.py,sha256=cco3JQI3_a0U1S-4V2XER7w5YuGCwyNGQpkhAkCj5RA,160
+notte_sdk/client.py,sha256=uMg7X4wmxBlX50Kfk17v_55srGiV3-dzoxjauzFU0dg,1807
+notte_sdk/errors.py,sha256=yETg6rOO817W5XE37YiFFZxwiqj1z4uHOa6d0tyv31w,1429
+notte_sdk/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+notte_sdk/types.py,sha256=1D4HWtDc1ZACWOeaUSPupjLhO55igBOzekMnl-m2q7A,28523
+notte_sdk/vault.py,sha256=t2dP54RAZRCo25DZKx2h0LNVXwBh_M1LQzrPUIJ2ivA,2450
+notte_sdk/endpoints/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+notte_sdk/endpoints/agents.py,sha256=wqHtgQF_65uGNJA153LW0vi2hifkWDZwkM8Y7pd0Ov0,19039
+notte_sdk/endpoints/base.py,sha256=wloIHfEV5WTv82yaTczN8IjqXretMk6ov66wqvzNF-w,10272
+notte_sdk/endpoints/page.py,sha256=RuZk0MfyDZSd-W7VMN2lPyTxeiMQmj2uheM-pPIf_QE,8835
+notte_sdk/endpoints/personas.py,sha256=7KHzcRIoqSYfJZNVLhnBhAny-9adJRn0EjojmXAc1E4,10542
+notte_sdk/endpoints/sessions.py,sha256=F8cjcWmhSihQtEYoCSeHgica-bSNdPTdap3Q-UreZQ4,21347
+notte_sdk/endpoints/vaults.py,sha256=1qvKYXsJzjJjcS8xLDnrGQ_o6yCKEQ-T11uORUjR5R4,2614
+notte_sdk/websockets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+notte_sdk/websockets/recording.py,sha256=4vi-GNW_LKLK3vHPAxG36VJVR7k2RhFRykRsediE6R8,3868
+notte_sdk-0.0.dev0.dist-info/METADATA,sha256=Qt1vM2FiBAWh1cCsDsLzn7Ok-I0NUTpte1JD1jDEtUU,217
+notte_sdk-0.0.dev0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+notte_sdk-0.0.dev0.dist-info/RECORD,,

notte_sdk-0.0.dev0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any