loopbot-discord-sdk 1.0.0__py3-none-any.whl → 1.0.5__py3-none-any.whl

loopbot/bot.py

@@ -49,7 +49,7 @@ class Bot:
     def __init__(
         self,
         token: str,
-        api_url: str = "https://api.loopbot.app",
+        api_url: str = "https://gatewayloop.squareweb.app",
     ):
         self.token = token
         self.api_url = api_url

loopbot/client.py

@@ -1,5 +1,5 @@
 """
-HTTP/SSE Client for Loop Discord SDK
+WebSocket Client for Loop Discord SDK (Lightweight version)
 """
 
 import asyncio
@@ -7,18 +7,23 @@ import json
 from typing import Any, Callable, Dict, List, Optional
 
 import aiohttp
-from aiohttp_sse_client import client as sse_client
 
 
 class Client:
-    """HTTP client for communicating with the Loop API"""
+    """HTTP/WebSocket client for communicating with the Loop API"""
 
-    def __init__(self, token: str, base_url: str = "https://gatewayloop.discloud.app"):
+    def __init__(self, token: str, base_url: str = "https://api.loopbot.app"):
         self.token = token
         self.base_url = base_url.rstrip("/")
         self._session: Optional[aiohttp.ClientSession] = None
-        self._sse_task: Optional[asyncio.Task] = None
+        self._ws: Optional[aiohttp.ClientWebSocketResponse] = None
+        self._ws_task: Optional[asyncio.Task] = None
         self._connected = False
+        self._reconnect_attempts = 0
+        self._max_reconnect_attempts = 10
+        self._reconnect_delay = 1.0
+        self._on_interaction: Optional[Callable[[Dict[str, Any]], None]] = None
+        self._heartbeat_task: Optional[asyncio.Task] = None
 
     @property
     def headers(self) -> Dict[str, str]:
@@ -27,6 +32,11 @@ class Client:
             "Content-Type": "application/json",
         }
 
+    @property
+    def ws_url(self) -> str:
+        """Convert HTTP URL to WebSocket URL"""
+        return self.base_url.replace("https://", "wss://").replace("http://", "ws://") + "/api/sdk/ws"
+
     async def _get_session(self) -> aiohttp.ClientSession:
         if self._session is None or self._session.closed:
             self._session = aiohttp.ClientSession()
@@ -63,25 +73,94 @@ class Client:
         self._connected = True
         return result
 
-    async def connect_sse(self, on_interaction: Callable[[Dict[str, Any]], None]) -> None:
-        """Connect to SSE for receiving interactions"""
-        url = f"{self.base_url}/api/sdk/events"
+    async def connect_ws(self, on_interaction: Callable[[Dict[str, Any]], None]) -> None:
+        """Connect to WebSocket for receiving interactions"""
+        self._on_interaction = on_interaction
+        await self._create_websocket()
 
-        async with sse_client.EventSource(
-            url,
-            headers=self.headers,
-        ) as event_source:
-            async for event in event_source:
-                if event.type == "connected":
-                    print("[Loop SDK] SSE connected")
-                elif event.type == "interaction":
+    async def _create_websocket(self) -> None:
+        """Create and manage WebSocket connection"""
+        session = await self._get_session()
+        
+        try:
+            self._ws = await session.ws_connect(
+                self.ws_url,
+                headers=self.headers,
+                heartbeat=30.0,
+            )
+            print("[Loop SDK] WebSocket connected")
+            self._reconnect_attempts = 0
+            
+            # Start heartbeat
+            self._heartbeat_task = asyncio.create_task(self._heartbeat_loop())
+            
+            # Message loop
+            async for msg in self._ws:
+                if msg.type == aiohttp.WSMsgType.TEXT:
                     try:
-                        interaction = json.loads(event.data)
-                        on_interaction(interaction)
+                        data = json.loads(msg.data)
+                        if data.get("type") == "interaction" and self._on_interaction:
+                            self._on_interaction(data.get("data", {}))
+                        elif data.get("type") == "connected":
+                            print("[Loop SDK] Authenticated with API")
+                        elif data.get("type") == "pong":
+                            pass  # Heartbeat response
                     except json.JSONDecodeError as e:
