Nextcord

https://docs.nextcord.dev/en/stable
Admin
Nextcord is a modern, easy-to-use, feature-rich async-ready Python API wrapper for Discord that...
Tokens:48,406
Snippets:653
Trust Score:7
Update:3 months ago
Show doc for...
Tokens:
Raw
### Install Nextcord via pip

Source: https://docs.nextcord.dev/en/stable/intro.html

Standard command to install the library from PyPI.

```bash
python3 -m pip install -U nextcord
```

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

### Install Nextcord

Source: https://docs.nextcord.dev/en/stable/migrating_to_nextcord.html

Commands to install the Nextcord library.

```bash
# Linux/macOS
python3 -m pip install -U nextcord

# Windows
py -3 -m pip install -U nextcord
```

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

### Install Nextcord with voice support

Source: https://docs.nextcord.dev/en/stable/intro.html

Install the library with optional voice dependencies included.

```bash
python3 -m pip install -U nextcord[voice]
```

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

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

Source: https://docs.nextcord.dev/en/stable/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.

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

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

### Basic Logging Configuration

Source: https://docs.nextcord.dev/en/stable/logging.html

A simple setup to output logs to the console, recommended to be placed at the start of the application.

```python
import logging

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

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

### Implement setup and teardown

Source: https://docs.nextcord.dev/en/stable/ext/commands/extensions.html

Use teardown 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!')
```

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

### Create a basic event-driven bot

Source: https://docs.nextcord.dev/en/stable/intro.html

A minimal example demonstrating how to initialize a bot and listen for message events.

```python
from nextcord.ext import commands

# the prefix is not used in this example
bot = commands.Bot(command_prefix='$')

@bot.event
async def on_message(message):
    print(f'Message from {message.author}: {message.content}')

bot.run('token')
```

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

### Defining a Cog with Setup Function

Source: https://docs.nextcord.dev/en/stable/ext/commands/api.html

Standard structure for a Cog class and its corresponding setup function to be loaded by the bot.

```python
class MyCog(commands.Cog):
    def __init__(self, bot, my_attribute):
        self.bot = bot
        self.my_attribute = my_attribute

    # ...

def setup(bot, **kwargs):
    bot.add_cog(MyCog(bot, **kwargs))
```

```python
class MyCogTwo(commands.Cog):
    def __init__(self, bot, my_other_attribute):
        self.bot = bot
        self.my_other_attribute = my_other_attribute

    # ...

def setup(bot, my_other_attribute):
    bot.add_cog(MyCogTwo(bot, my_other_attribute))
```

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

### Run bot setup as a coroutine

Source: https://docs.nextcord.dev/en/stable/faq.html

Use asyncio.run to execute an async main function for bot startup.

```python
import asyncio

async def main():
    bot.load_extension('cog_name')
    await bot.start("token")

asyncio.run(main())
```

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

### Define a Cog with Setup Arguments

Source: https://docs.nextcord.dev/en/stable/ext/commands/api.html

Shows how to structure a Cog to accept keyword arguments passed from the extension loader.

```python
class MeCog(commands.Cog):
    def __init__(self, bot, keyword_arg):
        self.bot = bot
        self.keyword_arg = keyword_arg

def setup(bot, **kwargs):
    bot.add_cog(MeCog(bot, **kwargs))

# Alternately
def setup(bot, keyword_arg):
    bot.add_cog(MeCog(bot, keyword_arg))
```

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

### start

Source: https://docs.nextcord.dev/en/stable/ext/commands/api.html

A coroutine that performs a login and connection to Discord.

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

### Description
A shorthand coroutine for login() + connect().

### Parameters
- **token** (str) - Required - The bot token.
- **reconnect** (bool) - Optional - Whether to reconnect automatically.
```

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

### Example command invocations

Source: https://docs.nextcord.dev/en/stable/ext/commands/commands.html

Demonstrates various ways to invoke a command that uses Greedy and Optional converters.

```text
$ban @Member @Member2 spam bot
$ban @Member @Member2 7 spam bot
$ban @Member spam
```

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

### Install Nextcord on Windows

Source: https://docs.nextcord.dev/en/stable/intro.html

Command for Windows users who have not added Python to their system PATH.

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

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

### Install packages in virtual environment

Source: https://docs.nextcord.dev/en/stable/intro.html

Standard pip command to install packages once the virtual environment is active.

```bash
$ pip install -U nextcord
```

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

### Define a basic extension

Source: https://docs.nextcord.dev/en/stable/ext/commands/extensions.html

An extension requires a setup function to register commands or other bot functionality.

```python
from nextcord.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)
```

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

### Load an extension with extra arguments

Source: https://docs.nextcord.dev/en/stable/ext/commands/api.html

Pass keyword arguments to an extension's setup function using the extras parameter.

```python
# main.py
bot.load_extension("cogs.me_cog", extras={"keyword_arg": True})

# cogs/me_cog.py
class MeCog(commands.Cog):
    def __init__(self, bot, keyword_arg):
        self.bot = bot
        self.keyword_arg = keyword_arg

def setup(bot, **kwargs):
    bot.add_cog(MeCog(bot, **kwargs))

# Alternately
def setup(bot, keyword_arg):
    bot.add_cog(MeCog(bot, keyword_arg))
