Pycord

https://docs.pycord.dev/en/master/
Admin
Pycord is a modern, easy to use, feature-rich, and async ready API wrapper for Discord, offering a...
Tokens:581,272
Snippets:3,630
Trust Score:7.3
Update:2 months ago
Show doc for...
Tokens:
Raw
### Start recording with a custom Sink

Source: https://docs.pycord.dev/en/master/_modules/discord/sinks/core.html

Example of how to initiate recording using a subclassed Sink instance.

```python
vc.start_recording(
    MySubClassedSink(),
    finished_callback,
    ctx.channel,
)
```

--------------------------------

### start(*args, **kwargs)

Source: https://docs.pycord.dev/en/master/ext/tasks/index.html

Starts the internal task in the event loop.

```APIDOC
## start(*args, **kwargs)

### Description
Starts the internal task in the event loop.

### Parameters
- ***args** (Any) - Optional - The arguments to use.
- ****kwargs** (Any) - Optional - The keyword arguments to use.

### Errors
- **RuntimeError** - Raised if a task has already been launched and is running.

### Returns
- **Task** - The task that has been created.
```

--------------------------------

### Basic Pycord Event Example

Source: https://docs.pycord.dev/en/master/installing.html

A minimal example demonstrating how to define a client and handle events.

```python
import discord

class MyClient(discord.Client):
    async def on_ready(self):
        print(f'Logged on as {self.user}!')

    async def on_message(self, message):
        print(f'Message from {message.author}: {message.content}')

client = MyClient()
client.run('my token goes here')
```

--------------------------------

### start(*args, **kwargs)

Source: https://docs.pycord.dev/en/master/_modules/discord/ext/tasks.html

Starts the internal task in the event loop. Returns the created asyncio.Task.

```APIDOC
## start(*args, **kwargs)

### Description
Starts the internal task in the event loop. If the task is already running, a RuntimeError is raised.

### Parameters
- **args** (Any) - Optional - The arguments to use.
- **kwargs** (Any) - Optional - The keyword arguments to use.

### Returns
- **asyncio.Task** - The task that has been created.
```

--------------------------------

### Install Pycord with Optional Dependencies

Source: https://docs.pycord.dev/en/master/installing.html

Commands to install Pycord with speed or voice support extensions.

```bash
# Linux/macOS
python3 -m pip install -U "py-cord[speed]"

# Windows
py -3 -m pip install -U py-cord[speed]
```

```bash
python3 -m pip install -U py-cord[voice]
```

--------------------------------

### Configure basic console logging

Source: https://docs.pycord.dev/en/master/logging.html

A minimal setup to output logs to the console. Place this at the start of your application.

```python
import logging

logging.basicConfig(level=logging.INFO)
```

--------------------------------

### start_recording(sink, callback=None)

Source: https://docs.pycord.dev/en/master/api/voice.html

Starts recording audio from the connected channel.

```APIDOC
## start_recording(sink, callback=None)

### Description
Starts recording audio from the current connected channel to the provided sink.

### Parameters
- **sink** (Sink) - Required - The sink to process audio packets.
- **callback** (Callable) - Optional - Function called after recording stops.
```

--------------------------------

### Install Pycord Stable

Source: https://docs.pycord.dev/en/master/installing.html

Commands to install the stable version of Pycord from PyPI.

```bash
python3 -m pip install -U py-cord
```

```bash
py -3 -m pip install -U py-cord
```

--------------------------------

### Wait for bot readiness before starting a loop

Source: https://docs.pycord.dev/en/master/ext/tasks/index.html

Use the before_loop decorator to perform setup tasks, such as waiting for the bot to be ready, before the loop begins.

```python
from discord.ext import tasks, commands

class MyCog(commands.Cog):
    def __init__(self, bot):
        self.index = 0
        self.bot = bot
        self.printer.start()

    def cog_unload(self):
        self.printer.cancel()

    @tasks.loop(seconds=5.0)
    async def printer(self):
        print(self.index)
        self.index += 1

    @printer.before_loop
    async def before_printer(self):
        print('waiting...')
        await self.bot.wait_until_ready()
```

--------------------------------

### Install Pycord Pre-release

Source: https://docs.pycord.dev/en/master/installing.html

Commands to install the latest pre-release version of Pycord.

```bash
python3 -m pip install -U py-cord --pre
```

```bash
py -3 -m pip install -U py-cord --pre
```

--------------------------------

### start_recording

Source: https://docs.pycord.dev/en/master/_modules/discord/voice/client.html

Starts recording audio from the voice channel into the provided sink.

```APIDOC
## start_recording(sink, callback=None)

### Description
Starts recording audio packets into the specified Sink. Note that voice reception is currently affected by Discord's DAVE protocol.

### Parameters
- **sink** (Sink) - Required - The Sink in which all audio packets will be processed.
- **callback** (Callable[[Exception | None], Any]) - Optional - A function called after recording stops, taking an exception parameter.

### Raises
- **RecordingException** - Raised if not connected to a voice channel or already recording.
- **TypeError** - Raised if the provided sink is not a Sink object.
```

--------------------------------

### connect()

Source: https://docs.pycord.dev/en/master/api/clients.html

Creates a WebSocket connection to Discord and starts the event loop.

```APIDOC
## connect(reconnect=True)

### Description
Creates a WebSocket connection and lets the WebSocket listen to messages from Discord. This is a coroutine.

### Parameters
- **reconnect** (bool) - Optional - If we should attempt reconnecting, either due to internet failure or a specific failure on Discord's part.

### Raises
- **GatewayNotFound** - The gateway to connect to Discord is not found.
- **ConnectionClosed** - The WebSocket connection has been terminated.
```

--------------------------------

### Configure Application Install Parameters

Source: https://docs.pycord.dev/en/master/_modules/discord/appinfo.html

Manages OAuth2 scopes and permissions for adding applications to guilds.

