Teloxide

https://docs.rs/teloxide/latest/teloxide/
Admin
Teloxide is a full-featured Rust framework that empowers you to easily build Telegram bots with...
Tokens:1,380,843
Snippets:11,319
Trust Score:9.1
Update:2 months ago
Show doc for...
Tokens:
Raw
### Basic Dispatcher Setup with Handler

Source: https://docs.rs/teloxide/latest/teloxide/dispatching/struct.DispatcherBuilder.html

Sets up a basic dispatcher with a message handler. This example demonstrates how to filter messages and define an endpoint for them.

```rust
let handler = Update::filter_message().endpoint(
        |bot: Bot, messages_total: Arc<AtomicU64>, msg: Message| async move {
            let previous = messages_total.fetch_add(1, Ordering::Relaxed);
            bot.send_message(msg.chat.id, format!("I received {previous} messages in total."))
                .await?;
            respond(())
        },
    );

    Dispatcher::builder(bot, handler)
        .dependencies(dptree::deps![messages_total])
        .enable_ctrlc_handler()
        .build()
        .dispatch()
        .await;
```

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

### Dialogue Initialization Example

Source: https://docs.rs/teloxide/latest/teloxide/dispatching/dialogue/struct.Dialogue.html

Demonstrates how to initialize a Dialogue object. This is typically the starting point for managing a conversation.

```rust
impl Dialogue {
    pub fn new() -> Self {
        Dialogue {
            state: DialogueState::new(),
            handler: Box::new(DefaultDialogueHandler),
        }
    }
}
```

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

### Create Bot and Get Me

Source: https://docs.rs/teloxide/latest/teloxide/struct.Bot.html

Demonstrates creating a Bot instance with a token and making a 'get me' API call. Requires importing Bot and other prelude items.

```rust
use teloxide_core::prelude::*;

let bot = Bot::new("TOKEN");
dbg!(bot.get_me().await?);
```

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

### Example Usage of Storage with Redis or SQLite

Source: https://docs.rs/teloxide/latest/teloxide/dispatching/dialogue/trait.Storage.html

Demonstrates how to initialize a storage backend (Redis or SQLite) and use its `erase` method to prepare it for use with the dispatcher. This example is typically found in the main function of a bot.

```rust
    let storage: MyStorage = if std::env::var("DB_REMEMBER_REDIS").is_ok() {
        RedisStorage::open("redis://127.0.0.1:6379", Bincode).await.unwrap().erase()
    } else {
        SqliteStorage::open("db.sqlite", Json).await.unwrap().erase()
    };

    let handler = Update::filter_message()
        .enter_dialogue::<Message, ErasedStorage<State>, State>()
        .branch(dptree::case![State::Start].endpoint(start))
        .branch(
            dptree::case![State::GotNumber(n)]
                .branch(dptree::entry().filter_command::<Command>().endpoint(got_number))
                .branch(dptree::endpoint(invalid_command)),
        );

    Dispatcher::builder(bot, handler)
        .dependencies(dptree::deps![storage])
        .enable_ctrlc_handler()
        .build()
        .dispatch()
        .await;
```

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

### Example: Using RedisStorage in a Bot

Source: https://docs.rs/teloxide/latest/teloxide/dispatching/dialogue/struct.RedisStorage.html

Demonstrates how to initialize and use RedisStorage within a teloxide bot. This example shows conditional storage initialization based on environment variables.

```rust
async fn main() {
    pretty_env_logger::init();
    log::info!("Starting DB remember bot...");

    let bot = Bot::from_env();

    let storage: MyStorage = if std::env::var("DB_REMEMBER_REDIS").is_ok() {
        RedisStorage::open("redis://127.0.0.1:6379", Bincode).await.unwrap().erase()
    } else {
        SqliteStorage::open("db.sqlite", Json).await.unwrap().erase()
    };

    let handler = Update::filter_message()
        .enter_dialogue::<Message, ErasedStorage<State>, State>()
        .branch(dptree::case![State::Start].endpoint(start))
        .branch(
            dptree::case![State::GotNumber(n)]
                .branch(dptree::entry().filter_command::<Command>().endpoint(got_number))
                .branch(dptree::endpoint(invalid_command)),
        );

    Dispatcher::builder(bot, handler)
        .dependencies(dptree::deps![storage])
        .enable_ctrlc_handler()
        .build()
        .dispatch()
        .await;
}
```

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

### ChatPermissions Usage Examples

Source: https://docs.rs/teloxide/latest/teloxide/types/struct.ChatPermissions.html

Examples demonstrating how to use ChatPermissions, including creating, checking, and combining permissions.

```APIDOC
## ChatPermissions Usage Examples

### Creating and Checking Permissions
```rust
use teloxide_core::types::ChatPermissions;

// No permissions, nothing is allowed
let _ = ChatPermissions::empty();

// All permissions, everything is allowed
let _ = ChatPermissions::all();

// One particular permission
let permissions_v0 = ChatPermissions::INVITE_USERS;

// Check what is permitted
assert!(permissions_v0.contains(ChatPermissions::INVITE_USERS));
assert!(!permissions_v0.contains(ChatPermissions::SEND_MESSAGES));
```

### Combining Permissions
```rust
use teloxide_core::types::ChatPermissions;

let permissions_v0 = ChatPermissions::INVITE_USERS;

// Union, add permissions
let permissions_v1 = permissions_v0 | ChatPermissions::SEND_VIDEOS;
assert!(permissions_v1.contains(ChatPermissions::INVITE_USERS));
assert!(permissions_v1.contains(ChatPermissions::SEND_VIDEOS));

// Difference, remove permissions
let permissions_v2 = permissions_v1 - ChatPermissions::SEND_VIDEOS;
assert!(!permissions_v2.contains(ChatPermissions::SEND_VIDEOS));
```
```

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

### Example: Purchasing a Product with Dialogue

Source: https://docs.rs/teloxide/latest/teloxide/dispatching/dialogue/struct.Dialogue.html

This example demonstrates how to use `dialogue.chat_id()` to send a message to the correct chat and `dialogue.exit()` to end the dialogue after a successful purchase.