```

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

### connect

Source: https://docs.nextcord.dev/en/stable/ext/commands/api.html

Creates a websocket connection and starts the event loop.

```APIDOC
## await 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.

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

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

### Install Linux voice dependencies

Source: https://docs.nextcord.dev/en/stable/intro.html

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

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

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

### Registering Events with Coroutines

Source: https://docs.nextcord.dev/en/stable/migrating_to_async.html

Examples showing the transition from standard functions to asyncio coroutines for event registration.

```python
@client.event
def on_message(message):
    pass
```

```python
@client.event
@asyncio.coroutine
def on_message(message):
    pass
```

```python
@client.event
async def on_message(message):
    pass
```

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

### load_extension(name, *, package=None, extras=None)

Source: https://docs.nextcord.dev/en/stable/ext/commands/api.html

Loads a single extension into the bot. This method allows passing extra arguments to the extension's setup function.

```APIDOC
## load_extension(name, *, package=None, extras=None)

### Description
Loads a single extension. If extras are provided, they are passed to the extension's setup function.

### Parameters
- **name** (str) - Required - The name of the extension to load.
- **package** (str) - Optional - The package name to resolve relative imports.
- **extras** (dict) - Optional - Extra arguments to pass to the setup function.

### Raises
- **ExtensionNotFound** - Extension could not be imported.
- **ExtensionAlreadyLoaded** - Extension is already loaded.
- **NoEntryPointError** - Extension lacks a setup function.
- **ExtensionFailed** - Execution error in setup function.
- **InvalidSetupArguments** - Extras provided but setup function does not accept them.
```

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

### fetch_template

Source: https://docs.nextcord.dev/en/stable/ext/commands/api.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.
```

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

### Invoke a command

Source: https://docs.nextcord.dev/en/stable/ext/commands/commands.html

Example of how a user invokes a command defined in the bot.

```text
$foo abc
```

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

### Configure custom sharding parameters

Source: https://docs.nextcord.dev/en/stable/migrating.html

Provides examples for manual shard count and specific shard ID allocation.

```python
# launch 10 shards regardless
client = nextcord.AutoShardedClient(shard_count=10)

# launch specific shard IDs in this process
client = nextcord.AutoShardedClient(shard_count=10, shard_ids=(1, 2, 5, 6))
```

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

### Configure Intents for Messages and Guilds

Source: https://docs.nextcord.dev/en/stable/intents.html

Example of creating an intents object for basic message and guild event handling.

```python
 import nextcord
 intents = nextcord.Intents(messages=True, guilds=True)
 # If you also want reaction events enable the following:
 # intents.reactions = True

 # Somewhere else:
 # client = nextcord.Client(intents=intents)
 # or
 # from nextcord.ext import commands
 # bot = commands.Bot(command_prefix='!', intents=intents)
```

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

### fetch_invite

Source: https://docs.nextcord.dev/en/stable/ext/commands/api.html

Gets an Invite from a discord.gg URL or ID.

```APIDOC
## fetch_invite(url, with_counts=True, with_expiration=True)

### Description
Gets an `Invite` from a discord.gg URL or ID.

### Parameters
- **url** (Union[Invite, str]) - Required - The Discord invite ID or URL.
- **with_counts** (bool) - Optional - Whether to include count information. Defaults to True.
- **with_expiration** (bool) - Optional - Whether to include the expiration date. Defaults to True.

### Returns
- **Invite** - The invite from the URL/ID.
```

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

### Wait for bot readiness before starting a loop

Source: https://docs.nextcord.dev/en/stable/ext/tasks/index.html

Uses the before_loop decorator to ensure the bot is fully connected and ready before the task begins execution.

```python
from nextcord.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()
```

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

### Create a simple background task in a Cog

Source: https://docs.nextcord.dev/en/stable/ext/tasks/index.html

Demonstrates a basic background loop running every 5 seconds within a Cog, including manual start and cancellation.

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

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

### Define a Cog Class

Source: https://docs.nextcord.dev/en/stable/ext/commands/cogs.html

A basic example of a Cog class containing a listener and a command.

```python
class Greetings(commands.Cog):
    def __init__(self, bot):
        self.bot = bot
        self._last_member = None

    @commands.Cog.listener()
    async def on_member_join(self, member):
        channel = member.guild.system_channel
        if channel is not None:
            await channel.send(f'Welcome {member.mention}.')

    @commands.command()
    async def hello(self, ctx, *, member: nextcord.Member = None):
        """Says hello"""
        member = member or ctx.author
        if self._last_member is None or self._last_member.id != member.id:
            await ctx.send(f'Hello {member.name}~')
        else:
            await ctx.send(f'Hello {member.name}... This feels familiar.')
        self._last_member = member
```

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

### Create a virtual environment

Source: https://docs.nextcord.dev/en/stable/intro.html

Commands to navigate to the project directory and initialize a new virtual environment.

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

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

### Get single element from history

Source: https://docs.nextcord.dev/en/stable/migrating.html

Retrieve a specific message from history using the get method.

```python
my_last_message = await channel.history().get(author=client.user)
```

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

### get_cog(name)

Source: https://docs.nextcord.dev/en/stable/ext/commands/api.html

Gets the cog instance requested.

```APIDOC
## get_cog(name)

### Description
Gets the cog instance requested. If the cog is not found, None is returned.

### Parameters
- **name** (str) - Required - The name of the cog you are requesting.