```python
class AppInstallParams:
    """Represents the settings for the custom authorization URL of an application.

    .. versionadded:: 2.7

    Attributes
    ----------
    scopes: List[:class:`str`]
        The list of OAuth2 scopes for adding the application to a guild.
    permissions: :class:`Permissions`
        The permissions to request for the bot role in the guild.
    """

    __slots__ = ("scopes", "permissions")

    def __init__(self, data: AppInstallParamsPayload) -> None:
        self.scopes: list[str] = data.get("scopes", [])
        self.permissions: Permissions = Permissions(int(data["permissions"]))

    def _to_payload(self) -> dict[str, object]:
        """Serialize this object into an application install params payload.

        .. versionadded:: 2.8

        Returns
        -------
        Dict[str, Any]
            A dict with ``scopes`` and ``permissions`` (string form) suitable for the API.
        """
        if self.permissions.value > 0 and "bot" not in self.scopes:
            raise ValueError(
                "'bot' must be in install_params.scopes if permissions are requested"
            )
        return {
            "scopes": list(self.scopes),
            "permissions": str(self.permissions.value),
        }
```

--------------------------------

### Setup Cog

Source: https://docs.pycord.dev/en/master/ext/pages/index.html

Register the paginator test cog with the bot instance.

```python
def setup(bot):
    bot.add_cog(PageTest(bot))
```

--------------------------------

### await bot.connect(reconnect=True)

Source: https://docs.pycord.dev/en/master/api/clients.html

Creates a WebSocket connection and starts the event loop.

```APIDOC
## await bot.connect(reconnect=True)

### Description
Creates a WebSocket connection and lets the WebSocket listen to messages from Discord. This is a loop that runs the entire event system.

### Parameters
- **reconnect** (bool) - Optional - If we should attempt reconnecting, either due to internet failure or a specific failure on Discord’s part.
```

--------------------------------

### Implement setup and teardown

Source: https://docs.pycord.dev/en/master/ext/commands/extensions.html

The teardown function provides a hook to perform cleanup tasks when an extension is unloaded.

```python
def setup(bot):
    print('I am being loaded!')

def teardown(bot):
    print('I am being unloaded!')
```

--------------------------------

### Start the Discord Client

Source: https://docs.pycord.dev/en/master/_modules/discord/client.html

A shorthand coroutine that logs in and connects the client to Discord.

```python
async def start(self, token: str, *, reconnect: bool = True) -> None:
    """|coro|

    A shorthand coroutine for :meth:`login` + :meth:`connect`.

    Raises
    ------
    TypeError
        An unexpected keyword argument was received.
    """
    await self.login(token)
    await self.connect(reconnect=reconnect)
```

--------------------------------

### Load Extension from Module Spec

Source: https://docs.pycord.dev/en/master/_modules/discord/cog.html

Loads an extension using its module specification and executes the setup function.

```python
def _load_from_module_spec(
    self, spec: importlib.machinery.ModuleSpec, key: str
) -> None:
    # precondition: key not in self.__extensions
    lib = importlib.util.module_from_spec(spec)
    sys.modules[key] = lib
    try:
        spec.loader.exec_module(lib)  # type: ignore
    except Exception as e:
        del sys.modules[key]
        raise errors.ExtensionFailed(key, e) from e

    try:
        setup = getattr(lib, "setup")
    except AttributeError:
        del sys.modules[key]
        raise errors.NoEntryPointError(key)

    try:
        setup(self)
    except Exception as e:
        del sys.modules[key]
        self._remove_module_references(lib.__name__)
        self._call_module_finalizers(lib, key)
        raise errors.ExtensionFailed(key, e) from e
    else:
        self.__extensions[key] = lib
```

--------------------------------

### Configure Integration Types

Source: https://docs.pycord.dev/en/master/_modules/discord/appinfo.html

Handles per-installation context configuration for guild and user installation types.

```python
class IntegrationTypesConfig:
    """Represents per-installation context configuration for an application.

    This object is used to build the payload for the ``integration_types_config`` field when editing an application.

    .. versionadded:: 2.8

    Parameters
    ----------
    guild: Optional[:class:`AppInstallParams`]
        The configuration for the guild installation context. Omit to leave unchanged; pass ``None`` to clear.
    user: Optional[:class:`AppInstallParams`]
        The configuration for the user installation context. Omit to leave unchanged; pass ``None`` to clear.
    """

    __slots__ = ("guild", "user")

    def __init__(
        self,
        *,
        guild: AppInstallParams | None = utils.MISSING,
        user: AppInstallParams | None = utils.MISSING,
    ) -> None:
        self.guild: AppInstallParams | None = guild
        self.user: AppInstallParams | None = user

    @staticmethod
    def _get_ctx(
        raw: dict[int | str, dict[str, object] | None] | None, key: int
    ) -> dict[str, object] | None:
        if raw is None:
            return None
        if key in raw:
            return raw[key]
        skey = str(key)
        return raw.get(skey)

    @staticmethod
    def _decode_ctx(value: dict[str, Any] | None) -> AppInstallParams | None:
        if value is None:
            return None
        params = value.get("oauth2_install_params")
        if not params:
            return None
        return AppInstallParams(params)

    @classmethod
    def from_payload(
        cls, data: dict[int | str, dict[str, Any] | None] | None
    ) -> IntegrationTypesConfig | None:
        if data is None:
            return None
        guild_ctx = cls._decode_ctx(cls._get_ctx(data, 0))
        user_ctx = cls._decode_ctx(cls._get_ctx(data, 1))
        return cls(guild=guild_ctx, user=user_ctx)

    def _encode_install_params(
        self, value: AppInstallParams | None
    ) -> dict[str, dict[str, Any]] | None:
        if value is None:
            return None
        return {"oauth2_install_params": value._to_payload()}

    def _to_payload(self) -> dict[int, dict[str, dict[str, Any]] | None]:
        """Serialize this configuration into the payload expected by the API.

        Returns
        -------
        Dict[int, Dict[str, Dict[str, Any]] | None]
            Mapping of integration context IDs to encoded install parameters, or ``None`` to clear.
"
```