```rust
async fn receive_product_selection(
    bot: Bot,
    dialogue: MyDialogue,
    full_name: String, // Available from `State::ReceiveProductChoice`.
    q: CallbackQuery,
) -> HandlerResult {
    if let Some(product) = &q.data {
        bot.send_message(
            dialogue.chat_id(),
            format!( "{full_name}, product '{product}' has been purchased successfully!ிகளில்"),
        )
        .await?;
        dialogue.exit().await?;
    }

    Ok(())
}
```

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

### Create Webhook Options with Axum (ngrok example)

Source: https://docs.rs/teloxide/latest/teloxide/update_listeners/webhooks/struct.Options.html

Constructs new webhook options using the `axum` integration. This example demonstrates setting up a webhook listener for a bot, often used with tools like ngrok for local testing.

```rust
let addr = ([127, 0, 0, 1], 8443).into();
let url = "Your HTTPS ngrok URL here. Get it by `ngrok http 8443`".parse().unwrap();
let listener = webhooks::axum(bot.clone(), webhooks::Options::new(addr, url))
    .await
    .expect("Couldn't setup webhook");

```

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

### Dialogue Start and Cancel (Rust)

Source: https://docs.rs/teloxide/latest/teloxide/dispatching/dialogue/struct.Dialogue.html

Shows how to initiate a dialogue and how to cancel it. The `start` function begins the conversation, and `cancel` terminates it, resetting the dialogue state.

```rust
async fn start(bot: Bot, dialogue: MyDialogue, msg: Message) -> HandlerResult {
    bot.send_message(msg.chat.id, "Let's start! What's your full name?").await?;
    dialogue.update(State::ReceiveFullName).await?;
    Ok(())
}
```

```rust
async fn cancel(bot: Bot, dialogue: MyDialogue, msg: Message) -> HandlerResult {
    bot.send_message(msg.chat.id, "Cancelling the dialogue.").await?;
    dialogue.exit().await?;
    Ok(())
}
```

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

### Trace Logging Examples

Source: https://docs.rs/teloxide/latest/teloxide/adaptors/struct.Trace.html

Examples of log messages generated by the Trace adaptor, showing request sending and response reception.

```log
TRACE teloxide_core::adaptors::trace > Sending `SendDice` request
TRACE teloxide_core::adaptors::trace > Got response from `SendDice` request
TRACE teloxide_core::adaptors::trace > Sending `SendDice` request: SendDice { chat_id: Id(0), emoji: Some(Dice), disable_notification: None, reply_to_message_id: None, allow_sending_without_reply: None, reply_markup: None }
TRACE teloxide_core::adaptors::trace > Got response from `SendDice` request: Ok(Message { id: 13812, date: 1625926524, chat: Chat { .. }, via_bot: None, kind: Dice(MessageDice { dice: Dice { emoji: Dice, value: 3 } }) })
```

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

### Basic REPL Example with teloxide

Source: https://docs.rs/teloxide/latest/teloxide/repls/fn.repl.html

An example demonstrating how to use the `teloxide::repl` function to create a simple bot that sends a dice emoji in response to any message. Ensure `pretty_env_logger` is initialized for logging.

```rust
async fn main() {
    pretty_env_logger::init();
    log::info!("Starting throw dice bot...");

    let bot = Bot::from_env();

    teloxide::repl(bot, |bot: Bot, msg: Message| async move {
        bot.send_dice(msg.chat.id).await?;
        Ok(())
    })
    .await;
}
```

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

### Example: Command Bot from Environment

Source: https://docs.rs/teloxide/latest/teloxide/struct.Bot.html

Illustrates initializing a command-based bot using `Bot::from_env()` and setting up a command repl. Assumes `pretty_env_logger` is initialized.

```rust
async fn main() {
    pretty_env_logger::init();
    log::info!("Starting command bot...");

    let bot = Bot::from_env();

    Command::repl(bot, answer).await;
}
```

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

### Filter Commands with teloxide

Source: https://docs.rs/teloxide/latest/teloxide/dispatching/fn.filter_command.html

This example demonstrates how to use `teloxide::filter_command` to create a handler for specific bot commands. It's part of a larger handler setup that branches based on different states and commands, including help, start, and cancel.

```rust
pub fn filter_command<C, Output>() -> Handler<'static, Output, DpHandlerDescription>
where
    C: BotCommands + Send + Sync + 'static,
    Output: Send + Sync + 'static,

```

```rust
62    use dptree::case;
63
64    let command_handler = teloxide::filter_command::<Command, _>()
65        .branch(
66            case![State::Start]
67                .branch(case![Command::Help].endpoint(help))
68                .branch(case![Command::Start].endpoint(start)),
69        )
70        .branch(case![Command::Cancel].endpoint(cancel));
71
72    let message_handler = Update::filter_message()
73        .branch(command_handler)
74        .branch(case![State::ReceiveFullName].endpoint(receive_full_name))
75        .branch(dptree::endpoint(invalid_state));
76
77    let callback_query_handler = Update::filter_callback_query().branch(
78        case![State::ReceiveProductChoice { full_name }].endpoint(receive_product_selection),
79    );
80
81    dialogue::enter::<Update, InMemStorage<State>, State, _>()
82        .branch(message_handler)
83        .branch(callback_query_handler)
84}
```

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

### GetWebhookInfo Request

Source: https://docs.rs/teloxide/latest/teloxide/requests/trait.Requester.html

Represents a request to get information about the current webhook setup.

```APIDOC
## GetWebhookInfo Request

### Description
Use this method to get the current webhook status.

### Method
GET

### Endpoint
/getWebhookInfo

### Parameters
(Specific parameters depend on the `GetWebhookInfo` payload type)

### Response
(Specific response depends on the `GetWebhookInfo` payload type and API success/error codes)

### Request Example
(Example request depends on the `GetWebhookInfo` payload)

### Response Example
(Example response depends on the `GetWebhookInfo` payload)
```

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

### Example: Admin Bot from Environment