-                        print(f"[Loop SDK] Failed to parse interaction: {e}")
-                elif event.type == "ping":
-                    pass  # Heartbeat
+                        print(f"[Loop SDK] Failed to parse message: {e}")
+                elif msg.type == aiohttp.WSMsgType.ERROR:
+                    print(f"[Loop SDK] WebSocket error: {self._ws.exception()}")
+                    break
+                elif msg.type == aiohttp.WSMsgType.CLOSED:
+                    break
+                    
+        except Exception as e:
+            print(f"[Loop SDK] WebSocket connection error: {e}")
+        finally:
+            if self._heartbeat_task:
+                self._heartbeat_task.cancel()
+                self._heartbeat_task = None
+            await self._attempt_reconnect()
+
+    async def _heartbeat_loop(self) -> None:
+        """Send periodic heartbeats"""
+        try:
+            while True:
+                await asyncio.sleep(30)
+                if self._ws and not self._ws.closed:
+                    await self._ws.send_json({"type": "ping"})
+        except asyncio.CancelledError:
+            pass
+
+    async def _attempt_reconnect(self) -> None:
+        """Attempt to reconnect to WebSocket"""
+        if self._reconnect_attempts >= self._max_reconnect_attempts:
+            print("[Loop SDK] Max reconnect attempts reached")
+            return
+
+        self._reconnect_attempts += 1
+        delay = self._reconnect_delay * (2 ** (self._reconnect_attempts - 1))
+        
+        print(f"[Loop SDK] Reconnecting in {delay}s (attempt {self._reconnect_attempts}/{self._max_reconnect_attempts})")
+        
+        await asyncio.sleep(delay)
+        
+        if self._on_interaction:
+            await self._create_websocket()
+
+    async def connect_sse(self, on_interaction: Callable[[Dict[str, Any]], None]) -> None:
+        """Legacy SSE method - now uses WebSocket internally"""
+        await self.connect_ws(on_interaction)
+
+    async def disconnect_ws(self) -> None:
+        """Disconnect WebSocket"""
+        if self._heartbeat_task:
+            self._heartbeat_task.cancel()
+            self._heartbeat_task = None
+            
+        if self._ws and not self._ws.closed:
+            await self._ws.close()
+        self._ws = None
+        self._on_interaction = None
 
     async def respond(self, interaction_id: str, response: Dict[str, Any]) -> None:
         """Send interaction response"""
@@ -118,6 +197,8 @@ class Client:
 
     async def disconnect(self) -> None:
         """Disconnect from API"""
+        await self.disconnect_ws()
+        
         if self._connected:
             try:
                 await self.request("POST", "/sdk/disconnect", {})
@@ -802,4 +883,3 @@ class Client:
             "webhookToken": webhook_token,
             "messageId": message_id,
         })
-

{loopbot_discord_sdk-1.0.0.dist-info → loopbot_discord_sdk-1.0.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: loopbot-discord-sdk
-Version: 1.0.0
+Version: 1.0.5
 Summary: Official Loop Discord SDK for Python - Build Discord bots without websockets
 Author-email: Loop <contact@loopbot.app>
 License: MIT
@@ -25,7 +25,6 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 Requires-Dist: aiohttp>=3.8.0
-Requires-Dist: aiohttp-sse-client>=0.2.1
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"

{loopbot_discord_sdk-1.0.0.dist-info → loopbot_discord_sdk-1.0.5.dist-info}/RECORD

@@ -1,6 +1,6 @@
 loopbot/__init__.py,sha256=oIkHZq8f8ygeHGLMiYgTd8cB_PmrNFDcNZnkccES7ws,1197
-loopbot/bot.py,sha256=1KXrUJwlplc0cwrrLN_svJMSO41ToVdbGfPVvt39_m8,20615
-loopbot/client.py,sha256=oCevrQZLGXJnaIZ87KY-VkzsZGEYJiCfFpYTE5s2nnA,26790
+loopbot/bot.py,sha256=ne_dgvYqIq7jW1cNS8-jjbX7IKXIDtTHzxvReh7JZDM,20625
+loopbot/client.py,sha256=s7UG3Fd_GUA6qpil5fbH3d3VFXJMDPjUX513_1Og4Fs,30124
 loopbot/types.py,sha256=MZcQgVvVDSs60UqAF5lWkHNM3yo9KLKDxZaU6tKndZQ,1645
 loopbot/builders/__init__.py,sha256=STrS9XOMPsVDzx9VAvbOZW2f8fp6mITbZWzdkgmqNe4,790
 loopbot/builders/action_row.py,sha256=ouQKGpcb9KIWwUWJzUT6kH7Ov60UCZi5FjWlXC6sRVw,1225
@@ -20,7 +20,7 @@ loopbot/context/button.py,sha256=5-XO6mYNMx2FPHhv8ijiUrsALOkxzSal-NKvVvXvMnM,756
 loopbot/context/command.py,sha256=i7Z8o3F5mLvQDDSVdio8LMB5-zPzMKtSiPsK1WgNg4c,3076
 loopbot/context/modal.py,sha256=QTgKDRZP7g43S3ScR5dMGKzZolUDWMtVmYqEip4GJXI,1476
 loopbot/context/select.py,sha256=8ozLkBNdlZBdQdeCbJ2545j3YkwsCBUnFpHWQPW5VIw,954
-loopbot_discord_sdk-1.0.0.dist-info/METADATA,sha256=2ooM5EqAJQXzhCZdAcnwpLnhbis9Duwwuyy2lBgyG0Y,12504
-loopbot_discord_sdk-1.0.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-loopbot_discord_sdk-1.0.0.dist-info/top_level.txt,sha256=4sZzEMpMwz6lUz7RJzVFFh7LY-vr5W1-RAfn_bF6tks,8
-loopbot_discord_sdk-1.0.0.dist-info/RECORD,,
+loopbot_discord_sdk-1.0.5.dist-info/METADATA,sha256=6pv-i-_TC8C0h0rCqNOxdtPOGOf_MVWSyCRsAcPD2rk,12462
+loopbot_discord_sdk-1.0.5.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+loopbot_discord_sdk-1.0.5.dist-info/top_level.txt,sha256=4sZzEMpMwz6lUz7RJzVFFh7LY-vr5W1-RAfn_bF6tks,8
+loopbot_discord_sdk-1.0.5.dist-info/RECORD,,