scurrypy 0.1.0__py3-none-any.whl

discord/resources/interaction.py

@@ -0,0 +1,155 @@
+from dataclasses import dataclass
+from typing import Optional, Unpack
+
+from ..http import HTTPClient
+from ..model import DataModel
+
+from ..parts.modal import ModalBuilder
+from ..parts.message import *
+from ..parts.embed import *
+from ..parts.component_types import *
+
+from ..models.guild import GuildModel
+from ..models.member import MemberModel
+
+from .channel import Channel
+
+class InteractionDataTypes:
+    """Interaction data types constants."""
+
+    SLASH_COMMAND = 1
+    """The interaction is a slash command."""
+
+    USER_COMMAND = 2
+    """The interaction is attached to a user."""
+
+    MESSAGE_COMMAND = 3
+    """The interaction is attached to a message."""
+
+class InteractionCallbackTypes:
+    """Interaction callback types constants."""
+
+    PONG = 1
+    """Acknowledge a Ping."""
+
+    CHANNEL_MESSAGE_WITH_SOURCE = 4
+    """Respond to an interaction with a message."""
+
+    DEFERRED_CHANNEL_MESSAGE_WITH_SOURCE = 5
+    """Acknowledge an interaction and edit a response later. User sees a loading state."""
+
+    DEFERRED_UPDATE_MESSAGE = 6
+    """Acknowledge an interaction and edit the original message later. 
+    The user does NOT see a loading state. (Components only)
+    """
+
+    UPDATE_MESSAGE = 7
+    """Edit the message in which the component was attached."""
+
+    APPLICATION_COMMAND_AUTOCOMPLETE_RESULT = 8
+    """Respond to an autocomplete interaction with suggested choices."""
+
+    MODAL = 9
+    """Respond to an interaction with a popup modal (not available for MODAL_SUBMIT and PING interactions)."""
+
+    LAUNCH_ACTIVITY = 12
+    """Launch an activity associated with the app (Activities must be enabled)."""
+
+@dataclass
+class Interaction(DataModel):
+    """Represents a Discord Interaction object."""
+
+    id: int
+    """ID of the interaction."""
+
+    token: str
+    """Continuation token for responding to the interaction."""
+
+    _http: HTTPClient
+    """HTTP session for requests."""
+
+    type: int
+    """Type of interaction."""
+
+    channel_id: int
+    """ID of the channel where the interaction was sent."""
+
+    application_id: int
+    """ID of the application that owns the interaction."""
+
+    app_permissions: int
+    """Bitwise set of permissions pertaining to the location of the interaction."""
+
+    member: MemberModel = None # guild member invoking the interaction
+    """Guild member invoking the interaction."""
+
+    locale: str = None
+    """Invoking user's locale."""
+
+    guild_locale: str = None
+    """Locale of the guild the interaction was invoked (if invoked in a guild)."""
+
+    guild_id: Optional[int] = None
+    """ID of guild the interaction was invoked (if invoked in a guild)."""
+
+    guild: Optional[GuildModel] = None
+    """Partial guild object of the guild the interaction was invoked (if invoked in a guild)."""
+
+    channel: Optional[Channel] = None
+    """Partial channel object the interaction was invoked."""
+
+    async def respond(self, message: str | MessageBuilder, **flags: Unpack[MessageFlagParams]):
+        """Create a message in response to an interaction.
+
+        Args:
+            message (str | MessageBuilder): content as a string or from MessageBuilder
+        """
+        if isinstance(message, str):
+            message = MessageBuilder(content=message).set_flags(**flags)
+
+        content = {
+            'type': InteractionCallbackTypes.CHANNEL_MESSAGE_WITH_SOURCE,
+            'data': message._to_dict()
+        }
+
+        await self._http.request(
+            'POST', 
+            f'/interactions/{self.id}/{self.token}/callback', 
+            content, 
+            files=[fp.path for fp in message.attachments])
+
+    async def update(self, message: str | MessageBuilder, **flags: Unpack[MessageFlagParams]):
+        """Update a message in response to an interaction.
+
+        Args:
+            message (str | MessageBuilder): content as a string or from MessageBuilder
+        """
+        if isinstance(message, str):
+            message = MessageBuilder(content=message).set_flags(**flags)
+
+        content = {
+            'type': InteractionCallbackTypes.UPDATE_MESSAGE,
+            'data': message._to_dict()
+        }
+
+        await self._http.request(
+            'POST', 
+            f'/interactions/{self.id}/{self.token}/callback', 
+            content, 
+            files=[fp.path for fp in message.attachments])
+
+    async def respond_modal(self, modal: ModalBuilder):
+        """Create a modal in response to an interaction.
+
+        Args:
+            modal (ModalBuilder): modal data
+        """
+        content = {
+            'type': InteractionCallbackTypes.MODAL,
+            'data': modal._to_dict()
+        }
+
+        await self._http.request(
+            'POST', 
+            f'/interactions/{self.id}/{self.token}/callback', 
+            content)