Source: https://docs.rs/teloxide/latest/teloxide/struct.Bot.html

Shows how to create an admin bot using `teloxide::Bot::from_env()` and setting up a command repl. Assumes `pretty_env_logger` is initialized.

```rust
async fn main() {
    pretty_env_logger::init();
    log::info!("Starting admin bot...");

    let bot = teloxide::Bot::from_env();

    Command::repl(bot, action).await;
}
```

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

### Download File Example

Source: https://docs.rs/teloxide/latest/teloxide/net/trait.Download.html

Demonstrates how to download a file using the `download_file` method. Ensure you have a valid file ID and a destination path. This method writes the file content directly to an `AsyncWrite`.

```rust
use teloxide_core::{
    net::Download,
    requests::{Request, Requester},
    types::{File, FileId},
    Bot,
};
use tokio::fs;

let bot = Bot::new("TOKEN");

let file = bot.get_file(FileId("*file_id*".to_string())).await?;
let mut dst = fs::File::create("/tmp/test.png").await?;
bot.download_file(&file.path, &mut dst).await?;
```

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

### Get Chat Title - Rust

Source: https://docs.rs/teloxide/latest/teloxide/types/struct.Chat.html

Retrieves the title of a chat, which is available for supergroups, channels, and group chats. This example demonstrates its usage within a handler function.

```rust
async fn new_chat_member(bot: Bot, chat_member: ChatMemberUpdated) -> ResponseResult<()> {
    let user = chat_member.old_chat_member.user.clone();

    let telegram_group_name = chat_member.chat.title().unwrap_or("");

    let username =
        user.mention().unwrap_or_else(|| html::user_mention(user.id, user.full_name().as_str()));

    bot.send_message(chat_member.chat.id, format!("Welcome to {telegram_group_name} {username}!"))
        .await?;

    Ok(())
}
```

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

### Building a Dispatcher with Handlers and Dependencies

Source: https://docs.rs/teloxide/latest/teloxide/dispatching/struct.DispatcherBuilder.html

This example demonstrates how to build a Dispatcher with a complex handler tree, initial dependencies, a default handler for unhandled updates, and an error handler. It also enables Ctrl+C handling for graceful shutdown.

```rust
async fn main() {
    pretty_env_logger::init();
    log::info!("Starting dispatching features bot...");

    let bot = Bot::from_env();

    let parameters = ConfigParameters {
        bot_maintainer: UserId(0), // Paste your ID to run this bot.
        maintainer_username: None,
    };

    let handler = Update::filter_message()
        // You can use branching to define multiple ways in which an update will be handled. If the
        // first branch fails, an update will be passed to the second branch, and so on.
        .branch(
            dptree::entry()
                // Filter commands: the next handlers will receive a parsed `SimpleCommand`.
                .filter_command::<SimpleCommand>()
                // If a command parsing fails, this handler will not be executed.
                .endpoint(simple_commands_handler),
        )
        .branch(
            // Filter a maintainer by a user ID.
            dptree::filter(|cfg: ConfigParameters, msg: Message| {
                msg.from.map(|user| user.id == cfg.bot_maintainer).unwrap_or_default()
            })
            .filter_command::<MaintainerCommands>()
            .endpoint(|msg: Message, bot: Bot, cmd: MaintainerCommands| async move {
                match cmd {
                    MaintainerCommands::Rand { from, to } => {
                        let mut rng = rand::rngs::OsRng;
                        let value: u64 = rng.gen_range(from..=to);

                        bot.send_message(msg.chat.id, value.to_string()).await?;
                        Ok(())
                    }
                }
            }),
        )
        .branch(
            // Filtering allow you to filter updates by some condition.
            dptree::filter(|msg: Message| msg.chat.is_group() || msg.chat.is_supergroup())
                .branch(
                    // Filtering by mention allows to filter only `/repeat@my_bot` commands.
                    // Use if you want to make sure that users refer specifically to your bot.
                    // Same as filter_command, the next handlers will receive a parsed
                    // `GroupCommand`.
                    dptree::entry().filter_mention_command::<GroupCommand>().endpoint(
                        |bot: Bot, msg: Message, cmd: GroupCommand| async move {
                            match cmd {
                                GroupCommand::Repeat { text } => {
                                    bot.send_message(msg.chat.id, format!("You said: {text}"))
                                        .await?;
                                    Ok(())
                                }
                            }
                        },
                    ),
                )
                .branch(
                    // An endpoint is the last update handler.
                    dptree::endpoint(|msg: Message, bot: Bot| async move {
                        log::info!("Received a message from a group chat.");
                        bot.send_message(msg.chat.id, "This is a group chat.").await?;
                        respond(())
                    }),
                ),
        )
        .branch(
            // There are some extension filtering functions on `Message`. The following filter will
            // filter only messages with dices.
            Message::filter_dice().endpoint(|bot: Bot, msg: Message, dice: Dice| async move {
                bot.send_message(msg.chat.id, format!("Dice value: {}", dice.value))
                    .reply_to(msg)
                    .await?;
                Ok(())
            }),
        );

    Dispatcher::builder(bot, handler)
        // Here you specify initial dependencies that all handlers will receive; they can be
        // database connections, configurations, and other auxiliary arguments. It is similar to
        // `actix_web::Extensions`.
        .dependencies(dptree::deps![parameters])
        // If no handler succeeded to handle an update, this closure will be called.
        .default_handler(|upd| async move {
            log::warn!("Unhandled update: {upd:?}");
        })
        // If the dispatcher fails for some reason, execute this handler.
        .error_handler(LoggingErrorHandler::with_custom_text(
            "An error has occurred in the dispatcher",
        ))
        .enable_ctrlc_handler()
        .build()
        .dispatch()
        .await;
}

```

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

### Example: Kicking a user by replying to their message

Source: https://docs.rs/teloxide/latest/teloxide/prelude/struct.Message.html

Demonstrates how to kick a user from a chat by replying to the message they sent. This function uses `msg.reply_to_message()` to get the context of the replied message.

