scurrypy 0.2.2__tar.gz → 0.3.2__tar.gz

{scurrypy-0.2.2/scurrypy.egg-info → scurrypy-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scurrypy
-Version: 0.2.2
+Version: 0.3.2
 Summary: Discord API Wrapper in Python
 Author: Furmissile
 Requires-Python: >=3.10
@@ -46,14 +46,14 @@ load_dotenv(dotenv_path='./path/to/env') # omit argument if your env file is on
 
 bot = discord.Client(
     token=os.getenv("DISCORD_TOKEN"),
-    application_id=1234567890 # replace with your bot's user ID
+    application_id=APPLICATION_ID # replace with your bot's user ID
 )
 
 @bot.command(
     command=discord.SlashCommand(name='example', description='Demonstrate the minimal slash command!'),
     guild_id=GUILD_ID # must be a guild ID your bot is in!
 )
-async def example(event: discord.InteractionEvent):
+async def example(bot: discord.Client, event: discord.InteractionEvent):
     await event.interaction.respond(f'Hello, {event.interaction.member.user.username}!')
 
 bot.run()
@@ -69,13 +69,13 @@ load_dotenv(dotenv_path='./path/to/env') # omit argument if your env file is on
 
 bot = discord.Client(
     token=os.getenv("DISCORD_TOKEN"),
-    application_id=1234567890, # replace with your bot's user ID
+    application_id=APPLICATION_ID, # replace with your bot's user ID
     intents=discord.set_intents(message_content=True),
     prefix='!' # your custom prefix
 )
 
 @bot.prefix_command
-async def ping(event: discord.MessageCreateEvent): # the function name is the name of the command!
+async def ping(bot: discord.Client, event: discord.MessageCreateEvent): # the function name is the name of the command!
     await event.message.send(f"Pong!")
 
 bot.run()

{scurrypy-0.2.2 → scurrypy-0.3.2}/README.md

@@ -36,14 +36,14 @@ load_dotenv(dotenv_path='./path/to/env') # omit argument if your env file is on
 
 bot = discord.Client(
     token=os.getenv("DISCORD_TOKEN"),
-    application_id=1234567890 # replace with your bot's user ID
+    application_id=APPLICATION_ID # replace with your bot's user ID
 )
 
 @bot.command(
     command=discord.SlashCommand(name='example', description='Demonstrate the minimal slash command!'),
     guild_id=GUILD_ID # must be a guild ID your bot is in!
 )
-async def example(event: discord.InteractionEvent):
+async def example(bot: discord.Client, event: discord.InteractionEvent):
     await event.interaction.respond(f'Hello, {event.interaction.member.user.username}!')
 
 bot.run()
@@ -59,13 +59,13 @@ load_dotenv(dotenv_path='./path/to/env') # omit argument if your env file is on
 
 bot = discord.Client(
     token=os.getenv("DISCORD_TOKEN"),
-    application_id=1234567890, # replace with your bot's user ID
+    application_id=APPLICATION_ID, # replace with your bot's user ID
     intents=discord.set_intents(message_content=True),
     prefix='!' # your custom prefix
 )
 
 @bot.prefix_command
-async def ping(event: discord.MessageCreateEvent): # the function name is the name of the command!
+async def ping(bot: discord.Client, event: discord.MessageCreateEvent): # the function name is the name of the command!
     await event.message.send(f"Pong!")
 
 bot.run()

{scurrypy-0.2.2 → scurrypy-0.3.2}/discord/client.py

@@ -6,6 +6,7 @@ from .http import HTTPClient
 from .intents import Intents
 from .error import DiscordError
 from .config import BaseConfig
+from .client_like import ClientLike
 
 from .resources.guild import Guild
 from .resources.channel import Channel
@@ -20,7 +21,7 @@ from .dispatch.event_dispatcher import EventDispatcher
 from .dispatch.prefix_dispatcher import PrefixDispatcher
 from .dispatch.command_dispatcher import CommandDispatcher
 
-class Client:
+class Client(ClientLike):
     """Main entry point for Discord bots.
         Ties together the moving parts: gateway, HTTP, event dispatching, command handling, and resource managers.
     """
@@ -39,6 +40,7 @@ class Client:
             token (str): the bot's token
             application_id (int): the bot's user ID
             intents (int, optional): gateway intents. Defaults to Intents.DEFAULT.
+            config (BaseConfig, optional): user-defined config data
             debug_mode (bool, optional): toggle debug messages. Defaults to False.
             prefix (str, optional): set message prefix if using command prefixes
             quiet (bool, optional): if INFO, DEBUG, and WARN should be logged
@@ -54,9 +56,9 @@ class Client:
         if prefix and (intents & Intents.MESSAGE_CONTENT == 0):
             self._logger.log_warn('Prefix set without message content enabled.')
 
-        self.dispatcher = EventDispatcher(self.application_id, self._http, self._logger, config)
-        self.prefix_dispatcher = PrefixDispatcher(self._http, self._logger, prefix, config)
-        self.command_dispatcher = CommandDispatcher(self.application_id, self._http, self._logger, config)
+        self.dispatcher = EventDispatcher(self)
+        self.prefix_dispatcher = PrefixDispatcher(self, prefix)
+        self.command_dispatcher = CommandDispatcher(self)
 
         self._global_commands = [] # SlashCommand
         self._guild_commands = {} # {guild_id : [commands], ...}
@@ -75,13 +77,18 @@ class Client:
         """
         self.prefix_dispatcher.register(func.__name__, func)
 
-    def component(self, func):
+    def component(self, custom_id: str):
         """Decorator registers a function for a component handler.
 
         Args:
-            func (callable): callback handle for component response
+            custom_id (str): Identifier of the component 
+                !!! warning "Important"
+                    Must match the `custom_id` set where the component was created.
         """
-        self.command_dispatcher.component(func)
+        def decorator(func):
+            self.command_dispatcher.component(func, custom_id)
+            return func
+        return decorator
 
     def command(self, command: SlashCommand | MessageCommand | UserCommand, guild_id: int = 0):
         """Decorator registers a function for a command handler.
@@ -93,13 +100,13 @@ class Client:
         def decorator(func):
             # hash out command type
             if isinstance(command, MessageCommand):
-                self.command_dispatcher.message_command(func)
+                self.command_dispatcher.message_command(command.name, func)
             elif isinstance(command, UserCommand):
-                self.command_dispatcher.user_command(func)
+                self.command_dispatcher.user_command(command.name, func)
             elif isinstance(command, SlashCommand):
-                self.command_dispatcher.command(func)
+                self.command_dispatcher.command(command.name, func)
             else:
-                raise ValueError(f'Command {func.__name__} expected to be of type SlashCommand, UserCommand, MessageCommand; \
+                raise ValueError(f'Command {command.name} expected to be of type SlashCommand, UserCommand, MessageCommand; \
                     got {type(command).__name__}.')
             
             # then hash out if this command should be guild or global level

scurrypy-0.3.2/discord/client_like.py

@@ -0,0 +1,19 @@
+from typing import Protocol
+
+from .config import BaseConfig
+from .http import HTTPClient
+from .logger import Logger
+
+class ClientLike(Protocol):
+    """Exposes a common interface for [`Client`][discord.client.Client]."""
+    application_id: int
+    """Bot's application ID."""
+
+    config: BaseConfig
+    """User-defined config."""
+
+    _http: HTTPClient
+    """HTTP session for requests."""
+
+    _logger: Logger
+    """Logger instance to log events."""

{scurrypy-0.2.2 → scurrypy-0.3.2}/discord/dispatch/command_dispatcher.py

@@ -1,8 +1,4 @@
-import asyncio
-
-from ..http import HTTPClient
-from ..logger import Logger
-from ..config import BaseConfig
+from ..client_like import ClientLike
 
 from ..events.interaction_events import ApplicationCommandData, MessageComponentData, ModalData, InteractionEvent
 from ..resources.interaction import Interaction, InteractionDataTypes
@@ -29,17 +25,20 @@ class CommandDispatcher:
     }
     """Maps [`InteractionTypes`][discord.dispatch.command_dispatcher.InteractionTypes] to their respective dataclass."""
 
-    def __init__(self, application_id: int, http: HTTPClient, logger: Logger, config: BaseConfig):
-        self.application_id = application_id
+    def __init__(self, client: ClientLike):
+        self.application_id = client.application_id
         """Bot's application ID."""
 
-        self._http = http
+        self.bot = client
+        """Bot session for user access to bot."""
+
+        self._http = client._http
         """HTTP session for requests."""
 
-        self._logger = logger
+        self._logger = client._logger
         """Logger instance to log events."""
 
-        self.config = config
+        self.config = client.config
 
         self._component_handlers = {}
         """Mapping of component custom IDs to handler."""
@@ -79,37 +78,42 @@ class CommandDispatcher:
 
         await self._http.request('PUT', f"applications/{self.application_id}/commands", global_commands)
 
-    def command(self, handler):
+    def command(self, name: str, handler):
         """Decorator to register slash commands.
 
         Args:
+            name (str): name of the command to register
             handler (callable): callback handle for command response
         """
-        self._handlers[handler.__name__] = handler
-
-    def component(self, handler):
-        """Decorator to register component interactions.
-
-        Args:
-            handler (callable): callback handle for component response
-        """
-        self._component_handlers[handler.__name__] = handler
+        self._handlers[name] = handler
 
-    def user_command(self, handler):
+    def user_command(self, name: str, handler):
         """Decorator to register user commands.
 
         Args:
+            name (str): name of the command to register
             handler (callable): callback handle for user command response
         """
-        self._user_handlers[handler.__name__] = handler
+        self._user_handlers[name] = handler
 
-    def message_command(self, handler):
+    def message_command(self, name: str, handler):
         """Decorator to register message commands.
 
         Args:
+            name (str): name of the command to register
             handler (callable): callback handle for message command response
         """
-        self._message_handlers[handler.__name__] = handler
+        self._message_handlers[name] = handler
+
+    def component(self, func, custom_id: str):
+        """Decorator to register component interactions.
+
+        Args:
+            custom_id (str): Identifier of the component 
+                !!! warning "Important"
+                    Must match the `custom_id` set where the component was created.
+        """
+        self._component_handlers[custom_id] = func
 
     async def dispatch(self, data: dict):
         """Dispatch a response to an `INTERACTION_CREATE` event
@@ -117,7 +121,7 @@ class CommandDispatcher:
         Args:
             data (dict): interaction data
         """
-        event = InteractionEvent(config=self.config, interaction=Interaction.from_dict(data, self._http))
+        event = InteractionEvent(interaction=Interaction.from_dict(data, self._http))
 
         event_data_obj = self.RESOURCE_MAP.get(event.interaction.type)
 
@@ -153,7 +157,7 @@ class CommandDispatcher:
             return
 
         try:
-            await handler(event) # NOTE: treat command options as args!
+            await handler(self.bot, event) # NOTE: treat command options as args!
             self._logger.log_info(f"Interaction Event '{name}' Acknowledged.")
         except Exception as e:
             self._logger.log_error(f"Error in interaction '{name}': {e}")

{scurrypy-0.2.2 → scurrypy-0.3.2}/discord/dispatch/event_dispatcher.py

@@ -1,6 +1,4 @@
-from ..http import HTTPClient
-from ..logger import Logger
-from ..config import BaseConfig
+from ..client_like import ClientLike
 
 from ..events.ready_event import *
 from ..events.reaction_events import *
@@ -41,17 +39,20 @@ class EventDispatcher:
     }
     """Mapping of event names to respective dataclass."""
     
