### Basic Paginator Setup

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

Demonstrates the basic usage of the Paginator class with a list of pages. This is the simplest way to get started with pagination.

```python
import asyncio

import discord
from discord.commands import SlashCommandGroup
from discord.ext import commands, pages


class PageTest(commands.Cog):
    def __init__(self, bot):
        self.bot = bot
        self.pages = [
            "Page 1",
            [
                discord.Embed(title="Page 2, Embed 1"),
                discord.Embed(title="Page 2, Embed 2"),
            ],
            "Page Three",
            discord.Embed(title="Page Four"),
            discord.Embed(title="Page Five"),
            [
                discord.Embed(title="Page Six, Embed 1"),
                discord.Embed(title="Page Seven, Embed 2"),
            ],
        ]
        self.pages[3].set_image(
            url="https://c.tenor.com/pPKOYQpTO8AAAAAM/monkey-developer.gif"
        )
        self.pages[4].add_field(
            name="Example Field", value="Example Value", inline=False
        )
        self.pages[4].add_field(
            name="Another Example Field", value="Another Example Value", inline=False
        )

        self.more_pages = [
            "Second Page One",
            discord.Embed(title="Second Page Two"),
            discord.Embed(title="Second Page Three"),
        ]

        self.even_more_pages = ["11111", "22222", "33333"]

    def get_pages(self):
        return self.pages

    pagetest = SlashCommandGroup("pagetest", "Commands for testing ext.pages")

    # These examples use a Slash Command Group in a cog for better organization - it's not required for using ext.pages.
    @pagetest.command(name="default")
    async def pagetest_default(self, ctx: discord.ApplicationContext):
        """Demonstrates using the paginator with the default options."""
        paginator = pages.Paginator(pages=self.get_pages())
        await paginator.respond(ctx.interaction, ephemeral=False)
```

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

### Custom Sink Implementation Example

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

Demonstrates how to subclass the core Sink class for custom audio recording storage. Replace the example with your custom sink class when starting a recording.

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

```

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

### Create a Simple Extension with a Command

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

An extension is a Python file with a `setup` function that takes the bot instance. This example defines a command and adds it to the bot upon loading.

```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)
```

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

### Start Listening from Store

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

Initializes the view's listening process from a store, setting up the cancel callback and starting the timeout task if a timeout is defined.

```python
def _start_listening_from_store(self, store: ViewStore) -> None:
    self._cancel_callback = partial(store.remove_view)
    if self.timeout:
        loop = asyncio.get_running_loop()
        if self._timeout_task is not None:
            self._timeout_task.cancel()

        self._timeout_expiry = time.monotonic() + self.timeout
        self._timeout_task = loop.create_task(self._timeout_task_impl())
```

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

### Task Waiting for Bot Ready

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

This example shows how to ensure a background task only starts after the bot has successfully connected and is ready. The `before_loop` decorator is used to implement this waiting logic.

```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()

```

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

### NoEntryPointError

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

Raised when an extension does not have a `setup` entry point function.

```APIDOC
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)
```

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

### start(token, reconnect=True)

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

A shorthand coroutine that combines logging in with starting the connection to Discord. It first calls `login` with the provided token and then calls `connect` to establish the WebSocket connection.

```APIDOC
## start(token, reconnect=True)

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

### Method
`async def start(token: str, *, reconnect: bool = True) -> None`

### Parameters
- **token** (str) - The token to log in with.
- **reconnect** (bool) - Optional. Whether to attempt to reconnect if the connection is lost. Defaults to True.

### Returns
None

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

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

### Get Help Command Opening Note

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

Returns the help command's opening note, useful for overriding for i18n purposes. The default implementation provides instructions on how to get more info on commands and categories.

```python
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.

    Returns
    -------
    :class:`str` 
        The help command opening note.
    """
    command_name = self.invoked_with
    return (
        f"Use `{self.context.clean_prefix}{command_name} [command]` for more info"
        " on a command.\nYou can also use"
        f" `{self.context.clean_prefix}{command_name} [category]` for more info on"
        " a category."
    )
```

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

### Get Onboarding Flow

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

Returns the onboarding flow for the guild.