```rust
async fn kick_user(bot: Bot, msg: Message) -> ResponseResult<()> {
    match msg.reply_to_message() {
        Some(replied) => {
            // bot.unban_chat_member can also kicks a user from a group chat.
            bot.unban_chat_member(msg.chat.id, replied.from.as_ref().unwrap().id).await?;
        }
        None => {
            bot.send_message(msg.chat.id, "Use this command in reply to another message").await?;
        }
    }
    Ok(())
}
```

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

### GetFile

Source: https://docs.rs/teloxide/latest/teloxide/struct.Bot.html

Gets information about a file. This method can be used to get a file path to `GET` the file. For photos that appear on the Telegram website, only the big version of the photo is available.

```APIDOC
## GetFile

### Description
Gets information about a file.

### Method
GET

### Endpoint
/bot<token>/getFile

### Parameters
#### Query Parameters
- **file_id** (String) - Required - File identifier to get information about

### Response
#### Success Response (200)
- **ok** (Boolean) - True on success
- **result** (File) - An object containing information about the file

#### Response Example
```json
{
  "ok": true,
  "result": {
    "file_id": "file_id",
    "file_unique_id": "file_unique_id",
    "file_size": 12345,
    "file_path": "path/to/file.jpg"
  }
}
```
```

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

### Set Video Start Timestamp

Source: https://docs.rs/teloxide/latest/teloxide/types/struct.InputMediaVideo.html

Specifies the start timestamp for the video playback.

```rust
pub fn start_timestamp(self, val: Seconds) -> InputMediaVideo
```

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

### Get Chat

Source: https://docs.rs/teloxide/latest/teloxide/adaptors/cache_me/struct.CacheMe.html

Use this method to get up-to-date information about the chat (this is a bot only method).

```APIDOC
## GetChat

### Description
Use this method to get up-to-date information about the chat (this is a bot only method).

### Method
GetChat

### Endpoint
GetChat

### Parameters
This method does not explicitly define parameters in the source. Refer to the underlying Requester type for details.
```

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

### Basic Dispatcher Setup

Source: https://docs.rs/teloxide/latest/teloxide/dispatching/struct.Dispatcher.html

Sets up a basic dispatcher with a schema and in-memory storage. Enables Ctrl+C handling for graceful shutdown.

```rust
async fn main() {
    pretty_env_logger::init();
    log::info!("Starting purchase bot...");

    let bot = Bot::from_env();

    Dispatcher::builder(bot, schema())
        .dependencies(dptree::deps![InMemStorage::<State>::new()])
        .enable_ctrlc_handler()
        .build()
        .dispatch()
        .await;
}
```

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

### Get My Description

Source: https://docs.rs/teloxide/latest/teloxide/adaptors/cache_me/struct.CacheMe.html

Use this method to get the current description of the bot. Returns `BotDescription` on success. Bot API only.

```APIDOC
## GetMyDescription

### Description
Use this method to get the current description of the bot. Returns `BotDescription` on success. Bot API only.

### Method
GetMyDescription

### Endpoint
GetMyDescription

### Parameters
This method does not explicitly define parameters in the source. Refer to the underlying Requester type for details.
```

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

### Example: Command with default parser

Source: https://docs.rs/teloxide/latest/teloxide/utils/command/trait.BotCommands.html

Shows how to define a simple command that captures all text after the command name as a single String argument using the default parser. Useful for commands that take a single block of text as input.

```rust
use teloxide::utils::command::BotCommands;

#[derive(BotCommands, PartialEq, Debug)]
#[command(rename_rule = "lowercase")]
enum Command {
    Text(String),
}

let command = Command::parse("/text hello my dear friend!", "").unwrap();
assert_eq!(command, Command::Text("hello my dear friend!".to_string()));
```

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

### Get My Name

Source: https://docs.rs/teloxide/latest/teloxide/adaptors/cache_me/struct.CacheMe.html

Use this method to get the current name of the bot. Returns `BotName` on success. Bot API only.

```APIDOC
## GetMyName

### Description
Use this method to get the current name of the bot. Returns `BotName` on success. Bot API only.

### Method
GetMyName

### Endpoint
GetMyName

### Parameters
This method does not explicitly define parameters in the source. Refer to the underlying Requester type for details.
```

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

### InputMediaPhoto Constructor and Methods

Source: https://docs.rs/teloxide/latest/teloxide/types/struct.InputMediaPhoto.html

Provides methods for creating and configuring InputMediaPhoto instances.

```APIDOC
### impl InputMediaPhoto

#### pub const fn new(media: InputFile) -> InputMediaPhoto
Creates a new InputMediaPhoto with the specified media.

#### pub fn media(self, val: InputFile) -> InputMediaPhoto
Sets the media file for the photo.

#### pub fn caption<S>(self, val: S) -> InputMediaPhoto
where S: Into<String>
Sets the caption for the photo.

#### pub const fn parse_mode(self, val: ParseMode) -> InputMediaPhoto
Sets the parse mode for the caption (Markdown or HTML).

#### pub fn caption_entities<C>(self, val: C) -> InputMediaPhoto
where C: IntoIterator<Item = MessageEntity>
Sets the caption entities for the photo.

#### pub fn show_caption_above_media(self, val: bool) -> InputMediaPhoto
Sets whether the caption should be shown above the media.

#### pub fn spoiler(self) -> InputMediaPhoto
Sets the `has_spoiler` field to `true`.
```

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

### Get My Short Description

Source: https://docs.rs/teloxide/latest/teloxide/adaptors/cache_me/struct.CacheMe.html

Use this method to get the current short description of the bot. Returns `BotShortDescription` on success. Bot API only.

```APIDOC
## GetMyShortDescription

### Description
Use this method to get the current short description of the bot. Returns `BotShortDescription` on success. Bot API only.

### Method
GetMyShortDescription

### Endpoint
GetMyShortDescription

### Parameters
This method does not explicitly define parameters in the source. Refer to the underlying Requester type for details.
```

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

### Example: Command with split parser and multiple arguments

Source: https://docs.rs/teloxide/latest/teloxide/utils/command/trait.BotCommands.html