--------------------------------

### Get starting message

Source: https://docs.pycord.dev/en/master/_modules/discord/threads.html

Returns the message that started the thread, using the thread ID.

```python
@property
def starting_message(self) -> Message | None:
    """Returns the message that started this thread.

    The message might not be valid or point to an existing message.

    .. note::
        The ID for this message is the same as the thread ID.

    Returns
    -------
    Optional[:class:`Message`]
        The message that started this thread or ``None`` if not found in the cache.
    """
    return self._state._get_message(self.id)
```

--------------------------------

### Set Up Virtual Environment

Source: https://docs.pycord.dev/en/master/installing.html

Commands to create and activate a virtual environment for your project.

```bash
$ cd your-bot-source
$ python3 -m venv bot-env
```

```bash
$ source bot-env/bin/activate
```

```bash
$ bot-env\Scripts\activate.bat
```

```bash
$ pip install -U py-cord
```

--------------------------------

### Define NoEntryPointError

Source: https://docs.pycord.dev/en/master/_modules/discord/errors.html

Exception raised when an extension lacks the required setup entry point function.

```python
class NoEntryPointError(ExtensionError):
    """An exception raised when an extension does not have a ``setup`` entry point function.

    This inherits from :exc:`ExtensionError`
    """

    def __init__(self, name: str) -> None:
        super().__init__(f"Extension {name!r} has no 'setup' function.", name=name)
```

--------------------------------

### Initialize OnboardingPrompt

Source: https://docs.pycord.dev/en/master/_modules/discord/onboarding.html

Constructs an onboarding prompt instance. The ID is automatically generated if not provided.

```python
def __init__(
    self,
    type: PromptType,
    title: str,
    options: list[PromptOption],
    single_select: bool,
    required: bool,
    in_onboarding: bool,
    id: int | None = None,  # Currently optional as users can manually create these
):
    # ID is required when making edits, but it can be any snowflake that isn't already used by another prompt during edits
    self.id: int = int(id) if id else generate_snowflake()

    self.type: PromptType = type
    if isinstance(self.type, int):
        self.type = try_enum(PromptType, self.type)
    self.options: list[PromptOption] = options
    self.title: str = title
    self.single_select: bool = single_select
    self.required: bool = required
    self.in_onboarding: bool = in_onboarding
```

--------------------------------

### Initialize HelpCommand

Source: https://docs.pycord.dev/en/master/_modules/discord/ext/commands/help.html

Constructor for the HelpCommand class, setting up default configuration options like width, indentation, and pagination.

```python
def __init__(self, **options):
    self.width = options.pop("width", 80)
    self.indent = options.pop("indent", 2)
    self.sort_commands = options.pop("sort_commands", True)
    self.dm_help = options.pop("dm_help", False)
    self.dm_help_threshold = options.pop("dm_help_threshold", 1000)
    self.commands_heading = options.pop("commands_heading", "Commands:")
    self.no_category = options.pop("no_category", "No Category")
    self.paginator = options.pop("paginator", None)

    if self.paginator is None:
        self.paginator = Paginator()

    super().__init__(**options)
```

--------------------------------

### start_recording(sink, callback=None, *args, sync_start=MISSING)

Source: https://docs.pycord.dev/en/master/_modules/discord/voice/client.html

Initiates recording of audio from the connected channel to a sink.

```APIDOC
## start_recording(sink, callback=None, *args, sync_start=MISSING)

### Description
Start recording the audio from the current connected channel to the provided sink.

### Parameters
- **sink** (Sink) - Required - The sink object to record audio into.
- **callback** (AfterCallback) - Optional - A callback function to execute after recording.
- **sync_start** (bool) - Optional - Whether to synchronize the start of the recording.
```

--------------------------------

### Start a Scheduled Event

Source: https://docs.pycord.dev/en/master/_modules/discord/scheduled_events.html

Starts a scheduled event that is currently in the scheduled status.

```python
    async def start(self, *, reason: str | None = None) -> None:
        """|coro|

        Starts the scheduled event. Shortcut from :meth:`.edit`.

        .. note::

            This method can only be used if :attr:`.status` is :attr:`ScheduledEventStatus.scheduled`.

        Parameters
        ----------
        reason: Optional[:class:`str`]
            The reason to show in the audit log.

        Returns
        -------
        Optional[:class:`.ScheduledEvent`]
            The newly updated scheduled event object.

        Raises
        ------
        Forbidden
            You do not have the Manage Events permission.
        HTTPException
            The operation failed.
        """
        return await self.edit(status=ScheduledEventStatus.active, reason=reason)
```

--------------------------------

### Initialize FFmpegOpusAudio with from_probe

Source: https://docs.pycord.dev/en/master/_modules/discord/player.html

Create an FFmpegOpusAudio instance by probing the source file for audio metadata.

```python
source = await discord.FFmpegOpusAudio.from_probe("song.webm")
voice_client.play(source)
```

```python
source = await discord.FFmpegOpusAudio.from_probe("song.webm", method='fallback')
voice_client.play(source)
```

```python
def custom_probe(source, executable):
    # some analysis code here
    return codec, bitrate

source = await discord.FFmpegOpusAudio.from_probe("song.webm", method=custom_probe)
voice_client.play(source)
```

--------------------------------

### Initialize BotBase

Source: https://docs.pycord.dev/en/master/_modules/discord/bot.html

Sets up the initial state for the bot, including command contexts, integration types, and owner configurations.

