feat(cli): add Worker and main for TDATA check

modules/checker.py

@@ -14,15 +14,17 @@ from modules.tdata import TDATA
 logger = logging.getLogger(__name__)
 
 
+class SessionInvalid(Exception):
+    pass
+
+
 # Unified Result class
 @dataclass
 class Result:
-    valid: bool
-    error: Optional[str] = None
-
     me: Optional[User] = None
     stars: Optional[int] = None
     country: Optional[str] = None
+
     contacts: Optional[List[User]] = None
     chats: Optional[List[Chat]] = None
     channels: Optional[List[Channel]] = None
@@ -41,6 +43,7 @@ class Checker:
             self.desktop = None
 
     async def __aenter__(self):
+        self.__ensure_client()
         return self
 
     async def __aexit__(self, exc_type, exc_val, exc_tb):
@@ -48,110 +51,94 @@ class Checker:
             logger.debug("Отключение клиента Telethon")
             try:
                 await self.client.disconnect()
-            except:
-                pass
 
-    async def _ensure_client(self):
-        """Обеспечение инициализации клиента перед операцией"""
+            except Exception as e:
+                logger.error(f"Ошибка отключения клиента Telethon: {e}")
+
+    async def __ensure_client(self):
         if self.client is None:
             if self.desktop is None:
                 raise Exception("TDATA не инициализирована")
+
             logger.debug("Инициализация клиента Telethon из TDATA")
             self.client = await self.desktop.convert()
 
-    async def validate(self) -> Result:
-        """Валидация TDATA"""
+    async def check_stars(self, me: User) -> int:
         try:
-            if self.desktop is None:
-                return Result(valid=False, error="TDATA не инициализирована")
-
-            if not await self.desktop.validate():
-                return Result(valid=False, error="TDATA невалидна или пуста")
-
-            await self._ensure_client()
-            me = await self.client.get_me()
-
-            if not me:
-                return Result(
-                    valid=False, error="Не удалось получить информацию о пользователе"
-                )
-
-            return Result(valid=True, me=me)
+            stars_status = await self.client(GetStarsStatusRequest(peer=me))
+            return stars_status.balance.amount
 
         except Exception as e:
-            logger.error(f"Ошибка валидации: {e}")
-            return Result(valid=False, error=str(e))
+            logger.warning(f"Не удалось получить баланс звезд: {e}")
+            return 0
+
+    async def check_country(self, me: User) -> str:
+        try:
+            phone_parse = parse(str(f"+{me.phone}"))
+            return geocoder.description_for_number(phone_parse, "en")
+
+        except Exception as e:
+            logger.warning(f"Не удалось определить страну: {e}")
+            return "N/A"
+
+    async def check_contacts(self) -> List[User]:
+        try:
+            logger.debug("Получение контактов")
+            result = await self.client(GetContactsRequest(hash=0))
+            return result.users
+
+        except Exception as e:
+            logger.warning(f"Не удалось получить контакты: {e}")
+
+    async def check_chats(self) -> List[Chat]:
+        try:
+            logger.debug("Получение всех диалогов")
+            chats = []
+            async for dialog in self.client.iter_dialogs():
+                chats.append(dialog.entity)
+
+            return chats
+
+        except Exception as e:
+            logger.warning(f"Не удалось получить чаты: {e}")
+
+    async def check_channels(self, chats: List[Chat]) -> List[Channel]:
+        try:
+            channels = [chat for chat in chats if isinstance(chat, Channel)]
+            return channels
+
+        except Exception as e:
+            logger.warning(f"Не удалось отфильтровать каналы: {e}")
+
+    async def check_admin_channels(self, channels: List[Channel]) -> List[Channel]:
+        try:
+            logger.debug("Проверка прав администратора")
+            admin_channels = []
+
+            for channel in channels:
+                permissions = await self.client.get_permissions(channel, "me")
+                if permissions.is_admin or permissions.is_creator:
+                    admin_channels.append(channel)
+
+        except Exception as e:
+            logger.warning(f"Не удалось проверить админские права: {e}")
 
     async def check_all(self) -> Result:
-        """Полная проверка аккаунта"""
         try:
-            # Сначала валидация
-            validation = await self.validate()
-            if not validation.valid:
-                return validation
-
-            me = validation.me
-            logger.debug(f"Пользователь: {me.first_name} (+{me.phone})")
+            me = await self.client.get_me()
 
             # Собираем данные с обработкой ошибок
-            stars = None
-            country = None
-            contacts = None
-            chats = None
-            channels = None
-            admin_channels = None
+            stars = self.check_stars(me=me)
+            country = self.check_country(me=me)
 
-            try:
-                stars_status = await self.client(GetStarsStatusRequest(peer=me))
-                stars = stars_status.balance.amount
-            except Exception as e:
-                logger.warning(f"Не удалось получить баланс звезд: {e}")
-
-            try:
-                phone_parse = parse(str(f"+{me.phone}"))
-                country = geocoder.description_for_number(phone_parse, "ru")
-            except Exception as e:
-                logger.warning(f"Не удалось определить страну: {e}")
-
-            try:
-                logger.debug("Получение контактов")
-                result = await self.client(GetContactsRequest(hash=0))
-                contacts = result.users
-            except Exception as e:
-                logger.warning(f"Не удалось получить контакты: {e}")
-
-            try:
-                logger.debug("Получение всех диалогов")
-                chats = []
-                async for dialog in self.client.iter_dialogs():
-                    chats.append(dialog.entity)
-            except Exception as e:
-                logger.warning(f"Не удалось получить чаты: {e}")
-
-            if chats:
-                try:
-                    channels = [chat for chat in chats if isinstance(chat, Channel)]
-                except Exception as e:
-                    logger.warning(f"Не удалось отфильтровать каналы: {e}")
-
-                try:
-                    logger.debug("Проверка прав администратора")
-                    admin_channels = []
-                    for chat in chats:
-                        if isinstance(chat, Channel):
-                            try:
-                                permissions = await self.client.get_permissions(
-                                    chat, "me"
-                                )
-                                if permissions.is_admin or permissions.is_creator:
-                                    admin_channels.append(chat)
-                            except:
-                                pass
-                except Exception as e:
-                    logger.warning(f"Не удалось проверить админские права: {e}")
+            contacts = self.check_contacts()
+            chats = self.check_chats()
+            channels = [] if chats == [] else self.check_channels(chats=chats)
+            admin_channels = (
+                [] if channels == [] else self.check_admin_channels(channels=channels)
+            )
 
             return Result(
-                valid=True,
                 me=me,
                 stars=stars,
                 country=country,
@@ -163,9 +150,4 @@ class Checker:
 
         except Exception as e:
             logger.error(f"Критическая ошибка при проверке: {e}")
-            return Result(valid=False, error=str(e))
-
-
-class MassChecker:
-    def __init__(self):
-        pass
+            raise SessionInvalid()