Illustrates using the 'split' parser with multiple arguments of different types. Each argument is parsed from a space-separated string.

```rust
use teloxide::utils::command::BotCommands;

#[derive(BotCommands, PartialEq, Debug)]
#[command(rename_rule = "lowercase", parse_with = "split")]
enum Command {
    Nums(u8, u16, i32),
}

let command = Command::parse("/nums 1 32 -5", "").unwrap();
assert_eq!(command, Command::Nums(1, 32, -5));
```

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

### Initialize Trace Settings

Source: https://docs.rs/teloxide/latest/teloxide/adaptors/trace/struct.Settings.html

Demonstrates how to initialize `Settings` for different logging levels, from tracing nothing to tracing everything verbosely. Use `Settings::empty()` to disable logging, `Settings::TRACE_REQUESTS` for basic request logging, and combinations like `Settings::TRACE_REQUESTS_VERBOSE | Settings::TRACE_RESPONSES` for more granular control.

```rust
use teloxide_core::adaptors::trace::Settings;

// Trace nothing
let _ = Settings::empty();
// Trace only requests
let _ = Settings::TRACE_REQUESTS;
// Trace requests verbosely and responses (non verbosely)
let _ = Settings::TRACE_REQUESTS_VERBOSE | Settings::TRACE_RESPONSES;
```

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

### Get Business Connection

Source: https://docs.rs/teloxide/latest/teloxide/adaptors/cache_me/struct.CacheMe.html

Use this method to get a list of bot's business connections that are currently active. Bot API only.

```APIDOC
## GetBusinessConnection

### Description
Use this method to get a list of bot's business connections that are currently active. Bot API only.

### Method
GetBusinessConnection

### Endpoint
GetBusinessConnection

### Parameters
This method does not explicitly define parameters in the source. Refer to the underlying Requester type for details.
```

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

### repl

Source: https://docs.rs/teloxide/latest/teloxide/repls/trait.CommandReplExt.html

Starts a REPL for commands. This method is intended for simple bots and rapid prototyping. It takes a bot instance and a handler function. All errors from the handler and update listener will be logged.

```APIDOC
## fn repl<'a, R, H, Args>(bot: R, handler: H) -> BoxFuture<'a, ()>

### Description
A REPL for commands. See `CommandReplExt` for more details.

### Parameters
- `bot`: A bot instance implementing the `Requester` trait.
- `handler`: An `async` function that takes arguments from `DependencyMap` and returns `ResponseResult<()>`.

### Type Parameters
- `'a`: Lifetime parameter.
- `R`: Type implementing `Requester`.
- `H`: Type implementing `Injectable` for command handling.
- `Args`: Arguments type for the handler.

### Return Value
A `BoxFuture` that resolves when the REPL stops.
```

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

### Get Custom Emoji Stickers

Source: https://docs.rs/teloxide/latest/teloxide/requests/trait.Requester.html

Use this method to get a list of custom emoji stickers by their emojis. On success, a `Stickers` array is returned.

```APIDOC
## get_custom_emoji_stickers

### Description
Gets a list of custom emoji stickers by their emojis.

### Method
GET

### Endpoint
/getCustomEmojiStickers

### Parameters
#### Query Parameters
- **custom_emoji_ids** (array) - Required - A list of custom emoji IDs. At most 200 custom emoji IDs can be specified.

### Response
#### Success Response (200)
- **ok** (boolean) - True if the request was successful.
- **result** (array) - A list of `Sticker` objects.

### Request Example
```json
{
  "custom_emoji_ids": ["1F44D", "1F44C"]
}
```

### Response Example
```json
{
  "ok": true,
  "result": [
    {
      "width": 512,
      "height": 512,
      "is_animated": false,
      "is_video": false,
      "file_id": "CAACAgIAAxkBAAIBj2XyZ_a_b_c_d_e_f_g",
      "file_unique_id": "AQAD...",
      "file_size": 1024,
      "custom_emoji_id": "1F44D"
    }
  ]
}
```
```

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

### GetFile

Source: https://docs.rs/teloxide/latest/teloxide/requests/trait.Requester.html

Retrieves information about a file. This method is used to get a file_path to download a file that was sent to the bot.

```APIDOC
## GetFile

### Description
Retrieves information about a file.

### Method
GET (or equivalent for the SDK)

### Endpoint
/getFile

### Parameters
(Details not provided in source)

### Request Example
(Details not provided in source)

### Response
(Details not provided in source)
```

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

### SqliteStorage Example in Main Function

Source: https://docs.rs/teloxide/latest/teloxide/dispatching/dialogue/struct.SqliteStorage.html

Demonstrates the usage of SqliteStorage within a typical bot's main function, including initialization and error handling.

```rust
35async fn main() {
    pretty_env_logger::init();
    log::info!("Starting DB remember bot...");

    let bot = Bot::from_env();

    let storage: MyStorage = if std::env::var("DB_REMEMBER_REDIS").is_ok() {
        RedisStorage::open("redis://127.0.0.1:6379", Bincode).await.unwrap().erase()
    } else {
        SqliteStorage::open("db.sqlite", Json).await.unwrap().erase()
    };

    let handler = Update::filter_message()
        .enter_dialogue::<Message, ErasedStorage<State>, State>()
        .branch(dptree::case![State::Start].endpoint(start))
        .branch(
            dptree::case![State::GotNumber(n)]
                .branch(dptree::entry().filter_command::<Command>().endpoint(got_number))
                .branch(dptree::endpoint(invalid_command)),
        );

    Dispatcher::builder(bot, handler)
        .dependencies(dptree::deps![storage])
        .enable_ctrlc_handler()
        .build()
        .dispatch()
        .await;
}
```

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

### Get Chat Menu Button

Source: https://docs.rs/teloxide/latest/teloxide/adaptors/cache_me/struct.CacheMe.html

Use this method to get the current menu button for a private chat. Returns `MenuButton` on success. Bot API only.

```APIDOC
## GetChatMenuButton