```APIDOC
## Get Onboarding Flow

### Description
Returns the `Onboarding` flow for the guild.
Added in version 2.5.

### Method
GET

### Endpoint
`/guild/{guild_id}/onboarding`

### Response
#### Success Response (200)
- **onboarding** (`Onboarding`) - The onboarding flow for the guild.

#### Response Example
```json
{
  "prompts": [
    {
      "type": "multiple_choice",
      "options": [
        {
          "title": "What are you interested in?",
          "emoji_id": null,
          "emoji_name": null
        }
      ],
      "title": "What brings you here?",
      "single_select": false
    }
  ],
  "default_channels": ["1122334455"]
}
```
```

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

### start_recording

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

Starts recording audio from the connected voice channel to a specified sink.

```APIDOC
## start_recording

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

.. versionadded:: 2.0

.. warning::

    Recording may not work as expected due to the new DAVE (End-to-End Encryption) for voice calls.

### Parameters
- **sink**: Sink - A Sink in which all audio packets will be processed in.
- **callback**: Optional[AfterCallback] - A callback function to be called after recording stops or an error occurs.
- **sync_start**: bool - If True, the recording will start synchronously. Defaults to MISSING.
```

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

### prepare_help_command

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

Clears the paginator and performs initial setup before a help command is processed.

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

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

### Get Game Start Timestamp

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

Returns the datetime when the user started playing the game, in UTC. Returns None if the start timestamp is not set.

```python
def start(self) -> datetime.datetime | None:
        """When the user started playing this game in UTC, if applicable."""
        if self._start:
            return datetime.datetime.fromtimestamp(
                self._start / 1000, tz=datetime.timezone.utc
            )
        return None
```

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

### get_ending_note

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

Returns the ending note for the help command, which typically guides users on how to get more information.

```APIDOC
def get_ending_note(self) -> str:
    """Returns help command's ending note. This is mainly useful to override for i18n purposes."""
    command_name = self.invoked_with
    return (
        f"Type {self.context.clean_prefix}{command_name} command for more info on a"
        " command.\n        You can also type"
        f" {self.context.clean_prefix}{command_name} category for more info on a"
        " category."
    )
```

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

### BotBase initialization

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

Initializes the BotBase class, setting up command prefix and help command. The command prefix can be a string, an iterable of strings, or a callable that returns a string or iterable of strings. The help command defaults to `DefaultHelpCommand` if not provided.

```python
def __init__(
    self,
    command_prefix: (
        str
        | Iterable[str]
        | Callable[
            [Bot | AutoShardedBot, Message],
            str | Iterable[str] | Coroutine[Any, Any, str | Iterable[str]],
        ]
    ) = when_mentioned,
    help_command: HelpCommand | None = MISSING,
    **options,
):
    super().__init__(**options)
    self.command_prefix = command_prefix
    self.help_command = (
        DefaultHelpCommand() if help_command is MISSING else help_command
    )
    self.strip_after_prefix = options.get("strip_after_prefix", False)
```

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

### Basic Logging Configuration

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

Configure the logging module to output logs to the console. This is a simple setup that can be placed at the start of your application.

```python
import logging

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

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

### before_invoke Decorator Example

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

Registers a coroutine to be executed before a command is invoked. This can be used for logging or setup tasks across multiple commands or cogs.

```python
async def record_usage(ctx):
    print(ctx.author, 'used', ctx.command, 'at', ctx.message.created_at)

@bot.command()
@commands.before_invoke(record_usage)
async def who(ctx): # Output: <User> used who at <Time>
    await ctx.send('I am a bot')

class What(commands.Cog):

    @commands.before_invoke(record_usage)
    @commands.command()
    async def when(self, ctx): # Output: <User> used when at <Time>
        await ctx.send(f'and I have existed since {ctx.bot.user.created_at}')

    @commands.command()
    async def where(self, ctx): # Output: <Nothing>
        await ctx.send('on Discord')

    @commands.command()
    async def why(self, ctx): # Output: <Nothing>
        await ctx.send('because someone made me')

bot.add_cog(What())
```

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

### Subclassing the Sink Class

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

Example of how to subclass the Sink class for custom audio recording. Replace the default Sink with your custom subclass when starting a recording.

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

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

### onboarding()

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

Retrieves the onboarding data for a guild.

```APIDOC
## onboarding()

### Description
Retrieves the onboarding data for a guild.

### Method
discord.Guild method
```

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

### Set Allow and Deny Permissions

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

Example demonstrating how to set both allowed and denied permissions for a target.

```python
Setting allow and deny:
```

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

### Get Pinned Messages Iterator in Pycord

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

Returns an iterator for retrieving pinned messages within a channel. Requires 'read_message_history' permissions. Starting from version 3.0, this method returns an iterator, not a list directly. You can flatten the iterator to get a list.

```python
counter = 0
async for pin in channel.pins(limit=250):
    if pin.message.author == client.user:
        counter += 1
