RubigramClient 1.5.5__tar.gz → 1.5.7__tar.gz

{rubigramclient-1.5.5 → rubigramclient-1.5.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: RubigramClient
-Version: 1.5.5
+Version: 1.5.7
 Summary: A simple and flexible Python library for building advanced Rubika bots with powerful message handling, inline buttons, and custom filters.
 Author-email: Javad RZ <Javad.Py1385@gmail.com>
 Classifier: Programming Language :: Python :: 3
@@ -27,7 +27,7 @@ pip install RubigramClient
 from rubigram import Client, filters
 from rubigram.models import Update
 
-bot = Client("your_bot_token", "you_endpoint_url")
+bot = Client("your_bot_token")
 
 @bot.on_message(filters.command("start") & filters.private)
 async def start_handler(client, message: Update):    
@@ -51,8 +51,8 @@ async def start(_, message: Update):
         rows=[
             KeypadRow(
                 buttons=[
-                    Button("1", "Simple", "Button 1"),
-                    Button("2", "Simple", "Button 2")
+                    Button("1", "Button 1"),
+                    Button("2", "Button 2")
                 ]
             )
         ]

{rubigramclient-1.5.5 → rubigramclient-1.5.7}/README.md

@@ -11,7 +11,7 @@ pip install RubigramClient
 from rubigram import Client, filters
 from rubigram.models import Update
 
-bot = Client("your_bot_token", "you_endpoint_url")
+bot = Client("your_bot_token")
 
 @bot.on_message(filters.command("start") & filters.private)
 async def start_handler(client, message: Update):    
@@ -35,8 +35,8 @@ async def start(_, message: Update):
         rows=[
             KeypadRow(
                 buttons=[
-                    Button("1", "Simple", "Button 1"),
-                    Button("2", "Simple", "Button 2")
+                    Button("1", "Button 1"),
+                    Button("2", "Button 2")
                 ]
             )
         ]

{rubigramclient-1.5.5 → rubigramclient-1.5.7}/RubigramClient.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: RubigramClient
-Version: 1.5.5
+Version: 1.5.7
 Summary: A simple and flexible Python library for building advanced Rubika bots with powerful message handling, inline buttons, and custom filters.
 Author-email: Javad RZ <Javad.Py1385@gmail.com>
 Classifier: Programming Language :: Python :: 3
@@ -27,7 +27,7 @@ pip install RubigramClient
 from rubigram import Client, filters
 from rubigram.models import Update
 
-bot = Client("your_bot_token", "you_endpoint_url")
+bot = Client("your_bot_token")
 
 @bot.on_message(filters.command("start") & filters.private)
 async def start_handler(client, message: Update):    
@@ -51,8 +51,8 @@ async def start(_, message: Update):
         rows=[
             KeypadRow(
                 buttons=[
-                    Button("1", "Simple", "Button 1"),
-                    Button("2", "Simple", "Button 2")
+                    Button("1", "Button 1"),
+                    Button("2", "Button 2")
                 ]
             )
         ]

{rubigramclient-1.5.5 → rubigramclient-1.5.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "RubigramClient"
-version = "1.5.5"
+version = "1.5.7"
 description = "A simple and flexible Python library for building advanced Rubika bots with powerful message handling, inline buttons, and custom filters."
 readme = "README.md"
 requires-python = ">=3.7"

rubigramclient-1.5.7/rubigram/client.py

@@ -0,0 +1,115 @@
+from typing import Optional, Callable, Literal, Union
+from rubigram.models import Update, InlineMessage
+from rubigram.method import Method
+from rubigram.filters import Filter
+from rubigram.state import StateManager
+from datetime import datetime
+from aiohttp import web
+import asyncio
+
+
+class Client(Method):
+    def __init__(
+        self,
+        token: str,
+        endpoint: Optional[str] = None,
+        host: str = "0.0.0.0",
+        port: int = 8000
+    ):
+        self.token = token
+        self.endpoint = endpoint
+        self.host = host
+        self.port = port
+        self.offset_id = None
+        self.MESSAGE_HANDLER = []
+        self.INLINE_HANDLER = []
+        self.state = StateManager()
+        super().__init__(token)     
+            
+    def create_handler(self, type: Literal["message", "inline"], filters: Optional[Filter] = None):
+        def decorator(func: Callable) -> Callable:
+            async def wrapper(client: Client, update: Update):
+                if filters is None or await filters(update):
+                    await func(client, update)
+                    return True
+                return False
+            self.MESSAGE_HANDLER.append(wrapper) if type == "message" else self.INLINE_HANDLER.append(wrapper)
+            return func
+        return decorator
+    
+    def on_message(self, filters: Optional[Filter] = None):
+        return self.create_handler("message", filters)
+
+    def on_inline_message(self, filters: Optional[Filter] = None):
+        return self.create_handler("inline", filters)
+        
+    async def dispatch(self, update: Union[Update, InlineMessage], type: Literal["message", "inline"]):
+        handlers = self.MESSAGE_HANDLER if type == "message" else self.INLINE_HANDLER
+        for handler in handlers:
+            matched = await handler(self, update)
+            if matched:
+                return
+
+    async def updater(self, data: dict):
+        if "inline_message" in data:
+            event = InlineMessage.from_dict(data["inline_message"])
+            type = "inline"
+        elif "update" in data:
+            event = Update.from_dict(data["update"])
+            type = "message"
+        else: return
+        event.client = self
+        await self.dispatch(event, type)
+    
+    async def set_endpoints(self):
+        endpoint_type = ["ReceiveUpdate", "ReceiveInlineMessage"]
+        if self.endpoint:
+            for i in endpoint_type:
+                await self.update_bot_endpoint(f"{self.endpoint}/{i}", i)
+    
+    async def on_startup(self, app):
+        await self.set_endpoints()
+        await self.state.start()
+        await self.start()
+
+    async def on_cleanup(self, app):
+        await self.state.stop()
+        await self.stop()
+        
+    def create_request_handler(self):
+        async def wrapper(request: web.Request):
+            data = await request.json()
+            await self.updater(data)
+            return web.json_response({"status": "OK"})
+        return wrapper
+    
+    async def runner(self):
+        try:
+            await self.state.start()
+            while True:
+                get_updates = await self.get_update(100, self.offset_id)
+                if get_updates.updates:
+                    updates = get_updates.updates
+                    for update in updates:
+                        time = int(update.new_message.time) if update.type == "NewMessage" else int(update.updated_message.time) if update.type == "UpdatedMessage" else None
+                        now = int(datetime.now().timestamp())
+                        if time and time >= now or time + 2 >= now:
+                            update.client = self
+                            await self.dispatch(update, "message")
+                    self.offset_id = get_updates.next_offset_id
+        except Exception as error:
+            print(f"ERROR : {error}")
+        finally:
+            await self.state.stop()
+            await self.stop()
+    
+    def run(self):
+        if self.endpoint:
+            app = web.Application()            
+            app.router.add_post("/ReceiveUpdate", self.create_request_handler())
+            app.router.add_post("/ReceiveInlineMessage", self.create_request_handler())
+            web.run_app(app, host=self.host, port=self.port)
+        else:
+            try:
+                asyncio.run(self.runner())
+            except:pass

rubigramclient-1.5.7/rubigram/filters.py

@@ -0,0 +1,180 @@
+from rubigram.models import Update, InlineMessage
+from typing import Union
+import re
+
+
+
+class Filter:
+    def __init__(self, func):
+        self.func = func
+    
+    async def __call__(self, update: Union[Update, InlineMessage]):
+        return await self.func(update)
+    
+    async def __and__(self, other: "Filter"):
+        async def filter(update):
+            return await self(update) and await other(update)
+        return Filter(filter)
+    
+    async def __or__(self, other: "Filter"):
+        async def filter(update):
+            return await self(update) or await other(update)
+        return Filter(filter)
+
+
+
+async def TEXT(message: Update):
+    if isinstance(message, Update):
+        return True if message.new_message and message.new_message.text else False
+    return False
+
+async def FILE(message: Update):
+    if isinstance(message, Update):
+        return True if message.new_message and message.new_message.file else False
+    return False
+
+async def LIVE(message: Update):
+    if isinstance(message, Update):
+        return True if message.new_message and message.new_message.live_location else False
+    return False
+
+async def POLL(message: Update):
+    if isinstance(message, Update):
+        return True if message.new_message and message.new_message.poll else False
+    return False
+
+async def CONTACT(message: Update):
+    if isinstance(message, Update):
+        return True if message.new_message and message.new_message.contact_message else False
+    return False
+
+async def STICKER(message: Update):
+    if isinstance(message, Update):
+        return True if message.new_message and message.new_message.sticker else False
+    return False
+
+async def LOCATION(message: Update):
+    if isinstance(message, Update):
+        return True if message.new_message and message.new_message.location else False
+    return False
+
+async def FORWARD(message: Update):
+    if isinstance(message, Update):
+        return True if message.new_message and message.new_message.forwarded_from else False
+    return False
+
+async def EDITED(message: Update):
+    if isinstance(message, Update):
+        return True if message.updated_message else False
+    return False
+
+async def PRIVATE(message: Union[Update, InlineMessage]):
+    return True if message.chat_id.startswith("b0") else False
+    
+async def GROUP(message: Union[Update, InlineMessage]):
+    return True if message.chat_id.startswith("g0") else False
+
+async def CHANNEL(message: Union[Update, InlineMessage]):
+    return True if message.chat_id.startswith("c0") else False
+
+async def FORWARD_BOT(message: Update):
+    if isinstance(message, Update) and message.new_message:
+        return True if message.new_message.forwarded_from and message.new_message.forwarded_from.type_from == "Bot" else False
+
+async def FORWARD_USER(message: Update):
+    if isinstance(message, Update) and message.new_message:
+        return True if message.new_message.forwarded_from and message.new_message.forwarded_from.type_from == "User" else False
+    
+async def FORWARD_CHANNEL(message: Update):
+    if isinstance(message, Update) and message.new_message:
+        return True if message.new_message.forwarded_from and message.new_message.forwarded_from.type_from == "Channel" else False
+
+
+text = Filter(TEXT)
+file = Filter(FILE)
+live = Filter(LIVE)
+poll = Filter(POLL)
+contact = Filter(CONTACT)
+sticker = Filter(STICKER)
+location = Filter(LOCATION)
+forward = Filter(FORWARD)
+edited = Filter(EDITED)
+private = Filter(PRIVATE)
+group = Filter(GROUP)
+channel = Filter(CHANNEL)
+forward_bot = Filter(FORWARD_BOT)
+forward_user = Filter(FORWARD_USER)
+forward_channel = Filter(FORWARD_CHANNEL)
+
+
+class state(Filter):
+    def __init__(self, states: Union[str, list[str]]):
+        self.states = states
+        super().__init__(self.filter)
+        
+    async def filter(self, update: Union[Update, InlineMessage]):
+        states = self.states if isinstance(self.states, list) else [self.states]
+        user = await update.client.state.get_state(update.chat_id)
+        return user.lower() in states if user else False
+            
+
+class command(Filter):
+    def __init__(self, cmd: Union[str, list[str]], prefix: str = "/"):
+        self.cmd = cmd
+        self.prefix = prefix
+        super().__init__(self.filter)
+
+    async def filter(self, update: Update):
+        commands = self.cmd if isinstance(self.cmd, list) else [self.cmd]
+        text = ""
+        if isinstance(update, Update):
+            if update.type == "NewMessage":
+                text = update.new_message.text
+            elif update.type == "UpdatedMessage":
+                text = update.updated_message.text
+            if text:
+                for cmd in commands:
+                    if text.lower().startswith(self.prefix + cmd.lower()):
+                        return True
+                return False
+
+
+class regex(Filter):
+    def __init__(self, pattern: str):
+        self.pattern = pattern
+        super().__init__(self.filter)
+
+    async def filter(self, update: Union[Update, InlineMessage]):
+        text = ""
+        if isinstance(update, Update):
+            if update.type == "NewMessage":
+                text = getattr(update.new_message, "text", "")
+            elif update.type == "UpdatedMessage":
+                text = getattr(update.updated_message, "text", "")
+        elif isinstance(update, InlineMessage):
+            text = getattr(update, "text", "")
+
+        if text:
+            return bool(re.search(self.pattern, text))
+        return False
+
+
+class chat(Filter):
+    def __init__(self, chat_id: Union[str, list[str]]):
+        self.chat_id = chat_id
+        super().__init__(self.filter)
+
+    async def filter(self, update: Union[Update, InlineMessage]):
+        chat_ids = self.chat_id if isinstance(self.chat_id, list) else [self.chat_id]
+        return update.chat_id in chat_ids
+
+
+class button(Filter):
+    def __init__(self, button_id: Union[str, list[str]]):
+        self.button_id = button_id
+        super().__init__(self.filter)
+
+    async def filter(self, update: InlineMessage):
+        if isinstance(update, InlineMessage):
+            button_ids = self.button_id if isinstance(self.button_id, list) else [self.button_id]
+            return update.aux_data.button_id in button_ids

{rubigramclient-1.5.5 → rubigramclient-1.5.7}/rubigram/method.py

@@ -3,12 +3,10 @@ from typing import Literal, Optional
 from rubigram.models import Bot, Chat, Keypad, MessageId, Updates
 
 
-
 class Method(Network):
     def __init__(self, token: str):
         super().__init__(token)
 
-
     async def get_me(self) -> "Bot":
         response = await self.request("getMe", {})
         return Bot.from_dict(response["bot"])

{rubigramclient-1.5.5 → rubigramclient-1.5.7}/rubigram/network.py

@@ -3,7 +3,6 @@ from typing import Any, Optional
 import aiofiles, re, os
 
 
-
 class Network:
     def __init__(self, token: str) -> None:
         self.token: str = token

{rubigramclient-1.5.5 → rubigramclient-1.5.7}/rubigram/state.py

@@ -62,7 +62,6 @@ class ManageDB:
                 data = await cursor.fetchall()
             return {k: v for k, v in data} if data else {}
 
-          
             
     async def remove_data(self, user_id: str, key: str = None):
         await self.connect()
@@ -71,8 +70,7 @@ class ManageDB:
         else:
             await self.connection.execute("DELETE FROM user_data WHERE user_id = ?", (user_id,))
         await self.connection.commit()
-        
-        
+              
         
 class StateManager:
     def __init__(self):

rubigramclient-1.5.5/rubigram/client.py

@@ -1,159 +0,0 @@
-from __future__ import annotations
-from typing import Optional, Callable, Literal
-from aiohttp import web
-from functools import wraps
-from rubigram.models import Update, InlineMessage
-from rubigram.method import Method
-from rubigram.filters import Filter
-from rubigram.state import StateManager
-from datetime import datetime
-import asyncio
-import logging
-
-
-logger = logging.getLogger(__name__)
-
-
-class Client(Method):
-    def __init__(self, token: str, endpoint: Optional[str] = None, host: str = "0.0.0.0", port: int = 8000):
-        self.token = token
-        self.endpoint = endpoint
-        self.host = host
-        self.port = port
-        self.offset_id = None
-        self.state = StateManager()
-        self.routes = web.RouteTableDef()
-        self.message_handlers = []
-        self.inline_handlers = []
-        super().__init__(token)
-
-    def on_message(self, *filters: Filter):
-        def decorator(func: Callable) -> Callable:
-            @wraps(func)
-            async def wrapper(client: Client, update: Update):
-                try:
-                    combined_filter = filters[0] if filters else None
-                    for filter in filters[1:]:
-                        combined_filter = combined_filter & filter
-
-                    if combined_filter is None or await combined_filter(update):
-                        await func(client, update)
-                        return True
-                    return False
-                except Exception as error:
-                    logger.exception("Error {}: {}".format(func.__name__, error))
-
-            self.message_handlers.append(wrapper)
-            return func
-        return decorator
-
-    def on_inline_message(self, *filters: Filter):
-        def decorator(func: Callable) -> Callable:
-            @wraps(func)
-            async def wrapper(client: Client, update: InlineMessage):
-                try:
-                    combined_filter = filters[0] if filters else None
-                    for filter in filters[1:]:
-                        combined_filter = combined_filter & filter
-
-                    if combined_filter is None or await combined_filter(update):
-                        await func(client, update)
-                        return True
-                    return False
-                except Exception as error:
-                    logger.exception("Error {}: {}".format(func.__name__, error))
-
-            self.inline_handlers.append(wrapper)
-            return func
-        return decorator
-
-    async def dispatch(self, update: Update, type: Literal["update", "inline_message"] = "update"):
-        handlers = self.message_handlers if type == "update" else self.inline_handlers
-        for handler in handlers:
-            try:
-                matched = await handler(self, update)
-                if matched:
-                    return
-            except Exception as error:
-                logger.exception(f"Dispatch Error in handler [ {handler.__name__} ] : {error}")
-
-    async def updater(self, data: dict):
-        if "inline_message" in data:
-            event = InlineMessage.from_dict(data.get("inline_message", {}))
-            event.client = self
-            await self.dispatch(event, "inline_message")
-        elif "update" in data:
-            event = Update.from_dict(data.get("update", {}))
-            event.client = self
-            await self.dispatch(event)
-        else:
-            return
-
-    async def set_endpoints(self):
-        if self.endpoint:
-            await self.update_bot_endpoint(f"{self.endpoint}/ReceiveUpdate", "ReceiveUpdate")
-            await self.update_bot_endpoint(f"{self.endpoint}/ReceiveInlineMessage", "ReceiveInlineMessage")
-
-    def run(self):
-        if self.endpoint:
-            @self.routes.post("/ReceiveUpdate")
-            async def receive_update(request: web.Request):
-                data = await request.json()
-                await self.updater(data)
-                return web.json_response({"status": "OK"})
-
-            @self.routes.post("/ReceiveInlineMessage")
-            async def receive_inline_message(request: web.Request):
-                data = await request.json()
-                await self.updater(data)
-                return web.json_response({"status": "OK"})
-
-            app = web.Application()
-            app.add_routes(self.routes)
-
-            async def on_startup(app):
-                await self.set_endpoints()
-                await self.state.start()
-                await self.start()
-
-            async def on_cleanup(app):
-                await self.state.stop()
-                await self.stop()
-
-            app.on_startup.append(on_startup)
-            app.on_cleanup.append(on_cleanup)
-            web.run_app(app, host=self.host, port=self.port)
-
-        else:
-            async def polling():
-                try:
-                    await self.state.start()
-                    while True:
-                        try:
-                            get_update = await self.get_update(100, self.offset_id)
-                            if get_update.updates:
-                                updates = get_update.updates
-                                for update in updates:
-                                    if update.type == "NewMessage":
-                                        message_time = int(update.new_message.time)
-                                    elif update.type == "UpdatedMessage":
-                                        message_time = int(update.updated_message.time)
-                                    else:continue
-
-                                    now = int(datetime.now().timestamp())
-                                    if message_time >= now or message_time + 2 >= now:
-                                        if isinstance(update, Update):
-                                            update.client = self
-                                        await self.dispatch(update)
-
-                                self.offset_id = get_update.next_offset_id
-                        except Exception as error:
-                            logger.exception("Polling Error : {}".format(error))
-                            await asyncio.sleep(1)
-
-                except:
-                    pass
-                finally:
-                    await self.state.stop()
-                    await self.stop()
-            asyncio.run(polling())

rubigramclient-1.5.5/rubigram/filters.py

@@ -1,189 +0,0 @@
-from rubigram.models import Update, InlineMessage
-from typing import Union, Callable, Awaitable
-import re
-
-
-class Filter:
-    def __init__(self, func: Callable[[Union[Update, InlineMessage]], Union[bool, Awaitable[bool]]]):
-        self.func = func
-
-    async def __call__(self, update: Union[Update, InlineMessage]) -> bool:
-        result = self.func(update)
-        if isinstance(result, Awaitable):
-            return await result
-        return result
-
-    def __and__(self, other: "Filter"):
-        async def combined(update):
-            return await self(update) and await other(update)
-        return Filter(combined)
-
-    def __or__(self, other: "Filter"):
-        async def combined(update):
-            return await self(update) or await other(update)
-        return Filter(combined)
-
-
-class state(Filter):
-    def __init__(self, states: Union[str, list[str]]):
-        self.states = states
-        super().__init__(self.filter)
-        
-    async def filter(self, update: Update):
-        states = self.states if isinstance(self.states, list) else [self.states]
-        if isinstance(update, Update):
-            user = await update.client.state.get_state(update.chat_id)
-            return user.lower() in states if user else False
-        return False
-            
-
-class command(Filter):
-    def __init__(self, cmd: Union[str, list[str]], prefix: str = "/"):
-        self.cmd = cmd
-        self.prefix = prefix
-        super().__init__(self.filter)
-
-    def filter(self, update: Update):
-        commands = self.cmd if isinstance(self.cmd, list) else [self.cmd]
-        text = ""
-        if isinstance(update, Update):
-            if update.type == "NewMessage":
-                text = update.new_message.text
-            elif update.type == "UpdatedMessage":
-                text = update.updated_message.text
-            if text:
-                for cmd in commands:
-                    if text.lower().startswith(self.prefix + cmd.lower()):
-                        return True
-                return False
-
-
-class regex(Filter):
-    def __init__(self, pattern: str):
-        self.pattern = pattern
-        super().__init__(self.filter)
-
-    def filter(self, update: Union[Update, InlineMessage]):
-        text = ""
-        if isinstance(update, Update):
-            if update.type == "NewMessage":
-                text = getattr(update.new_message, "text", "")
-            elif update.type == "UpdatedMessage":
-                text = getattr(update.updated_message, "text", "")
-        elif isinstance(update, InlineMessage):
-            text = getattr(update, "text", "")
-
-        if text:
-            return bool(re.search(self.pattern, text))
-        return False
-
-
-class chat(Filter):
-    def __init__(self, chat_id: Union[str, list[str]]):
-        self.chat_id = chat_id
-        super().__init__(self.filter)
-
-    def filter(self, update: Union[Update, InlineMessage]):
-        chat_ids = self.chat_id if isinstance(self.chat_id, list) else [self.chat_id]
-        return update.chat_id in chat_ids
-
-
-class button(Filter):
-    def __init__(self, button_id: Union[str, list[str]]):
-        self.button_id = button_id
-        super().__init__(self.filter)
-
-    def filter(self, update: InlineMessage):
-        if isinstance(update, InlineMessage):
-            button_ids = self.button_id if isinstance(self.button_id, list) else [self.button_id]
-            return update.aux_data.button_id in button_ids
-
-
-
-def TEXT(update: Update):
-    return bool(update.new_message and getattr(update.new_message, "text", None))
-
-
-def FILE(update: Update):
-    return bool(update.new_message and getattr(update.new_message, "file", None))
-
-
-def LIVE(update: Update):
-    return bool(update.new_message and getattr(update.new_message, "live_location", None))
-
-
-def POLL(update: Update):
-    return bool(update.new_message and getattr(update.new_message, "poll", None))
-
-
-def CONTACT(update: Update):
-    return bool(update.new_message and getattr(update.new_message, "contact_message", None))
-
-
-def STICKER(update: Update):
-    return bool(update.new_message and getattr(update.new_message, "sticker", None))
-
-
-def LOCATION(update: Update):
-    return bool(update.new_message and getattr(update.new_message, "location", None))
-
-
-def FORWARD(update: Update):
-    return bool(update.new_message and getattr(update.new_message, "forwarded_from", None))
-
-
-def EDITED(update: Update):
-    if isinstance(update, Update) and update.type == "UpdatedMessage":
-        return update.updated_message.is_edited
-
-
-def PRIVATE(update: Update):
-    if isinstance(update, Update) and update.type == "NewMessage":
-        return update.new_message.sender_type in ["User", "Bot"]
-    return False
-
-
-def FORWARD_BOT(update: Update):
-    if isinstance(update, Update) and update.type == "NewMessage" and update.new_message.forwarded_from:
-        return update.new_message.forwarded_from.type_from == "Bot"
-    return False
-
-
-def FORWARD_USER(update: Update):
-    if isinstance(update, Update) and update.type == "NewMessage" and update.new_message.forwarded_from:
-        return update.new_message.forwarded_from.type_from == "User"
-    return False
-
-
-def FORWARD_CHANNEL(update: Update):
-    if isinstance(update, Update) and update.type == "NewMessage" and update.new_message.forwarded_from:
-        return update.new_message.forwarded_from.type_from == "Channel"
-    return False
-
-def GROUP(update: Update):
-    if isinstance(update, Update):
-        return update.chat_id.startswith("g0")
-    return False
-
-
-def CHANNEL(update: Update):
-    if isinstance(update, Update):
-        return update.chat_id.startswith("c0")
-    return False
-    
-
-text = Filter(TEXT)
-file = Filter(FILE)
-live = Filter(LIVE)
-poll = Filter(POLL)
-group = Filter(GROUP)
-channel = Filter(CHANNEL)
-edited = Filter(EDITED)
-contact = Filter(CONTACT)
-sticker = Filter(STICKER)
-location = Filter(LOCATION)
-forward = Filter(FORWARD)
-private = Filter(PRIVATE)
-forward_bot = Filter(FORWARD_BOT)
-forward_user = Filter(FORWARD_USER)
-forward_channel = Filter(FORWARD_CHANNEL)