### Description
Use this method to get the current menu button for a private chat. Returns `MenuButton` on success. Bot API only.

### Method
GetChatMenuButton

### Endpoint
GetChatMenuButton

### Parameters
This method does not explicitly define parameters in the source. Refer to the underlying Requester type for details.
```

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

### Create New InputMediaPhoto

Source: https://docs.rs/teloxide/latest/teloxide/types/struct.InputMediaPhoto.html

Initializes a new InputMediaPhoto with the required media file.

```rust
pub const fn new(media: InputFile) -> InputMediaPhoto
```

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

### Build and Dispatch

Source: https://docs.rs/teloxide/latest/teloxide/dispatching/type.UpdateHandler.html

Construct the `Dispatcher` with your bot token and handler, enable Ctrl+C handling, and start the dispatching process.

```rust
Dispatcher::builder(bot, handler).enable_ctrlc_handler().build().dispatch().await;
```

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

### REPL with Heroku Webhook Listener

Source: https://docs.rs/teloxide/latest/teloxide/repls/fn.repl_with_listener.html

This example shows how to set up a REPL for a bot deployed on Heroku, utilizing a webhook listener. It dynamically configures the address and URL based on environment variables for the port and host, then uses the `axum` web framework to handle incoming updates. The bot responds with 'pong' to each message.

```rust
async fn main() {
    pretty_env_logger::init();
    log::info!("Starting Heroku ping-pong bot...");

    let bot = Bot::from_env();

    // Heroku auto defines a port value
    let port: u16 = env::var("PORT")
        .expect("PORT env variable is not set")
        .parse()
        .expect("PORT env variable value is not an integer");

    let addr = ([0, 0, 0, 0], port).into();

    // Heroku host example: "heroku-ping-pong-bot.herokuapp.com"
    let host = env::var("HOST").expect("HOST env variable is not set");
    let url = format!("https://{{host}}/webhook").parse().unwrap();

    let listener = webhooks::axum(bot.clone(), webhooks::Options::new(addr, url))
        .await
        .expect("Couldn't setup webhook");

    teloxide::repl_with_listener(
        bot,
        |bot: Bot, msg: Message| async move {
            bot.send_message(msg.chat.id, "pong").await?;
            Ok(())
        },
        listener,
    )
    .await;
}
```

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

### Main Dispatcher Setup in Rust

Source: https://docs.rs/teloxide/latest/teloxide/types/struct.Chat.html

Sets up the main bot dispatcher with various handlers for different update types. Includes command parsing, message filtering, and error handling.

```rust
async fn main() {
    pretty_env_logger::init();
    log::info!("Starting dispatching features bot...");

    let bot = Bot::from_env();

    let parameters = ConfigParameters {
        bot_maintainer: UserId(0), // Paste your ID to run this bot.
        maintainer_username: None,
    };

    let handler = Update::filter_message()
        // You can use branching to define multiple ways in which an update will be handled. If the
        // first branch fails, an update will be passed to the second branch, and so on.
        .branch(
            dptree::entry()
                // Filter commands: the next handlers will receive a parsed `SimpleCommand`.
                .filter_command::<SimpleCommand>()
                // If a command parsing fails, this handler will not be executed.
                .endpoint(simple_commands_handler),
        )
        .branch(
            // Filter a maintainer by a user ID.
            dptree::filter(|cfg: ConfigParameters, msg: Message| {
                msg.from.map(|user| user.id == cfg.bot_maintainer).unwrap_or_default()
            })
            .filter_command::<MaintainerCommands>()
            .endpoint(|msg: Message, bot: Bot, cmd: MaintainerCommands| async move {
                match cmd {
                    MaintainerCommands::Rand { from, to } => {
                        let mut rng = rand::rngs::OsRng;
                        let value: u64 = rng.gen_range(from..=to);

                        bot.send_message(msg.chat.id, value.to_string()).await?;
                        Ok(())
                    }
                }
            }),
        )
        .branch(
            // Filtering allow you to filter updates by some condition.
            dptree::filter(|msg: Message| msg.chat.is_group() || msg.chat.is_supergroup())
                .branch(
                    // Filtering by mention allows to filter only `/repeat@my_bot` commands.
                    // Use if you want to make sure that users refer specifically to your bot.
                    // Same as filter_command, the next handlers will receive a parsed
                    // `GroupCommand`.
                    dptree::entry().filter_mention_command::<GroupCommand>().endpoint(
                        |bot: Bot, msg: Message, cmd: GroupCommand| async move {
                            match cmd {
                                GroupCommand::Repeat { text } => {
                                    bot.send_message(msg.chat.id, format!("You said: {text}"))
                                        .await?;
                                    Ok(())
                                }
                            }
                        },
                    ),
                )
                .branch(
                    // An endpoint is the last update handler.
                    dptree::endpoint(|msg: Message, bot: Bot| async move {
                        log::info!("Received a message from a group chat.");
                        bot.send_message(msg.chat.id, "This is a group chat.").await?;
                        respond(())
                    }),
                ),
        )
        .branch(
            // There are some extension filtering functions on `Message`. The following filter will
            // filter only messages with dices.
            Message::filter_dice().endpoint(|bot: Bot, msg: Message, dice: Dice| async move {
                bot.send_message(msg.chat.id, format!("Dice value: {}", dice.value))
                    .reply_to(msg)
                    .await?;
                Ok(())
            }),
        );

    Dispatcher::builder(bot, handler)
        // Here you specify initial dependencies that all handlers will receive; they can be
        // database connections, configurations, and other auxiliary arguments. It is similar to
        // `actix_web::Extensions`.
        .dependencies(dptree::deps![parameters])
        // If no handler succeeded to handle an update, this closure will be called.
        .default_handler(|upd| async move {
            log::warn!("Unhandled update: {upd:?}");
        })
        // If the dispatcher fails for some reason, execute this handler.
        .error_handler(LoggingErrorHandler::with_custom_text(
            "An error has occurred in the dispatcher",
        ))
        .enable_ctrlc_handler()
        .build()
        .dispatch()
        .await;
}