### Returns
- **Optional[Cog]** - The cog that was requested, or None if not found.
```

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

### fetch_widget(guild_id)

Source: https://docs.nextcord.dev/en/stable/ext/commands/api.html

Gets a Widget from a guild ID.

```APIDOC
## fetch_widget(guild_id)

### Description
Gets a `Widget` from a guild ID. The guild must have the widget enabled. This is a coroutine.

### Parameters
- **guild_id** (int) - Required - The ID of the guild.

### Returns
- **Widget** - The guild's widget.

### Raises
- **Forbidden** - The widget for this guild is disabled.
- **HTTPException** - Retrieving the widget failed.
```

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

### Initialize Synchronous and Asynchronous Webhooks

Source: https://docs.nextcord.dev/en/stable/migrating_2.html

Demonstrates the use of SyncWebhook for synchronous requests and Webhook.partial for asynchronous operations with a provided session.

```python
webhook = nextcord.SyncWebhook.from_url(
        f"https://discord.com/api/webhooks/{id}/{token}"
    )
webhook.send("Hello from nextcord!")
async with aiohttp.ClientSession() as session:
    webhook = nextcord.Webhook.partial(
            id,
            token,
            session=session
        )
    await webhook.send("Hello from nextcord!")
```

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

### Initialize Client or Bot with Intents

Source: https://docs.nextcord.dev/en/stable/intents.html

Basic initialization patterns for Nextcord clients and command bots using an intents object.

```python
# Somewhere else:
# client = nextcord.Client(intents=intents)
# or
# from nextcord.ext import commands
# bot = commands.Bot(command_prefix='!', intents=intents)
```

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

### fetch_stage_instance

Source: https://docs.nextcord.dev/en/stable/ext/commands/api.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.
```

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

### @before_loop

Source: https://docs.nextcord.dev/en/stable/ext/tasks/index.html

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

```APIDOC
## @before_loop

### Description
Registers a coroutine to be executed before the loop starts. Useful for waiting for bot state, such as `wait_until_ready()`.

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

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

### Use and configure built-in converters

Source: https://docs.nextcord.dev/en/stable/ext/commands/commands.html

Demonstrates using clean_content with and without custom configuration parameters.

```python
@bot.command()
async def clean(ctx, *, content: commands.clean_content):
    await ctx.send(content)

# or for fine-tuning

@bot.command()
async def clean(ctx, *, content: commands.clean_content(use_nicknames=False)):
    await ctx.send(content)
```

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

### Get sent message ID

Source: https://docs.nextcord.dev/en/stable/faq.html

Retrieve the ID of a message after sending it.

```python
message = await channel.send('hmm…')
message_id = message.id
```

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

### Configure Bot Intents

Source: https://docs.nextcord.dev/en/stable/intents.html

Demonstrates how to initialize default intents and disable specific ones like typing and presences.

```python
import nextcord
intents = nextcord.Intents.default()
intents.typing = False
intents.presences = False
```

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

### Default Help Command Opening Note

Source: https://docs.nextcord.dev/en/stable/ext/commands/api.html

The default string returned by get_opening_note() for help command instructions.

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

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

### Migrate voice connection and playback

Source: https://docs.nextcord.dev/en/stable/migrating.html

Voice handling now uses AudioSource and direct VoiceClient methods.

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

```python
vc = await channel.connect()
vc.play(nextcord.FFmpegPCMAudio('testing.mp3'), after=lambda e: print('done', e))
vc.is_playing()
vc.pause()
vc.resume()
vc.stop()
```

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

### Create a Minimal Nextcord Bot

Source: https://docs.nextcord.dev/en/stable/quickstart.html

A basic bot implementation using the commands framework, featuring an on_ready event and a slash command.

```python
import nextcord
from nextcord.ext import commands

TESTING_GUILD_ID = 123456789  # Replace with your guild ID

bot = commands.Bot()

@bot.event
async def on_ready():
    print(f'We have logged in as {bot.user}')

@bot.slash_command(description="My first slash command", guild_ids=[TESTING_GUILD_ID])
async def hello(interaction: nextcord.Interaction):
    await interaction.send("Hello!")

bot.run('your token here')
```

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

### load_extension(name, *, package=None, extras=None)

Source: https://docs.nextcord.dev/en/stable/ext/commands/api.html

Loads an extension into the bot.

```APIDOC
## load_extension(name, *, package=None, extras=None)

### Description
Loads an extension. An extension is a python module that contains commands, cogs, or listeners. An extension must have a global function, `setup` defined as the entry point.

### Parameters
- **name** (`str`) - Required - The extension name to load (dot separated).
- **package** (`Optional[str]`) - Optional - The package name to resolve relative imports with.
- **extras** (`Optional[dict]`) - Optional - A mapping of kwargs to values to be passed to your cog’s `__init__` method.
```

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

### Bulk Loading Extensions with Configuration

Source: https://docs.nextcord.dev/en/stable/ext/commands/api.html

Loads multiple extensions from a package with associated configuration attributes.

```python
bot.load_extensions(
    [
        ".my_cog",
        ".my_cog_two",
    ],
    package="cogs",
    extras=[{"my_attribute": 11}, {"my_other_attribute": 12}],
)
```

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

### is_ready()

Source: https://docs.nextcord.dev/en/stable/ext/commands/api.html

Specifies if the client’s internal cache is ready for use.

```APIDOC
## is_ready()