```

```python
pins = await channel.pins(limit=None).flatten()
```

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

### Prepare Help Command

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

Prepares the help command for execution by updating the injected command with the current context and setting up the error handler based on whether it's overridden.

```python
async def prepare(self, ctx):
        self._injected = injected = self._original.copy()
        injected.context = ctx
        self.callback = injected.command_callback

        on_error = injected.on_help_command_error
        if not hasattr(on_error, "__help_command_not_overridden__"):
            if self.cog is not None:
                self.on_error = self._on_error_cog_implementation
            else:
                self.on_error = on_error

        await super().prepare(ctx)
```

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

### Initialize Help Command Options

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

Initializes options for the help command, such as headings, DM help settings, and paginator.

```python
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)
```

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

### Simple Background Task in Cog

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

A basic example of a background task that runs every 5 seconds within a Cog. The task is started when the Cog is initialized and cancelled when the Cog is unloaded.

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

class MyCog(commands.Cog):
    def __init__(self):
        self.index = 0
        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

```

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

### Set Allow and Deny Permissions

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

Example demonstrating how to set both allowed and denied permissions for a target within a channel.

```python
await channel.set_permissions(user, overwrite=discord.PermissionOverwrite(read_messages=False, send_messages=True))
```

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

### Help Command Implementation Initialization

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

Initializes the internal help command implementation, storing the original command and setting up context for the current command.

```python
def __init__(self, inject, *args, **kwargs):
        super().__init__(inject.command_callback, *args, **kwargs)
        self._original = inject
        self._injected = inject
```

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

### Get Stage Instance by ID (Python)

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

Retrieves a stage instance from the guild using its ID. Returns the StageInstance object if found, otherwise returns None. This function is available starting from version 2.0.

```python
stage_instance = guild.get_stage_instance(123456789012345678)
if stage_instance:
    print(f"Stage instance found: {stage_instance.topic}")
```

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

### Get Pinned Messages (Python)

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

Returns an iterator for receiving pinned messages in a channel. Requires 'read_message_history' permission. Note: Starting from version 3.0, this method will no longer return a list of Message objects directly.

```python
async def pins(_*_ , limit =50_, before =None_):
    """Returns a `MessagePinIterator` that enables receiving the destination’s pinned messages.

You must have `read_message_history` permissions to use this.
Warning
Starting from version 3.0, await channel.pins() will no longer return a list of `Message`. See examples below for new usage instead.

Parameters:
    limit (int) – The maximum number of pinned messages to retrieve.
    before (Optional[`Snowflake`]) – A message ID to fetch messages before.
"""
    # Implementation details...
```

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

### Command Initialization and Configuration

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

Details the `__init__` method of the `Command` class, outlining how commands are created and configured with various options.

```APIDOC
## Command Class

### Description
Represents a command that can be invoked by users. This class handles the core logic for command parsing, execution, and configuration.

### Method
`__init__(self, func, **kwargs)`

### Parameters
- **func** (Callable): The coroutine function that will be executed when the command is invoked.
- **name** (str, optional): The name of the command. Defaults to the function's name.
- **help** (str, optional): The help text for the command. Defaults to the function's docstring.
- **brief** (str, optional): A short description of the command for brief help messages.
- **usage** (str, optional): The usage string for the command.
- **rest_is_raw** (bool): If True, keyword-only arguments are passed raw. Defaults to False.
- **aliases** (list[str] | tuple[str], optional): A list or tuple of aliases for the command.
- **description** (str): A detailed description of the command.
- **hidden** (bool): If True, the command will be hidden from help output. Defaults to False.
- **checks** (list[Check], optional): A list of checks to be performed before executing the command.
- **cooldown** (Cooldown | CooldownMapping, optional): The cooldown configuration for the command.
- **extras** (dict[str, Any], optional): A dictionary of user-provided extras to attach to the command.

### Attributes
- **name** (str): The name of the command.
- **callback** (Callable): The coroutine function associated with the command.
- **enabled** (bool): Whether the command is currently enabled.
- **help** (str | None): The help text for the command.
- **brief** (str | None): The brief description for the command.
- **usage** (str | None): The usage string for the command.
- **rest_is_raw** (bool): Configuration for raw argument passing.
- **aliases** (list[str] | tuple[str]): Aliases for the command.
- **description** (str): Detailed description of the command.
- **hidden** (bool): Whether the command is hidden.
- **checks** (list[Check]): List of checks applied to the command.
- **extras** (dict[str, Any]): Extra data associated with the command.
- **__original_kwargs__** (dict[str, Any]): A copy of the original keyword arguments passed during initialization.

### Exceptions
- **TypeError**: Raised if the callback is not a coroutine function, if the name is not a string, or if aliases are not a list or tuple.

### Notes
- The `__original_kwargs__` attribute is used internally to preserve original keyword arguments, especially when subclasses might modify them.
- Argument parsing behavior is influenced by `rest_is_raw` and `ignore_extra`.
- Cooldown processing can be configured to happen before or after argument parsing using `cooldown_after_parsing`.
```

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