#[derive(Clone)]
struct ConfigParameters {
    bot_maintainer: UserId,
    maintainer_username: Option<String>,
}

/// Simple commands
#[derive(BotCommands, Clone)]
#[command(rename_rule = "lowercase")]
enum SimpleCommand {
    /// Shows this message.
    Help,
}
```

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

### Get My Default Administrator Rights

Source: https://docs.rs/teloxide/latest/teloxide/adaptors/cache_me/struct.CacheMe.html

Use this method to get the current default administrator rights for all new chats. Returns `ChatAdministratorRights` on success. Bot API only.

```APIDOC
## GetMyDefaultAdministratorRights

### Description
Use this method to get the current default administrator rights for all new chats. Returns `ChatAdministratorRights` on success. Bot API only.

### Method
GetMyDefaultAdministratorRights

### Endpoint
GetMyDefaultAdministratorRights

### Parameters
This method does not explicitly define parameters in the source. Refer to the underlying Requester type for details.
```

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

### Create New String

Source: https://docs.rs/teloxide/latest/teloxide/utils/command/type.PrefixedBotCommand.html

Initializes an empty String.

```rust
let s = String::new();
```

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

### Get Chat Member

Source: https://docs.rs/teloxide/latest/teloxide/adaptors/cache_me/struct.CacheMe.html

Use this method to get information about the user's chat member status. Returns a "Not Found" error when the chat is not found.

```APIDOC
## GetChatMember

### Description
Use this method to get information about the user's chat member status. Returns a "Not Found" error when the chat is not found.

### Method
GetChatMember

### Endpoint
GetChatMember

### Parameters
This method does not explicitly define parameters in the source. Refer to the underlying Requester type for details.
```

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

### Throttle Initialization with Settings and Spawning Worker

Source: https://docs.rs/teloxide/latest/teloxide/adaptors/struct.Throttle.html

Creates a new Throttle adaptor using provided settings and spawns its worker future using `tokio::spawn`.

```APIDOC
## pub fn spawn_with_settings(bot: B, settings: Settings) -> Throttle<B>

### Description
Creates new `Throttle` spawning the worker with `tokio::spawn`.

### Parameters
#### Path Parameters
- `bot` (B): The underlying Requester instance.
- `settings` (Settings): The settings for the throttle.

### Returns
The `Throttle` adaptor.
```

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

### Mute User Example

Source: https://docs.rs/teloxide/latest/teloxide/payloads/trait.RestrictChatMemberSetters.html

Demonstrates how to mute a user in a chat for a specified duration using the restrict_chat_member method and its setters. This example requires the message to be a reply to another message.

```rust
async fn mute_user(bot: Bot, msg: Message, time: Duration) -> ResponseResult<()> {
    match msg.reply_to_message() {
        Some(replied) => {
            bot.restrict_chat_member(
                msg.chat.id,
                replied.from.as_ref().expect("Must be MessageKind::Common").id,
                ChatPermissions::empty(),
            )
            .until_date(msg.date + time)
            .await?;
        }
        None => {
            bot.send_message(msg.chat.id, "Use this command in a reply to another message!")
                .await?;
        }
    }
    Ok(())
}
```

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

### GetMyStarBalance

Source: https://docs.rs/teloxide/latest/teloxide/requests/trait.Requester.html

Represents the operation to get the user's star balance. This is a type alias for `<B as Requester>::GetMyStarBalance`.

```APIDOC
#### type GetMyStarBalance = <B as Requester>::GetMyStarBalance
```

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

### Get My Commands

Source: https://docs.rs/teloxide/latest/teloxide/adaptors/cache_me/struct.CacheMe.html

Use this method to get the current list of the bot's commands for the given scope and user language. Returns an empty list if the bot has no commands assigned.

```APIDOC
## GetMyCommands

### Description
Use this method to get the current list of the bot's commands for the given scope and user language. Returns an empty list if the bot has no commands assigned.

### Method
GetMyCommands

### Endpoint
GetMyCommands

### Parameters
This method does not explicitly define parameters in the source. Refer to the underlying Requester type for details.
```

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

### Ban User Example

Source: https://docs.rs/teloxide/latest/teloxide/payloads/trait.KickChatMemberSetters.html

This example demonstrates how to ban a user in a chat for a specified duration using the `kick_chat_member` method and its `until_date` setter. It requires the command to be used in a reply to another message.

```rust
async fn ban_user(bot: Bot, msg: Message, time: Duration) -> ResponseResult<()> {
    match msg.reply_to_message() {
        Some(replied) => {
            bot.kick_chat_member(
                msg.chat.id,
                replied.from.as_ref().expect("Must be MessageKind::Common").id,
            )
            .until_date(msg.date + time)
            .await?;
        }
        None => {
            bot.send_message(msg.chat.id, "Use this command in a reply to another message!")
                .await?;
        }
    }
    Ok(())
}
```

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

### GetMyStarBalance

Source: https://docs.rs/teloxide/latest/teloxide/requests/trait.Requester.html

Gets the user's star balance. This method is part of the Requester trait.

```APIDOC
## GetMyStarBalance

### Description
Gets the user's star balance.

### Method
TraceRequest<<B as Requester>::GetMyStarBalance>

### Endpoint
Not specified in source
```

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

### Check if User Left Chat - Example

Source: https://docs.rs/teloxide/latest/teloxide/types/enum.ChatMemberKind.html

This example demonstrates how to filter for chat member updates where a user has left the chat and then joined again. It uses the `is_left()` and `is_present()` methods to determine the state transitions.

```rust
m.old_chat_member.is_left() && m.new_chat_member.is_present()
```

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

### Create InlineKeyboardButton for Product Selection

Source: https://docs.rs/teloxide/latest/teloxide/types/struct.InlineKeyboardButton.html

This example demonstrates creating multiple callback buttons for product selection within a message. It's a common pattern for user interaction in e-commerce or selection-based bots.

```rust
let products = ["Apple", "Banana", "Orange", "Potato"]
                .map(|product| InlineKeyboardButton::callback(product, product));