### Description
Specifies if the client’s internal cache is ready for use.

### Returns
- **bool** - Whether the cache is ready.
```

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

### load_extensions(names, *, package=None, packages=None, extras=None, stop_at_error=False)

Source: https://docs.nextcord.dev/en/stable/ext/commands/api.html

Loads a list of extensions into the bot. Supports passing packages and extra configuration attributes for each extension.

```APIDOC
## load_extensions

### Description
Loads a list of extensions into the bot. This method allows for bulk loading of extensions with optional package paths and extra configuration data.

### Parameters
- **names** (List[str]) - Required - The names of the extensions to load.
- **package** (str) - Optional - The package to use for relative imports.
- **packages** (List[str]) - Optional - A list of packages corresponding to the names.
- **extras** (List[dict]) - Optional - A list of extra arguments to pass to the setup function of each extension.
- **stop_at_error** (bool) - Optional - Whether to raise an exception on failure. Defaults to False.

### Returns
- List[str] - A list of names of extensions that loaded successfully.

### Raises
- ValueError, InvalidArgument, ExtensionNotFound, ExtensionAlreadyLoaded, NoEntryPointError, ExtensionFailed
```

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

### await send_help(entity=None)

Source: https://docs.nextcord.dev/en/stable/ext/commands/api.html

Shows the help command for the specified entity (command or cog). If no entity is provided, it displays help for the entire bot.

```APIDOC
## await send_help(entity=None)

### Description
Shows the help command for the specified entity. If the entity is a string, it attempts to look up a Cog or Command.

### Parameters
- **entity** (Optional[Union[Command, Cog, str]]) - Optional - The entity to show help for.
```

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

### Define a Cog with Special Methods

Source: https://docs.nextcord.dev/en/stable/migrating.html

Example of a Cog class implementing various special methods for lifecycle management, checks, error handling, and hooks.

```python
class MyCog(commands.Cog, name='Example Cog'):
    def cog_unload(self):
        print('cleanup goes here')

    def bot_check(self, ctx):
        print('bot check')
        return True

    def bot_check_once(self, ctx):
        print('bot check once')
        return True

    async def cog_check(self, ctx):
        print('cog local check')
        return await ctx.bot.is_owner(ctx.author)

    async def cog_command_error(self, ctx, error):
        print('Error in {0.command.qualified_name}: {1}'.format(ctx, error))

    async def cog_before_invoke(self, ctx):
        print('cog local before: {0.command.qualified_name}'.format(ctx))

    async def cog_after_invoke(self, ctx):
        print('cog local after: {0.command.qualified_name}'.format(ctx))

    @commands.Cog.listener()
    async def on_message(self, message):
        pass
```

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

### Implement a basic command check

Source: https://docs.nextcord.dev/en/stable/ext/application_checks/index.html

Shows how to define a simple predicate function and apply it to a slash command.

```python
def check_if_it_is_me(interaction: Interaction):
    return interaction.message.author.id == 85309593344815104

@bot.slash_command()
@application_checks.check(check_if_it_is_me)
async def only_for_me(interaction: Interaction):
    await interaction.response.send_message('I know you!')
```

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

### Creating a Basic Command Check

Source: https://docs.nextcord.dev/en/stable/ext/commands/api.html

Shows how to define a simple predicate function and apply it to a command using the @commands.check decorator.

```python
def check_if_it_is_me(ctx):
    return ctx.message.author.id == 85309593344815104

@bot.command()
@commands.check(check_if_it_is_me)
async def only_for_me(ctx):
    await ctx.send('I know you!')
```

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

### Load and Reload Extensions with Arguments

Source: https://docs.nextcord.dev/en/stable/ext/commands/api.html

Demonstrates passing extra arguments to extensions during load and reload operations.

```python
bot.load_extension("cogs.me_cog", extras={"keyword_arg": False})
bot.reload_extension("cogs.me_cog", extras={"keyword_arg": True})
```

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

### Implement a custom HelpCommand within a Cog

Source: https://docs.nextcord.dev/en/stable/migrating.html

Demonstrates how to subclass MinimalHelpCommand and bind it to a Cog, ensuring the help command is properly restored when the cog is unloaded.

```python
class MyHelpCommand(commands.MinimalHelpCommand):
    def get_command_signature(self, command):
        return '{0.clean_prefix}{1.qualified_name} {1.signature}'.format(self, command)

class MyCog(commands.Cog):
    def __init__(self, bot):
        self._original_help_command = bot.help_command
        bot.help_command = MyHelpCommand()
        bot.help_command.cog = self

    def cog_unload(self):
        self.bot.help_command = self._original_help_command
```

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

### Create a custom converter by extending MemberConverter

Source: https://docs.nextcord.dev/en/stable/ext/commands/commands.html

Shows how to build a custom converter by inheriting from existing ones to process data before it reaches the command function.

```python
class MemberRoles(commands.MemberConverter):
    async def convert(self, ctx, argument):
        member = await super().convert(ctx, argument)
        return [role.name for role in member.roles[1:]] # Remove everyone role!

@bot.command()
async def roles(ctx, *, member: MemberRoles):
    """Tells you a member's roles."""
    await ctx.send('I see the following roles: ' + ', '.join(member))