### Retrieve Pinned Messages

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

Returns an iterator for fetching pinned messages in a channel. Requires 'read_message_history' permission. Note: Starting from version 3.0, this method no longer returns a list of Message directly. Use the provided examples for updated usage.

```python
def pins(self, *, limit: int | None = 50, before: Snowflake | datetime.datetime | None = None) -> MessagePinIterator:
    """Returns a MessagePinIterator that enables receiving the destination’s pinned messages."""
    pass
```

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

### Basic Bridge Bot Setup

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

Set up a bot using discord.ext.bridge to handle both prefix and slash commands. Ensure message content intent is enabled if needed for prefix commands.

```python
import discord
from discord.ext import bridge

intents = discord.Intents.default()
intents.message_content = True

bot = bridge.Bot(command_prefix="!", intents=intents)

@bot.bridge_command()
async def hello(ctx):
    await ctx.respond("Hello!")

@bot.bridge_command()
async def bye(ctx):
    await ctx.respond("Bye!")

@bot.bridge_command()
async def sum(ctx, first: int, second: int):
    s = first + second
    await ctx.respond(f"{s}")

bot.run("TOKEN")

```

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

### Install Pycord within Virtual Environment

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

Installs Pycord using pip after a virtual environment has been activated. This ensures the library is installed within the isolated environment.

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

```

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

### prepare_help_command

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

A low-level method that can be used to prepare the help command before it does anything else. This is useful for subclasses that need to set up state before the command processing begins. The default implementation does nothing.

```APIDOC
## prepare_help_command

### Description
A low level method that can be used to prepare the help command
before it does anything. For example, if you need to prepare
some state in your subclass before the command does its processing
then this would be the place to do it.

The default implementation does nothing.

.. note::

    This is called *inside* the help command callback body. So all
    the usual rules that happen inside apply here as well.

### Parameters
#### ctx
- **ctx** (:class:`Context`) - The invocation context.
#### command
- **command** (Optional[:class:`str`]) - The argument passed to the help command.
```

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

### Voice connection and playback (Before v1.0)

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

Illustrates the older method of joining a voice channel and creating an audio player using `client.join_voice_channel` and `vc.create_ffmpeg_player`.

```python
vc = await client.join_voice_channel(channel)
player = vc.create_ffmpeg_player('testing.mp3', after=lambda: print('done'))
player.start()

player.is_playing()
player.pause()
player.resume()
player.stop()
# ...

```

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

### start Method

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`) - The arguments to use.
* ****kwargs** (`Any`) - The keyword arguments to use.

### Raises
* **RuntimeError** - A task has already been launched and is running.

### Returns
The task that has been created.

### Return Type
`Task`[`None`]
```

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

### start

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

Starts the scheduled event. This method can only be used if `status` is `ScheduledEventStatus.scheduled`.

```APIDOC
await start(_*_ , _reason =None_)

Parameters:
  * **reason** (`str` | `None`) – The reason to show in the audit log.
```

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

### Basic Slash Command with Options

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

Demonstrates a simple slash command with string and integer options, including setting minimum/maximum values and a default value for an optional argument.

```python
import discord

@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.")
```

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

### start

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

A shorthand coroutine for `login()` + `connect()`. This function initiates the client's connection to Discord.

```APIDOC
## start

### Description
This function is a _coroutine_.
A shorthand coroutine for `login()` + `connect()`.

### Parameters
* **token** (str)
* **reconnect** (bool) - Defaults to True.

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

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

### Install Pycord from PyPI (Windows)

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