discord/resources/message.py

@@ -0,0 +1,223 @@
+from dataclasses import dataclass
+from typing import Optional
+
+from ..http import HTTPClient
+from ..model import DataModel
+
+from ..models.user import UserModel
+from ..models.emoji import EmojiModel
+from ..parts.message import MessageBuilder
+
+@dataclass
+class Message(DataModel):
+    """A Discord message."""
+
+    id: int
+    """ID of the message"""
+
+    channel_id: int
+    """Channel ID of the message."""
+
+    _http: HTTPClient
+    """HTTP session for requests."""
+
+    author: UserModel = None
+    """User data of author of the message."""
+    
+    content: str = None
+    """Content of the message."""
+
+    pinned: bool = None
+    """If the message is pinned."""
+
+    type: int = None
+    """Type of message."""
+
+    webhook_id: Optional[int] = None
+    """ID of the webhook if the message is a webhook."""
+
+    def _update(self, data: dict):
+        """Update this message in place."""
+        self.__dict__.update(Message.from_dict(data, self._http).__dict__)
+
+    async def fetch(self):
+        """Fetches the message data based on the given channel id and message id.
+
+        Returns:
+            (Message): the message object
+        """
+        data = await self._http.request('GET', f"/channels/{self.channel_id}/messages/{self.id}")
+
+        return Message.from_dict(data, self._http)
+
+    async def send(self, message: str | MessageBuilder):
+        """Sends a new message to the current channel.
+
+        Permissions:
+            * SEND_MESSAGES → required to senf your own messages
+
+        Args:
+            message (str | MessageBuilder): can be just text or the MessageBuilder for dynamic messages
+
+        Returns:
+            (Message): the new Message object with all fields populated
+        """
+        if isinstance(message, str):
+            message = MessageBuilder(content=message)
+
+        data = await self._http.request(
+            "POST",
+            f"/channels/{self.channel_id}/messages",
+            message._to_dict(),
+            files=[fp.path for fp in message.attachments] if message.attachments else None
+        )
+        return Message.from_dict(data, self._http)
+
+    async def edit(self, message: str | MessageBuilder):
+        """Edits this message.
+
+        Permissions:
+            * MANAGE_MESSAGES → ONLY if editing another user's message
+
+        Args:
+            message (str | MessageBuilder): can be just text or the MessageBuilder for dynamic messages
+        """
+        if isinstance(message, str):
+            message = MessageBuilder(content=message)
+
+        data = await self._http.request(
+            "PATCH", 
+            f"/channels/{self.channel_id}/messages/{self.id}", 
+            message._to_dict(),
+            files=[fp.path for fp in message.attachments] if message.attachments else None)
+
+        self._update(data)
+
+    async def reply(self, message: str | MessageBuilder):
+        """Reply to this message with a new message.
+
+        Permissions:
+            * SEND_MESSAGES → required to send the message
+
+        Args:
+            message (str | MessageBuilder): the new message
+        """
+        if isinstance(message, str):
+            message = MessageBuilder(content=message)
+
+        message = message._set_reference(self.id, self.channel_id)
+
+        await self._http.request(
+            'POST', 
+            f"/channels/{self.channel_id}/messages",
+            message._to_dict(),
+            files=[fp.path for fp in message.attachments] if message.attachments else None)
+
+    async def crosspost(self):
+        """Crosspost this message in an Annoucement channel to all following channels.
+
+        Permissions:
+            * SEND_MESSAGES → required to publish your own messages
+            * MANAGE_MESSAGES → required to publish messages from others
+
+        Returns:
+            (Message): the published (crossposted) message
+        """
+        data = await self._http.request('POST', f'/channels/{self.channel_id}/messages/{self.id}/crosspost')
+
+        return Message.from_dict(data, self._http)
+
+    async def delete(self):
+        """Deletes this message."""
+        await self._http.request("DELETE", f"/channels/{self.channel_id}/messages/{self.id}")
+
+    async def add_reaction(self, emoji: EmojiModel | str):
+        """Add a reaction from this message.
+
+        Permissions:
+            * READ_MESSAGE_HISTORY → required to view message
+            * ADD_REACTIONS → required to create reaction
+
+        Args:
+            emoji (EmojiModel | str): the standard emoji (str) or custom emoji (EmojiModel)
+        """
+        if isinstance(emoji, str):
+            emoji = EmojiModel(emoji)
+
+        await self._http.request(
+            "PUT",
+            f"/channels/{self.channel_id}/messages/{self.id}/reactions/{emoji.api_code}/@me")
+    
+    async def remove_reaction(self, emoji: EmojiModel | str):
+        """Remove the bot's reaction from this message.
+
+        Args:
+            emoji (EmojiModel | str): the standard emoji (str) or custom emoji (EmojiModel)
+        """
+        if isinstance(emoji, str):
+            emoji = EmojiModel(emoji)
+
+        await self._http.request(
+            "DELETE",
+            f"/channels/{self.channel_id}/messages/{self.id}/reactions/{emoji.api_code}/@me")
+
+    async def remove_user_reaction(self, emoji: EmojiModel | str, user_id: int):
+        """Remove a specific user's reaction from this message.
+
+        Permissions:
+            * MANAGE_MESSAGES → required to remove another user's reaction
+
+        Args:
+            emoji (EmojiModel | str): the standard emoji (str) or custom emoji (EmojiModel)
+            user_id (int): user's ID
+        """
+        if isinstance(emoji, str):
+            emoji = EmojiModel(emoji)
+
+        await self._http.request(
+            "DELETE",
+            f"/channels/{self.channel_id}/messages/{self.id}/reactions/{emoji.api_code}/{user_id}")
+
+    async def remove_all_reactions(self):
+        """Clear all reactions from this message.
+
+        Permissions:
+            * MANAGE_MESSAGES → required to remove all reaction
+        """
+        await self._http.request(
+            "DELETE",
+            f"/channels/{self.channel_id}/messages/{self.id}/reactions")
+
+    async def pin(self):
+        """Pin this message to its channel's pins."""
+        await self._http.request('PUT', f'/channels/{self.channel_id}/messages/pins/{self.id}')
+
+    async def unpin(self):
+        """Unpin this message from its channel's pins."""
+        await self._http.request('DELETE', f'/channels/{self.channel_id}/messages/pins/{self.id}')
+
+    def _has_prefix(self, prefix: str):
+        """Utility function. Checks if this message starts with the given prefix.
+
+        Args:
+            prefix (str): the prefix
+
+        Returns:
+            (bool): whether the message starts with the prefix
+        """
+        if not self.content:
+            return False
+        return self.content.lower().startswith(prefix.lower())
+
+    def _extract_args(self, prefix: str):
+        """Utility function. Extracts the args from this message's content.
+
+        Args:
+            prefix (str): the prefix
+
+        Returns:
+            (list[str] | None): list of args or None if no content
+        """
+        if not self.content:
+            return
+        return self.content[len(prefix):].strip().lower().split()