```

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

### Use typing context manager

Source: https://docs.nextcord.dev/en/stable/ext/commands/api.html

Demonstrates using the typing context manager to indicate bot activity during long-running operations.

```python
async with channel.typing():
    # simulate something heavy
    await asyncio.sleep(10)

await channel.send('done!')
```

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

### await login(token)

Source: https://docs.nextcord.dev/en/stable/ext/commands/api.html

Authenticates the client with the provided token.

```APIDOC
## login

### Description
Logs the client into the Discord gateway using the provided authentication token.

### Parameters
- **token** (str) - Required - The authentication token. Do not include prefixes.

### Raises
- LoginFailure, HTTPException
```

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

### Activate virtual environment

Source: https://docs.nextcord.dev/en/stable/intro.html

Commands to activate the virtual environment on different operating systems.

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

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

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

### load_extensions(names, *, package=None, packages=None, extras=None, stop_at_error=False)

Source: https://docs.nextcord.dev/en/stable/ext/commands/api.html

Loads multiple extensions provided in a list. Exceptions are printed to stderr by default unless configured otherwise.

```APIDOC
## load_extensions(names, *, package=None, packages=None, extras=None, stop_at_error=False)

### Description
Loads all extensions provided in a list. By default, exceptions are printed to the console rather than raised.

### Parameters
- **names** (List[str]) - Required - The names of all extensions to load.
- **package** (str) - Optional - Package name to resolve relative imports.
- **packages** (List[str]) - Optional - List of package names to resolve relative imports.
- **extras** (List[Dict[str, Any]]) - Optional - List of extra arguments to pass to each extension's setup function.
- **stop_at_error** (bool) - Optional - Whether to stop loading if an error occurs.
```

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

### Define a basic command

Source: https://docs.nextcord.dev/en/stable/ext/commands/commands.html

Commands are defined by decorating a function with @bot.command(). The first parameter must be the context object.

```python
@bot.command()
async def foo(ctx, arg):
    await ctx.send(arg)
```

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

### Registering global command hooks

Source: https://docs.nextcord.dev/en/stable/migrating.html

Use before_invoke and after_invoke decorators on the bot instance to execute logic globally for all commands.

```python
@bot.before_invoke
async def before_any_command(ctx):
    # do something before a command is called
    pass

@bot.after_invoke
async def after_any_command(ctx):
    # do something after a command is called
    pass
```

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

### application_info()

Source: https://docs.nextcord.dev/en/stable/ext/commands/api.html

Retrieves the bot's application information.

```APIDOC
## application_info()

### Description
Retrieves the bot's application information. This is a coroutine.

### Returns
- `AppInfo` - The bot's application information.

### Raises
- **HTTPException** - Retrieving the information failed.
```

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

### Run the Bot Script

Source: https://docs.nextcord.dev/en/stable/quickstart.html

Commands to execute the bot script on different operating systems.

```bash
$ py -3 example_bot.py
```

```bash
$ python3 example_bot.py
```

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

### Registering a pre-invoke hook with application_command_before_invoke

Source: https://docs.nextcord.dev/en/stable/ext/application_checks/index.html

Demonstrates using a coroutine as a pre-invoke hook for both global slash commands and commands within a Cog.

```python
async def record_usage(interaction: Interaction):
    print(
        interaction.user,
        "used",
        interaction.application_command,
        "at",
        interaction.message.created_at
    )

@bot.slash_command()
@application_checks.application_command_before_invoke(record_usage)
async def who(interaction: Interaction): # Output: <User> used who at <Time>
    await interaction.response.send_message("I am a bot")

class What(commands.Cog):
    @application_checks.application_command_before_invoke(record_usage)
    @nextcord.slash_command()
    async def when(self, interaction: Interaction):
        # Output: <User> used when at <Time>
        await interaction.response.send_message(
            f"and i have existed since {interaction.client.user.created_at}"
        )

    @nextcord.slash_command()
    async def where(self, interaction: Interaction): # Output: <Nothing>
        await interaction.response.send_message("on Discord")

    @nextcord.slash_command()
    async def why(self, interaction: Interaction): # Output: <Nothing>
        await interaction.response.send_message("because someone made me")

bot.add_cog(What())
```

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

### Subclassing Context

Source: https://docs.nextcord.dev/en/stable/migrating.html

Define a custom context class by inheriting from commands.Context.

```python
class MyContext(commands.Context):
    @property
    def secret(self):
        return 'my secret here'
```

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

### Define User Context Menu Command

Source: https://docs.nextcord.dev/en/stable/interactions.html

Registers a command in the user right-click menu. Requires a guild_ids list for testing.

```python
@bot.user_command(guild_ids=[TESTING_GUILD_ID])
async def hello(interaction: nextcord.Interaction, member: nextcord.Member):
    """Says hi to a user that was right-clicked on"""
    await interaction.response.send_message(f"Hello {member}!")
```

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

### Upload Multiple Files

Source: https://docs.nextcord.dev/en/stable/migrating.html

Shows how to send multiple file attachments using a list of File objects.

```python
my_files = [
    nextcord.File('cool.png', 'testing.png'),
    nextcord.File(some_fp, 'cool_filename.png'),
]