Installs the latest stable version of Pycord from PyPI for Windows users.

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

```

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

### Start Scheduled Event

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

Starts a scheduled event. This is a shortcut for editing the status to 'active'.

```APIDOC
## POST /channels/{channel_id}/events/{event_id}/start

### Description
Starts the scheduled event. This method is a coroutine and serves as a shortcut for editing the event's status to `ScheduledEventStatus.active`.

### Method
POST

### Endpoint
`/channels/{channel_id}/events/{event_id}/start`

### Parameters
#### Path Parameters
- **channel_id** (int) - Required - The ID of the channel associated with the event.
- **event_id** (int) - Required - The ID of the event to start.

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

#### Request Body
None

### Response
#### Success Response (200)
- **ScheduledEvent** (`ScheduledEvent`) - The updated scheduled event object.

#### Response Example
```json
{
  "id": "1234567890",
  "guild_id": "0987654321",
  "channel_id": "1122334455",
  "name": "Active Event Name",
  "description": "This event is now active.",
  "scheduled_start_time": "2023-10-27T10:00:00Z",
  "scheduled_end_time": "2023-10-27T12:00:00Z",
  "privacy_level": 2,
  "status": 2, 
  "creator_id": "5544332211"
}
```

#### Error Handling
- **Forbidden** - You do not have the Manage Events permission.
- **HTTPException** - The operation failed.
- **ValueError** - This method can only be used if `status` is `ScheduledEventStatus.scheduled`.
```

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

### HelpCommand Initialization

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

Initializes the HelpCommand with various configuration options to customize the help message output.

```APIDOC
class HelpCommand:
    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 Audio Playback

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

Starts playing audio from an AudioSource. Handles encoder initialization if necessary and provides an option to wait for playback to finish.

```python
def play(self, source: AudioSource, *, after: Callable[[Exception | None], None] | None = None, error_callback: Callable[[Exception], None] | None = None, seek: float = 0, volume: float = 1.0, bypass_audio_filter: bool = False, application: int = opus.Application.AUDIO, bitrate: int = 128000, fec: bool = False, expected_packet_loss: int = 0, bandwidth: int = opus.Bandwidth.MAX, signal_type: int = opus.SignalType.AUTO, wait_finish: bool = False) -> asyncio.Future | None:
    """Plays an audio source. 

    Parameters
    ----------
    source: :class:`~discord.AudioSource`
        The audio source to play.
    after
        A callable that is called after the audio finishes playing. It is
        called with the exception that occurred during playback, if any.
    error_callback
        A callable that is called when an error occurs during playback.
    seek: :class:`float`
        How many HZ to seek into the track. 
    volume: :class:`float`
        The volume to play the track at. 
    bypass_audio_filter: :class:`bool`
        If true, the audio will not be filtered. 
    application: :class:`int`
        The opus application to use. Defaults to :attr:`opus.Application.AUDIO`.
    bitrate: :class:`int`
        The bitrate to use for the Opus encoder. Defaults to 128kbps.
    fec: :class:`bool`
        Whether to enable forward error correction. Defaults to ``False``.
    expected_packet_loss: :class:`int`
        The expected packet loss to use for the Opus encoder. Defaults to 0.
    bandwidth: :class:`int`
        The bandwidth to use for the Opus encoder. Defaults to :attr:`opus.Bandwidth.MAX`.
    signal_type: :class:`int`
        The signal type to use for the Opus encoder. Defaults to :attr:`opus.SignalType.AUTO`.
    wait_finish: :class:`bool`
        Whether to wait for the audio to finish playing before returning.

    Raises
    ------
    ClientException
        Not connected to voice.
        Already playing audio.
    TypeError
        Source is not a :class:`AudioSource`, or after is not a callable.
    OpusNotLoaded
        Source is not opus encoded and opus is not loaded.
    """

    if not self.is_connected():
        raise ClientException("Not connected to voice")
    if self.is_playing():
        raise ClientException("Already playing audio")
    if not isinstance(source, AudioSource):
        raise TypeError(
            f"Source must be an AudioSource, not {source.__class__.__name__}",
        )
    if not self.encoder and not source.is_opus():
        self.encoder = opus.Encoder(
            application=application,
            bitrate=bitrate,
            fec=fec,
            expected_packet_loss=expected_packet_loss,
            bandwidth=bandwidth,
            signal_type=signal_type,
        )

    future = None
    if wait_finish:
        self._player_future = future = self.loop.create_future()
        after_callback = after

        def _after(exc: Exception | None) -> None:
            if callable(after_callback):
                after_callback(exc)
            self.loop.call_soon_threadsafe(
                self._set_future_result_if_pending, future, exc
            )

        after = _after

    self._player = AudioPlayer(source, self, after=after)
    self._player.start()
    return future

```

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

