modifyself 0.2.4__tar.gz → 0.2.6__tar.gz

{modifyself-0.2.4 → modifyself-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modifyself
-Version: 0.2.4
+Version: 0.2.6
 Summary: A clean, pythonic Discord self-bot library
 Author-email: modifyself <modifyself@example.com>
 License-Expression: MIT

modifyself-0.2.6/modifyself/interactions.py

@@ -0,0 +1,216 @@
+"""
+Interaction handling (buttons, selects, modals).
+"""
+
+import json
+from typing import Optional, Dict, Any, List, Union, Callable, Awaitable
+from enum import IntEnum
+from dataclasses import dataclass, field
+
+from .models.message import Message
+from .models.user import User
+from .models.member import Member
+from .components import ComponentType, ButtonStyle, TextInputStyle, ActionRow, Component
+
+class InteractionType(IntEnum):
+    PING = 1
+    APPLICATION_COMMAND = 2
+    MESSAGE_COMPONENT = 3
+    APPLICATION_COMMAND_AUTOCOMPLETE = 4
+    MODAL_SUBMIT = 5
+
+class InteractionCallbackType(IntEnum):
+    PONG = 1
+    CHANNEL_MESSAGE_WITH_SOURCE = 4
+    DEFERRED_CHANNEL_MESSAGE_WITH_SOURCE = 5
+    DEFERRED_UPDATE_MESSAGE = 6
+    UPDATE_MESSAGE = 7
+    APPLICATION_COMMAND_AUTOCOMPLETE_RESULT = 8
+    MODAL = 9
+
+class Interaction:
+    """Represents a Discord interaction."""
+    
+    def __init__(self, state, data: dict):
+        self._state = state
+        self.id = int(data["id"])
+        self.application_id = int(data["application_id"])
+        self.type = InteractionType(data["type"])
+        self.token = data["token"]
+        self.version = data["version"]
+        self.guild_id = int(data["guild_id"]) if data.get("guild_id") else None
+        self.channel_id = int(data["channel_id"]) if data.get("channel_id") else None
+        
+        # Message
+        self.message = None
+        if data.get("message"):
+            self.message = Message(state=self._state, data=data["message"])
+        
+        # Member/User
+        self.member = None
+        self.user = None
+        if data.get("member"):
+            self.member = Member(state=self._state, data=data["member"], guild_id=self.guild_id)
+            self.user = self.member.user
+        elif data.get("user"):
+            self.user = User(state=self._state, data=data["user"])
+        
+        # Data
+        self.data = data.get("data", {})
+        self.custom_id = self.data.get("custom_id")
+        
+        # Values (for selects)
+        self.values = self.data.get("values")
+        
+        # Component type
+        self.component_type = self.data.get("component_type")
+    
+    @property
+    def author(self):
+        """The user who triggered the interaction."""
+        return self.user or (self.member.user if self.member else None)
+    
+    async def respond(
+        self,
+        content: Optional[str] = None,
+        embeds: Optional[List[Dict[str, Any]]] = None,
+        components: Optional[List[ActionRow]] = None,
+        **kwargs,
+    ) -> Dict[str, Any]:
+        """Respond to the interaction."""
+        payload = {
+            "type": InteractionCallbackType.CHANNEL_MESSAGE_WITH_SOURCE,
+            "data": {},
+        }
+        if content is not None:
+            payload["data"]["content"] = content
+        if embeds is not None:
+            payload["data"]["embeds"] = embeds
+        if components is not None:
+            payload["data"]["components"] = [c.to_dict() for c in components]
+        payload["data"].update(kwargs)
+        
+        await self._state.http.request(
+            method="POST",
+            url=f"/interactions/{self.id}/{self.token}/callback",
+            json=payload,
+        )
+        return payload
+    
+    async def update(
+        self,
+        content: Optional[str] = None,
+        embeds: Optional[List[Dict[str, Any]]] = None,
+        components: Optional[List[ActionRow]] = None,
+        **kwargs,
+    ) -> Dict[str, Any]:
+        """Update the message that the interaction was triggered from."""
+        payload = {
+            "type": InteractionCallbackType.UPDATE_MESSAGE,
+            "data": {},
+        }
+        if content is not None:
+            payload["data"]["content"] = content
+        if embeds is not None:
+            payload["data"]["embeds"] = embeds
+        if components is not None:
+            payload["data"]["components"] = [c.to_dict() for c in components]
+        payload["data"].update(kwargs)
+        
+        await self._state.http.request(
+            method="POST",
+            url=f"/interactions/{self.id}/{self.token}/callback",
+            json=payload,
+        )
+        return payload
+    
+    async def defer(self, ephemeral: bool = False) -> None:
+        """Defer the interaction response."""
+        payload = {
+            "type": InteractionCallbackType.DEFERRED_CHANNEL_MESSAGE_WITH_SOURCE,
+            "data": {"flags": 64 if ephemeral else 0},
+        }
+        await self._state.http.request(
+            method="POST",
+            url=f"/interactions/{self.id}/{self.token}/callback",
+            json=payload,
+        )
+    
+    async def defer_update(self) -> None:
+        """Defer the interaction response for message updates."""
+        payload = {
+            "type": InteractionCallbackType.DEFERRED_UPDATE_MESSAGE,
+            "data": {},
+        }
+        await self._state.http.request(
+            method="POST",
+            url=f"/interactions/{self.id}/{self.token}/callback",
+            json=payload,
+        )
+    
+    async def show_modal(self, modal) -> None:
+        """Show a modal to the user."""
+        payload = {
+            "type": InteractionCallbackType.MODAL,
+            "data": modal.to_dict(),
+        }
+        await self._state.http.request(
+            method="POST",
+            url=f"/interactions/{self.id}/{self.token}/callback",
+            json=payload,
+        )
+    
+    async def edit_original_response(
+        self,
+        content: Optional[str] = None,
+        embeds: Optional[List[Dict[str, Any]]] = None,
+        components: Optional[List[ActionRow]] = None,
+        **kwargs,
+    ) -> Dict[str, Any]:
+        """Edit the original response message."""
+        payload = {}
+        if content is not None:
+            payload["content"] = content
+        if embeds is not None:
+            payload["embeds"] = embeds
+        if components is not None:
+            payload["components"] = [c.to_dict() for c in components]
+        payload.update(kwargs)
+        
+        return await self._state.http.request(
+            method="PATCH",
+            url=f"/webhooks/{self.application_id}/{self.token}/messages/@original",
+            json=payload,
+        )
+    
+    async def delete_original_response(self) -> None:
+        """Delete the original response message."""
+        await self._state.http.request(
+            method="DELETE",
+            url=f"/webhooks/{self.application_id}/{self.token}/messages/@original",
+        )
+
+
+class InteractionHandler:
+    """Manages interaction callbacks."""
+    
+    def __init__(self):
+        self._handlers: Dict[str, Callable] = {}
+    
+    def on(self, custom_id: str):
+        """Decorator to register a handler for a specific custom_id."""
+        def decorator(func: Callable[[Interaction], Awaitable[None]]):
+            self._handlers[custom_id] = func
+            return func
+        return decorator
+    
+    async def handle(self, interaction: Interaction) -> bool:
+        """Handle an interaction."""
+        if interaction.custom_id in self._handlers:
+            await self._handlers[interaction.custom_id](interaction)
+            return True
+        return False
+
+
+# Global interaction handler instance
+interaction_handler = InteractionHandler()

modifyself-0.2.6/modifyself/voice.py

@@ -0,0 +1,277 @@
+"""
+Discord voice support.
+"""
+
+import asyncio
+import json
+import logging
+import socket
+import struct
+import threading
+import time
+import uuid
+from typing import Optional, List, Dict, Any, Callable, Union
+from dataclasses import dataclass
+
+try:
+    import nacl.secret
+    import nacl.utils
+    HAS_NACL = True
+except ImportError:
+    HAS_NACL = False
+
+try:
+    import opuslib
+    HAS_OPUS = True
+except ImportError:
+    HAS_OPUS = False
+
+from .http.route import Route
+from .errors import VoiceError
+
+logger = logging.getLogger(__name__)
+
+class VoiceState:
+    """Voice connection state."""
+    def __init__(self):
+        self.session_id = None
+        self.token = None
+        self.endpoint = None
+        self.guild_id = None
+        self.user_id = None
+        self.channel_id = None
+        self.mute = False
+        self.deaf = False
+        self.self_mute = False
+        self.self_deaf = False
+        self.self_stream = False
+
+
+class VoiceClient:
+    """Represents a connection to a Discord voice channel."""
+    
+    def __init__(self, client, channel_id: int, guild_id: int, endpoint: str, token: str, session_id: str):
+        self.client = client
+        self.channel_id = channel_id
+        self.guild_id = guild_id
+        self.endpoint = endpoint
+        self.token = token
+        self.session_id = session_id
+        self._state = VoiceState()
+        self._state.channel_id = channel_id
+        self._state.guild_id = guild_id
+        self._state.session_id = session_id
+        self._state.token = token
+        self._state.endpoint = endpoint
+        
+        self._ws = None
+        self._connected = False
+        self._closed = False
+        self._sequence = 0
+        self._timestamp = 0
+        self._ssrc = None
+        self._encryption = None
+        self._secret_key = None
+        self._voice_ip = None
+        self._voice_port = None
+        self._sock = None
+        
+        self._heartbeat_task = None
+        self._receive_task = None
+        self._audio_task = None
+        self._audio_queue = asyncio.Queue()
+        self._ready = asyncio.Event()
+        
+        self._handlers = {
+            "on_ready": [],
+            "on_speaking": [],
+            "on_disconnect": [],
+            "on_error": [],
+        }
+        
+        logger.info(f"Voice client created for guild {guild_id}, channel {channel_id}")
+
+    @property
+    def is_connected(self) -> bool:
+        return self._connected and not self._closed
+
+    async def connect(self) -> bool:
+        """Connect to the voice channel."""
+        if self._connected:
+            return True
+        
+        try:
+            import websockets
+            ws_url = f"wss://{self.endpoint}?v=4"
+            self._ws = await websockets.connect(ws_url)
+            
+            await self._send({
+                "op": 0,
+                "d": {
+                    "server_id": str(self.guild_id),
+                    "user_id": str(self.client.user.id),
+                    "session_id": self.session_id,
+                    "token": self.token,
+                }
+            })
+            
+            ready = await self._wait_for_event("ready", timeout=10)
+            if ready:
+                self._connected = True
+                self._ready.set()
+                logger.info("Voice connection ready")
+                await self._on_ready()
+                return True
+            
+            return False
+            
+        except Exception as e:
+            logger.error(f"Voice connection failed: {e}")
+            await self._on_error(e)
+            return False
+
+    async def disconnect(self) -> None:
+        """Disconnect from voice channel."""
+        if self._closed:
+            return
+        
+        self._closed = True
+        self._connected = False
+        self._ready.clear()
+        
+        if self._heartbeat_task:
+            self._heartbeat_task.cancel()
+        
+        if self._receive_task:
+            self._receive_task.cancel()
+        
+        if self._audio_task:
+            self._audio_task.cancel()
+        
+        if self._sock:
+            self._sock.close()
+            self._sock = None
+        
+        if self._ws:
+            await self._ws.close()
+            self._ws = None
+        
+        logger.info("Voice connection closed")
+
+    async def send_audio(self, data: bytes) -> None:
+        """Send audio data to the voice channel."""
+        if not self._connected:
+            raise VoiceError("Not connected to voice")
+        await self._audio_queue.put(data)
+
+    async def _send(self, data: dict) -> None:
+        """Send a WebSocket message."""
+        if self._ws:
+            await self._ws.send(json.dumps(data))
+
+    async def _wait_for_event(self, event_type: str, timeout: float = 10) -> Optional[dict]:
+        """Wait for a specific voice event."""
+        start = time.time()
+        while time.time() - start < timeout:
+            if self._ws:
+                try:
+                    msg = await asyncio.wait_for(self._ws.recv(), timeout=1)
+                    data = json.loads(msg)
+                    if data.get("op") == 2 and data.get("t") == event_type.upper():
+                        return data
+                except asyncio.TimeoutError:
+                    continue
+                except Exception as e:
+                    logger.error(f"Error waiting for event: {e}")
+                    break
+        return None
+
+    def on(self, event: str, callback: Callable):
+        """Register an event handler."""
+        if event not in self._handlers:
+            self._handlers[event] = []
+        self._handlers[event].append(callback)
+
+    async def _on_ready(self):
+        for callback in self._handlers.get("on_ready", []):
+            try:
+                if asyncio.iscoroutinefunction(callback):
+                    await callback(self)
+                else:
+                    callback(self)
+            except Exception as e:
+                logger.error(f"Error in on_ready handler: {e}")
+
+    async def _on_error(self, error: Exception):
+        for callback in self._handlers.get("on_error", []):
+            try:
+                if asyncio.iscoroutinefunction(callback):
+                    await callback(error)
+                else:
+                    callback(error)
+            except Exception as e:
+                logger.error(f"Error in on_error handler: {e}")
+
+    def __repr__(self) -> str:
+        return f"<VoiceClient guild={self.guild_id} channel={self.channel_id} connected={self._connected}>"
+
+
+class VoiceManager:
+    """Manages voice connections."""
+    
+    def __init__(self, client):
+        self.client = client
+        self._connections: Dict[int, VoiceClient] = {}
+        self._state: Dict[int, VoiceState] = {}
+
+    async def connect(
+        self,
+        channel_id: int,
+        guild_id: int,
+        endpoint: str,
+        token: str,
+        session_id: str,
+    ) -> VoiceClient:
+        """Create and connect a voice client."""
+        if guild_id in self._connections:
+            await self._connections[guild_id].disconnect()
+        
+        client = VoiceClient(
+            self.client,
+            channel_id,
+            guild_id,
+            endpoint,
+            token,
+            session_id,
+        )
+        
+        await client.connect()
+        self._connections[guild_id] = client
+        return client
+
+    def get_client(self, guild_id: int) -> Optional[VoiceClient]:
+        """Get the voice client for a guild."""
+        return self._connections.get(guild_id)
+
+    async def disconnect(self, guild_id: int) -> None:
+        """Disconnect a voice client."""
+        if guild_id in self._connections:
+            await self._connections[guild_id].disconnect()
+            del self._connections[guild_id]
+
+    async def disconnect_all(self) -> None:
+        """Disconnect all voice clients."""
+        for guild_id in list(self._connections.keys()):
+            await self.disconnect(guild_id)
+
+    def update_state(self, guild_id: int, state_data: dict) -> None:
+        """Update voice state."""
+        state = self._state.get(guild_id)
+        if not state:
+            state = VoiceState()
+            self._state[guild_id] = state
+        
+        state.session_id = state_data.get("session_id")
+        state.token = state_data.get("token")
+        state.endpoint = state_data.get("endpoint")
+        state.channel_id = state_data.get("channel_id")

{modifyself-0.2.4 → modifyself-0.2.6}/modifyself.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modifyself
-Version: 0.2.4
+Version: 0.2.6
 Summary: A clean, pythonic Discord self-bot library
 Author-email: modifyself <modifyself@example.com>
 License-Expression: MIT

{modifyself-0.2.4 → modifyself-0.2.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "modifyself"
-version = "0.2.4"
+version = "0.2.6"
 description = "A clean, pythonic Discord self-bot library"
 readme = "README.md"
 license = "MIT"