-    def __init__(self, application_id: int, http: HTTPClient, logger: Logger, config: BaseConfig):
-        self.application_id = application_id
+    def __init__(self, client: ClientLike):
+        self.application_id = client.application_id
         """Bot's ID."""
 
-        self._http = http
+        self.bot = client
+        """Top-level discord client."""
+
+        self._http = client._http
         """HTTP session for requests."""
 
-        self._logger = logger
+        self._logger = client._logger
         """HTTP session for requests"""
 
-        self.config = config
+        self.config = client.config
         """User-defined bot config for persistent data."""
 
         self._handlers = {}
@@ -86,5 +87,5 @@ class EventDispatcher:
         if handler:
             obj = cls.from_dict(data, self._http)
             obj.config = self.config
-            await handler(obj)
+            await handler(self.bot, obj)
             self._logger.log_info(f"Event {event_name} Acknowledged.")

{scurrypy-0.2.2 → scurrypy-0.3.2}/discord/dispatch/prefix_dispatcher.py

@@ -1,6 +1,4 @@
-from ..http import HTTPClient
-from ..logger import Logger
-from ..config import BaseConfig
+from ..client_like import ClientLike
 
 from ..events.message_events import MessageCreateEvent
 
@@ -9,17 +7,21 @@ from ..models.member import MemberModel
 
 class PrefixDispatcher:
     """Handles text-based command messages that start with a specific prefix."""
