scurrypy 0.4__py3-none-any.whl → 0.6.6__py3-none-any.whl

discord/http.py

@@ -1,280 +0,0 @@
-import aiohttp
-import aiofiles
-import asyncio
-import time
-import json
-import ssl
-from dataclasses import dataclass
-from urllib.parse import urlencode
-
-from .logger import Logger
-from .error import DiscordError
-
-ssl_ctx = ssl.create_default_context()
-ssl_ctx.options |= ssl.OP_NO_SSLv2 | ssl.OP_NO_SSLv3  # Disable old SSL
-
-DISCORD_HTTP_CODES = {
-    200: "Successful Request",
-    201: "Successful Creation",
-    204: "No Content",
-    304: "Not Modified",
-    400: "Bad Request",
-    401: "Missing Authorization",
-    403: "Missing Permission",
-    404: "Resource Not Found",
-    405: "Invalid Method",
-    429: "Rate Limited",
-    502: "Gateway Unavailable"
-}
-
-@dataclass
-class RequestItem:
-    """Data container representing an HTTP request to Discord's API.
-        Used internally by HTTPClient for queuing and processing requests.
-    """
-    method: str
-    """HTTP method (e.g., GET, POST, DELETE, PUT, PATCH)"""
-
-    url: str
-    """Fully qualifying URL for this request."""
-
-    endpoint: str
-    """Endpoint of the URL for this request."""
-
-    data: dict | None
-    """Relevant data for this request."""
-
-    files: list | None
-    """Relevant files for this request."""
-
-    future: asyncio.Future
-    """Track the result of this request."""
-
-class RouteQueue:
-    """Represents a queue of requests for a single rate-limit bucket.
-        Manages task worker that processes requests for that bucket.
-    """
-    def __init__(self):
-        self.queue = asyncio.Queue()
-        """Queue holding RequestItem for this bucket."""
-
-        self.worker = None
-        """Process for executing request for this bucket."""
-
-class HTTPClient:
-    """Handles all HTTP communication with Discord's API
-        including rate-limiting by bucket and globally, async request handling,
-        multipart/form-data file uploads, and error handling/retries.
-    """
-    def __init__(self, token: str, logger: Logger):
-        self.token = token
-        """The bot's token."""
-
-        self._logger = logger
-        """Logger instance to log events."""
-
-        self.session: aiohttp.ClientSession = None
-        """Client session instance."""
-
-        self.global_reset = 0
-        """Global rete limit cooldown if a global rate limit is active."""
-
-        self.global_lock: asyncio.Lock = None
-        """Lock on queues to avoid race conditions."""
-
-        self.pending_queue: asyncio.Queue = None
-        """Queue for requests not yet assigned to bucket."""
-
-        self.pending_worker: asyncio.Task = None
-        """Task processing for the pending queue."""
-
-        self.endpoint_to_bucket: dict[str, str] = {}
-        """Maps endpoints to rate-limit buckets"""
-
-        self.bucket_queues: dict[str, RouteQueue] = {}
-        """Maps endpoints to RouteQueue objects."""
-
-        self._sentinel = object()
-        """Sentinel to terminate session."""
-
-        self.base_url = "https://discord.com/api/v10"
-        """Base URL for discord's API requests."""
-
-    async def start_session(self):
-        """Initializes aiohttp session, queues, locks, and starting pending worker."""
-        self.session = aiohttp.ClientSession()
-        self.pending_queue = asyncio.Queue()
-        self.global_lock = asyncio.Lock()
-        self.pending_worker = asyncio.create_task(self._pending_worker())
-        self._logger.log_debug("Session started.")
-
-    async def request(self, method: str, endpoint: str, data=None, params=None, files=None):
-        """Enqueues request WRT rate-limit buckets.
-
-        Args:
-            method (str): HTTP method (e.g., POST, GET, DELETE, PATCH, etc.)
-            endpoint (str): Discord endpoint (e.g., /channels/123/messages)
-            data (dict, optional): relevant data
-            files (list[str], optional): relevant files
-
-        Returns:
-            (Future): future with response
-        """
-        url = f"{self.base_url.rstrip('/')}/{endpoint.lstrip('/')}" # normalize for single slashes
-        if params:
-            url += f"?{urlencode(params)}"
-
-        future = asyncio.get_event_loop().create_future()
-
-        if endpoint in self.endpoint_to_bucket:
-            bucket = self.endpoint_to_bucket[endpoint]
-            if bucket not in self.bucket_queues:
-                self.bucket_queues[bucket] = RouteQueue()
-                self.bucket_queues[bucket].worker = asyncio.create_task(
-                    self._route_worker(bucket)
-                )
-            await self.bucket_queues[bucket].queue.put(RequestItem(method, url, endpoint, data, files, future))
-        else:
-            await self.pending_queue.put(RequestItem(method, url, endpoint, data, files, future))
-
-        return await future
-
-    async def _pending_worker(self):
-        """Processes requests from global pending queue."""
-        while True:
-            item = await self.pending_queue.get()
-            if item is self._sentinel:
-                self.pending_queue.task_done()
-                break
-            await self._process_request(item)
-            self.pending_queue.task_done()
-
-    async def _route_worker(self, bucket: str):
-        """Processes request from specific rate-limit bucket.
-
-        Args:
-            bucket (str): endpoint
-        """
-        queue = self.bucket_queues[bucket].queue
-        while True:
-            item = await queue.get()
-            if item is self._sentinel:
-                queue.task_done()
-                break
-            await self._process_request(item)
-            queue.task_done()
-
-    async def _process_request(self, item: RequestItem):
-        """Core request execution. Handles headers, payload, files, retries, and bucket assignment.
-
-        Args:
-            item (RequestItem): incoming request
-
-        Raises:
-            DiscordError: discord error object
-        """
-        try:
-            await self._check_global_limit()
-
-            headers = {"Authorization": f"Bot {self.token}"}
-
-            # Build multipart if files exist
-            request_kwargs = {'headers': headers, 'ssl': ssl_ctx}
-
-            if item.files: # only create FormData if files exist
-                form = aiohttp.FormData()
-                form.add_field('payload_json', json.dumps(item.data))
-
-                for idx, file_path in enumerate(item.files):
-                    try:
-                        async with aiofiles.open(file_path, 'rb') as f:
-                            data = await f.read()
-                        form.add_field(
-                            f'files[{idx}]',
-                            data,
-                            filename=file_path.split('/')[-1],
-                            content_type='application/octet-stream'
-                        )
-                    except FileNotFoundError:
-                        self._logger.log_warn(f"File '{file_path}' could not be found.")
-                        break
-
-                request_kwargs['data'] = form
-
-            elif item.data is not None:
-                request_kwargs['json'] = item.data # aiohttp sets Content-Type automatically
-
-            async with self.session.request(item.method, item.url, **request_kwargs) as resp:
-                self._logger.log_debug(f"{item.method} {item.endpoint}: {resp.status} {DISCORD_HTTP_CODES.get(resp.status, 'Unknown Status')}")
-
-                # if triggered rate-limit
-                if resp.status == 429:
-                    data = await resp.json()
-                    retry_after = float(data.get("retry_after", 1))
-                    is_global = data.get("global")
-                    if is_global:
-                        self.global_reset = time.time() + retry_after
-
-                    try:
-                        self._logger.log_warn( f"You are being rate limited on {item.endpoint}. Retrying in {retry_after}s (global={is_global})")
-                        await asyncio.sleep(retry_after + 0.5)
-                    except asyncio.CancelledError:
-                        # shutdown is happening
-                        raise
-
-                    # retry the request
-                    await self._process_request(item)
-                    return
-
-                # if response failed (either lethal or recoverable)
-                elif resp.status not in [200, 201, 204]:
-                    raise DiscordError(resp.status, await resp.json())
-
-                await self._handle_response(item, resp)
-
-                # Handle rate-limit bucket headers
-                bucket = resp.headers.get("X-RateLimit-Bucket")
-                if bucket and item.endpoint not in self.endpoint_to_bucket:
-                    self.endpoint_to_bucket[item.endpoint] = bucket
-                    if bucket not in self.bucket_queues:
-                        self.bucket_queues[bucket] = RouteQueue()
-                        self.bucket_queues[bucket].worker = asyncio.create_task(
-                            self._route_worker(bucket)
-                        )
-
-        except Exception as e:
-            if not item.future.done():
-                item.future.set_exception(e)
-
-    async def _handle_response(self, item: RequestItem, resp: aiohttp.ClientResponse):
-        """Resolves future with parsed JSON/text response.
-
-        Args:
-            item (RequestItem): request data to handle
-            resp (aiohttp.ClientResponse): response for item
-        """
-        if resp.status == 204:
-            item.future.set_result((None, 204))
-        else:
-            try:
-                result = await resp.json()
-            except aiohttp.ContentTypeError:
-                result = await resp.text()
-            item.future.set_result(result)
-
-    async def _check_global_limit(self):
-        """Waits if the global rate-limit is in effect."""
-        async with self.global_lock:
-            now = time.time()
-            if now < self.global_reset:
-                await asyncio.sleep(self.global_reset - now)
-
-    async def close_session(self):  
-        """Gracefully shuts down all workes and closes aiohttp session."""      
-        # Stop workers
-        for q in self.bucket_queues.values():
-            await q.queue.put(self._sentinel)
-        await self.pending_queue.put(self._sentinel)
-        
-        if self.session and not self.session.closed:
-            await self.session.close()