```

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

### Initialize and Use DependencyMap

Source: https://docs.rs/teloxide/latest/teloxide/prelude/struct.DependencyMap.html

Demonstrates initializing a DependencyMap, inserting values, and retrieving them. If a type already exists, it will be replaced, and the old value returned.

```rust
use dptree::di::DependencyMap;
use std::sync::Arc;

let mut container = DependencyMap::new();
container.insert(5_i32);
container.insert("abc");

assert_eq!(container.get(), Arc::new(5_i32));
assert_eq!(container.get(), Arc::new("abc"));

// If a type of a value already exists within the container, it will be replaced.
let old_value = container.insert(10_i32).unwrap();

assert_eq!(old_value, Arc::new(5_i32));
assert_eq!(container.get(), Arc::new(10_i32));
```

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

### Create a new InputPaidMediaVideo

Source: https://docs.rs/teloxide/latest/teloxide/types/struct.InputPaidMediaVideo.html

Use this constructor to create a new InputPaidMediaVideo instance with the required media file.

```rust
pub const fn new(media: InputFile) -> InputPaidMediaVideo
```

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

### get_file

Source: https://docs.rs/teloxide/latest/teloxide/requests/trait.Requester.html

Gets information about a file.

```APIDOC
## get_file

### Description
Gets information about a file.

### Method
GET

### Endpoint
/getFile

### Parameters
#### Path Parameters
- **file_id** (FileId) - Required - The ID of the file.
```

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

### Create New InputMediaDocument

Source: https://docs.rs/teloxide/latest/teloxide/types/struct.InputMediaDocument.html

Use this constructor to create a new InputMediaDocument with the required media file.

```rust
pub const fn new(media: InputFile) -> InputMediaDocument
```

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

### GetChat

Source: https://docs.rs/teloxide/latest/teloxide/requests/trait.Requester.html

Gets information about a chat.

```APIDOC
## GetChat

### Description
Gets information about a chat.

### Method
(Not specified in source)

### Endpoint
(Not specified in source)

### Parameters
(Not specified in source)

### Request Example
(Not specified in source)

### Response
#### Success Response (200)
(Not specified in source)

#### Response Example
(Not specified in source)
```

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

### Example: Command with split parser and custom separator

Source: https://docs.rs/teloxide/latest/teloxide/utils/command/trait.BotCommands.html

Demonstrates how to use a custom separator for the 'split' parser. This is helpful when command arguments might contain spaces and a different delimiter is needed.

```rust
use teloxide::utils::command::BotCommands;

#[derive(BotCommands, PartialEq, Debug)]
#[command(rename_rule = "lowercase", parse_with = "split", separator = "|")]
enum Command {
    Nums(u8, u16, i32),
}

let command = Command::parse("/nums 1|32|5", "").unwrap();
assert_eq!(command, Command::Nums(1, 32, 5));
```

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

### GetFile

Source: https://docs.rs/teloxide/latest/teloxide/requests/trait.Requester.html

Gets information about a file.

```APIDOC
## GetFile

### Description
Gets information about a file.

### Method
(Not specified in source)

### Endpoint
(Not specified in source)

### Parameters
(Not specified in source)

### Request Example
(Not specified in source)

### Response
#### Success Response (200)
(Not specified in source)

#### Response Example
(Not specified in source)
```

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

### SMEMBERS

Source: https://docs.rs/teloxide/latest/teloxide/requests/struct.JsonRequest.html

Get all the members in a set.

```APIDOC
## SMEMBERS

### Description
Get all the members in a set.

### Method
`SMEMBERS`

### Parameters
#### Path Parameters
- **key** (K) - Required - The key of the set.

### Response
#### Success Response (RV)
- Returns all the members of the set.
```

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

### Example: Command with custom command and argument separators

Source: https://docs.rs/teloxide/latest/teloxide/utils/command/trait.BotCommands.html

Shows how to define custom separators for both the command itself and its arguments when using the 'split' parser. This allows for more flexible command formats.

```rust
use teloxide::utils::command::BotCommands;

#[derive(BotCommands, PartialEq, Debug)]
#[command(
    rename_rule = "lowercase",
    parse_with = "split",
    separator = "_",
    command_separator = "_"
)]
enum Command {
    Nums(u8, u16, i32),
}

let command = Command::parse("/nums_1_32_5", "").unwrap();
assert_eq!(command, Command::Nums(1, 32, 5));
```

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

### hlen

Source: https://docs.rs/teloxide/latest/teloxide/requests/struct.MultipartRequest.html

Gets the length of a hash.

```APIDOC
## hlen

### Description
Gets the length of a hash.

### Method
Not applicable (function signature provided)

### Endpoint
Not applicable (function signature provided)

### Parameters
- **key** (K): The key of the hash.

### Request Example
Not applicable (function signature provided)

### Response
- **RV** (FromRedisValue): The result of the operation.
```

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

### Create New InputMediaVideo

Source: https://docs.rs/teloxide/latest/teloxide/types/struct.InputMediaVideo.html

Constructor for creating a new InputMediaVideo instance with the required media.

```rust
pub const fn new(media: InputFile) -> InputMediaVideo
```

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

### hvals

Source: https://docs.rs/teloxide/latest/teloxide/requests/struct.MultipartRequest.html

Gets all the values in a hash.

```APIDOC
## hvals

### Description
Gets all the values in a hash.

### Method
Not applicable (function signature provided)

### Endpoint
Not applicable (function signature provided)

### Parameters
- **key** (K): The key of the hash.

### Request Example
Not applicable (function signature provided)

### Response
- **RV** (FromRedisValue): The result of the operation.
```

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

### BotCommand::new

Source: https://docs.rs/teloxide/latest/teloxide/types/struct.BotCommand.html

Creates a new BotCommand instance.

```APIDOC
## fn new<S1, S2>(command: S1, description: S2) -> BotCommand

### Description
Creates a new BotCommand instance.

### Parameters
- `command` (S1): The command text.
- `description` (S2): The command description.

### Returns
A new `BotCommand` instance.
```
Tokens:
Raw