### MinimalHelpCommand Class

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

A simplified implementation of the HelpCommand.

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

    # Attributes:
    # sort_commands: bool - Whether to sort commands alphabetically. Defaults to True.
    # commands_heading: str - Heading for the command list. Defaults to "Commands".
    # aliases_heading: str - Heading for the alias list. Defaults to "Aliases:".
    # dm_help: Optional[bool] - Whether to DM the help message. Defaults to False.
    # dm_help_threshold: Optional[int] - Character threshold for DMing help. Defaults to 1000.
    # no_category: str - String for commands without a category. Defaults to "No Category".
    # paginator: Paginator - The paginator used for help output.
```

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

### Install Pycord from PyPI (Linux/macOS)

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

Installs the latest stable version of Pycord directly from the Python Package Index (PyPI) on Linux or macOS.

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

```

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

### Button Initialization and Properties

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

Demonstrates the initialization of a button component, including setting its style, label, emoji, and custom ID. It also shows how to handle URL-based buttons and premium buttons.

```python
custom_id = os.urandom(16).hex()

        if url is not None:
            style = ButtonStyle.link
        if sku_id is not None:
            style = ButtonStyle.premium

        if emoji is not None:
            if isinstance(emoji, str):
                emoji = PartialEmoji.from_str(emoji)
            elif isinstance(emoji, _EmojiTag):
                emoji = emoji._to_partial()
            else:
                raise TypeError(
                    "expected emoji to be str, GuildEmoji, AppEmoji, or PartialEmoji not"
                    f" {emoji.__class__}"
                )

        self.row = row
        self._underlying = self._generate_underlying(
            custom_id=custom_id,
            url=url,
            disabled=disabled,
            label=label,
            style=style,
            emoji=emoji,
            sku_id=sku_id,
            id=id,
        )
```

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

### Install Pycord with Voice Support

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

Installs Pycord with the necessary components for voice channel functionality. This is required if your bot needs to interact with voice channels.

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

```

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

### Command Initialization

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

Demonstrates the initialization of a Command object, including handling coroutine callbacks, names, help text, aliases, and checks. It also shows how original keyword arguments are stored.

```python
def __new__(cls: type[CommandT], *args: Any, **kwargs: Any) -> CommandT:
    # if you're wondering why this is done, it's because we need to ensure
    # we have a complete original copy of **kwargs even for classes that
    # mess with it by popping before delegating to the subclass __init__.
    # In order to do this, we need to control the instance creation and
    # inject the original kwargs through __new__ rather than doing it
    # inside __init__.
    self = super().__new__(cls)

    # we do a shallow copy because it's probably the most common use case.
    # this could potentially break if someone modifies a list or something
    # while it's in movement, but for now this is the cheapest and
    # fastest way to do what we want.
    self.__original_kwargs__ = kwargs.copy()
    return self