discord/model.py

@@ -1,90 +0,0 @@
-from dataclasses import dataclass, fields, is_dataclass
-from typing import get_args, get_origin, Union
-
-from .http import HTTPClient
-
-@dataclass
-class DataModel:    
-    """DataModel is a base class for Discord JSONs that provides hydration from raw dicts, 
-        optional field defaults, and access to HTTP-bound methods.
-    """
-    
-    @classmethod
-    def from_dict(cls, data: dict, http: HTTPClient = None):
-        """Hydrates the given data into the dataclass child.
-
-        Args:
-            data (dict): JSON data
-            http (HTTPClient, optional): HTTP session for requests
-
-        Returns:
-            (dataclass): hydrated dataclass
-        """
-        kwargs = {}
-
-        def unwrap_optional(typ):
-            """Remove NoneType from Optional or leave Union as-is."""
-            if get_origin(typ) is Union:
-                args = tuple(a for a in get_args(typ) if a is not type(None))
-                if len(args) == 1:
-                    return args[0]  # single type left
-                else:
-                    return Union[args]  # multi-type union remains
-            return typ
-        
-        for field in fields(cls):
-            # property must be in given json!
-            value = data.get(field.name)
-            
-            inner_type = unwrap_optional(field.type)
-
-            # Handle None
-            if value is None:
-                kwargs[field.name] = None
-            # Integers stored as strings
-            elif isinstance(value, str) and value.isdigit():
-                kwargs[field.name] = int(value)
-            # Nested dataclass
-            elif is_dataclass(inner_type):
-                kwargs[field.name] = inner_type.from_dict(value, http)
-            # List type
-            elif get_origin(inner_type) is list:
-                list_type = get_args(inner_type)[0]
-                kwargs[field.name] = [
-                    list_type.from_dict(v, http) if is_dataclass(list_type) else v
-                    for v in value
-                ]
-            # Everything else (primitive, Union of primitives)
-            else:
-                kwargs[field.name] = value
-            
-        instance = cls(**kwargs)
-
-        # attach HTTP if given
-        if http:
-            instance._http = http
-
-        return instance
-
-    def _to_dict(self):
-        """Recursively turns the dataclass into a dictionary and drops empty fields.
-
-        Returns:
-            (dict): serialized dataclasss
-        """
-        def serialize(value):
-            if isinstance(value, list):
-                return [serialize(v) for v in value]
-            if isinstance(value, DataModel):
-                return value._to_dict()
-            return value
-    
-        result = {}
-        for f in fields(self):
-            if f.name.startswith('_'): # ignore private fields
-                continue
-            value = getattr(self, f.name)
-            if value not in (None, [], {}, "", 0):
-                result[f.name] = serialize(value)
-        
-        return result

