Teloxide

https://docs.rs/teloxide/latest/
Admin
Teloxide is a full-featured framework for building Telegram bots using Rust, handling complex tasks...
Tokens:1,471,895
Snippets:14,199
Trust Score:9.7
Update:2 months ago
Show doc for...
Tokens:
Raw
### Basic Command Bot Setup

Source: https://docs.rs/teloxide/latest/src/command/command.rs.html

This snippet shows the basic setup for a command-handling bot using Teloxide. It initializes logging, creates a bot instance, and starts a command repl.

```Rust
use teloxide::{prelude::*, utils::command::BotCommands};

#[tokio::main]
async fn main() {
    pretty_env_logger::init();
    log::info!("Starting command bot...");

    let bot = Bot::from_env();

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

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

### 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),
        }
    }
}
```

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

### Main Bot Setup and Handler Registration

Source: https://docs.rs/teloxide/latest/src/chat_member_updates/chat_member_updates.rs.html

Sets up the bot with HTML parse mode, registers handlers for new and departing chat members, and starts the dispatcher. Requires `teloxide` and `pretty_env_logger` crates.

```Rust
use teloxide::{prelude::*, types::ParseMode, utils::html};
use teloxide_core::adaptors::DefaultParseMode;

type Bot = DefaultParseMode<teloxide::Bot>;

#[tokio::main]
async fn main() -> ResponseResult<()> {
    pretty_env_logger::init();

    let bot = teloxide::Bot::from_env().parse_mode(ParseMode::Html);

    let handler = dptree::entry()
        .inspect(|u: Update| {
            eprintln!("{u:#?}");
        })
        .branch(
            Update::filter_chat_member()
                .branch(
                    dptree::filter(|m: ChatMemberUpdated| {
                        m.old_chat_member.is_left() && m.new_chat_member.is_present()
                    })
                    .endpoint(new_chat_member),
                )
                .branch(
                    dptree::filter(|m: ChatMemberUpdated| {
                        m.old_chat_member.is_present() && m.new_chat_member.is_left()
                    })
                    .endpoint(left_chat_member),
                ),
        );

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

    Ok(())
}
```

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

### 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;
}
```

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

### Setup Webhook with Options

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

Configures and sends a webhook setup request to Telegram using provided bot and options. It handles taking ownership of the certificate and setting various webhook parameters.

```rust
async fn setup_webhook<R>(bot: R, options: &mut Options) -> Result<(), R::Err>
where
    R: Requester,
{
    use crate::requests::Request;
    use teloxide_core::requests::HasPayload;

    let secret = options.get_or_gen_secret_token().to_owned();
    let &mut Options {
        ref url, ref mut certificate, max_connections, drop_pending_updates, ..
    } = options;

    let mut req = bot.set_webhook(url.clone());
    req.payload_mut().certificate = certificate.take();
    req.payload_mut().max_connections = max_connections;
    req.payload_mut().drop_pending_updates = Some(drop_pending_updates);
    req.payload_mut().secret_token = Some(secret);

    req.send().await?;

    Ok(())
}
```

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

### Axum Webhook Listener Setup

Source: https://docs.rs/teloxide/latest/src/teloxide/update_listeners/webhooks/axum.rs.html

Example of setting up an Axum application to listen for Teloxide webhooks. It includes secret checking and response mapping.

```rust
impl UpdateListener for AxumListener {
    type Accept = Response;

    async fn poll_next(mut self) -> Result<BotEvent, axum::extract::rejection::Failed to extract the request body::Rejection> {
        let (req, state) = self.0.into_inner();

        let res: Result<Response, StatusCode> = req
            .headers()
            .get(HEADER_NAME)
            .map(|header| {
                check_secret(header.as_bytes())
                    .map(<_>::to_owned)
                    .map_err(|_| StatusCode::BAD_REQUEST)
            })
            .transpose()
            .map(Self);

        async { res }
    }
}
```

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

### Basic Dispatcher Setup

Source: https://docs.rs/teloxide/latest/src/teloxide/dispatching.rs.html

This snippet shows the fundamental setup of a Teloxide dispatcher. It requires importing necessary components and defining an update handler.

```rust
use teloxide::prelude::*;

#[tokio::main]
async fn main() {
    pretty_env_logger::init();
    log::info!("Starting dispatcher...");

    Dispatcher::builder(Bot::from_env(),)
        .enable_ctrlc_handler()
        .build()
        .dispatch()
        .await;
}

```

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

### 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");

```

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

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

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

### Calling a Documented Function in an Example

Source: https://docs.rs/teloxide/latest/scrape-examples-help.html

Example of how to call a documented function from another crate within an example file. This demonstrates the usage that Rustdoc scrapes.

```rust
// examples/ex.rs
fn main() {
  a_crate::a_func();
}
```

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

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

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