```python
def __init__(self, description=None, *args, **options):
        super().__init__(*args, **options)
        self.__cogs = {}  # TYPE: Dict[str, Cog]
        self.__extensions = {}  # TYPE: Dict[str, types.ModuleType]
        self._checks = []  # TYPE: List[Check]
        self._check_once = []
        self._before_invoke = None
        self._after_invoke = None
        self.description = inspect.cleandoc(description) if description else ""
        self.owner_id = options.get("owner_id")
        self.owner_ids = options.get("owner_ids", set())
        self.auto_sync_commands = options.get("auto_sync_commands", True)

        self.debug_guilds = options.pop("debug_guilds", None)
        self.default_command_contexts = options.pop(
            "default_command_contexts",
            {
                InteractionContextType.guild,
                InteractionContextType.bot_dm,
                InteractionContextType.private_channel,
            },
        )

        self.default_command_integration_types = options.pop(
            "default_command_integration_types",
            {
                IntegrationType.guild_install,
            },
        )

        if self.owner_id and self.owner_ids:
            raise TypeError("Both owner_id and owner_ids are set.")
```

--------------------------------

### Client Initialization

Source: https://docs.pycord.dev/en/master/api/clients.html

Configuration parameters for initializing a new Client instance.

```APIDOC
## Client Configuration

### Parameters
- **max_messages** (int) - Optional - The maximum number of messages to store in the internal message cache. Defaults to 1000.
- **loop** (AbstractEventLoop) - Optional - The asyncio event loop to use for asynchronous operations.
- **connector** (aiohttp.BaseConnector) - Optional - The connector to use for connection pooling.
- **proxy** (str) - Optional - Proxy URL.
- **proxy_auth** (aiohttp.BasicAuth) - Optional - Proxy HTTP Basic Authorization object.
- **shard_id** (int) - Optional - Integer starting at 0 and less than shard_count.
- **shard_count** (int) - Optional - The total number of shards.
- **application_id** (int) - Required - The client’s application ID.
- **intents** (Intents) - Required - The intents to enable for the session.
- **capabilities** (GatewayCapabilities) - Optional - Gateway capabilities to include with the IDENTIFY payload.
- **member_cache_flags** (MemberCacheFlags) - Optional - Control over how the library caches members.
- **chunk_guilds_at_startup** (bool) - Optional - Indicates if on_ready should be delayed to chunk all guilds at start-up.
- **status** (Status) - Optional - Initial presence status.
- **activity** (BaseActivity) - Optional - Initial presence activity.
- **allowed_mentions** (AllowedMentions) - Optional - Default mention handling.
- **heartbeat_timeout** (float) - Required - Seconds before timing out the WebSocket if no HEARTBEAT_ACK is received.
- **guild_ready_timeout** (float) - Required - Seconds to wait for the GUILD_CREATE stream to end.
- **assume_unsync_clock** (bool) - Required - Whether to assume the system clock is unsynced for rate limit handling.
- **enable_debug_events** (bool) - Required - Whether to enable gateway debug events.
- **cache_app_emojis** (bool) - Required - Whether to automatically fetch and cache application emojis.
- **cache_default_sounds** (bool) - Required - Whether to automatically fetch and cache default soundboard sounds.
```

--------------------------------

### Install Linux Voice Dependencies

Source: https://docs.pycord.dev/en/master/installing.html

Command to install required system dependencies for voice support on Debian-based systems.

```bash
$ apt install libffi-dev libnacl-dev python3-dev
```

--------------------------------

### load_extension(name, package=None, recursive=False, store=False)

Source: https://docs.pycord.dev/en/master/_modules/discord/cog.html

Loads an extension or a folder of extensions into the bot. An extension must define a global 'setup' function as an entry point.

```APIDOC
## load_extension(name, package=None, recursive=False, store=False)

### Description
Loads an extension or a folder of extensions into the bot. The extension must have a global 'setup' function defined as the entry point.

### Parameters
- **name** (str) - Required - The extension or folder name to load (dot-separated).
- **package** (str) - Optional - The package name to resolve relative imports with. Defaults to None.
- **recursive** (bool) - Optional - Whether to recursively load subdirectories. Defaults to False.
- **store** (bool) - Optional - If True, exceptions are stored in a dictionary; if False, exceptions are raised. Defaults to False.

### Returns
- **Optional[Union[Dict[str, Union[errors.ExtensionError, bool]], List[str]]]** - Returns a dictionary of load statuses if store is True, or a list of loaded extension names if store is False.

### Raises
- **ExtensionNotFound** - The extension could not be imported or resolved.
- **ExtensionAlreadyLoaded** - The extension is already loaded.
- **NoEntryPointError** - The extension does not have a setup function.
- **ExtensionFailed** - The extension or its setup function had an execution error.
```

--------------------------------

### Encode Application Installation Parameters

Source: https://docs.pycord.dev/en/master/_modules/discord/appinfo.html

Internal method for serializing guild and user installation parameters into a payload dictionary.

```python
        .. versionadded:: 2.8
        """
        payload: dict[int, dict[str, dict[str, Any]] | None] = {}
        if self.guild is not utils.MISSING:
            payload[0] = self._encode_install_params(self.guild)
        if self.user is not utils.MISSING:
            payload[1] = self._encode_install_params(self.user)
        return payload
```

--------------------------------

### guild.templates

Source: https://docs.pycord.dev/en/master/_modules/discord/guild.html

Gets the list of templates from this guild.

```APIDOC
## guild.templates()

### Description
Gets the list of templates from this guild. Requires manage_guild permissions.

### Returns
- **List[Template]** - The templates for this guild.

### Raises
- **Forbidden** - Missing manage_guild permissions.
```

--------------------------------

### await webhooks()

Source: https://docs.pycord.dev/en/master/api/models.html

Gets the list of webhooks from this channel.

```APIDOC
## await webhooks()

### Description
Gets the list of webhooks from this channel. Requires manage_webhooks permissions.

### Returns
- **list[Webhook]** - The webhooks for this channel.
```

--------------------------------