-    def __init__(self, http: HTTPClient, logger: Logger, prefix: str, config: BaseConfig):
-        self._http = http
+    def __init__(self, client: ClientLike, prefix: str):
+
+        self.bot = client
+        """Bot session for user access to bot."""
+
+        self._http = client._http
         """HTTP session for requests."""
 
-        self._logger = logger
+        self._logger = client._logger
         """Logger instance to log events."""
 
         self.prefix = prefix
         """User-defined command prefix."""
 
-        self.config = config
+        self.config = client.config
         """User-defined bot config for persistent data."""
 
         self._handlers = {}
@@ -41,7 +43,6 @@ class PrefixDispatcher:
             data (dict): Discord's raw event payload
         """
         event = MessageCreateEvent(
-            config=self.config,
             guild_id=data.get('guild_id'),
             message=Message.from_dict(data, self._http),
             member=MemberModel.from_dict(data.get('member'))
@@ -52,7 +53,7 @@ class PrefixDispatcher:
             handler = self._handlers.get(command)
             if handler:
                 try:
-                    await handler(event, *args)
+                    await handler(self.bot, event, *args)
                     self._logger.log_info(f"Prefix Event '{command}' Acknowledged.")
                 except Exception as e:
                     self._logger.log_error(f"Error in prefix command '{command}': {e}")

{scurrypy-0.2.2 → scurrypy-0.3.2}/discord/events/channel_events.py

@@ -1,9 +1,8 @@
 from dataclasses import dataclass
 from typing import Optional
-from .event_model import EventModel
 
 @dataclass
-class GuildChannelEvent(EventModel):
+class GuildChannelEvent:
     """Base guild channel event."""
 
     id: int
@@ -46,7 +45,7 @@ class GuildChannelDeleteEvent(GuildChannelEvent):
     pass
 
 @dataclass
-class ChannelPinsUpdateEvent(EventModel):
+class ChannelPinsUpdateEvent:
     """Pin update event."""
     channel_id: int
     guild_id: Optional[int]

{scurrypy-0.2.2 → scurrypy-0.3.2}/discord/events/guild_events.py

@@ -1,10 +1,9 @@
 from dataclasses import dataclass
-from .event_model import EventModel
 from ..models import MemberModel
 from ..resources.channel import Channel
 
 @dataclass
-class GuildEvent(EventModel):
+class GuildEvent:
     """Base guild event."""
     joined_at: str
     """ISO8601 timestamp of when app joined the guild."""

{scurrypy-0.2.2 → scurrypy-0.3.2}/discord/events/interaction_events.py

@@ -1,7 +1,6 @@
 from dataclasses import dataclass, field
 from typing import Optional
 from ..model import DataModel
-from ..config import BaseConfig
 
 from ..resources.interaction import Interaction
 
@@ -142,8 +141,5 @@ class InteractionEvent(DataModel):
     interaction: Interaction
     """Interaction resource object. See [`Interaction`][discord.resources.interaction.Interaction]."""
 
-    config: BaseConfig
-    """User-defined bot config for persistent data."""
-
     data: Optional[ApplicationCommandData | MessageComponentData | ModalData] = None
     """Interaction response data."""

{scurrypy-0.2.2 → scurrypy-0.3.2}/discord/events/message_events.py

@@ -1,12 +1,11 @@
 from dataclasses import dataclass
 from typing import Optional
-from .event_model import EventModel
 
 from ..resources.message import Message
 from ..models.member import MemberModel
 
 @dataclass
-class MessageCreateEvent(EventModel):
+class MessageCreateEvent:
     """Received when a message is created."""
     message: Message
     """Message resource object. See [`Resource.Message`][discord.resources.message.Message]."""
@@ -18,7 +17,7 @@ class MessageCreateEvent(EventModel):
     """Partial Member object of the author of the message. See [`MemberModel`][discord.models.member.MemberModel]."""
     
 @dataclass
-class MessageUpdateEvent(EventModel):
+class MessageUpdateEvent:
     """Received when a message is updated."""
     message: Message
     """Message resource object. See [`Resource.Message`][discord.resources.message.Message]."""
@@ -30,7 +29,7 @@ class MessageUpdateEvent(EventModel):
     """Partial Member object of the author of the message. See [`MemberModel`][discord.models.member.MemberModel]."""
 
 @dataclass
-class MessageDeleteEvent(EventModel):
+class MessageDeleteEvent:
     """Received when a message is deleted."""
 
     id: int

{scurrypy-0.2.2 → scurrypy-0.3.2}/discord/events/reaction_events.py

@@ -1,6 +1,5 @@
 from dataclasses import dataclass
 from typing import Optional
-from .event_model import EventModel
 
 from ..models.member import MemberModel
 from ..models.emoji import EmojiModel
@@ -15,7 +14,7 @@ class ReactionType:
     """A super emoji."""
 
 @dataclass
-class ReactionAddEvent(EventModel):
+class ReactionAddEvent:
     """Reaction added event."""
 
     type: int
@@ -46,7 +45,7 @@ class ReactionAddEvent(EventModel):
     """ID of the user who sent the message where the reaction was added."""
 
 @dataclass
-class ReactionRemoveEvent(EventModel):
+class ReactionRemoveEvent:
     """Reaction removed event."""
 
     type: int
@@ -70,7 +69,7 @@ class ReactionRemoveEvent(EventModel):
     burst: bool
     """If the emoji of the removed reaction is super."""
 
-class ReactionRemoveAllEvent(EventModel):
+class ReactionRemoveAllEvent:
     """Remove all reactions event."""
 
     channel_id: int
@@ -83,7 +82,7 @@ class ReactionRemoveAllEvent(EventModel):
     """ID of the guild where all reaction were removed (if in a guild)."""
 
 @dataclass
-class ReactionRemoveEmojiEvent(EventModel):
+class ReactionRemoveEmojiEvent:
     """All reactions of a specific emoji removed."""
 
     emoji: EmojiModel

{scurrypy-0.2.2 → scurrypy-0.3.2}/discord/events/ready_event.py

@@ -1,6 +1,5 @@
 from dataclasses import dataclass
 from ..model import DataModel
-from ..config import BaseConfig
 
 from ..models.user import UserModel
 from ..models.guild import ReadyGuildModel
@@ -30,6 +29,3 @@ class ReadyEvent(DataModel):
 
     application: ApplicationModel
     """Partial application object. Contains ID and flags."""
-
-    config: BaseConfig
-    """User-defined bot config for persistent data."""

{scurrypy-0.2.2 → scurrypy-0.3.2}/discord/model.py

@@ -81,6 +81,8 @@ class DataModel:
     
         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)

scurrypy-0.3.2/discord/models/interaction.py

@@ -0,0 +1,26 @@
+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

{scurrypy-0.2.2 → scurrypy-0.3.2}/discord/parts/action_row.py

@@ -28,7 +28,6 @@ class _Button(DataModel, ActionRowChild, SectionAccessory):
 @dataclass
 class _SelectOption(DataModel):
     """Represents the Select Option component"""
-
     label: str
     value: str
     description: Optional[str] = None # appears below the label

{scurrypy-0.2.2 → scurrypy-0.3.2}/discord/resources/channel.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass
-from typing import TypedDict, Unpack, Optional
+from typing import TypedDict, Unpack, Optional, Literal
 
 from ..http import HTTPClient
 from ..model import DataModel
@@ -32,6 +32,15 @@ class PinsFetchParams(TypedDict, total=False):
     limit: int
     """Max number of pinned messages to return. Range 1 - 50. Default 50."""
 
+class ThreadFromMessageParams(TypedDict, total=False):
+    """Params when attaching a thread to a message."""
+
+    rate_limit_per_user: Literal[60, 1440, 4320, 10080]
+    """time (minutes) of inactivity before thread is archived."""
+
+    rate_limit_per_user: int
+    """time (seconds) user waits before sending another message."""
+
 @dataclass
 class PinnedMessage(DataModel):
     """Pinned message data."""
@@ -160,6 +169,26 @@ class Channel(DataModel):
 
         return self
     
+    async def create_thread_from_message(self, message_id: int, name: str, **kwargs: Unpack[ThreadFromMessageParams]):
+        """Create a thread from this message
+
+        Args:
+            message_id: ID of message to attach thread
+            name (str): thread name
+
+        Returns:
+            (Channel): The updated channel object
+        """
+
+        content = {
+            'name': name, 
+            **kwargs
+        }
+
+        data = await self._http.request('POST', f"channels/{self.id}/messages/{message_id}/threads", data=content)
+
+        return Channel.from_dict(data, self._http)
+    
     async def fetch_pins(self, **kwargs: Unpack[PinsFetchParams]):
         """Get this channel's pinned messages.
 