def __init__(
    self,
    func: (
        Callable[Concatenate[CogT, ContextT, P], Coro[T]]
        | Callable[Concatenate[ContextT, P], Coro[T]]
    ),
    **kwargs: Any,
):
    if not asyncio.iscoroutinefunction(func):
        raise TypeError("Callback must be a coroutine.")

    name = kwargs.get("name") or func.__name__
    if not isinstance(name, str):
        raise TypeError("Name of a command must be a string.")
    self.name: str = name

    self.callback = func
    self.enabled: bool = kwargs.get("enabled", True)

    help_doc = kwargs.get("help")
    if help_doc is not None:
        help_doc = inspect.cleandoc(help_doc)
    else:
        help_doc = inspect.getdoc(func)
        if isinstance(help_doc, bytes):
            help_doc = help_doc.decode("utf-8")

    self.help: str | None = help_doc

    self.brief: str | None = kwargs.get("brief")
    self.usage: str | None = kwargs.get("usage")
    self.rest_is_raw: bool = kwargs.get("rest_is_raw", False)
    self.aliases: list[str] | tuple[str] = kwargs.get("aliases", [])
    self.extras: dict[str, Any] = kwargs.get("extras", {})

    if not isinstance(self.aliases, (list, tuple)):
        raise TypeError(
            "Aliases of a command must be a list or a tuple of strings."
        )

    self.description: str = inspect.cleandoc(kwargs.get("description", ""))
    self.hidden: bool = kwargs.get("hidden", False)

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

    self.checks: list[Check] = checks

    try:
        cooldown = func.__commands_cooldown__
    except AttributeError:
        cooldown = kwargs.get("cooldown")

    if cooldown is None:
        buckets = CooldownMapping(cooldown, BucketType.default)
    elif isinstance(cooldown, CooldownMapping):
        buckets = cooldown
    else:
        raise TypeError(

```

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

### Onboarding.add_prompt

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

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

```APIDOC
## Onboarding.add_prompt

### Description
Adds a new onboarding prompt. You must have the `manage_guild` and `manage_roles` permissions in the guild to do this.

### Method
`await`

### Parameters
#### Path 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 on this prompt.
- **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` | `None`) - Optional - The reason for adding this prompt. Shows up on the audit log.

### Response
#### Success Response (200)
- **Onboarding** - The updated onboarding flow.

#### Response Example
```json
{
  "example": "Onboarding object"
}
```

### Raises
- **HTTPException** – Editing the onboarding flow failed somehow.
- **Forbidden** – You don’t have permissions to edit the onboarding flow.
```

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

### Install Pycord Pre-release (Windows)

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

For Windows users, this command installs the pre-release version of Pycord. It is necessary for accessing the latest features before they are officially released.

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

```

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

### Onboarding.get_prompt

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

Retrieves an onboarding prompt by its ID.

```APIDOC
## Onboarding.get_prompt

### Description
Get an onboarding prompt with the given ID.

### Method
`await`

### Parameters
#### Path Parameters
- **id** (`int`) - Required - The ID of the prompt to get.

### Response
#### Success Response (200)
- **OnboardingPrompt** - The matching prompt, or None if it didn’t exist.

#### Response Example
```json
{
  "example": "OnboardingPrompt object or null"
}
```
```

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

### Install Voice Dependencies (Debian-based Linux)

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

Installs the required system-level dependencies for voice support on Debian-based Linux distributions. These include libffi, libnacl, and python3-dev.

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

```

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

### Install Pycord with Speedup Packages (Windows)

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

Installs Pycord with optional packages for speed improvements on Windows systems. This command ensures optimal performance for your Discord bot.

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

```

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

### Run Bot with Blocking Call

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

Use this function for a simple, blocking bot startup. It abstracts event loop initialization. Avoid if more control over the event loop is needed; use `start()` or `connect()` + `login()` instead. This must be the last function called.

```python
try:
    loop.run_until_complete(start(*args, **kwargs))
except KeyboardInterrupt:
    loop.run_until_complete(close())
    # cancel all tasks lingering
finally:
    loop.close()
```

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

### DefaultHelpCommand

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

The default implementation of the help command.

```APIDOC
## DefaultHelpCommand

### Description
The default help command implementation. It provides a comprehensive way to display bot commands and their descriptions.

### Attributes
- **width** (int) - The width of the help message.
- **sort_commands** (bool) - Whether to sort commands alphabetically.
- **dm_help** (bool) - Whether to send help messages via direct message.
- **dm_help_threshold** (int | None) - The threshold for sending help via DM (e.g., number of commands).
- **indent** (int) - The indentation level for commands.
- **commands_heading** (str) - The heading for the commands list.
- **no_category** (str) - The string to use when a command has no category.
- **paginator** (Paginator | None) - The paginator to use for long help messages.

### Methods
- **shorten_text(text)** - Shortens the given text to fit within the width.
- **get_ending_note()** - Gets the ending note for the help message.
- **add_indented_commands(commands, *, level=0, space=2, prefix='', to_be_added=None)** - Adds indented commands to the help message.
- **send_pages()** - Sends the paginated help messages.
- **add_command_formatting(command)** - Formats a single command for display.
- **get_destination()** - Gets the destination for sending messages.
```

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

### Install Pycord with Speedup Packages (Linux/macOS)

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

Installs Pycord along with additional packages for performance enhancements on Linux or macOS. Use this when speed is a critical factor for your application.

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

```

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

### Install Pycord Pre-release (Linux/macOS)

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

Use this command to install the pre-release version of Pycord on Linux or macOS systems. This is recommended for accessing new features before a stable release.

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

```

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

### MKASink

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

Initializes the MKASink with optional filters. It sets up the encoding type and prepares for audio recording.

```APIDOC
## MKASink

### Description
A special sink for .mka files.

### Parameters
- **filters** (dict, optional) - Filters to apply to the audio. Defaults to `default_filters`.
```

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

### Welcome Screen Methods

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

Methods for managing the welcome screen, including editing its description, channels, and enabled status.

```APIDOC
## Welcome Screen Methods

### `edit()`

Edits the welcome screen.
```

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

### Onboarding Methods

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

Methods for managing the onboarding process, including editing prompts, adding, getting, and deleting prompts.

```APIDOC
## Onboarding Methods

### `edit()`

Edits the onboarding configuration.

### `add_prompt()`

Adds a new prompt to the onboarding configuration.

### `append_prompt()`

Appends a prompt to the onboarding configuration.

### `get_prompt()`

Retrieves a specific prompt from the onboarding configuration.

### `delete_prompt()`

Deletes a prompt from the onboarding configuration.
```

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

### Cog Inter-Command Communication Example

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

This example demonstrates how one cog can interact with another by retrieving it using `bot.get_cog()`. This is useful for sharing state or functionality between cogs, such as in an economy system.

```python
class Economy(commands.Cog):
    ...

    async def withdraw_money(self, member, money):
        # implementation here
        ...

    async def deposit_money(self, member, money):
        # implementation here
        ...

class Gambling(commands.Cog):
    def __init__(self, bot):
        self.bot = bot

    def coinflip(self):
        return random.randint(0, 1)

    @commands.command()
    async def gamble(self, ctx, money: int):
        """Gambles some money."""
        economy = self.bot.get_cog('Economy')
        if economy is not None:
            await economy.withdraw_money(ctx.author, money)
            if self.coinflip() == 1:
                await economy.deposit_money(ctx.author, money * 1.5)

```

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

### Container Initialization

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

Initializes a new Container with specified items, color, and spoiler settings.

```APIDOC
## Container(*items: ViewItem, colour: Union[Colour, int, None] = None, color: Union[Colour, int, None] = None, spoiler: bool = False, id: Optional[int] = None)

### Description
Represents a UI Container. The current items supported are as follows:

- :class:`discord.ui.ActionRow`
- :class:`discord.ui.Section`
- :class:`discord.ui.TextDisplay`
- :class:`discord.ui.MediaGallery`
- :class:`discord.ui.File`
- :class:`discord.ui.Separator`

.. versionadded:: 2.7

### Parameters
#### Parameters
- **items**: :class:`ViewItem` - The initial items in this container.
- **colour**: Union[:class:`Colour`, :class:`int`] - The accent colour of the container. Aliased to ``color`` as well.
- **spoiler**: Optional[:class:`bool`] - Whether this container has the spoiler overlay.
- **id**: Optional[:class:`int`] - The container's ID.

### Attributes
- **items**: List[:class:`ViewItem`] - The list of items in this container.
- **colour**: Union[:class:`Colour`, :class:`int`] - The accent colour of the container.
- **spoiler**: :class:`bool` - Whether this container has the spoiler overlay.
- **id**: Optional[:class:`int`] - The container's ID.
```

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

### Basic Pycord Event Handling Example

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

A simple Python example demonstrating how to create a Discord client, log in, and respond to 'ready' and 'message' events. This showcases the core event-driven nature of Pycord.

```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')

```

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

### Initialize a UI File

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

Constructs a File object with a given URL and optional spoiler tag or ID. The URL must be an `attachment://` URL.

```python
file = File("attachment://my_file.png", spoiler=True, id=123)
```

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

### Get Autocomplete Context

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

Asynchronously gets the autocomplete context from an interaction. This is a lower-level counterpart to process_application_commands() for fine-grained control. Should a custom context class be provided, it must be similar enough to AutocompleteContext's interface.

```python
await get_autocomplete_context(_interaction_ , _cls =<class 'discord.commands.context.AutocompleteContext'>_)
```

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

### Get Application Context

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

Asynchronously gets the invocation context from an interaction. This is a lower-level counterpart to process_application_commands() for fine-grained control. Should a custom context class be provided, it must be similar enough to ApplicationContext's interface.

```python
await get_application_context(_interaction_ , _cls =<class 'discord.commands.context.ApplicationContext'>_)
```