Client and Bot

Make a function an event handler: on_message, on_ready... One per event; it replaces the default.

Any coroutine is set on the client by its name, so @bot.event async def setup_hook() replaces the hook.

A callback for one button, matched by what it reports (this library's first version; a ui.View is the current way).

It runs only for a press on a message this bot sent, naming a button that message carried and left enabled, from somebody who could see the message. Any other press is dropped (and said once in the log): a press is a message any member can seal.

A listener: like event, but any number can listen to one event, beside its @event handler.

Wait for the next event ("message" or "on_message") that passes check, and return what it was handed.

Raises asyncio.TimeoutError after timeout seconds. One value is returned as itself, several as a tuple.

Fire an event ("message" runs on_message), from code of the bot's own; it runs as its own task.

What a handler's exception does when the bot sets no on_error: the traceback, logged.

The servers the bot knows it is in.

The bot's user id: on ILLEST the application and its bot account are one.

How long the server took to answer the last heartbeat, in seconds. The first is sent on connecting, so this is known a round trip after the bot signs in (nan only before that answer).

Per action the bot has used: its limit, what is left of it now, the seconds spent waiting for it, and refusals.

The bot's slash commands, when it has made an app_commands.CommandTree(client) (a commands.Bot always has one).

Seal and send a message (this library's first version; channel.send is the current way).

client_id is this message's own name: 8 to 64 letters, digits, - or _. Pass the same one again to retry a send whose answer never came back, and the server answers with the message it already stored instead of posting a second one.

A picture at url, fetched once by this bot's server and sealed as a file, so it can be sent with a message and shown in place: its reference, or None when the server will not fetch it (its switch is off, the address is private, it is not a picture). Readers then open it from the conversation's sealed files and never reach url's host.

Keep a view answering across restarts: timeout=None and its own custom_id on every item, given here in setup_hook.

Any server action by name, answered (or refused with a GatewayError subclass). Paced to its rate limit.

Replace the text of one of this bot's own messages (this library's first version; message.edit is the current way).

Take back one of this bot's own messages, on every client; its buttons stop answering.

Destroy the stored ciphertext of anybody's message, as a moderator (moderate scope, and the permission there).

Put an emoji on a message: one emoji, or a server's emoji as its <:name:id> token.

Show the bot as composing in a channel for a few seconds.

The direct conversation with a person, opened if it is not (messages.write).

What the bot shows, everywhere a person's status shows: the member list, its profile, direct messages.

Args: activity: One line under its name: Game("chess"), Streaming(name=..., url=...), Activity(type=ActivityType.watching, name="/help") (or listening), or CustomActivity("Type /help") for words of its own. None clears it. Each call replaces the line. status: Status.online, Status.idle, Status.dnd or Status.invisible (or those words). Left out, the status stays as it is. Invisible shows the bot as offline while it keeps working.

Everybody who shares a server or a conversation with the bot sees it. It lasts until the bot disconnects; when it connects again it shows the default its team set on the developer portal's Bot page, until this is called again.

await bot.change_presence(activity=illest.Activity(type=illest.ActivityType.watching, name="/help"))
await bot.change_presence(status=illest.Status.idle, activity=illest.CustomActivity("Back soon"))

Every server the bot is in (guilds.read): await it for a list, or async for over it.

One server, with its channels and roles (guilds.read).

A channel the bot can see. A server's channels are read with the server; a direct conversation is the one held.

Join a server by an invite code, as anybody does (guilds.read). None when the server asks applicants to apply first.

The members of a server: everyone in a small one, a page of limit in a large one, or those whose name matches query (members.read).

An account's public profile, by id.

Remove somebody from a server (moderate, and KICK_MEMBERS there above them).

Keep somebody from speaking in a server for seconds: 0 lifts it, 28 days at most (moderate).

Seal a file here, send the ciphertext, and return the reference to attach to a message.

The same sealed format the first-party client makes, so a picture sent this way opens in its reader: a fresh key for the file, the key inside the message and never beside the bytes, and the server holding something it cannot open. A file over 8 MiB goes up in parts. Raises AttachmentError with a sentence (the server's own, when it refused: it knows the limit it enforced).

Fetch a sealed file a message carries and open it with the key the message holds.

Runs once the bot has signed in and before on_ready: load extensions, add_view, tree.sync() here.

Take the token to sign in with. The sign-in itself is part of connect, since a bot proves its device on the socket.

Connect and run until the bot is closed. A dropped socket is resumed, or signed in again, by itself.

login and connect: run the bot until it stops.

Block on the bot until it stops. Ctrl-C stops it.

Sets up logging to the terminal first, unless the program has configured logging itself; pass log_handler=None to leave logging alone, or a handler of your own.

Is a key other than the pinned one waiting to be accepted for this account?

The operator's word that the key an account now shows is its own. Call it only after asking the person another way.

Stop: the socket closes and start returns.

Ready this client to start again after close.

Every command once, aliases folded. By name (aliases too): all_commands.

The bot's slash commands and context menus: @bot.tree.command(), then await bot.tree.sync().

A command used both as !name and as /name.

Whether user owns this bot: owner_id/owner_ids when given, else the account that made the bot (the server says).

Import a module and run its async def setup(bot): await bot.load_extension("cogs.music").

A command by its name or an alias; "tag add" finds a subcommand.

A check every command must pass.

Run the command a message names, if it names one. A message is processed once, however often this is called.

What happens to a command's error when the bot has no on_command_error of its own.

The person's mistakes are answered with the sentence; a check that said no is answered quietly to them alone; an unknown command is silence; what the command itself raised is logged with its traceback and answered with one line.

The / menu this bot would list: one row per visible command whose name the menu can show.

List this bot's commands in the app's / menu now, replacing what was listed. Returns what the server kept.

With slash commands in bot.tree, await bot.tree.sync() lists both (a sync replaces the whole menu).