{scurrypy-0.2.2 → scurrypy-0.3.2}/discord/resources/interaction.py

@@ -11,6 +11,7 @@ from ..parts.component_types import *
 
 from ..models.guild import GuildModel
 from ..models.member import MemberModel
+from ..models.interaction import InteractionCallbackModel
 
 from .channel import Channel
 
@@ -98,11 +99,12 @@ class Interaction(DataModel):
     channel: Optional[Channel] = None
     """Partial channel object the interaction was invoked."""
 
-    async def respond(self, message: str | MessageBuilder, **flags: Unpack[MessageFlagParams]):
+    async def respond(self, message: str | MessageBuilder, with_response: bool = False, **flags: Unpack[MessageFlagParams]):
         """Create a message in response to an interaction.
 
         Args:
             message (str | MessageBuilder): content as a string or from MessageBuilder
+            with_response (bool, optional): if the interaction data should be returned. Defaults to False.
         """
         if isinstance(message, str):
             message = MessageBuilder(content=message).set_flags(**flags)
@@ -112,12 +114,18 @@ class Interaction(DataModel):
             'data': message._to_dict()
         }
 
-        await self._http.request(
+        params = {'with_response': with_response}
+
+        data = await self._http.request(
             'POST', 
             f'/interactions/{self.id}/{self.token}/callback', 
             content, 
-            files=[fp.path for fp in message.attachments])
+            files=[fp.path for fp in message.attachments],
+            params=params)
 