discord/resources/user.py

@@ -0,0 +1,111 @@
+from dataclasses import dataclass
+from typing import Optional, TypedDict, Unpack
+
+from ..http import HTTPClient
+from ..model import DataModel
+
+from ..models.guild import GuildModel
+from ..models.member import MemberModel
+
+class FetchUserGuildsParams(TypedDict, total=False):
+    before: int
+    """Get guilds before this guild ID."""
+
+    after: int
+    """Get guilds after this guild ID."""
+
+    limit: int
+    """Max number of guilds to return. Range 1 - 200. Default 200."""
+
+    with_counts: bool
+    """Include approximate member and presence count."""
+
+@dataclass
+class User(DataModel):
+    """A Discord user."""
+
+    id: int
+    """ID of the user."""
+
+    _http: HTTPClient
+    """HTTP session for requests."""
+
+    username: str = None
+    """Username of the user."""
+
+    discriminator: str = None
+    """Discriminator of the user (#XXXX)"""
+
+    global_name: str = None
+    """Global name of the user."""
+
+    avatar: str = None
+    """Image hash of the user's avatar."""
+
+    bot: Optional[bool] = None
+    """If the user is a bot."""
+
+    system: Optional[bool] = None
+    """If the user belongs to an OAuth2 application."""
+
+    mfa_enabled: Optional[bool] = None
+    """Whether the user has two factor enabled."""
+
+    banner: Optional[str] = None
+    """Image hash of the user's banner."""
+
+    accent_color: Optional[int] = None
+    """Color of user's banner represented as an integer."""
+
+    locale: Optional[str] = None
+    """Chosen language option of the user."""
+
+    async def fetch(self):
+        """Fetch this user by ID.
+        !!! note
+            Fetch includes both /users/@me AND /users/{user.id}!
+
+        Returns:
+            (User): the User object
+        """
+        data = await self._http.request('GET', f'/users/{self.id}')
+
+        return User.from_dict(data, self._http)
+    
+    async def fetch_guilds(self, **kwargs: Unpack[FetchUserGuildsParams]):
+        """Fetch this user's guilds.
+        !!! warning "Important"
+            Requires the OAuth2 guilds scope!
+
+        Args:
+            kwargs: Field-specific data
+                !!! note
+                    If no kwargs are provided, default to 200 guilds limit.
+
+        Returns:
+            (list[GuildModel]): each guild's data
+        """
+        params = {
+            'limit': 200,
+            'with_counts': False,
+            **kwargs
+        }
+
+        data = await self._http.request('GET', '/users/@me/guilds', params=params)
+
+        return [GuildModel.from_dict(guild) for guild in data]
+
+    async def fetch_guild_member(self, guild_id: int):
+        """Fetch this user's guild member data.
+        !!! warning "Important"
+            Requires the OAuth2 guilds.members.read scope!
+
+        Args:
+            guild_id (int): id of guild to fetch data from
+
+        Returns:
+            (MemberModel): member data from guild
+        """
+        data = await self._http.request('GET', f'/users/@me/{guild_id}/member')
+
+        return MemberModel.from_dict(data)