### Create and use a Webhook with aiohttp

Source: https://docs.pycord.dev/en/master/api/webhooks.html

Demonstrates initializing a webhook from a URL using an aiohttp session and sending a message.

```python
from discord import Webhook
import aiohttp

async def foo():
    async with aiohttp.ClientSession() as session:
        webhook = Webhook.from_url('url-here', session=session)
        await webhook.send('Hello World', username='Foo')
```

--------------------------------

### fetch_stage_instance

Source: https://docs.pycord.dev/en/master/_modules/discord/client.html

Gets a StageInstance for a stage channel id.

```APIDOC
## fetch_stage_instance(channel_id)

### Description
Gets a StageInstance for a stage channel id.

### Parameters
- **channel_id** (int) - Required - The stage channel ID.

### Returns
- **StageInstance** - The stage instance from the stage channel ID.
```

--------------------------------

### Define a basic extension

Source: https://docs.pycord.dev/en/master/ext/commands/extensions.html

An extension requires a setup function that accepts the bot instance to register commands or other functionality.

```python
from discord.ext import commands

@commands.command()
async def hello(ctx):
    await ctx.send(f'Hello {ctx.author.display_name}.')

def setup(bot):
    bot.add_command(hello)
```

--------------------------------

### fetch_template

Source: https://docs.pycord.dev/en/master/_modules/discord/client.html

Gets a Template from a discord.new URL or code.

```APIDOC
## fetch_template(code)

### Description
Gets a Template from a discord.new URL or code.

### Parameters
- **code** (Union[Template, str]) - Required - The Discord Template Code or URL.

### Returns
- **Template** - The template from the URL/code.
```

--------------------------------

### onboarding

Source: https://docs.pycord.dev/en/master/api/models.html

Retrieves the onboarding flow for the guild.

```APIDOC
## await onboarding()

### Description
Returns the Onboarding flow for the guild. This is a coroutine.

### Returns
- **Onboarding** - The onboarding flow for the guild.

### Raises
- **HTTPException** - Retrieving the onboarding flow failed.
```

--------------------------------

### ScheduledEvent.start()

Source: https://docs.pycord.dev/en/master/_modules/discord/scheduled_events.html

Starts the scheduled event. Can only be used if the status is scheduled.

```APIDOC
## start(*, reason=None)

### Description
Starts the scheduled event. Shortcut from .edit().

### Parameters
- **reason** (str) - Optional - The reason to show in the audit log.

### Returns
- **ScheduledEvent** - The newly updated scheduled event object.
```

--------------------------------

### before_loop(coro)

Source: https://docs.pycord.dev/en/master/_modules/discord/ext/tasks.html

Registers a coroutine to be called before the loop starts.

```APIDOC
## before_loop(coro)

### Description
A decorator that registers a coroutine to be called before the loop starts running.

### Parameters
- **coro** (coroutine) - Required - The coroutine to register.

### Raises
- **TypeError** - Raised if the function is not a coroutine.
```

--------------------------------

### MinimalHelpCommand Implementation

Source: https://docs.pycord.dev/en/master/_modules/discord/ext/commands/help.html

A minimal implementation of the HelpCommand class with configurable attributes and initialization logic.

```python
class MinimalHelpCommand(HelpCommand):
    """An implementation of a help command with minimal output.

    This inherits from :class:`HelpCommand`.

    Attributes
    ----------
    sort_commands: :class:`bool`
        Whether to sort the commands in the output alphabetically. Defaults to ``True``.
    commands_heading: :class:`str`
        The command list's heading string used when the help command is invoked with a category name.
        Useful for i18n. Defaults to ``"Commands"``
    aliases_heading: :class:`str`
        The alias list's heading string used to list the aliases of the command. Useful for i18n.
        Defaults to ``"Aliases:"``.
    dm_help: Optional[:class:`bool`]
        A tribool that indicates if the help command should DM the user instead of
        sending it to the channel it received it from. If the boolean is set to
        ``True``, then all help output is DM'd. If ``False``, none of the help
        output is DM'd. If ``None``, then the bot will only DM when the help
        message becomes too long (dictated by more than :attr:`dm_help_threshold` characters).
        Defaults to ``False``.
    dm_help_threshold: Optional[:class:`int`]
        The number of characters the paginator must accumulate before getting DM'd to the
        user if :attr:`dm_help` is set to ``None``. Defaults to 1000.
    no_category: :class:`str`
        The string used when there is a command which does not belong to any category(cog).
        Useful for i18n. Defaults to ``"No Category"``
    paginator: :class:`Paginator`
        The paginator used to paginate the help command output.
    """

    def __init__(self, **options):
        self.sort_commands = options.pop("sort_commands", True)
        self.commands_heading = options.pop("commands_heading", "Commands")
        self.dm_help = options.pop("dm_help", False)
        self.dm_help_threshold = options.pop("dm_help_threshold", 1000)
        self.aliases_heading = options.pop("aliases_heading", "Aliases:")
        self.no_category = options.pop("no_category", "No Category")
        self.paginator = options.pop("paginator", None)

        if self.paginator is None:
            self.paginator = Paginator(suffix=None, prefix=None)

        super().__init__(**options)

    async def send_pages(self):
        """A helper utility to send the page output from :attr:`paginator` to the destination."""
        destination = self.get_destination()
        for page in self.paginator.pages:
            await destination.send(page)

    def get_opening_note(self):
        """Returns help command's opening note. This is mainly useful to override for i18n purposes.

        The default implementation returns ::

            Use `{prefix}{command_name} [command]` for more info on a command.
            You can also use `{prefix}{command_name} [category]` for more info on a category.
```

--------------------------------

### Invoke a command

Source: https://docs.pycord.dev/en/master/ext/commands/commands.html

Example of how a user invokes a command with a prefix.

```text
$foo abc
```

--------------------------------

### Get Item from Section