+        if with_response:
+            return InteractionCallbackModel.from_dict(data, self._http)
+        
     async def update(self, message: str | MessageBuilder, **flags: Unpack[MessageFlagParams]):
         """Update a message in response to an interaction.
 

{scurrypy-0.2.2 → scurrypy-0.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "scurrypy"
-version = "0.2.2"
+version = "0.3.2"
 
 description = "Discord API Wrapper in Python"
 readme = "README.md"

{scurrypy-0.2.2 → scurrypy-0.3.2/scurrypy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scurrypy
-Version: 0.2.2
+Version: 0.3.2
 Summary: Discord API Wrapper in Python
 Author: Furmissile
 Requires-Python: >=3.10
@@ -46,14 +46,14 @@ load_dotenv(dotenv_path='./path/to/env') # omit argument if your env file is on
 
 bot = discord.Client(
     token=os.getenv("DISCORD_TOKEN"),
-    application_id=1234567890 # replace with your bot's user ID
+    application_id=APPLICATION_ID # replace with your bot's user ID
 )
 
 @bot.command(
     command=discord.SlashCommand(name='example', description='Demonstrate the minimal slash command!'),
     guild_id=GUILD_ID # must be a guild ID your bot is in!
 )
-async def example(event: discord.InteractionEvent):
+async def example(bot: discord.Client, event: discord.InteractionEvent):
     await event.interaction.respond(f'Hello, {event.interaction.member.user.username}!')
 
 bot.run()
@@ -69,13 +69,13 @@ load_dotenv(dotenv_path='./path/to/env') # omit argument if your env file is on
 
 bot = discord.Client(
     token=os.getenv("DISCORD_TOKEN"),
-    application_id=1234567890, # replace with your bot's user ID
+    application_id=APPLICATION_ID, # replace with your bot's user ID
     intents=discord.set_intents(message_content=True),
     prefix='!' # your custom prefix
 )
 
 @bot.prefix_command
-async def ping(event: discord.MessageCreateEvent): # the function name is the name of the command!
+async def ping(bot: discord.Client, event: discord.MessageCreateEvent): # the function name is the name of the command!
     await event.message.send(f"Pong!")
 
 bot.run()

{scurrypy-0.2.2 → scurrypy-0.3.2}/scurrypy.egg-info/SOURCES.txt

@@ -3,6 +3,7 @@ README.md
 pyproject.toml
 discord/__init__.py
 discord/client.py
+discord/client_like.py
 discord/config.py
 discord/error.py
 discord/gateway.py
@@ -16,7 +17,6 @@ discord/dispatch/event_dispatcher.py
 discord/dispatch/prefix_dispatcher.py
 discord/events/__init__.py
 discord/events/channel_events.py
-discord/events/event_model.py
 discord/events/guild_events.py
 discord/events/hello_event.py
 discord/events/interaction_events.py
@@ -28,6 +28,7 @@ discord/models/application.py
 discord/models/emoji.py
 discord/models/guild.py
 discord/models/integration.py
+discord/models/interaction.py
 discord/models/member.py
 discord/models/role.py
 discord/models/user.py

scurrypy-0.2.2/discord/events/event_model.py

@@ -1,10 +0,0 @@
-from dataclasses import dataclass
-from ..model import DataModel
-from ..config import BaseConfig
-
-@dataclass
-class EventModel(DataModel):
-    """Event Model for event-driven fields common among all events."""
-
-    config: BaseConfig
-    """User-defined bot config for persistent data."""