await channel.send('Your images:', files=my_files)
```

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

### Implement subcommands

Source: https://docs.nextcord.dev/en/stable/interactions.html

Creates a base command that acts as a prefix for multiple subcommands using the subcommand decorator.

```python
@bot.slash_command(guild_ids=[TESTING_GUILD_ID])
async def main(interaction: nextcord.Interaction):
    """
    This is the main slash command that will be the prefix of all commands below.
    This will never get called since it has subcommands.
    """
    pass


@main.subcommand(description="Subcommand 1")
async def sub1(interaction: nextcord.Interaction):
    """
    This is a subcommand of the '/main' slash command.
    It will appear in the menu as '/main sub1'.
    """
    await interaction.response.send_message("This is subcommand 1!")
```

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

### Using the Async Event Utility Decorator

Source: https://docs.nextcord.dev/en/stable/migrating_to_async.html

A shorthand utility decorator for registering coroutine events.

```python
@client.async_event
def on_message(message):
    pass
```

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

### Update Command Syntax

Source: https://docs.nextcord.dev/en/stable/migrating.html

The bot.say helper is replaced by Context.send, and the context object is now passed by default.

```python
# before
@bot.command()
async def foo():
    await bot.say('Hello')

# after
@bot.command()
async def foo(ctx):
    await ctx.send('Hello')
```

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

### Registering per-command hooks

Source: https://docs.nextcord.dev/en/stable/migrating.html

Attach before_invoke and after_invoke decorators directly to specific command functions.

```python
@bot.command()
async def foo(ctx):
    await ctx.send('foo')

@foo.before_invoke
async def before_foo_command(ctx):
    # do something before the foo command is called
    pass

@foo.after_invoke
async def after_foo_command(ctx):
    # do something after the foo command is called
    pass
```

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

### create_guild

Source: https://docs.nextcord.dev/en/stable/ext/commands/api.html

Creates a new guild.

```APIDOC
## await create_guild(name, region=VoiceRegion.us_west, icon=None, code=...)

### Description
Creates a Guild. Bot accounts in more than 10 guilds are not allowed to create guilds.

### Parameters
- **name** (str) - Required - The name of the guild.
- **region** (VoiceRegion) - Optional - The region for the voice communication server.
- **icon** (Optional[Union[bytes, Asset, Attachment, File]]) - Optional - The icon image.
- **code** (str) - Optional - The code for a template to create the guild with.

### Returns
- **Guild** - The guild created.

### Raises
- **.HTTPException** - Guild creation failed.
- **.InvalidArgument** - Invalid icon image format given.
```

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

### load_extensions_from_module(source_module, *, ignore=None, stop_at_error=False)

Source: https://docs.nextcord.dev/en/stable/ext/commands/api.html

Loads all extensions found within a specified module.

```APIDOC
## load_extensions_from_module

### Description
Automatically discovers and loads all extensions located within the provided source module.

### Parameters
- **source_module** (str) - Required - The name of the module to scan for submodules.
- **ignore** (List[str]) - Optional - A list of extension file names to skip.
- **stop_at_error** (bool) - Optional - Whether to raise an exception on failure. Defaults to False.

### Returns
- List[str] - A list of names of extensions that loaded successfully.

### Raises
- ValueError, ExtensionNotFound, ExtensionAlreadyLoaded, NoEntryPointError, ExtensionFailed
```

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

### Define a command with a custom function converter

Source: https://docs.nextcord.dev/en/stable/ext/commands/commands.html

Demonstrates using a custom function as a converter to transform input strings to uppercase.

```python
def to_upper(argument):
    return argument.upper()

@bot.command()
async def up(ctx, *, content: to_upper):
    await ctx.send(content)
```

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

### Set client activity

Source: https://docs.nextcord.dev/en/stable/faq.html

Configure the client's activity status using the Activity object.

```python
activity = nextcord.Activity(name='my activity', type=nextcord.ActivityType.watching)
client = nextcord.Client(activity=activity)
```

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

### Load multiple extensions in batch

Source: https://docs.nextcord.dev/en/stable/ext/commands/api.html

Load a list of extensions using load_extensions, optionally specifying packages for relative imports.

```python
# main.py
bot.load_extensions(
    [
        ".my_cog",
        ".my_cog_two",
    ],
    packages=[
        "cogs.coolcog",
        "cogs.coolcogtwo",
    ],
)

# cogs/coolcog/my_cog.py
class MyCog(commands.Cog):
    def __init__(self, bot):
        self.bot = bot

    # ...

def setup(bot):
    bot.add_cog(MyCog(bot))

# cogs/coolcogtwo/my_cog_two.py
class MyCogTwo(commands.Cog):
    def __init__(self, bot):
        self.bot = bot

    # ...

def setup(bot):
    bot.add_cog(MyCogTwo(bot))
```

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

### Initialize AutoShardedClient

Source: https://docs.nextcord.dev/en/stable/migrating.html

Initializes the sharded client to handle multiple guilds across shards automatically.

```python
client = nextcord.AutoShardedClient()
```

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

### Use Discord object type hints

Source: https://docs.nextcord.dev/en/stable/interactions.html

Accepts Discord objects like Members or Channels as command arguments.

```python
@bot.slash_command(guild_ids=[TESTING_GUILD_ID])
async def hi(interaction: nextcord.Interaction, user: nextcord.Member):
    """Say hi to a user

    Parameters
    ----------
    interaction: Interaction
        The interaction object
    user: nextcord.Member
        The user to say hi to.
    """
    await interaction.response.send_message(
        f"{interaction.user} just said hi to {user.mention}"
    )