Source: https://docs.pycord.dev/en/master/_modules/discord/ui/section.html

Retrieves an item by its ID or custom_id.

```python
def get_item(self, id: int | str) -> ViewItem | None:
    """Get an item from this section. Alias for `utils.get(section.walk_items(), ...)`.
    If an ``int`` is provided, it will be retrieved by ``id``, otherwise it will check the accessory's ``custom_id``.

    Parameters
    ----------
    id: Union[:class:`str`, :class:`int`]
        The id or custom_id of the item to get.

    Returns
    -------
    Optional[:class:`ViewItem`]
        The item with the matching ``id`` if it exists.
    """
    if not id:
        return None
    attr = "id" if isinstance(id, int) else "custom_id"
    if self.accessory and id == getattr(self.accessory, attr, None):
        return self.accessory
    child = find(lambda i: getattr(i, attr, None) == id, self.items)
    return child
```

--------------------------------

### Prepare and Send Bot Help

Source: https://docs.pycord.dev/en/master/_modules/discord/ext/commands/help.html

Internal methods for preparing the help command state and generating the bot-wide help overview.

```python
async def prepare_help_command(self, ctx, command):
    self.paginator.clear()
    await super().prepare_help_command(ctx, command)

async def send_bot_help(self, mapping):
    ctx = self.context
    bot = ctx.bot

    if bot.description:
        # <description> portion
        self.paginator.add_line(bot.description, empty=True)

    no_category = f"\u200b{self.no_category}:"

    def get_category(command, *, no_category=no_category):
        cog = command.cog
        return f"{cog.qualified_name}:" if cog is not None else no_category

    filtered = await self.filter_commands(bot.commands, sort=True, key=get_category)
    max_size = self.get_max_size(filtered)
    to_iterate = itertools.groupby(filtered, key=get_category)
```

--------------------------------

### Get Channel Type

Source: https://docs.pycord.dev/en/master/_modules/discord/channel.html

Returns the Discord channel type.

```python
@property
def type(self) -> ChannelType:
    """The channel's Discord type."""
    return ChannelType.stage_voice
```

--------------------------------

### Define Slash Command Options

Source: https://docs.pycord.dev/en/master/_modules/discord/commands/options.html

Demonstrates how to use the Option class to define command parameters with types, descriptions, and constraints.

```python
@bot.slash_command(guild_ids=[...])
async def hello(
    ctx: discord.ApplicationContext,
    name: Option(str, "Enter your name"),
    age: Option(int, "Enter your age", min_value=1, max_value=99, default=18)
    # passing the default value makes an argument optional
    # you also can create optional argument using:
    # age: Option(int, "Enter your age") = 18
):
    await ctx.respond(f"Hello! Your name is {name} and you are {age} years old.")
```

--------------------------------

### Add onboarding prompt

Source: https://docs.pycord.dev/en/master/_modules/discord/onboarding.html

Creates and adds a new prompt to the onboarding flow. Requires manage_guild and manage_roles permissions.

```python
    async def add_prompt(
        self,
        type: PromptType,
        title: str,
        options: list[PromptOption],
        single_select: bool,
        required: bool,
        in_onboarding: bool,
        *,
        reason: str | None = None,
    ):
        """|coro|

        Adds a new onboarding prompt.

        You must have the :attr:`~Permissions.manage_guild` and :attr:`~Permissions.manage_roles` permissions in the
        guild to do this.

        Parameters
        ----------
        type: :class:`PromptType`
            The type of onboarding prompt.
        title: :class:`str`
            The prompt's title.
        options: List[:class:`PromptOption`]
            The list of options available in the prompt.
        single_select: :class:`bool`
            Whether the user is limited to selecting one option on this prompt.
        required: :class:`bool`
            Whether the user is required to answer this prompt.
        in_onboarding: :class:`bool`
            Whether this prompt is displayed in the initial onboarding flow.
        reason: Optional[:class:`str`]
            The reason for adding this prompt. Shows up on the audit log.

        Returns
        -------
        :class:`Onboarding`
            The updated onboarding flow.

        Raises
        ------
        HTTPException
            Editing the onboarding flow failed somehow.
        Forbidden
            You don't have permissions to edit the onboarding flow.
        """

        prompt = OnboardingPrompt(
            type, title, options, single_select, required, in_onboarding
        )
        prompts = self.prompts + [prompt]
        return await self.edit(prompts=prompts, reason=reason)
```

--------------------------------

### Get Template URL

Source: https://docs.pycord.dev/en/master/_modules/discord/template.html

Retrieves the public URL for the template.

```python
@property
    def url(self) -> str:
        """The template url.

        .. versionadded:: 2.0
        """
        return f"https://discord.new/{self.code}"
```

--------------------------------

### Get a Thread by ID

Source: https://docs.pycord.dev/en/master/_modules/discord/channel.html

Retrieves a thread from the guild by its ID.

```python
return self.guild.get_thread(thread_id)
```

--------------------------------

### Prepare command execution

Source: https://docs.pycord.dev/en/master/_modules/discord/commands/core.html

Sets up the command context, runs checks, and manages concurrency and cooldowns before execution.

```python
async def prepare(self, ctx: ApplicationContext) -> None:
    # This should be same across all 3 types
    ctx.command = self

    if not await self.can_run(ctx):
        raise CheckFailure(
            f"The check functions for the command {self.name} failed"
        )

    if self._max_concurrency is not None:
        # For this application, context can be duck-typed as a Message
        await self._max_concurrency.acquire(ctx)  # type: ignore # ctx instead of non-existent message

    try:
        self._prepare_cooldowns(ctx)
        await self.call_before_hooks(ctx)
    except:
        if self._max_concurrency is not None:
            await self._max_concurrency.release(ctx)  # type: ignore # ctx instead of non-existent message
        raise
```

--------------------------------

### start(token: str, *, reconnect: bool = True)

