5 Extensions Advanced Filters

Bibo-Joshi edited this page 2025-01-02 16:54:38 +01:00

Table of Contents

• Combining filters
• Examples
• Message is either video, photo, or document (generic file)
• Message is a forwarded photo
• Message is text and contains a link
• Message is a photo and it's not forwarded
• Custom filters
• Filters and CallbackContext

This page describes advanced use cases for the filters used with MessageHandler (also with CommandHandler and PrefixHandler) from telegram.ext.

Combining filters

When using MessageHandler it is sometimes useful to have more than one filter. This can be done using so called bit-wise operators. In Python those operators are &, | and ~ meaning AND, OR and NOT respectively. Since version 13.1 filters support ^ for XOR.

Examples

Message is either video, photo, or document (generic file)

from telegram.ext import MessageHandler, filters

handler = MessageHandler(
   filters.VIDEO | filters.PHOTO | filters.Document.ALL, 
   callback
)

Message is a forwarded photo

handler = MessageHandler(filters.FORWARDED & filters.PHOTO, callback)

Message is text and contains a link

from telegram import MessageEntity

handler = MessageHandler(
   filters.TEXT & (
      filters.Entity(MessageEntity.URL) |
      filters.Entity(MessageEntity.TEXT_LINK)
   ),
   callback
)

Message is a photo and it's not forwarded

handler = MessageHandler(
   filters.PHOTO & (~ filters.FORWARDED),
   callback
)

Custom filters

It is also possible to write our own filters. In essence, a filter is simply a function that receives either a Message instance or a Update instance and returns either True or False. This function has to be implemented in a new class that inherits from either MessageFilter or UpdateFilter, which allows it to be combined with other filters. If the combination of all filters evaluates to True, the message will be handled.

The difference between UpdateFilter and MessageFilter is that the filter function of the former will receive the update, allowing e.g. to differentiate between channel post updates and message updates, while the filter function of the latter will receive the update.effective_message.

Say we wanted to allow only those messages that contain the text "python-telegram-bot is awesome", we could write a custom filter as so:

from telegram.ext.filters import MessageFilter

class FilterAwesome(MessageFilter):
    def filter(self, message):
        return 'python-telegram-bot is awesome' in message.text

# Remember to initialize the class.
filter_awesome = FilterAwesome()

The class can of course be named however you want, the only important things are:

• The class has to inherit from MessageFilter or UpdateFilter
• It has to implement a filter method
• You have to create an instance of the class

The filter can then be used as:

awesome_handler = MessageHandler(filter_awesome, callback)
application.add_handler(awesome_handler)

Tip

Both MessageFilter and UpdateFilter accept optional arguments on initialization. Have a look at the commen base class BaseFilter for details. Make sure to call super().__init__(…) if you want to override the default values.

Filters and CallbackContext

You may have noticed that when using filters.Regex, the attributes context.matches and context.match are set to the corresponding matches. To achieve something like this for your custom filter, you can do the following:

1. Set self.data_filter=True for your filter.
2. If the update should be handled, return a dictionary of the form {attribute_name: [values]}. This dict will be merged with the internal dict of the context argument making value available as context.attribute_name. This currently works with MessageHandler, CommandHandler and PrefixHandler, which are the only handlers that accept filters.

Important

The values of the returned dict must be lists. This is necessary to make sure that multiple data filters can be merged meaningfully.

If you want this to work with your custom handler, make sure that YourHandler.collect_additional_context does something like

if isinstance(check_result, dict):
    context.update(check_result)

Must read

1. Introduction to the API
2. Tutorial: Your first bot
3. FAQ
4. How to ask good questions
5. How to write an MWE

Concepts & Important Elements

1. Architecture Overview
2. Builder Pattern for Application
3. Types of Handlers
4. Working with Files and Media
5. Exceptions, Warnings and Logging
6. Concurrency in PTB

Notable Features

1. Advanced Filters
2. Storing data
3. Making your bot persistent
4. Adding Defaults
5. Job Queue
6. Arbitrary callback_data
7. Avoiding flood limits
8. Webhooks
9. Bot API Forward Compatiblity

Code Resources

1. Frequently requested design patterns
2. Code snippets
3. Performance Optimizations
4. Telegram Passport
5. Bots built with PTB
6. Automated Bot Tests

Examples explained

1. InlineKeyboard Example

Networking

1. Working Behind a Proxy
2. Handling network errors

Other resources

1. Where to host Telegram Bots
2. How to host your bot
3. Local API Server
4. Type Checking with PTB
5. Press
6. Notes on GAE
7. Related Projects
8. Emoji

Transition Guides

• Version 4
• Version 5
• Version 12
• Version 13
• Version 20

Administration

• Test Bots
• How To Release
• Bots, Groups & Channels
• PTB tests knowledge base
• Bot API Backward Compatibility

Wiki of python-telegram-bot © Copyright 2015-2025 – Licensed by Creative Commons