scurrypy-0.1.0.dist-info/METADATA

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: scurrypy
+Version: 0.1.0
+Summary: Discord API Wrapper in Python
+Author: Furmissile
+Requires-Python: >=3.10
+License-File: LICENSE
+Dynamic: license-file

scurrypy-0.1.0.dist-info/RECORD

@@ -0,0 +1,52 @@
+discord/__init__.py,sha256=2mkaOJP7-7iT_aSkrstLuq10QykiDa3Y2vvl-wD9r1c,185
+discord/client.py,sha256=kLwVFjUkl4qQWSj6hsxUk4F_6FDbW462roeHgRXxfW4,11986
+discord/error.py,sha256=AlislRTna554cM6KC0KrwKugzYDYtx_9C8_3QFe4XDc,2070
+discord/gateway.py,sha256=H_WaUrpK8rl3rGlT3qNexpru7R6O6Y6GQPkQcDt_KX8,6555
+discord/http.py,sha256=cGFhGEeNebf1sgSUB4Xfnlj00twWLFi9AwO85gAAUDA,10955
+discord/intents.py,sha256=Lf2fogFFDqilZeKJv7tcUgKmMW3D7ykK4bBNi-zDzYA,2866
+discord/logger.py,sha256=GBcvldIrSBnwNSgus-oa1NsYV8hU7f8_4J4VX_GmkxA,4700
+discord/model.py,sha256=Fr0PO_8UCgEep_Dk9eVtHmgzrlxkdsEYeuiS3EYK4hY,3015
+discord/dispatch/__init__.py,sha256=m7ixrbNhOV9QRORXPw6LSwxofQMAvLmPFBweBZu9ACc,20
+discord/dispatch/command_dispatcher.py,sha256=jOfO6GEQvp0muY3iE9otucsyBE36-xhMcZKMwHGnstU,5543
+discord/dispatch/event_dispatcher.py,sha256=CX-7htyG7Gi9KobFIZJYHx78km3BT0M8gymZEVCi9LM,2902
+discord/dispatch/prefix_dispatcher.py,sha256=IV2xKqCVaz-PGvg9etgqqUpMWQgvRnYEk6eURt4UqQc,1894
+discord/events/__init__.py,sha256=BcmwAj84-nzMZEkip-V903jD0ZCKqhySzlAx5wDwJoo,630
+discord/events/channel_events.py,sha256=lkBzNI-gKNgIPfIrOJhx-zjbK5v4bErEUurWp9L-VWw,1369
+discord/events/guild_events.py,sha256=4rDPbldG4kjsBmSuRasDoXc-2cYmjdJOP5PTAdEbRw8,1008
+discord/events/hello_event.py,sha256=O8Ketu_N943cnGaFkGsAHfWhgKXFQCYCqSD3EqdsXjA,225
+discord/events/interaction_events.py,sha256=5hlYOsV1ROiRXISAGCKcZo8vfk6oqiZcNzzZjSteiag,4361
+discord/events/message_events.py,sha256=M5xdaJH1zRzdZk0oN0Jykaeu9k09EjgZjeiIT_EkL1A,1475
+discord/events/reaction_events.py,sha256=xx7GD-fqakhJmS-X-HbuAUg9pg6Gqo_KRtLTdPJu7UE,2643
+discord/events/ready_event.py,sha256=iDuCTegyrN05FdYVPY0hsfJn1NABslkzsa_b2WxrRu0,792
+discord/models/__init__.py,sha256=T6C5C8RdkEPurA_zQas5riq3nrThMaSWl9Yasha0xXc,216
+discord/models/application.py,sha256=2sXtRysUc2TJ40FjdcrWgosmwMrp_h3ybddubQMixKM,924
+discord/models/emoji.py,sha256=6iz1DhWj_eTUj2KHmwMewjB3AdEBm68EmIZp2WFFCQg,932
+discord/models/guild.py,sha256=aXUByOUUIGt9d2qIGC6_X_vh0Nyib8Iqj5ZElBeNV_I,819
+discord/models/integration.py,sha256=V29RO2925mQbVXPAMt665cML3m8mJACYmdJLWwbbUyE,612
+discord/models/member.py,sha256=pkI-NVRMb3hUBkxI26FSYZxzx2mRNGXOeWWCw3BGGsY,705
+discord/models/role.py,sha256=erlERmK-IZz4YzSNY-XLNvCc-Z5PoVlClxPOX67dQJg,1169
+discord/models/user.py,sha256=lgG6GoU_7L68oHt6PGTzTkU1vrbsclRQzGjKzsLBeKA,298
+discord/parts/__init__.py,sha256=dxrdklnWRHYIbPi6KBvUcJTWky8oTHRyMQbh58_2cmA,511
+discord/parts/action_row.py,sha256=D0oUJu_0yfLojqFbKyxfiFFOv9RcFFN11nVt5_y70mk,8266
+discord/parts/attachment.py,sha256=fhWpb5e0JKfbibcEc0EOiNrzqSSAUEL87NEhRmB1H34,388
+discord/parts/channel.py,sha256=2wmEjmRqUpORzL3CFp2rugMxrpSm_LxxvlcrmWIH4r4,584
+discord/parts/command.py,sha256=CPyPO_T5ULp7j7syF9z2LztP3SF6KyX89sodz2c40Aw,2924
+discord/parts/component_types.py,sha256=qr1R0jzXpE_h9Xv4P5DyYRSuhxS0Qnm9aag-JKrJvBA,131
+discord/parts/components_v2.py,sha256=53cQm4FmxXHAA7PmDcDIO4bergX-BaUB3bZVWej-U9s,8660
+discord/parts/embed.py,sha256=_PV-lEAKn-MiXyyLa2s8JKHEplA8J9dDO80NPdZtmLk,3986
+discord/parts/message.py,sha256=egCWGUxcTqbgzz_-dxZOV1WQZpuzd6tq9uFiZH40s1Y,5499
+discord/parts/modal.py,sha256=EX6J9Mh5dAQBOZqYKzSE7SFsKLfM_B1BhcJamjBNkZw,554
+discord/parts/role.py,sha256=cK96UdgT-kU0gY5C_1LZXPrYg144x2RDmGjT28so57A,920
+discord/resources/__init__.py,sha256=ubRaTXEy4dNJhqO8JXf-xBoJjPt9zKs1GZHY8Um2_mk,282
+discord/resources/application.py,sha256=vYMTli_FSbC7venMepsJ9bkzdEQVkKYpnxCJ9K2XDho,2765
+discord/resources/bot_emojis.py,sha256=RvGCSOBkjS39P2aab0FzYUOTzBOiHX99RLrJZzAYNiU,1701
+discord/resources/channel.py,sha256=-boYdVYW0v0oaV5X1SIhfdbKn0RDFF_HJo83dreVTm0,5943
+discord/resources/guild.py,sha256=Unld1lWY3XynmRHU2FCi3-LA9VNp2thMI2BlILUTTxk,8183
+discord/resources/interaction.py,sha256=8z91X49KSknaT1syBfLr0SHRgAxaQ-8lbhkb3LU21fg,4911
+discord/resources/message.py,sha256=RtvcCRx0lwW-mHPl3aNYoEvGffrvtpLsQ2fVWckywVI,7527
+discord/resources/user.py,sha256=vk89TnCVi-6ZgbDs_TZTCXrx_NfFS5Q9Wi_itYoaoyg,3085
+scurrypy-0.1.0.dist-info/licenses/LICENSE,sha256=NtspfRMAlryd1Eev4BYi9EFbKhvdmlCJJ2-ADUoEBoI,426
+scurrypy-0.1.0.dist-info/METADATA,sha256=uRHnWjovcV97VB7PQrhVDFUotTd53CGoAY9IVEmv0Ww,186
+scurrypy-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+scurrypy-0.1.0.dist-info/top_level.txt,sha256=fJkrNbR-_8ubMBUcDEJBcfkpECrvSEmMrNKgvLlQFoM,8
+scurrypy-0.1.0.dist-info/RECORD,,

scurrypy-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

scurrypy-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,5 @@
+Copyright (c) 2025 Furmissile. All rights reserved.
+
+Derivative works are not permitted -- the source code is made available for educational and reference purposes only, and is not exempt from licensing.
+This software is provided on an "as-is" basis and the author is not responsible for any liability that may come from misuse.
+No commercial profit may be drawn off of derivatives of this software project for any reason.

scurrypy-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+discord