Source: https://docs.pycord.dev/en/master/_modules/discord/client.html

A shorthand coroutine that logs the client in and connects to the Discord gateway.

```APIDOC
## start(token: str, *, reconnect: bool = True)

### Description
A shorthand coroutine for login + connect. This method handles the authentication and connection process for the bot.

### Parameters
- **token** (str) - Required - The authentication token for the bot.
- **reconnect** (bool) - Optional - Whether to automatically reconnect if the connection is lost. Defaults to True.

### Raises
- **TypeError** - An unexpected keyword argument was received.
```

--------------------------------

### Onboarding.add_prompt

Source: https://docs.pycord.dev/en/master/_modules/discord/onboarding.html

Adds a new onboarding prompt to the guild's onboarding flow.

```APIDOC
## async Onboarding.add_prompt(type, title, options, single_select, required, in_onboarding, reason=None)

### Description
Adds a new onboarding prompt to the flow. Requires manage_guild and manage_roles permissions.

### Parameters
- **type** (PromptType) - Required - The type of onboarding prompt.
- **title** (str) - Required - The prompt's title.
- **options** (list[PromptOption]) - Required - The list of options available in the prompt.
- **single_select** (bool) - Required - Whether the user is limited to selecting one option.
- **required** (bool) - Required - Whether the user is required to answer this prompt.
- **in_onboarding** (bool) - Required - Whether this prompt is displayed in the initial onboarding flow.
- **reason** (str) - Optional - The reason for adding this prompt, shown in the audit log.

### Returns
- **Onboarding** - The updated onboarding flow.
```

--------------------------------

### Get Webhook Message

Source: https://docs.pycord.dev/en/master/_modules/discord/webhook/async_.html

Retrieves a specific message sent by a webhook.

```python
    def get_webhook_message(
        self,
        webhook_id: int,
        token: str,
        message_id: int,
        *,
        session: aiohttp.ClientSession,
        proxy: str | None = None,
        proxy_auth: aiohttp.BasicAuth | None = None,
        thread_id: int | None = None,
    ) -> Response[MessagePayload]:
        params = {}

        if thread_id:
            params["thread_id"] = thread_id

        route = Route(
            "GET",
            "/webhooks/{webhook_id}/{webhook_token}/messages/{message_id}",
            webhook_id=webhook_id,
            webhook_token=token,
            message_id=message_id,
        )
        return self.request(
            route, session=session, proxy=proxy, proxy_auth=proxy_auth, params=params
        )
```

--------------------------------

### Initialize FFmpegPCMAudio

Source: https://docs.pycord.dev/en/master/_modules/discord/player.html

Configures the FFmpeg subprocess to output PCM audio data.

```python
def __init__(
    self,
    source: str | io.BufferedIOBase,
    *,
    executable: str = "ffmpeg",
    pipe: bool = False,
    stderr: IO[bytes] | None = None,
    before_options: str | None = None,
    options: str | None = None,
) -> None:
    args = []
    subprocess_kwargs = {
        "stdin": subprocess.PIPE if pipe else subprocess.DEVNULL,
        "stderr": stderr,
    }

    if isinstance(before_options, str):
        args.extend(shlex.split(before_options))

    args.append("-i")
    args.append("-" if pipe else source)

    args.extend(
        (
            "-f",
            "s16le",
            "-ar",
            "48000",
            "-ac",
            "2",
            "-loglevel",
            "warning",
            "-blocksize",
            str(self.BLOCKSIZE),
        )
    )

    if isinstance(options, str):
        args.extend(shlex.split(options))

    args.append("pipe:1")

    super().__init__(source, executable=executable, args=args, **subprocess_kwargs)
```

--------------------------------

### Get class slots

Source: https://docs.pycord.dev/en/master/_modules/discord/utils.html

Retrieves all slots defined in a class and its MRO.

```python
def get_slots(cls: type[Any]) -> Iterator[str]:
    for mro in reversed(cls.__mro__):
        try:
            yield from mro.__slots__
        except AttributeError:
            continue
```

--------------------------------

### Initialize ApplicationCommand

Source: https://docs.pycord.dev/en/master/_modules/discord/commands/core.html

Initializes an application command with cooldowns, concurrency, and permission settings.

```python
class ApplicationCommand(_BaseCommand, Generic[CogT, P, T]):
    __original_kwargs__: dict[str, Any]
    cog = None

    def __init__(self, func: Callable, **kwargs) -> None:
        from ..ext.commands.cooldowns import BucketType, CooldownMapping

        cooldown = getattr(func, "__commands_cooldown__", kwargs.get("cooldown"))

        if cooldown is None:
            buckets = CooldownMapping(cooldown, BucketType.default)
        elif isinstance(cooldown, CooldownMapping):
            buckets = cooldown
        else:
            raise TypeError("Cooldown must be an instance of CooldownMapping or None.")

        self._buckets: CooldownMapping = buckets

        max_concurrency = getattr(
            func, "__commands_max_concurrency__", kwargs.get("max_concurrency")
        )

        self._max_concurrency: MaxConcurrency | None = max_concurrency

        self._callback = None
        self.module = None

        self.name: str = kwargs.get("name", func.__name__)

        try:
            checks = func.__commands_checks__
            checks.reverse()
        except AttributeError:
            checks = kwargs.get("checks", [])

        self.checks = checks
        self.id: int | None = kwargs.get("id")
        self.guild_ids: list[int] | None = kwargs.get("guild_ids", None)
        self.parent = kwargs.get("parent")

        # Permissions
        self.default_member_permissions: Permissions | None = getattr(
            func,
            "__default_member_permissions__",
            kwargs.get("default_member_permissions", None),
        )
        self.nsfw: bool | None = getattr(func, "__nsfw__", kwargs.get("nsfw", False))

        integration_types = getattr(
            func, "__integration_types__", kwargs.get("integration_types", None)
        )
        contexts = getattr(func, "__contexts__", kwargs.get("contexts", None))
        guild_only = getattr(func, "__guild_only__", kwargs.get("guild_only", MISSING))
        if guild_only is not MISSING:
            warn_deprecated(
                "guild_only",
                "contexts",
                "2.6",
                reference="https://docs.discord.com/developers/change-log#user-installable-apps-preview",
            )
        if contexts and guild_only:
            raise InvalidArgument(
                "cannot pass both 'contexts' and 'guild_only' to ApplicationCommand"
            )
        if self.guild_ids and (
            (contexts is not None) or guild_only or integration_types
        ):
            raise InvalidArgument(
                "the 'contexts' and 'integration_types' parameters are not available for guild commands"
            )

        if guild_only:
            contexts = {InteractionContextType.guild}
        self.contexts: set[InteractionContextType] | None = contexts
        self.integration_types: set[InteractionType] | None = integration_types
```

