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

loopbot/__init__.py

@@ -5,6 +5,7 @@ Build Discord bots without websockets using HTTP Interactions
 
 from .bot import Bot
 from .client import Client
+from .database import Database
 from .builders import (
     EmbedBuilder,
     ButtonBuilder,
@@ -35,6 +36,7 @@ __all__ = [
     # Core
     "Bot",
     "Client",
+    "Database",
     # Builders
     "EmbedBuilder",
     "ButtonBuilder",

loopbot/bot.py

@@ -7,6 +7,7 @@ import signal
 from typing import Any, Callable, Dict, List, Optional, Union
 
 from .client import Client
+from .database import Database
 from .context.command import CommandContext
 from .context.button import ButtonContext
 from .context.modal import ModalContext
@@ -49,7 +50,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
@@ -60,6 +61,7 @@ class Bot:
         self._select_handlers: Dict[str, SelectHandler] = {}
         self._application_id: str = ""
         self._running = False
+        self.db = Database(self._client)
 
     def command(
         self,

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/context/base.py

@@ -5,6 +5,7 @@ Base Context for all interaction types
 from typing import Any, Dict, List, Optional, Union
 
 from ..types import Interaction, InteractionResponseType, DiscordUser, DiscordMember
+from ..database import Database
 from ..builders.embed import EmbedBuilder
 from ..builders.action_row import ActionRowBuilder
 from ..builders.modal import ModalBuilder
@@ -24,6 +25,7 @@ class BaseContext:
         self._application_id = application_id
         self._response: Optional[Dict[str, Any]] = None
         self._deferred = False
+        self.db = Database(client)
 
     @property
     def interaction_id(self) -> str:

loopbot/database.py

@@ -0,0 +1,70 @@
+"""
+Database class for persistent storage
+Makes HTTP calls to the Loop API to store/retrieve data
+"""
+
+from typing import Any, Dict, Optional
+import aiohttp
+
+
+class Database:
+    """Database for persistent storage via Loop API"""
+
+    def __init__(self, client: Any):
+        self._client = client
+
+    async def get(self, key: str) -> Optional[Any]:
+        """Get a value by key"""
+        try:
+            response = await self._client.request(
+                "GET",
+                f"/sdk/db/{key}",
+            )
+            return response.get("value")
+        except Exception:
+            return None
+
+    async def set(self, key: str, value: Any) -> bool:
+        """Set a value for a key"""
+        try:
+            response = await self._client.request(
+                "POST",
+                f"/sdk/db/{key}",
+                {"value": value},
+            )
+            return response.get("success", False)
+        except Exception:
+            return False
+
+    async def delete(self, key: str) -> bool:
+        """Delete a key"""
+        try:
+            response = await self._client.request(
+                "DELETE",
+                f"/sdk/db/{key}",
+            )
+            return response.get("success", False)
+        except Exception:
+            return False
+
+    async def get_all(self) -> Dict[str, Any]:
+        """Get all data"""
+        try:
+            response = await self._client.request(
+                "GET",
+                "/sdk/db",
+            )
+            return response.get("data", {})
+        except Exception:
+            return {}
+
+    async def clear(self) -> bool:
+        """Clear all data"""
+        try:
+            response = await self._client.request(
+                "DELETE",
+                "/sdk/db",
+            )
+            return response.get("success", False)
+        except Exception:
+            return False

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: loopbot-discord-sdk
-Version: 1.0.0
+Version: 1.0.6
 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.6.dist-info}/RECORD

@@ -1,6 +1,7 @@
-loopbot/__init__.py,sha256=oIkHZq8f8ygeHGLMiYgTd8cB_PmrNFDcNZnkccES7ws,1197
-loopbot/bot.py,sha256=1KXrUJwlplc0cwrrLN_svJMSO41ToVdbGfPVvt39_m8,20615
-loopbot/client.py,sha256=oCevrQZLGXJnaIZ87KY-VkzsZGEYJiCfFpYTE5s2nnA,26790
+loopbot/__init__.py,sha256=GiSEnH3mfcy7-ez01TXQnpiOOc_vPIbdN3mMqVo37Og,1246
+loopbot/bot.py,sha256=oVknClm_tOmocrsWBGP8P7VTBIeWHx8dsB9iJPI2dNY,20699
+loopbot/client.py,sha256=s7UG3Fd_GUA6qpil5fbH3d3VFXJMDPjUX513_1Og4Fs,30124
+loopbot/database.py,sha256=LxNMDQO0wi4YxJbLEdOpHSwOs7tibvSAA-BFcN15SFA,1948
 loopbot/types.py,sha256=MZcQgVvVDSs60UqAF5lWkHNM3yo9KLKDxZaU6tKndZQ,1645
 loopbot/builders/__init__.py,sha256=STrS9XOMPsVDzx9VAvbOZW2f8fp6mITbZWzdkgmqNe4,790
 loopbot/builders/action_row.py,sha256=ouQKGpcb9KIWwUWJzUT6kH7Ov60UCZi5FjWlXC6sRVw,1225
@@ -15,12 +16,12 @@ loopbot/builders/select_menu.py,sha256=Ay5-7mCnyt4Q9Diyd50T79nZrcWoWD6BITgaWCldt
 loopbot/builders/separator.py,sha256=RWy04jS6k67wWULoSI_wlTNbV0D8L0P4XFSQgjwWe_U,882
 loopbot/builders/text_display.py,sha256=vtU9NJ_QL0Kilp-nkub6mwREXcTaEzl-OFiWWlfwmEE,653
 loopbot/context/__init__.py,sha256=Z3-t2n-LcL4FT-rrmPPB131JBL3t6kbC2RSXopvOqKU,352
-loopbot/context/base.py,sha256=7GUiEBuo12KoJ1e2K0xR_u8idZr-mnO5OSxXTmAWgzI,8104
+loopbot/context/base.py,sha256=XDH8PbtymzjEEO66_4LvdIX-ixATu3QoDOOYwM7m6SI,8173
 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.6.dist-info/METADATA,sha256=7Dp39kOpthgVKx30H0OeoznNrJsIHtvh-moxhXDXUYM,12462
+loopbot_discord_sdk-1.0.6.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+loopbot_discord_sdk-1.0.6.dist-info/top_level.txt,sha256=4sZzEMpMwz6lUz7RJzVFFh7LY-vr5W1-RAfn_bF6tks,8
+loopbot_discord_sdk-1.0.6.dist-info/RECORD,,