discord/models/__init__.py

@@ -1 +0,0 @@
-# discord/models

discord/models/application.py

@@ -1,37 +0,0 @@
-from dataclasses import dataclass
-from ..model import DataModel
-from .user import UserModel
-from .guild import GuildModel
-
-@dataclass
-class ApplicationModel(DataModel):
-    """Represents a bot application object."""
-    id: int
-    """ID of the app."""
-
-    name: str
-    """Name of the app."""
-
-    icon: str
-    """Icon hash of the app."""
-
-    description: str
-    """Description of the app."""
-
-    bot_public: bool
-    """If other users can add this app to a guild."""
-
-    bot: UserModel
-    """Partial user obhect for the bot user associated with the app."""
-
-    owner: UserModel
-    """Partial user object for the owner of the app."""
-
-    guild_id: int
-    """Guild ID associated with the app (e.g., a support server)."""
-
-    guild: GuildModel
-    """Partial guild object of the associated guild."""
-
-    approximate_guild_count: int
-    """Approximate guild member count."""

discord/models/emoji.py

@@ -1,34 +0,0 @@
-from dataclasses import dataclass
-from ..model import DataModel
-
-from urllib.parse import quote
-
-@dataclass
-class EmojiModel(DataModel):
-    """Represents a Discord emoji."""
-    name: str
-    """Name of emoji."""
-
-    id: int = 0
-    """ID of the emoji (if custom)."""
-
-    animated: bool = False
-    """If the emoji is animated. Defaults to `False`."""
-
-    @property
-    def mention(self) -> str:
-        """For use in message content."""
-        return f"<a:{self.name}:{self.id}>" if self.animated else f"<:{self.name}:{self.id}>"
-
-    @property
-    def api_code(self) -> str:
-        """Return the correct API code for this emoji (URL-safe)."""
-        if not self.id:
-            # unicode emoji
-            return quote(self.name)
-
-        # custom emoji
-        if self.animated:
-            return quote(f"a:{self.name}:{self.id}")
-        
-        return quote(f"{self.name}:{self.id}")