--------------------------------

### Initialize AsyncWebhook

Source: https://docs.pycord.dev/en/master/_modules/discord/webhook/async_.html

The constructor requires a payload and an aiohttp session. It supports optional proxy configuration and interaction context.

```python
def __init__(
    self,
    data: WebhookPayload | FollowerWebhookPayload,
    session: aiohttp.ClientSession,
    proxy: str | None = None,
    proxy_auth: aiohttp.BasicAuth | None = None,
    token: str | None = None,
    state=None,
    parent: Interaction | None = None,
):
    super().__init__(data, token, state)
    self.session = session
    self.proxy: str | None = proxy
    self.proxy_auth: aiohttp.BasicAuth | None = proxy_auth
    self.parent: Interaction | None = parent
```

--------------------------------

### get(**attrs)

Source: https://docs.pycord.dev/en/master/api/async_iter.html

Retrieves the first element in the iterator that matches the provided attributes.

```APIDOC
## await get(**attrs)

### Description
Similar to `utils.get()` except run over the async iterator. Returns the first element that matches the provided attributes or `None`.

### Method
Coroutine

### Parameters
- **attrs** (dict) - Attributes to match against the elements.
```

--------------------------------

### Get User Mention String

Source: https://docs.pycord.dev/en/master/_modules/discord/user.html

Returns a string formatted to mention the user.

```python
@property
    def mention(self) -> str:
        """Returns a string that allows you to mention the given user."""
        return f"<@{self.id}>"
```

--------------------------------

### Initialize FFmpegOpusAudio from probe

Source: https://docs.pycord.dev/en/master/_modules/discord/player.html

Creates an instance of FFmpegOpusAudio by automatically probing the source for codec and bitrate information.

```python
executable = kwargs.get("executable")
codec, bitrate = await cls.probe(source, method=method, executable=executable)
return cls(source, bitrate=bitrate, codec=codec, **kwargs)
```

--------------------------------

### Get unique commands

Source: https://docs.pycord.dev/en/master/_modules/discord/ext/commands/core.html

Returns a set of registered commands excluding aliases.

```python
@property
def commands(self) -> set[Command[CogT, Any, Any]]:
    """A unique set of commands without aliases that are registered."""
    return set(self.prefixed_commands.values())
```

--------------------------------

### Deserialize OnboardingPrompt from Dictionary

Source: https://docs.pycord.dev/en/master/_modules/discord/onboarding.html

Creates an OnboardingPrompt instance from a raw API dictionary payload.

```python
@classmethod
def _from_dict(
    cls, data: OnboardingPromptPayload, guild: Guild
) -> OnboardingPrompt:
    id = data.get("id", 0)
    type = try_enum(PromptType, data.get("type"))
    title = data.get("title")
    single_select = data.get("single_select")
    required = data.get("required")
    in_onboarding = data.get("in_onboarding")
    options = [
        PromptOption._from_dict(option, guild) for option in data.get("options", [])
    ]

    return cls(type=type, title=title, single_select=single_select, required=required, in_onboarding=in_onboarding, options=options, id=id)  # type: ignore
```

--------------------------------

### Get Stage Instance

Source: https://docs.pycord.dev/en/master/_modules/discord/channel.html

Retrieves the currently running stage instance for the channel.

```python
@property
def instance(self) -> StageInstance | None:
    """The running stage instance of the stage channel.

    .. versionadded:: 2.0
    """
    return utils.get(self.guild.stage_instances, channel_id=self.id)
```

--------------------------------

### Serialize OnboardingPrompt to Dictionary

Source: https://docs.pycord.dev/en/master/_modules/discord/onboarding.html

Converts an OnboardingPrompt instance into a dictionary payload for API transmission.

```python
def to_dict(self) -> OnboardingPromptPayload:
    dict_: OnboardingPromptPayload = {
        "type": self.type.value,
        "title": self.title,
        "single_select": self.single_select,
        "required": self.required,
        "in_onboarding": self.in_onboarding,
        "options": [option.to_dict() for option in self.options],
        "id": self.id,
    }

    return dict_
```

--------------------------------

### Get Command Signature

Source: https://docs.pycord.dev/en/master/_modules/discord/ext/commands/help.html

Retrieves the formatted signature string for a specific command.

```python
def get_command_signature(self, command):
    """Retrieves the signature portion of the help page.

    Parameters
    ----------
    command: :class:`Command`
        The command to get the signature of.

    Returns
    -------
    :class:`str`
        The signature for the command.
    """
```

--------------------------------

### Get User by ID

Source: https://docs.pycord.dev/en/master/_modules/discord/client.html

Retrieves a user from the internal cache using their ID.

```python
def get_user(self, id: int, /) -> User | None:
    """Returns a user with the given ID.

    Parameters
    ----------
    id: :class:`int`
        The ID to search for.

    Returns
    -------
    Optional[:class:`~discord.User`]
        The user or ``None`` if not found.
    """
    return self._connection.get_user(id)
```
Tokens:
Raw