fastrub 5.2.2__tar.gz → 5.2.4__tar.gz

{fastrub-5.2.2 → fastrub-5.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastrub
-Version: 5.2.2
+Version: 5.2.4
 Summary: The fastest library for writing Rubika messenger bots both synchronously and asynchronously ⚡
 Author-email: "seyyed mohamad hosein moosavi raja(01)" <mohamadhosein159159@gmail.com>
 License: MIT

fastrub-5.2.4/fast_rub/core/conversation.py

@@ -0,0 +1,437 @@
+from collections.abc import Callable
+from ..types import Update
+from .client import Client
+from ..utils.filters import Filter
+from ..utils import _run_filter
+
+import asyncio
+
+class Conversation:
+    END = "__END__"
+    
+    def __init__(
+        self,
+        name: str = "default",
+        timeout: float = 300.0
+    ):
+        self.name = name
+        self._states: dict[str, Callable] = {}
+        self._entry_handler: Callable | None = None
+        self._entry_filters = None
+        self._user_states: dict[str, str] = {}
+        self._user_data: dict[str, dict] = {}
+        self.timeout = timeout
+        self._user_timers: dict[str, asyncio.Task] = {}
+        self.client = None
+    
+    def _set_timeout(self, chat_id: str):
+        if chat_id in self._user_timers:
+            self._user_timers[chat_id].cancel()
+        
+        async def _timeout():
+            await asyncio.sleep(self.timeout)
+            if chat_id in self._user_states:
+                self._cleanup(chat_id)
+        
+        self._user_timers[chat_id] = asyncio.create_task(_timeout())
+    
+    def entry(
+        self,
+        commands: list | None = None,
+        text: str | None = None,
+        filters: Filter | None = None
+    ):
+        """دکوراتور برای نقطه ورود مکالمه."""
+        def decorator(func):
+            self._entry_handler = func
+            self._entry_filters = {
+                "commands": commands,
+                "text": text,
+                "filters": filters
+            }
+            return func
+        return decorator
+    
+    async def _is_entry(self, update: Update) -> bool:
+        if not self._entry_filters:
+            return False
+        commands: list[str] | None = self._entry_filters.get("commands")
+        text = self._entry_filters.get("text")
+        filters: Filter | None = self._entry_filters.get("filters")
+
+        run_filter = await _run_filter(filters, update)
+        if filters and not run_filter:
+            return False
+        
+        if commands is not None and update.text:
+            for cmd in commands:
+                if update.text == cmd or update.text == f"/{cmd}":
+                    return True
+        
+        if text is not None and update.text == text:
+            return True
+        
+        if filters is not None:
+            return True
+        
+        return False
+    
+    def state(
+        self,
+        state_name: str
+    ):
+        """دکوراتور برای یک حالت (مرحله) از مکالمه"""
+        def decorator(func: Callable):
+            self._states[state_name] = func
+            return func
+        return decorator
+    
+    async def handle(self, update: Update, client: Client) -> bool:
+        chat_id = update.chat_id
+        self.client = client
+        
+        # ۱. کاربر جدید؟
+        if chat_id not in self._user_states:
+            is_entry = await self._is_entry(update)
+            if is_entry:
+                self._user_states[chat_id] = "__ENTRY__"
+                self._user_data[chat_id] = {}
+                self._set_timeout(chat_id)
+            else:
+                return False
+        
+        current_state = self._user_states.get(chat_id)
+
+        # ۲. حالت ENTRY
+        if current_state == "__ENTRY__":
+            if self._entry_handler:
+                try:
+                    next_state = self._entry_handler(update, self._user_data.get(chat_id, {}))
+                    if asyncio.iscoroutine(next_state):
+                        next_state = await next_state
+                except Exception as e:
+                    import traceback
+                    traceback.print_exc()
+                    self._cleanup(chat_id)
+                    return False
+                
+                if next_state == Conversation.END:
+                    self._cleanup(chat_id)
+                    return False
+                self._user_states[chat_id] = next_state
+                self._set_timeout(chat_id)
+                return True
+        
+        # ۳. حالت‌های معمولی
+        if current_state in self._states:
+            handler = self._states[current_state]
+            try:
+                result = handler(update, self._user_data.get(chat_id, {}))
+                if asyncio.iscoroutine(result):
+                    next_state = await result
+                else:
+                    next_state = result
+            except Exception as e:
+                import traceback
+                traceback.print_exc()
+                self._cleanup(chat_id)
+                return False
+            
+            if next_state == Conversation.END:
+                self._cleanup(chat_id)
+                return False
+            self._user_states[chat_id] = next_state
+            self._set_timeout(chat_id)
+            return True
+        
+        return False
+        
+    def entry_form(
+        self,
+        form_class: type,
+        commands: list[str] | None = None,
+        text: str | None = None,
+        filters: Filter | None = None,
+        on_start: Callable | None = None,
+        on_finish: Callable | None = None,
+        on_cancel: Callable | None = None,
+        on_error: Callable | None = None,
+        on_timeout: Callable | None = None,
+        timeout: int = 120,
+        allow_back: bool = False,
+        allow_skip: bool = False,
+    ):
+        """
+        دکوراتور برای ساخت یه فرم خودکار از روی DataForm.
+        
+        مثال:
+            @register.entry_form(UserInfo, on_finish=lambda data: print(data))
+            async def done(msg, data):
+                await msg.reply(f"ثبت شد: {data}")
+        """
+        def decorator(final_handler: Callable):
+            form = form_class()
+            fields = list(form.get_fields().items())
+            
+            self._form_config = {
+                "form_class": form_class,
+                "fields": fields,
+                "on_start": on_start,
+                "on_finish": on_finish,
+                "on_cancel": on_cancel,
+                "on_error": on_error,
+                "on_timeout": on_timeout,
+                "timeout": timeout,
+                "allow_back": allow_back,
+                "allow_skip": allow_skip,
+                "final_handler": final_handler,
+            }
+            
+            self._entry_filters = {
+                "commands": commands,
+                "text": text,
+                "filters": filters
+            }
+            
+            async def form_entry(update: Update, data: dict):
+                """نقطهٔ ورود فرم — اولین فیلد رو می‌پرسه"""
+                config = self._form_config
+                
+                if config["on_start"]:
+                    res = config["on_start"]()
+                    if asyncio.iscoroutine(res):
+                        await res
+                
+                field_name, field_config = config["fields"][0]
+                prompt = field_config.prompt
+                keypad = self._build_field_keypad(field_config)
+                
+                await update.reply(prompt, keypad=keypad)
+                
+                return f"__form_{field_name}"
+            
+            self._entry_handler = form_entry
+            
+            for i, (field_name, field_config) in enumerate(fields):
+                is_last = (i == len(fields) - 1)
+                next_field_name = fields[i + 1][0] if not is_last else None
+                
+                def make_field_handler(idx: int, f_name: str, f_config, next_f_name: str | None, last: bool):
+                    async def field_handler(update: Update, data: dict):
+                        config = self._form_config
+                        text = update.text
+                        
+                        if text == "/cancel":
+                            if config["on_cancel"]:
+                                res = config["on_cancel"]()
+                                if asyncio.iscoroutine(res):
+                                    await res
+                            return Conversation.END
+                        
+                        if text == "/back" and config["allow_back"]:
+                            prev_idx = idx - 1
+                            if prev_idx >= 0:
+                                prev_name, prev_config = config["fields"][prev_idx]
+                                prompt = prev_config.prompt
+                                keypad = self._build_field_keypad(prev_config)
+                                await update.reply(prompt, keypad=keypad)
+                                return f"__form_{prev_name}"
+                            prompt = f_config.prompt
+                            keypad = self._build_field_keypad(f_config)
+                            await update.reply(prompt, keypad=keypad)
+                            return f"__form_{f_name}"
+                        
+                        if text == "/skip" and config["allow_skip"]:
+                            if last:
+                                if config["on_finish"]:
+                                    res = config["on_finish"](data)
+                                    if asyncio.iscoroutine(res):
+                                        await res
+                                await config["final_handler"](update, data)
+                                return Conversation.END
+                            next_f_config = config["fields"][idx + 1][1]
+                            prompt = next_f_config.prompt
+                            keypad = self._build_field_keypad(next_f_config)
+                            await update.reply(prompt, keypad=keypad)
+                            return f"__form_{next_f_name}"
+                        
+                        validated = self._validate_field(f_config, text)
+                        
+                        if validated is False:
+                            err_msg = getattr(f_config, 'invalid_answer', '❌ ورودی نامعتبر است')
+                            await update.reply(err_msg)
+                            return f"__form_{f_name}"
+                        
+                        value = validated
+                        if hasattr(f_config, 'transform') and f_config.transform:
+                            try:
+                                value = f_config.transform(text)
+                            except Exception:
+                                value = validated
+                        
+                        data[f_name] = value
+                        
+                        if hasattr(f_config, 'func') and f_config.func:
+                            try:
+                                res = f_config.func()
+                                if asyncio.iscoroutine(res):
+                                    await res
+                            except Exception:
+                                pass
+                        
+                        if last:
+                            if config["on_finish"]:
+                                try:
+                                    res = config["on_finish"](data)
+                                    if asyncio.iscoroutine(res):
+                                        await res
+                                except Exception:
+                                    pass
+                            await config["final_handler"](update, data)
+                            return Conversation.END
+                        
+                        next_f_config = config["fields"][idx + 1][1]
+                        prompt = next_f_config.prompt
+                        keypad = self._build_field_keypad(next_f_config)
+                        await update.reply(prompt, keypad=keypad)
+                        return f"__form_{next_f_name}"
+                    
+                    return field_handler
+                
+                handler = make_field_handler(
+                    idx=i,
+                    f_name=field_name,
+                    f_config=field_config,
+                    next_f_name=next_field_name,
+                    last=is_last
+                )
+                state_name = f"__form_{field_name}"
+                self._states[state_name] = handler
+            
+            return final_handler
+        
+        return decorator
+
+
+    def _build_field_keypad(self, field_config) -> list | None:
+        """ساختن کیبورد برای Number و Choice"""
+        from fast_rub.button import KeyPad
+        
+        if hasattr(field_config, 'keypad') and field_config.keypad:
+            if field_config.min is not None and field_config.max is not None:
+                numbers = list(range(field_config.min, field_config.max + 1))
+                if getattr(field_config, 'sort_by', 'asc') == "desc":
+                    numbers.reverse()
+                
+                keypad = KeyPad()
+                row = []
+                max_row = getattr(field_config, 'max_btn_row', 4)
+                for num in numbers:
+                    row.append(keypad.simple(str(num), str(num)))
+                    if len(row) >= max_row:
+                        keypad.append(*row)
+                        row = []
+                if row:
+                    keypad.append(*row)
+                return keypad.build()
+        
+        if hasattr(field_config, 'options'):
+            options = field_config.options
+            if callable(options):
+                options = options()
+            
+            keypad = KeyPad()
+            row = []
+            max_row = getattr(field_config, 'max_btn_row', 2)
+            for opt in options:
+                row.append(keypad.simple(opt, opt))
+                if len(row) >= max_row:
+                    keypad.append(*row)
+                    row = []
+            if row:
+                keypad.append(*row)
+            return keypad.build()
+        
+        return None
+
+
+    def _validate_field(self, field_config, value: str):
+        """اعتبارسنجی فیلد"""
+        from .forms.fields import Text, Number, Choice
+        
+        if hasattr(field_config, 'validator') and field_config.validator:
+            result = field_config.validator(value)
+            if asyncio.iscoroutine(result):
+                pass
+            if not result:
+                return False
+        
+        if isinstance(field_config, Text):
+            if field_config.min_len and len(value) < field_config.min_len:
+                return False
+            if field_config.max_len and len(value) > field_config.max_len:
+                return False
+            if field_config.email and "@" not in value:
+                return False
+            if field_config.valid_inputs and value not in field_config.valid_inputs:
+                return False
+            return value
+        
+        elif isinstance(field_config, Number):
+            try:
+                num = int(value)
+            except ValueError:
+                return False
+            if field_config.min is not None and num < field_config.min:
+                return False
+            if field_config.max is not None and num > field_config.max:
+                return False
+            return num
+        
+        elif isinstance(field_config, Choice):
+            options = field_config.options
+            if callable(options):
+                options = options()
+            if value in options:
+                return value
+            return False
+        
+        return value
+
+    def _cleanup(self, chat_id: str):
+        """پاکسازی state کاربر بعد از تموم شدن مکالمه"""
+        self._user_states.pop(chat_id, None)
+        self._user_data.pop(chat_id, None)
+
+
+class ConversationManager:
+    """مدیریت چندین مکالمه همزمان"""
+    def __init__(self):
+        self._conversations: dict[str, Conversation] = {}
+    
+    def add(
+        self,
+        conversation: Conversation
+    ):
+        self._conversations[conversation.name] = conversation
+    
+    def remove(
+        self,
+        name: str
+    ):
+        self._conversations.pop(name, None)
+    
+    async def handle(
+        self,
+        update: Update,
+        client: Client
+    ) -> bool:
+        """همه مکالمات رو چک می‌کنه، اولویت با اولین مکالمه فعال"""
+        chat_id = update.chat_id
+        for conv in self._conversations.values():
+            if chat_id in conv._user_states:
+                return await conv.handle(update, client)
+        for conv in self._conversations.values():
+            if await conv._is_entry(update):
+                return await conv.handle(update, client)
+        return False

{fastrub-5.2.2 → fastrub-5.2.4}/fast_rub/core/forms/manager.py

@@ -18,165 +18,123 @@ class FormManager:
         self.wait_manager = update._client.wait_manager
         self.chat_id = update.chat_id
         self._retry_counts: dict[str, int] = {}
+        self._running = False
+        self._current_callback: Callable | None = None
     
-    async def run(self) -> dict | None:
-        try:
-            await self._call_callback(self.config.on_start)
-            
-            while self.current_index < len(self.fields):
-                field_name, field_config = self.fields[self.current_index]
-                
-                if self._should_skip(field_name):
-                    self.current_index += 1
-                    continue
-                
-                await self._call_callback(field_config.pre_func)
-                
-                value = await self._ask_field(field_name, field_config)
-                
-                if value is None:
-                    if self._is_timeout(field_name, field_config):
-                        await self._call_callback(
-                            self.config.on_timeout or self.form.on_timeout,
-                            field_name
-                        )
-                    await self._cancel()
-                    return None
-                
-                if value == "__BACK__":
-                    if self.current_index > 0:
-                        self.current_index -= 1
-                        continue
-                
-                if value == "__SKIP__":
-                    self.current_index += 1
-                    continue
-                
-                if value == "__CANCEL__":
-                    await self._cancel()
-                    return None
-                
-                if not await self._validate(field_config, value):
-                    self._retry_counts[field_name] = self._retry_counts.get(field_name, 0) + 1
-                    if self._retry_counts[field_name] <= field_config.retry:
-                        continue
-                    await self._cancel()
-                    return None
-                
-                self._retry_counts[field_name] = 0
-                
-                if field_config.transform:
-                    value = field_config.transform(value)
-                
-                self.data[field_name] = value
-                
-                await self._call_func(field_config.func, field_config, value, field_name)
-                
-                self.current_index += 1
-            
-            await self._call_callback(self.config.on_finish, self.data)
-            return self.data
+    async def start(self, callback: Callable):
+        """شروع فرم. callback وقتی همه داده‌ها جمع شد صدا زده می‌شه"""
+        self._current_callback = callback
+        self._running = True
         
-        except Exception as e:
-            await self._call_callback(
-                self.config.on_error or self.form.on_error,
-                e
-            )
-            return None
+        await self._call_callback(self.config.on_start)
+        await self._ask_next_field()
     
-    def _should_skip(self, field_name: str) -> bool:
-        field_config = self.fields[self.current_index][1]
+    async def handle_update(self, update) -> bool:
+        """پردازش آپدیت جدید. برگشت True یعنی فرم هنوز ادامه داره"""
+        if not self._running:
+            return False
         
-        if hasattr(field_config, 'skip_if') and field_config.skip_if:
-            if field_config.skip_if(self.data):
+        if update.chat_id != self.chat_id:
+            return False
+        
+        text = update.text
+        
+        if text == "/cancel":
+            await self._cancel()
+            return False
+        
+        if text == "/back" and self.config.allow_back and self.current_index > 0:
+            self.current_index -= 1
+            self._retry_counts[self.fields[self.current_index][0]] = 0
+            await self._ask_next_field()
+            return True
+        
+        if text == "/skip" and self.config.allow_skip:
+            self.current_index += 1
+            await self._ask_next_field()
+            return True
+        
+        field_name, field_config = self.fields[self.current_index]
+        
+        if not await self._validate(field_config, text):
+            self._retry_counts[field_name] = self._retry_counts.get(field_name, 0) + 1
+            if self._retry_counts[field_name] <= field_config.retry:
+                await self._ask_next_field()
                 return True
+            await self._cancel()
+            return False
         
-        if hasattr(field_config, 'depends_on') and field_config.depends_on:
-            for dep_field, expected in field_config.depends_on.items():
-                if dep_field not in self.data:
-                    return True
-                actual = self.data[dep_field]
-                if callable(expected):
-                    if not expected(actual):
-                        return True
-                elif actual != expected:
-                    return True
+        self._retry_counts[field_name] = 0
         
-        return False
+        value = text
+        if field_config.transform:
+            value = field_config.transform(value)
+        
+        self.data[field_name] = value
+        
+        await self._call_func(field_config.func, field_config, value, field_name)
+        
+        self.current_index += 1
+        
+        if self.current_index >= len(self.fields):
+            await self._call_callback(self.config.on_finish, self.data)
+            if self._current_callback:
+                await self._current_callback(self.update, self.data)
+            self._running = False
+            return False
+        
+        await self._ask_next_field()
+        return True
     
-    async def _ask_field(self, field_name: str, field_config: Text | Number | Choice) -> Any:
+    async def _ask_next_field(self):
+        """پرسیدن فیلد بعدی"""
+        if self.current_index >= len(self.fields):
+            return
+        
+        field_name, field_config = self.fields[self.current_index]
+        
+        if self._should_skip(field_name):
+            self.current_index += 1
+            await self._ask_next_field()
+            return
+        
+        await self._call_callback(field_config.pre_func)
+        
         prompt = field_config.prompt
         keypad = None
         
         if isinstance(field_config, Number) and field_config.keypad:
             keypad = self._build_number_keypad(field_config)
-        
         elif isinstance(field_config, Choice):
             options = field_config.options
             if callable(options):
                 options = options()
             keypad = self._build_choice_keypad(options, field_config.max_btn_row)
         
-        msg = await self.update.reply(prompt, keypad=keypad)
-        
-        try:
-            reply = await self.wait_manager.wait_for_message(
-                self.chat_id,
-                timeout=field_config.timeout
-            )
-        except asyncio.TimeoutError:
-            if field_config.default is not None:
-                return field_config.default
-            return None
-        
-        text = reply.text
-        
-        if text == "/cancel":
-            return "__CANCEL__"
-        if text == "/back" and self.config.allow_back:
-            return "__BACK__"
-        if text == "/skip" and self.config.allow_skip:
-            return "__SKIP__"
-        
-        return text
+        await self.update.reply(prompt, keypad=keypad)
     
-    def _build_number_keypad(self, field_config: Number) -> list | None:
-        if field_config.min is None or field_config.max is None:
-            return None
-        
-        numbers = list(range(field_config.min, field_config.max + 1))
-        
-        if field_config.sort_by == "desc":
-            numbers.reverse()
-        elif field_config.sort_by == "none":
-            pass
+    
+    def _should_skip(self, field_name: str) -> bool:
+        field_config = self.fields[self.current_index][1]
         
-        keypad = KeyPad()
-        row = []
-        for num in numbers:
-            row.append(keypad.simple(str(num), str(num)))
-            if len(row) >= field_config.max_btn_row:
-                keypad.append(*row)
-                row = []
-        if row:
-            keypad.append(*row)
+        if hasattr(field_config, 'skip_if') and field_config.skip_if:
+            if field_config.skip_if(self.data):
+                return True
         
-        return keypad.build()
-    
-    def _build_choice_keypad(self, options: list[str], max_btn_row: int) -> list | None:
-        keypad = KeyPad()
-        row = []
-        for opt in options:
-            row.append(keypad.simple(opt, opt))
-            if len(row) >= max_btn_row:
-                keypad.append(*row)
-                row = []
-        if row:
-            keypad.append(*row)
+        if hasattr(field_config, 'depends_on') and field_config.depends_on:
+            for dep_field, expected in field_config.depends_on.items():
+                if dep_field not in self.data:
+                    return True
+                actual = self.data[dep_field]
+                if callable(expected):
+                    if not expected(actual):
+                        return True
+                elif actual != expected:
+                    return True
         
-        return keypad.build()
+        return False
     
-    async def _validate(self, field_config: Text | Number | Choice, value: str) -> bool:
+    async def _validate(self, field_config, value: str) -> bool:
         if field_config.validator:
             result = field_config.validator(value)
             if asyncio.iscoroutine(result):
@@ -230,6 +188,40 @@ class FormManager:
         if hasattr(field_config, 'invalid_answer'):
             await self.update.reply(field_config.invalid_answer)
     
+    def _build_number_keypad(self, field_config: Number) -> list | None:
+        if field_config.min is None or field_config.max is None:
+            return None
+        
+        numbers = list(range(field_config.min, field_config.max + 1))
+        
+        if field_config.sort_by == "desc":
+            numbers.reverse()
+        
+        keypad = KeyPad()
+        row = []
+        for num in numbers:
+            row.append(keypad.simple(str(num), str(num)))
+            if len(row) >= field_config.max_btn_row:
+                keypad.append(*row)
+                row = []
+        if row:
+            keypad.append(*row)
+        
+        return keypad.build()
+    
+    def _build_choice_keypad(self, options: list[str], max_btn_row: int) -> list | None:
+        keypad = KeyPad()
+        row = []
+        for opt in options:
+            row.append(keypad.simple(opt, opt))
+            if len(row) >= max_btn_row:
+                keypad.append(*row)
+                row = []
+        if row:
+            keypad.append(*row)
+        
+        return keypad.build()
+    
     async def _call_func(self, func: Callable | None, field_config, value: Any, field_name: str):
         if not func:
             return
@@ -249,11 +241,8 @@ class FormManager:
             result = func(*args, **kwargs)
             if asyncio.iscoroutine(result):
                 await result
-        except Exception as e:
-            await self._call_callback(
-                self.config.on_error or self.form.on_error,
-                e
-            )
+        except Exception:
+            pass
     
     async def _call_callback(self, callback: Callable | None, *args):
         if not callback:
@@ -262,11 +251,9 @@ class FormManager:
             result = callback(*args)
             if asyncio.iscoroutine(result):
                 await result
-        except Exception as e:
+        except Exception:
             pass
     
     async def _cancel(self):
+        self._running = False
         await self._call_callback(self.config.on_cancel or self.form.on_cancel)
-    
-    def _is_timeout(self, field_name: str, field_config) -> bool:
-        return field_config.default is None

fastrub-5.2.4/fast_rub/utils/version.py

@@ -0,0 +1 @@
+v = "5.2.4"

{fastrub-5.2.2 → fastrub-5.2.4}/fastrub.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastrub
-Version: 5.2.2
+Version: 5.2.4
 Summary: The fastest library for writing Rubika messenger bots both synchronously and asynchronously ⚡
 Author-email: "seyyed mohamad hosein moosavi raja(01)" <mohamadhosein159159@gmail.com>
 License: MIT

fastrub-5.2.2/fast_rub/core/conversation.py

@@ -1,160 +0,0 @@
-from collections.abc import Callable
-from ..types import Update
-from .client import Client
-from ..utils.filters import Filter
-from ..utils import _run_filter
-
-import asyncio
-
-class Conversation:
-    END = "__END__"
-    
-    def __init__(
-        self,
-        name: str = "default",
-        timeout: float = 300.0
-    ):
-        self.name = name
-        self._states: dict[str, Callable] = {}
-        self._entry_handler: Callable | None = None
-        self._entry_filters = None
-        self._user_states: dict[str, str] = {}
-        self._user_data: dict[str, dict] = {}
-        self.timeout = timeout
-        self._user_timers: dict[str, asyncio.Task] = {}
-        self.client = None
-    
-    def _set_timeout(self, chat_id: str):
-        if chat_id in self._user_timers:
-            self._user_timers[chat_id].cancel()
-        
-        async def _timeout():
-            await asyncio.sleep(self.timeout)
-            if chat_id in self._user_states:
-                self._cleanup(chat_id)
-        
-        self._user_timers[chat_id] = asyncio.create_task(_timeout())
-    
-    def entry(
-        self,
-        commands: list | None = None,
-        text: str | None = None,
-        filters: Filter | None = None
-    ):
-        """دکوراتور برای نقطه ورود مکالمه."""
-        def decorator(func):
-            self._entry_handler = func
-            self._entry_filters = {
-                "commands": commands,
-                "text": text,
-                "filters": filters
-            }
-            return func
-        return decorator
-    
-    async def _is_entry(self, update: Update) -> bool:
-        if not self._entry_filters:
-            return False
-        commands: list[str] | None = self._entry_filters.get("commands")
-        text = self._entry_filters.get("text")
-        filters: Filter | None = self._entry_filters.get("filters")
-
-        run_filter = await _run_filter(filters, update)
-        if filters and not run_filter:
-            return False
-        
-        if commands is not None and update.text:
-            for cmd in commands:
-                if update.text == cmd or update.text == f"/{cmd}":
-                    return True
-        
-        if text is not None and update.text == text:
-            return True
-        
-        if filters is not None:
-            return True
-        
-        return False
-    
-    def state(
-        self,
-        state_name: str
-    ):
-        """دکوراتور برای یک حالت (مرحله) از مکالمه"""
-        def decorator(func: Callable):
-            self._states[state_name] = func
-            return func
-        return decorator
-    
-    async def handle(
-        self,
-        update: Update,
-        client: Client
-    ) -> bool:
-        """پردازش یه آپدیت توی مکالمه.برمی‌گردونه True اگه مکالمه هنوز ادامه داره، False اگه تموم شده."""
-        chat_id = update.chat_id
-        self.client = client
-        if chat_id not in self._user_states:
-            if await self._is_entry(update):
-                self._user_states[chat_id] = "__ENTRY__"
-                self._user_data[chat_id] = {}
-                self._set_timeout(chat_id)
-            else:
-                return False
-        current_state = self._user_states.get(chat_id)
-        if current_state == "__ENTRY__":
-            if self._entry_handler:
-                next_state = await self._entry_handler(update, self._user_data.get(chat_id, {}))
-                if next_state == Conversation.END:
-                    self._cleanup(chat_id)
-                    return False
-                self._user_states[chat_id] = next_state
-                self._set_timeout(chat_id)
-                return True
-        if current_state in self._states:
-            handler = self._states[current_state]
-            next_state = await handler(update, self._user_data.get(chat_id, {}))
-            if next_state == Conversation.END:
-                self._cleanup(chat_id)
-                return False
-            self._user_states[chat_id] = next_state
-            return True
-        return False
-    
-    def _cleanup(self, chat_id: str):
-        """پاکسازی state کاربر بعد از تموم شدن مکالمه"""
-        self._user_states.pop(chat_id, None)
-        self._user_data.pop(chat_id, None)
-
-
-class ConversationManager:
-    """مدیریت چندین مکالمه همزمان"""
-    def __init__(self):
-        self._conversations: dict[str, Conversation] = {}
-    
-    def add(
-        self,
-        conversation: Conversation
-    ):
-        self._conversations[conversation.name] = conversation
-    
-    def remove(
-        self,
-        name: str
-    ):
-        self._conversations.pop(name, None)
-    
-    async def handle(
-        self,
-        update: Update,
-        client: Client
-    ) -> bool:
-        """همه مکالمات رو چک می‌کنه، اولویت با اولین مکالمه فعال"""
-        chat_id = update.chat_id
-        for conv in self._conversations.values():
-            if chat_id in conv._user_states:
-                return await conv.handle(update, client)
-        for conv in self._conversations.values():
-            if await conv._is_entry(update):
-                return await conv.handle(update, client)
-        return False

fastrub-5.2.2/fast_rub/utils/version.py

@@ -1 +0,0 @@
-v = "5.2.2"