chore(userbot): apply ruff check --fix and ruff format

- ruff check --fix: 210 auto-fixed errors (import sorting, trailing
  whitespace, unused imports, f-string fixups, deprecated annotations)
- ruff format: 104 files reformatted to consistent style
- 268 non-auto-fixable issues remain (S113 requests timeout, etc.)

utils/conv.py

@@ -14,14 +14,12 @@
 #  You should have received a copy of the GNU General Public License
 #  along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
+import asyncio
 from collections import OrderedDict
 
 from pyrogram import Client, filters, types
-from pyrogram.handlers import MessageHandler
 from pyrogram.enums.parse_mode import ParseMode
-
-import asyncio
-from typing import Union, List, Dict, Optional
+from pyrogram.handlers import MessageHandler
 
 
 class _TrueFilter(filters.Filter):
@@ -30,12 +28,12 @@ class _TrueFilter(filters.Filter):
 
 
 class Conversation:
-    _locks: Dict[int, asyncio.Lock] = {}
+    _locks: dict[int, asyncio.Lock] = {}
 
     def __init__(
         self,
         client: Client,
-        chat: Union[str, int],
+        chat: str | int,
         timeout: float = 5,
         delete_at_end=True,
         exclusive=True,
@@ -49,10 +47,10 @@ class Conversation:
         self._chat_id = 0
         self._message_ids = []
         self._handler_object = None
-        self._chat_unique_lock: Optional[asyncio.Lock] = None
-        self._waiters: Dict[asyncio.Event, filters.Filter] = {}
-        self._responses: Dict[asyncio.Event, types.Message] = {}
-        self._pending_updates: List[types.Message] = []
+        self._chat_unique_lock: asyncio.Lock | None = None
+        self._waiters: dict[asyncio.Event, filters.Filter] = {}
+        self._responses: dict[asyncio.Event, types.Message] = {}
+        self._pending_updates: list[types.Message] = []
 
     async def __aenter__(self):
         self._chat_id = (await self.client.get_chat(self.chat)).id
@@ -65,9 +63,7 @@ class Conversation:
         if self.exclusive:
             await self._chat_unique_lock.acquire()
 
-        self._handler_object = MessageHandler(
-            self._handler, filters.chat(self._chat_id)
-        )
+        self._handler_object = MessageHandler(self._handler, filters.chat(self._chat_id))
 
         if -999 not in self.client.dispatcher.groups:
             new_groups = OrderedDict(self.client.dispatcher.groups)
@@ -101,7 +97,7 @@ class Conversation:
 
     async def get_response(
         self,
-        message_filter: Optional[filters.Filter] = None,
+        message_filter: filters.Filter | None = None,
         timeout: float = None,
     ) -> types.Message:
         if timeout is None:
@@ -119,15 +115,13 @@ class Conversation:
         self._message_ids.append(message.id)
         return message
 
-    async def _wait_message(
-        self, message_filter: Optional[filters.Filter], timeout: float
-    ) -> types.Message:
+    async def _wait_message(self, message_filter: filters.Filter | None, timeout: float) -> types.Message:
         event = asyncio.Event()
         self._waiters[event] = message_filter
 
         try:
             await asyncio.wait_for(event.wait(), timeout=timeout)
-        except asyncio.TimeoutError as e:
+        except TimeoutError as e:
             raise TimeoutError from e
         finally:
             self._waiters.pop(event)
@@ -137,8 +131,8 @@ class Conversation:
     async def send_message(
         self,
         text: str,
-        parse_mode: Optional[str] = ParseMode.HTML,
-        entities: List[types.MessageEntity] = None,
+        parse_mode: str | None = ParseMode.HTML,
+        entities: list[types.MessageEntity] = None,
         disable_web_page_preview: bool = None,
         disable_notification: bool = None,
         reply_to_message_id: int = None,