```

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

### Create a simple slash command

Source: https://docs.nextcord.dev/en/stable/interactions.html

Registers a basic slash command with Discord. Use guild_ids to limit availability during testing.

```python
@bot.slash_command(guild_ids=[TESTING_GUILD_ID])
async def ping(interaction: nextcord.Interaction):
    """Simple command that responds with Pong!"""
    await interaction.response.send_message("Pong!")
```

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

### Customize flags with flag()

Source: https://docs.nextcord.dev/en/stable/ext/commands/commands.html

Shows how to use the flag() function to customize flag names and default values.

```python
from typing import List

class BanFlags(commands.FlagConverter):
    members: List[nextcord.Member] = commands.flag(name='member', default=lambda ctx: [])
```

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

### Manual Event Loop Management

Source: https://docs.nextcord.dev/en/stable/migrating_to_async.html

Use this pattern if you require manual control over the event loop instead of using the blocking client.run() method.

```python
import nextcord
import asyncio

client = nextcord.Client()

@asyncio.coroutine
def main_task():
    yield from client.login('token')
    yield from client.connect()

loop = asyncio.get_event_loop()
try:
    loop.run_until_complete(main_task())
except:
    loop.run_until_complete(client.logout())
finally:
    loop.close()
```

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

### async with typing()

Source: https://docs.nextcord.dev/en/stable/ext/commands/api.html

Returns a context manager that allows you to type for an indefinite period of time, useful for denoting long computations.

```APIDOC
## async with typing()

### Description
Returns a context manager that allows you to type for an indefinite period of time. This is useful for denoting long computations in your bot.

### Usage
```python
async with channel.typing():
    # simulate something heavy
    await asyncio.sleep(10)
```
```

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

### Command definition with converter class

Source: https://docs.nextcord.dev/en/stable/ext/commands/commands.html

Shows the syntax for using a converter class in a command definition.

```python
@bot.command()
async def slap(ctx, *, reason: Slapper):
    await ctx.send(reason)
```

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

### sync_all_application_commands

Source: https://docs.nextcord.dev/en/stable/ext/commands/api.html

Synchronizes all application commands with Discord.

```APIDOC
## await sync_all_application_commands(data=None, *, use_rollout=True, associate_known=True, delete_unknown=True, update_known=True, register_new=True, ignore_forbidden=True)

### Description
Syncs all application commands with Discord. This may involve multiple API calls and should be used carefully to avoid rate limits.
```

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

### Find a guild and channel by name

Source: https://docs.nextcord.dev/en/stable/faq.html

Use nextcord.utils.get to retrieve objects from collections by attribute.

```python
guild = nextcord.utils.get(client.guilds, name='My Server')

# make sure to check if it's found
if guild is not None:
    # find a channel by name
    channel = nextcord.utils.get(guild.text_channels, name='cool-channel')
```

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

### add_view(view, *, message_id=None)

Source: https://docs.nextcord.dev/en/stable/ext/commands/api.html

Registers a View for persistent listening or non-persistent storage.

```APIDOC
## add_view(view, *, message_id=None)

### Description
Registers a `View` for persistent listening or for non-persistent storage. This should be used when a view is comprised of components that last longer than the lifecycle of the program.

### Parameters
- **view** (`nextcord.ui.View`) - Required - The view to register for dispatching or to add to storage.
- **message_id** (Optional[`int`]) - Optional - The message ID that the view is attached to. Used to refresh the view's state during message update events.
```

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

### Make a web request with aiohttp

Source: https://docs.nextcord.dev/en/stable/faq.html

Use a non-blocking library like aiohttp for web requests within an async context.

```python
async with aiohttp.ClientSession() as session:
    async with session.get('http://aws.random.cat/meow') as r:
        if r.status == 200:
            js = await r.json()
```

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

### Create a custom check decorator

Source: https://docs.nextcord.dev/en/stable/ext/application_checks/index.html

Demonstrates how to wrap an existing check with custom logic using the check decorator.

```python
def owner_or_permissions(**perms):
    original = application_checks.has_permissions(**perms).predicate
    async def extended_check(interaction: Interaction):
        if interaction.guild is None:
            return False

        return (
            interaction.guild.owner_id == interaction.user.id
            or await original(interaction)
        )
    return application_checks.check(extended_check)
```

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

### Create an Abstract Cog Mixin

Source: https://docs.nextcord.dev/en/stable/ext/commands/api.html

Demonstrates how to combine CogMeta with other metaclasses like abc.ABCMeta to create abstract mixin classes for cogs.

```python
import abc

class CogABCMeta(commands.CogMeta, abc.ABCMeta):
    pass

class SomeMixin(metaclass=abc.ABCMeta):
    pass

class SomeCogMixin(SomeMixin, commands.Cog, metaclass=CogABCMeta):
    pass
```

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

### await reply(content=None, **kwargs)

Source: https://docs.nextcord.dev/en/stable/ext/commands/api.html

A shortcut method to send a reply to a message.

```APIDOC
## await reply(content=None, **kwargs)

### Description
A shortcut method to `abc.Messageable.send()` to reply to the message.

### Parameters
- **content** (str) - Optional - The content of the message.
- **kwargs** (dict) - Optional - Additional arguments passed to the send method.