discord/models/guild.py

@@ -1,35 +0,0 @@
-from dataclasses import dataclass
-from typing import Optional
-from ..model import DataModel
-from .emoji import EmojiModel
-
-@dataclass
-class ReadyGuildModel(DataModel):
-    """Guild info from Ready event."""
-    id: int
-    """ID of the associated guild."""
-
-    unavailable: bool
-    """If the guild is offline."""
-
-@dataclass
-class GuildModel(DataModel):
-    """Represents a Discord guild."""
-
-    id: int
-    """ID of the guild."""
-
-    name: str
-    """Name of the guild."""
-
-    icon: Optional[str] = None
-    """Icon hash of the guild."""
-
-    emojis: list[EmojiModel] = None
-    """List of emojis reigstered in the guild."""
-
-    approximate_member_count: Optional[int] = None
-    """Approximate member count."""
-
-    description: str = None
-    """Description of the guild."""

discord/models/integration.py

@@ -1,23 +0,0 @@
-from dataclasses import dataclass
-from typing import Optional
-from ..model import DataModel
-from .application import ApplicationModel
-
-@dataclass
-class IntegrationModel(DataModel):
-    """Represents a guild integration."""
-
-    id: int
-    """ID of the integration."""
-
-    name: str
-    """Name of the integration."""
-
-    type: str
-    """Type of integration (e.g., twitch, youtube, discord, or guild_subscription)."""
-
-    enabled: bool
-    """If the integration is enabled."""
-
-    application: Optional[ApplicationModel] = None
-    """The bot aaplication for Discord integrations."""

discord/models/interaction.py

@@ -1,26 +0,0 @@
-from dataclasses import dataclass
-from ..model import DataModel
-
-@dataclass
-class InteractionCallbackDataModel(DataModel):
-    id: int
-    """ID of the interaction."""
-
-    type: int
-    """Type of interaction."""
-
-    activity_instance_id: str
-    """Instance ID of activity if an activity was launched or joined."""
-
-    response_message_id: int
-    """ID of the message created by the interaction."""
-
-    response_message_loading: bool
-    """If the interaction is in a loading state."""
-
-    response_message_ephemeral: bool
-    """If the interaction is ephemeral."""
-
-@dataclass
-class InteractionCallbackModel(DataModel):
-    interaction: InteractionCallbackDataModel

discord/models/member.py

@@ -1,27 +0,0 @@
-from dataclasses import dataclass
-from ..model import DataModel
-from ..models.user import UserModel
-
-@dataclass
-class MemberModel(DataModel):
-    """Represents a guild member."""
-
-    roles: list[int]
-    """List of roles registered to the guild member."""
-
-    user: UserModel
-    """User data associated with the guild member."""
-
-    nick: str
-    """Server nickname of the guild member."""
-
-    avatar: str
-    """Server avatar hash of the guild mmeber."""
-
-    joined_at: str
-    """ISO8601 timestamp of when the guild member joined server."""
-    deaf: bool
-    """If the member is deaf in a VC (input)."""
-
-    mute: bool
-    """If the member is muted in VC (output)."""

discord/models/role.py

@@ -1,53 +0,0 @@
-from dataclasses import dataclass
-from typing import Optional
-from ..model import DataModel
-
-@dataclass
-class RoleColors(DataModel):
-    """Role color data."""
-
-    primary_color: int
-    """Primary color of the role."""
-
-    secondary_color: int
-    """Secondary color of the role. Creates a gradient."""
-
-    tertiary_color: int
-    """Tertiary color of the role. Creates a holographic style."""
-
-@dataclass
-class RoleModel(DataModel):
-    """Represents a Discord role."""
-
-    id: int
-    """ID of the role."""
-
-    name: str
-    """Name of the role."""
-
-    colors: RoleColors
-    """Colors of the role."""
-
-    hoist: bool
-    """If the role is pinned in user listing."""
-
-    position: int
-    """Position of the role."""
-
-    permissions: str
-    """Permission bit set."""
-
-    managed: bool
-    """If the role is managed by an integration."""
-
-    mentionable: bool
-    """If the role is mentionable."""
-
-    flags: int
-    """Role flags combined as a bitfield."""
-
-    icon: Optional[str] = None
-    """Icon hash of the role."""
-
-    unicode_emoji: Optional[str] = None
-    """Unicode emoji of the role."""

discord/models/user.py

@@ -1,15 +0,0 @@
-from dataclasses import dataclass
-
-from ..model import DataModel
-
-@dataclass
-class UserModel(DataModel):
-    """Describes the User object."""
-    id: int
-    """ID of the user."""
-
-    username: str
-    """Username of the user."""
-
-    avatar: str
-    """Avatar hash of the user."""