pine-assistant 0.3.0__tar.gz → 0.3.2__tar.gz

{pine_assistant-0.3.0/src/pine_assistant.egg-info → pine_assistant-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pine-assistant
-Version: 0.3.0
+Version: 0.3.2
 Summary: Pine AI SDK — Let Pine AI handle your digital chores. Socket.IO + REST client.
 Author: Pine AI
 License-Expression: MIT
@@ -20,7 +20,7 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: python-socketio[asyncio]>=5.11.0
+Requires-Dist: python-socketio>=5.11.0
 Requires-Dist: httpx>=0.27.0
 Requires-Dist: pydantic>=2.0.0
 Provides-Extra: cli

{pine_assistant-0.3.0 → pine_assistant-0.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pine-assistant"
-version = "0.3.0"
+version = "0.3.2"
 description = "Pine AI SDK — Let Pine AI handle your digital chores. Socket.IO + REST client."
 readme = "README.md"
 license = "MIT"
@@ -23,7 +23,7 @@ classifiers = [
     "Topic :: Software Development :: Libraries :: Python Modules",
 ]
 dependencies = [
-    "python-socketio[asyncio]>=5.11.0",
+    "python-socketio>=5.11.0",
     "httpx>=0.27.0",
     "pydantic>=2.0.0",
 ]

{pine_assistant-0.3.0 → pine_assistant-0.3.2}/src/pine_assistant/__init__.py

@@ -11,7 +11,7 @@ from pine_assistant.sessions import SessionsAPI
 from pine_assistant.errors import PineAIError, AuthError, SessionError, ConnectionError
 from pine_assistant.models.events import C2SEvent, S2CEvent, NotificationEvent
 
-__version__ = "0.3.0"
+__version__ = "0.3.2"
 __all__ = [
     "PineAI",
     "AsyncPineAI",

{pine_assistant-0.3.0 → pine_assistant-0.3.2}/src/pine_assistant/client.py

@@ -3,6 +3,8 @@ PineAI / AsyncPineAI — main SDK clients.
 """
 
 import asyncio
+import logging
+import os
 import uuid
 from pathlib import Path
 from typing import Any, AsyncGenerator, Generator, Optional
@@ -16,20 +18,39 @@ from pine_assistant.errors import ConnectionError
 from pine_assistant.models.events import C2SEvent
 
 DEVICE_ID_FILE = Path.home() / ".pine" / "device_id"
+DEVICE_ID_ENV = "PINE_DEVICE_ID"
+
+_logger = logging.getLogger(__name__)
 
 
 def _get_or_create_device_id(provided: Optional[str] = None) -> str:
+    """Resolve a stable device_id.
+
+    Precedence: explicit argument → PINE_DEVICE_ID env var → ~/.pine/device_id
+    → a new random UUID persisted to ~/.pine/device_id.
+
+    If persistence fails, a warning is logged so callers running in sandboxed
+    or read-only environments learn why their device_id rotates on each launch
+    — set PINE_DEVICE_ID to pin it.
+    """
     if provided:
         return provided
+    env_value = os.environ.get(DEVICE_ID_ENV)
+    if env_value:
+        return env_value.strip()
     try:
         return DEVICE_ID_FILE.read_text().strip()
-    except FileNotFoundError:
+    except (FileNotFoundError, OSError):
         device_id = str(uuid.uuid4())
         try:
             DEVICE_ID_FILE.parent.mkdir(parents=True, exist_ok=True)
             DEVICE_ID_FILE.write_text(device_id)
-        except OSError:
-            pass
+        except OSError as exc:
+            _logger.warning(
+                "Could not persist device_id to %s (%s). "
+                "Set the %s env var to pin a stable device_id.",
+                DEVICE_ID_FILE, exc, DEVICE_ID_ENV,
+            )
         return device_id
 
 

{pine_assistant-0.3.0 → pine_assistant-0.3.2}/src/pine_assistant/transport/socketio.py

@@ -11,9 +11,24 @@ from typing import Any, Callable, Optional
 
 import socketio
 
+from pine_assistant.errors import ConnectionError as PineConnectionError
+
 SOCKETIO_PATH = "/api/v2/socket.io/"
 
 
+def _format_connect_error(data: Any) -> str:
+    """Render a server-supplied connect_error payload into a human-readable string."""
+    if data is None:
+        return "no payload"
+    if isinstance(data, str):
+        return data
+    if isinstance(data, dict):
+        msg = data.get("message") or data.get("error") or data.get("reason")
+        if msg:
+            return str(msg)
+    return repr(data)
+
+
 class SocketIOManager:
     def __init__(
         self,
@@ -66,11 +81,16 @@ class SocketIOManager:
 
         self._sio = socketio.AsyncClient()
         ready_event = asyncio.Event()
+        connect_error_data: dict[str, Any] = {}
 
         @self._sio.event
         async def connect() -> None:
             pass
 
+        @self._sio.event
+        async def connect_error(data: Any) -> None:
+            connect_error_data["payload"] = data
+
         @self._sio.on("ready")
         async def on_ready(*_args: Any) -> None:
             self._connected = True
@@ -93,19 +113,36 @@ class SocketIOManager:
         async def disconnect(_reason: str = "") -> None:
             self._connected = False
 
-        await self._sio.connect(
-            self._base_url,
-            auth={"token": self._token},
-            transports=self._transports,
-            socketio_path=SOCKETIO_PATH,
-            wait_timeout=self._ready_timeout,
-        )
+        try:
+            await self._sio.connect(
+                self._base_url,
+                auth={"token": self._token},
+                transports=self._transports,
+                socketio_path=SOCKETIO_PATH,
+                wait_timeout=self._ready_timeout,
+            )
+        except Exception as exc:
+            # python-socketio raises the generic "One or more namespaces
+            # failed to connect" when the server replies with connect_error.
+            # Surface the actual server-supplied reason if we captured one.
+            if "payload" in connect_error_data:
+                reason = _format_connect_error(connect_error_data["payload"])
+                raise PineConnectionError(
+                    f"Socket.IO connect rejected by server: {reason}"
+                ) from exc
+            raise PineConnectionError(f"Socket.IO connect failed: {exc}") from exc
 
         try:
             await asyncio.wait_for(ready_event.wait(), timeout=self._ready_timeout)
         except asyncio.TimeoutError:
             await self._sio.disconnect()
-            raise TimeoutError(f"Timed out waiting for 'ready' event after {self._ready_timeout}s")
+            # The Pine backend accepts the WebSocket but only emits 'ready' after
+            # its own auth check. A timeout here almost always means the token or
+            # user_id is rejected — surface that hint instead of a generic timeout.
+            raise PineConnectionError(
+                f"Socket.IO connected but no 'ready' event after {self._ready_timeout}s. "
+                "This usually means access_token or user_id is invalid/expired — re-run the auth flow."
+            )
 
     def emit(
         self,
@@ -136,6 +173,12 @@ class SocketIOManager:
         )
 
         async def _do_emit() -> None:
+            # The socket may be torn down between scheduling and execution —
+            # e.g. user calls leave_session() then disconnect() back-to-back.
+            # In that case the emit can't possibly succeed; skip silently
+            # instead of logging a misleading "/ is not a connected namespace".
+            if not self._sio or not self._sio.connected:
+                return
             try:
                 await self._sio.emit(event_type, envelope)  # type: ignore[union-attr]
             except Exception as e:

{pine_assistant-0.3.0 → pine_assistant-0.3.2/src/pine_assistant.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pine-assistant
-Version: 0.3.0
+Version: 0.3.2
 Summary: Pine AI SDK — Let Pine AI handle your digital chores. Socket.IO + REST client.
 Author: Pine AI
 License-Expression: MIT
@@ -20,7 +20,7 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: python-socketio[asyncio]>=5.11.0
+Requires-Dist: python-socketio>=5.11.0
 Requires-Dist: httpx>=0.27.0
 Requires-Dist: pydantic>=2.0.0
 Provides-Extra: cli

{pine_assistant-0.3.0 → pine_assistant-0.3.2}/src/pine_assistant.egg-info/SOURCES.txt

@@ -32,4 +32,6 @@ src/pine_assistant/transport/envelope.py
 src/pine_assistant/transport/http.py
 src/pine_assistant/transport/socketio.py
 tests/test_basics.py
-tests/test_chat_engine.py
+tests/test_chat_engine.py
+tests/test_device_id.py
+tests/test_socketio_connect.py

{pine_assistant-0.3.0 → pine_assistant-0.3.2}/src/pine_assistant.egg-info/requires.txt

@@ -1,4 +1,4 @@
-python-socketio[asyncio]>=5.11.0
+python-socketio>=5.11.0
 httpx>=0.27.0
 pydantic>=2.0.0
 

pine_assistant-0.3.2/tests/test_device_id.py

@@ -0,0 +1,57 @@
+"""Unit tests for device_id resolution — env var, explicit arg, file persistence."""
+
+from pathlib import Path
+from unittest.mock import patch
+
+import pine_assistant.client as client_module
+from pine_assistant.client import _get_or_create_device_id
+
+
+def test_explicit_arg_wins(monkeypatch, tmp_path):
+    monkeypatch.setenv("PINE_DEVICE_ID", "from-env")
+    monkeypatch.setattr(client_module, "DEVICE_ID_FILE", tmp_path / "device_id")
+    assert _get_or_create_device_id("explicit") == "explicit"
+
+
+def test_env_var_wins_over_file(monkeypatch, tmp_path):
+    device_file = tmp_path / "device_id"
+    device_file.write_text("from-file")
+    monkeypatch.setenv("PINE_DEVICE_ID", "from-env")
+    monkeypatch.setattr(client_module, "DEVICE_ID_FILE", device_file)
+    assert _get_or_create_device_id() == "from-env"
+
+
+def test_env_var_is_stripped(monkeypatch, tmp_path):
+    monkeypatch.setenv("PINE_DEVICE_ID", "  trimmed  \n")
+    monkeypatch.setattr(client_module, "DEVICE_ID_FILE", tmp_path / "device_id")
+    assert _get_or_create_device_id() == "trimmed"
+
+
+def test_falls_back_to_file(monkeypatch, tmp_path):
+    monkeypatch.delenv("PINE_DEVICE_ID", raising=False)
+    device_file = tmp_path / "device_id"
+    device_file.write_text("from-file")
+    monkeypatch.setattr(client_module, "DEVICE_ID_FILE", device_file)
+    assert _get_or_create_device_id() == "from-file"
+
+
+def test_creates_and_persists_when_missing(monkeypatch, tmp_path):
+    monkeypatch.delenv("PINE_DEVICE_ID", raising=False)
+    device_file = tmp_path / "nested" / "device_id"
+    monkeypatch.setattr(client_module, "DEVICE_ID_FILE", device_file)
+    first = _get_or_create_device_id()
+    assert device_file.read_text() == first
+    # A second call returns the persisted value, not a new UUID.
+    assert _get_or_create_device_id() == first
+
+
+def test_unwritable_dir_warns_and_returns_random(monkeypatch, tmp_path, caplog):
+    monkeypatch.delenv("PINE_DEVICE_ID", raising=False)
+    # Point at an unwritable location: a file used as a "directory".
+    blocker = tmp_path / "blocker"
+    blocker.write_text("not a directory")
+    monkeypatch.setattr(client_module, "DEVICE_ID_FILE", blocker / "device_id")
+    with caplog.at_level("WARNING", logger="pine_assistant.client"):
+        device_id = _get_or_create_device_id()
+    assert device_id  # got *some* id back
+    assert any("PINE_DEVICE_ID" in rec.message for rec in caplog.records)

pine_assistant-0.3.2/tests/test_socketio_connect.py

@@ -0,0 +1,149 @@
+"""Unit tests for SocketIOManager.connect() — connect_error surfacing."""
+
+import asyncio
+from typing import Any
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+from pine_assistant.errors import ConnectionError as PineConnectionError
+from pine_assistant.transport.socketio import (
+    SocketIOManager,
+    _format_connect_error,
+)
+
+
+def test_format_connect_error_string():
+    assert _format_connect_error("bad token") == "bad token"
+
+
+def test_format_connect_error_dict_message():
+    assert _format_connect_error({"message": "invalid token"}) == "invalid token"
+
+
+def test_format_connect_error_dict_error_key():
+    assert _format_connect_error({"error": "unauthorized"}) == "unauthorized"
+
+
+def test_format_connect_error_none():
+    assert _format_connect_error(None) == "no payload"
+
+
+def test_format_connect_error_unknown():
+    assert _format_connect_error([1, 2]) == "[1, 2]"
+
+
+class _FakeAsyncClient:
+    """Minimal stand-in for socketio.AsyncClient that lets a test drive the
+    connect_error path."""
+
+    def __init__(self, connect_error_payload: Any = None) -> None:
+        self._handlers: dict[str, Any] = {}
+        self._connect_error_payload = connect_error_payload
+        self.connected = False
+
+    def event(self, fn):
+        self._handlers[fn.__name__] = fn
+        return fn
+
+    def on(self, name):
+        def deco(fn):
+            self._handlers[name] = fn
+            return fn
+        return deco
+
+    async def connect(self, *_args, **_kwargs):
+        # Simulate the server replying with connect_error, then python-socketio
+        # raising the generic ConnectionError after wait_timeout.
+        handler = self._handlers.get("connect_error")
+        if handler is not None:
+            await handler(self._connect_error_payload)
+        raise ConnectionError("One or more namespaces failed to connect")
+
+    async def disconnect(self):
+        self.connected = False
+
+
+@pytest.mark.asyncio
+async def test_connect_error_payload_surfaces_in_pine_connection_error():
+    fake = _FakeAsyncClient(connect_error_payload={"message": "invalid token"})
+    mgr = SocketIOManager(
+        base_url="https://example.test",
+        token="bad-token",
+        user_id="u1",
+        device_id="d1",
+        ready_timeout=0.1,
+    )
+    with patch("pine_assistant.transport.socketio.socketio.AsyncClient", return_value=fake):
+        with pytest.raises(PineConnectionError) as excinfo:
+            await mgr.connect()
+    msg = str(excinfo.value)
+    assert "rejected by server" in msg
+    assert "invalid token" in msg
+
+
+@pytest.mark.asyncio
+async def test_connect_error_without_payload_falls_back_to_generic():
+    fake = _FakeAsyncClient(connect_error_payload=None)
+    # Override: don't invoke the connect_error handler at all — simulate a
+    # transport-level failure where the server never sent connect_error.
+    async def connect_no_event(*_args, **_kwargs):
+        raise ConnectionError("transport closed")
+    fake.connect = connect_no_event  # type: ignore[method-assign]
+
+    mgr = SocketIOManager(
+        base_url="https://example.test",
+        token="t",
+        user_id="u",
+        device_id="d",
+        ready_timeout=0.1,
+    )
+    with patch("pine_assistant.transport.socketio.socketio.AsyncClient", return_value=fake):
+        with pytest.raises(PineConnectionError) as excinfo:
+            await mgr.connect()
+    assert "transport closed" in str(excinfo.value)
+
+
+class _SilentStallClient:
+    """Stand-in that accepts the connect but never fires the 'ready' event —
+    matches Pine backend's behavior when access_token/user_id is rejected."""
+
+    def __init__(self) -> None:
+        self._handlers: dict[str, Any] = {}
+        self.connected = False
+
+    def event(self, fn):
+        self._handlers[fn.__name__] = fn
+        return fn
+
+    def on(self, name):
+        def deco(fn):
+            self._handlers[name] = fn
+            return fn
+        return deco
+
+    async def connect(self, *_args, **_kwargs):
+        self.connected = True
+
+    async def disconnect(self):
+        self.connected = False
+
+
+@pytest.mark.asyncio
+async def test_silent_stall_raises_diagnostic_pine_error():
+    """When the WS connects but no 'ready' event arrives, surface a hint that
+    points the user at re-auth, not a generic asyncio TimeoutError."""
+    fake = _SilentStallClient()
+    mgr = SocketIOManager(
+        base_url="https://example.test",
+        token="t",
+        user_id="u",
+        device_id="d",
+        ready_timeout=0.1,
+    )
+    with patch("pine_assistant.transport.socketio.socketio.AsyncClient", return_value=fake):
+        with pytest.raises(PineConnectionError) as excinfo:
+            await mgr.connect()
+    msg = str(excinfo.value)
+    assert "no 'ready' event" in msg
+    assert "re-run the auth flow" in msg