### Raises
- **HTTPException** - Sending the message failed.
- **Forbidden** - Insufficient permissions.
- **InvalidArgument** - Invalid file arguments.
```

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

### Configure Bot Prefix with when_mentioned_or

Source: https://docs.nextcord.dev/en/stable/ext/commands/api.html

Demonstrates using when_mentioned_or to set a command prefix that includes mentions and a custom string.

```python
bot = commands.Bot(command_prefix=commands.when_mentioned_or('!'))
```

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

### Handle multiple return arguments in wait_for

Source: https://docs.nextcord.dev/en/stable/migrating.html

Shows how to unpack multiple return values when waiting for a reaction event.

```python
reaction, user = await client.wait_for('reaction_add', check=lambda r, u: u.id == 176995180300206080)

# use user and reaction
```

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

### Wait for events with Client.wait_for

Source: https://docs.nextcord.dev/en/stable/migrating.html

Demonstrates waiting for a message event using a predicate function.

```python
def pred(m):
    return m.author == message.author and m.channel == message.channel

msg = await client.wait_for('message', check=pred)
```

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

### nextcord.ext.commands.on_command(ctx)

Source: https://docs.nextcord.dev/en/stable/ext/commands/api.html

An event handler called when a command is found and is about to be invoked.

```APIDOC
## nextcord.ext.commands.on_command(ctx)

### Description
An event that is called when a command is found and is about to be invoked. This event is called regardless of whether the command itself succeeds or fails.

### Parameters
- **ctx** (Context) - Required - The invocation context.
```

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

### Advanced Logging to File

Source: https://docs.nextcord.dev/en/stable/logging.html

Configures logging to write output to a file named 'nextcord.log' with a custom format, useful for verbose levels like INFO or DEBUG.

```python
import nextcord
import logging

logger = logging.getLogger('nextcord')
logger.setLevel(logging.DEBUG)
handler = logging.FileHandler(filename='nextcord.log', encoding='utf-8', mode='w')
handler.setFormatter(logging.Formatter('%(asctime)s:%(levelname)s:%(name)s: %(message)s'))
logger.addHandler(handler)
```

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

### Apply multiple command checks

Source: https://docs.nextcord.dev/en/stable/ext/commands/commands.html

Stack multiple check decorators; all must return True for the command to execute.

```python
def is_in_guild(guild_id):
    async def predicate(ctx):
        return ctx.guild and ctx.guild.id == guild_id
    return commands.check(predicate)

@bot.command()
@commands.is_owner()
@is_in_guild(41771983423143937)
async def secretguilddata(ctx):
    """super secret stuff"""
    await ctx.send('secret stuff')
```

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

### await invoke(command, *args, **kwargs)

Source: https://docs.nextcord.dev/en/stable/ext/commands/api.html

Calls a command with the arguments given by invoking the internal callback directly.

```APIDOC
## await invoke(command, *args, **kwargs)

### Description
Calls a command with the arguments given. This does not handle converters, checks, cooldowns, pre-invoke, or after-invoke hooks.

### Parameters
- **command** (Command) - Required - The command that is going to be called.
- ***args** - Optional - The arguments to use.
- ****kwargs** - Optional - The keyword arguments to use.

### Raises
- **TypeError** - The command argument to invoke is missing.
```

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

### nextcord.ext.commands.when_mentioned_or

Source: https://docs.nextcord.dev/en/stable/ext/commands/api.html

A callable that implements when mentioned or other prefixes provided. This is intended to be passed into the Bot.command_prefix attribute.

```APIDOC
## nextcord.ext.commands.when_mentioned_or(*prefixes)

### Description
A callable that implements when mentioned or other prefixes provided. These are meant to be passed into the `Bot.command_prefix` attribute.

### Example
```python
bot = commands.Bot(command_prefix=commands.when_mentioned_or('!'))
```
```

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

### Send Embeds

Source: https://docs.nextcord.dev/en/stable/migrating.html

Demonstrates sending an embed using the updated channel send method.

```python
e = nextcord.Embed(title='foo')
await channel.send('Hello', embed=e)
```

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

### Receive a Member object in a command

Source: https://docs.nextcord.dev/en/stable/ext/commands/commands.html

Demonstrates using the Member converter to automatically resolve a user mention, ID, or name into a Member object.

```python
@bot.command()
async def joined(ctx, *, member: nextcord.Member):
    await ctx.send(f'{member} joined on {member.joined_at}')
```

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

### @nextcord.ext.commands.command(name=..., cls=..., **attrs)

Source: https://docs.nextcord.dev/en/stable/ext/commands/api.html

A decorator that transforms a function into a Command.

```APIDOC
## @nextcord.ext.commands.command(name=..., cls=..., **attrs)

### Description
A decorator that transforms a function into a Command. By default, the help attribute is received automatically from the docstring of the function.

### Parameters
- **name** (str) - Optional - The name to create the command with. Defaults to the function name.
- **cls** (type) - Optional - The class to construct with. Defaults to Command.
- **attrs** (dict) - Optional - Keyword arguments to pass into the construction of the class.
```

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

### Registering a Pre-Invoke Hook

Source: https://docs.nextcord.dev/en/stable/ext/commands/api.html

Demonstrates using the before_invoke decorator to register a coroutine that executes before a command, applicable to both standalone commands and Cog methods.

```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())
```
Tokens:
Raw