### 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;
}
```

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

### Dispatcher Setup with Dependencies

Source: https://docs.rs/teloxide/latest/src/teloxide/dispatching.rs.html

Demonstrates how to build and run a Teloxide dispatcher. It shows how to initialize the Bot, define the handler schema, provide dependencies like dialogue storage, and enable default handlers like Ctrl+C. This setup is crucial for routing incoming updates to the appropriate handlers.

```rust
# #[cfg(feature = "ctrlc_handler")] {
# use teloxide::Bot;
# use teloxide::requests::RequesterExt;
# use teloxide::dispatching::{Dispatcher, dialogue::InMemStorage};
# enum State {}
# fn schema() -> teloxide::dispatching::UpdateHandler<Box<dyn std::error::Error + Send + Sync + 'static>> { teloxide::dptree::entry() }
#[tokio::main]
async fn main() {
    let bot = Bot::from_env();

    Dispatcher::builder(bot, schema())
        .dependencies(dptree::deps![InMemStorage::<State>::new()])
        .enable_ctrlc_handler()
        .build()
        .dispatch()
        .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?;
```

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

### Teloxide Bot Setup with Command, Callback, and Inline Handlers

Source: https://docs.rs/teloxide/latest/src/buttons/buttons.rs.html

This snippet sets up the main entry point for a Teloxide bot, configuring handlers for messages, callback queries, and inline queries. It initializes logging and the bot instance.

```Rust
use std::error::Error;
use teloxide::prelude::*;
use teloxide::utils::command::BotCommands;

#[derive(BotCommands)]
#[command(rename_rule = "lowercase")]
enum Command {
    Help,
    Start,
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    pretty_env_logger::init();
    log::info!("Starting buttons bot...");

    let bot = Bot::from_env();

    let handler = dptree::entry()
        .branch(Update::filter_message().endpoint(message_handler))
        .branch(Update::filter_callback_query().endpoint(callback_handler))
        .branch(Update::filter_inline_query().endpoint(inline_query_handler));

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

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

### Options::drop_pending_updates

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

Configures the webhook to drop all pending updates before setup. This ensures that the bot starts processing updates from the moment it's ready.

```APIDOC
## fn drop_pending_updates(self) -> Self

### Description
Drop all pending updates before setting up webhook.
```

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

### Polling Listener Example

Source: https://docs.rs/teloxide/latest/src/teloxide/update_listeners.rs.html

Demonstrates how to create a default long polling listener using `polling_default`. This is a common way to start receiving updates from Telegram.

```rust
use teloxide::update_listeners::polling_default;

#[tokio::main]
async fn main() {
    let listener = polling_default(env::var("TELOXIDE_TOKEN").unwrap()).await;
    // ... use the listener with a Dispatcher ...
}
```

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

### 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;
}

```

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

### Handling /start Command and Deep Links

Source: https://docs.rs/teloxide/latest/src/deep_linking/deep_linking.rs.html

This function handles the `/start` command and deep links. If the `start` argument is empty, it sends a welcome message with a deep link to the user. If `start` contains a valid `i64` ID, it transitions the dialogue state to `WriteToSomeone` to prepare for sending a message to that ID.

```Rust
pub async fn start(
    bot: Bot,
    dialogue: MyDialogue,
    msg: Message,
    start: String, // Available from `case![StartCommand::Start(start)]`
    me: Me,
) -> HandlerResult {
    if start.is_empty() {
        // This means that it is just a regular link like https://t.me/some_bot, or a /start command
        bot.send_message(
            msg.chat.id,
            format!(
                "Hello!\n\nThis link allows anyone to message you secretly: {}?start={}",
                me.tme_url(),
                msg.chat.id
            ),
        )
        .await?;
        dialogue.exit().await?;
    } else {
        // And this means that the link is like this: https://t.me/some_bot?start=123456789,
        // or a /start 123456789 command
        match start.parse::<i64>() {
            Ok(id) => {
                bot.send_message(msg.chat.id, "Send your message:").await?;
                dialogue.update(State::WriteToSomeone { id: ChatId(id) }).await?;
            }
            Err(_) => {
                bot.send_message(msg.chat.id, "Bad link!").await?;
                dialogue.exit().await?;
            }
        }
    }
    Ok(())
}
```

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

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

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

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

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

### 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 the Ctrl+C handler 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;
}
```

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

### Dispatcher Dispatch with Custom Listener

Source: https://docs.rs/teloxide/latest/src/teloxide/dispatching/dispatcher.rs.html

Starts the dispatcher with a custom update listener and error handler. This method panics if the initial API call to get bot information fails.

```rust
pub async fn dispatch_with_listener<'a, UListener, Eh>(
    &'a mut self,
    update_listener: UListener,
    update_listener_error_handler: Arc<Eh>,
)
where
    UListener: UpdateListener + Send + 'a,
    Eh: ErrorHandler<UListener::Err> + Send + Sync + 'a,
    UListener::Err: Debug,
{
    self.try_dispatch_with_listener(update_listener, update_listener_error_handler)
        .await
        .expect("Couldn't prepare dispatching context")
}
```

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

### Fallible Middleware Example

Source: https://docs.rs/teloxide/latest/src/middlewares_fallible/middlewares_fallible.rs.html

This Rust code demonstrates a fallible middleware setup for a Teloxide bot. It includes an endpoint handler and a middleware that inspects the handler's result, printing messages before, during, and after the endpoint execution. The middleware filters out errors from the endpoint and only allows successful results to proceed to the final handler.

```rust
use teloxide::prelude::*;

type HandlerResult = Result<(), teloxide::RequestError>;

#[tokio::main]
async fn main() {
    pretty_env_logger::init();
    log::info!("Starting middlewares_fallible bot...");

    let bot = Bot::from_env();

    let handler = Update::filter_message()
        // Executes before the endpoint.
        .inspect(|msg: Message| println!("Before (message #{})", msg.id))
        // Our "endpoint".
        .map_async(my_endpoint)
        // Executes after the endpoint. If the endpoint failed, print an error message and stop
        // execution; if not, continue.
        .filter(|result: HandlerResult, msg: Message| {
            println!("In-between (message #{})", msg.id);
            match result {
                Ok(()) => true,
                Err(err) => {
                    eprintln!("Our endpoint failed: {err}");
                    false
                }
            }
        })
        // Executes only if the endpoint succeeded.
        .endpoint(|msg: Message| async move {
            println!("After (message #{})", msg.id);
            HandlerResult::Ok(())
        });

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

async fn my_endpoint(bot: Bot, msg: Message) -> HandlerResult {
    bot.send_message(msg.chat.id, "Inside the endpoint.").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"
  }
}
```
```

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

### Create and Format Command Descriptions

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

Demonstrates creating `CommandDescriptions` and formatting them into a string, with and without a bot username.

```rust
use teloxide::utils::command::{CommandDescription, CommandDescriptions};

let descriptions = CommandDescriptions::new(&[
    CommandDescription {
        prefix: "/",
        command: "start",
        description: "start this bot",
        aliases: &[],
    },
    CommandDescription {
        prefix: "/",
        command: "help",
        description: "show this message",
        aliases: &[],
    },
]);

assert_eq!(descriptions.to_string(), "/start — start this bot\n/help — show this message");
assert_eq!(
    descriptions.username("username_of_the_bot").to_string(),
    "/start@username_of_the_bot — start this bot\n/help@username_of_the_bot — show this 
     message"
);
```

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

### 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;
}
```

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

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

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

### 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_sticker_set

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

Gets a sticker set. This method is used to get information about a sticker set.

```APIDOC
## fn get_sticker_set<N>(
  &self,
  name: N,
) -> <Throttle<B> as Requester>::GetStickerSet 
where N: Into<String>,
For Telegram documentation see `GetStickerSet`.
```

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

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

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

### Get Webhook Info

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

Gets information about the current webhook. For Telegram documentation see `GetWebhookInfo`.

```APIDOC
## Get Webhook Info

### Description
Gets information about the current webhook.

### Method
GET

### Endpoint
/getWebhookInfo

### Response
#### Success Response (200)
- **ok** (boolean) - True if the request was successful.
- **result** (WebhookInfo) - An object containing webhook information.

#### Response Example
```json
{
  "ok": true,
  "result": {
    "url": "https://example.com/webhook",
    "has_custom_certificate": false,
    "pending_update_count": 10,
    "last_error_date": 1678886400,
    "last_error_message": "Error message",
    "max_connections": 40
  }
}
```
```

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

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

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

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

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

### GetMe

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

Represents a request to get information about the bot itself.

```APIDOC
## GetMe

### Description
Gets information about the bot.

### Method
(Not specified, assumed to be part of the Requester trait)

### Parameters
None specified.

### Response
- Type: `JsonRequest<GetMe>` - Description not specified.
```

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

### get_custom_emoji_stickers

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

Gets custom emoji stickers. This method is used to get a list of custom emoji stickers.

```APIDOC
## fn get_custom_emoji_stickers<C>(
  &self,
  custom_emoji_ids: C,
) -> <Throttle<B> as Requester>::GetCustomEmojiStickers 
where C: IntoIterator<Item = CustomEmojiId>,
For Telegram documentation see `GetCustomEmojiStickers`.
```

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

### Basic Command Parsing

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

Demonstrates basic command parsing with default settings.

```rust
# #[cfg(feature = "macros")] {
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));
# }
```

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

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

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

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

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

### 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;
```

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

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

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

### 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 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.
```
Tokens:
Raw