tgparser-cli 0.1.0__py3-none-any.whl

tgparser/__init__.py

@@ -0,0 +1,3 @@
+"""TgParser — Telegram channel parser."""
+
+__version__ = "0.1.0"

tgparser/auth/__init__.py

@@ -0,0 +1,6 @@
+"""Authentication modules — web QR and MTProto."""
+
+from tgparser.auth.mtproto_auth import MTProtoAuth
+from tgparser.auth.web_auth import WebAuth
+
+__all__ = ["MTProtoAuth", "WebAuth"]

tgparser/auth/mtproto_auth.py

@@ -0,0 +1,130 @@
+"""MTProto (Telethon) phone-code authentication for open channels."""
+
+from pathlib import Path
+
+from telethon import TelegramClient
+from telethon.errors import (
+    SessionPasswordNeededError,
+)
+
+from tgparser.config import get_secret, get_setting
+from tgparser.utils import logger
+
+
+class MTProtoAuth:
+    """Authenticate via MTProto (Telethon) — phone number + code.
+
+    Uses api_id/api_hash from .env or config secrets.
+    Session is persisted as a Telethon .session file.
+    """
+
+    def __init__(
+        self,
+        api_id: int | None = None,
+        api_hash: str | None = None,
+        phone: str | None = None,
+        session_dir: str | Path | None = None,
+    ) -> None:
+        self.api_id = api_id or int(get_secret("TG_API_ID") or 0)
+        self.api_hash = api_hash or get_secret("TG_API_HASH") or ""
+        self.phone = phone or get_secret("TG_PHONE") or ""
+
+        if not self.api_id or not self.api_hash:
+            raise ValueError(
+                "MTProto credentials missing. "
+                "Set TG_API_ID and TG_API_HASH in .env or pass explicitly."
+            )
+
+        session_dir = Path(
+            session_dir or get_setting("session_dir", default="data/sessions/")
+        )
+        session_dir.mkdir(parents=True, exist_ok=True)
+        self.session_file = session_dir / "mtproto.session"
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    def login(self, force: bool = False) -> TelegramClient:
+        """Authenticate via phone code, persist session, return client.
+
+        If a valid session exists and force=False, reuses it.
+        Raises on authentication failure.
+        """
+        client = TelegramClient(
+            str(self.session_file),
+            self.api_id,
+            self.api_hash,
+        )
+
+        if not force and self.is_session_valid():
+            logger.info("Valid MTProto session found — reusing.")
+            client.connect()
+            return client
+
+        logger.info("Starting MTProto authentication for %s...", self.phone)
+        client.connect()
+
+        if not client.is_user_authorized():
+            client.send_code_request(self.phone)
+            logger.info("Verification code sent to %s.", self.phone)
+
+            code = self._prompt_code()
+            try:
+                client.sign_in(self.phone, code)
+            except SessionPasswordNeededError:
+                # 2FA enabled — ask for password
+                password = self._prompt_password()
+                client.sign_in(password=password)
+
+        logger.info(
+            "MTProto authentication successful — session saved to %s",
+            self.session_file,
+        )
+        return client
+
+    def is_session_valid(self) -> bool:
+        """Check whether a persisted .session file exists and can connect."""
+        if not self.session_file.exists():
+            return False
+        try:
+            client = TelegramClient(
+                str(self.session_file),
+                self.api_id,
+                self.api_hash,
+            )
+            client.connect()
+            authorized = client.is_user_authorized()
+            client.disconnect()
+            return authorized
+        except Exception as exc:
+            logger.debug("Session validity check failed: %s", exc)
+            return False
+
+    # ------------------------------------------------------------------
+    # Prompt helpers (interactive console input)
+    # ------------------------------------------------------------------
+
+    def _prompt_code(self) -> str:
+        """Read verification code from stdin with timeout."""
+        for _ in range(3):
+            try:
+                code = input("Enter the verification code from Telegram: ").strip()
+                if code:
+                    return code
+            except (EOFError, KeyboardInterrupt):
+                raise
+        raise ValueError("No verification code provided after 3 attempts.")
+
+    def _prompt_password(self) -> str:
+        """Read 2FA password from stdin."""
+        import getpass
+
+        for _ in range(3):
+            try:
+                password = getpass.getpass("Enter your 2FA password: ").strip()
+                if password:
+                    return password
+            except (EOFError, KeyboardInterrupt):
+                raise
+        raise ValueError("No 2FA password provided after 3 attempts.")

tgparser/auth/web_auth.py

@@ -0,0 +1,260 @@
+"""Web Telegram QR-code authentication via Playwright."""
+
+import json
+import time
+from pathlib import Path
+from typing import Any
+
+from playwright.sync_api import (
+    Browser,
+    BrowserContext,
+    Page,
+    Playwright,
+    sync_playwright,
+)
+from playwright.sync_api import (
+    TimeoutError as PwTimeout,
+)
+
+from tgparser.config import get_setting
+from tgparser.utils import logger
+
+# Default wait timeouts (seconds)
+QR_WAIT_TIMEOUT_S = 120
+LOGIN_WAIT_TIMEOUT_S = 300
+QR_RETRY_COUNT = 3
+
+
+class WebAuth:
+    """Authenticate to Telegram Web via QR code, persist session for reuse."""
+
+    def __init__(
+        self,
+        session_dir: str | Path | None = None,
+        headless: bool = False,
+        slow_mo: int = 100,
+    ) -> None:
+        self.session_dir = Path(session_dir or get_setting("session_dir", default="data/sessions/"))
+        self.session_dir.mkdir(parents=True, exist_ok=True)
+        self.session_file = self.session_dir / "web_session.json"
+        self.headless = headless
+        self.slow_mo = slow_mo or get_setting("browser", "slow_mo", default=100)
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    def login(self, force: bool = False) -> bool:
+        """Open browser, show QR, wait for scan, save session.
+
+        Returns True on success, False on failure.
+        """
+        if not force and self.is_session_valid():
+            logger.info("Valid session found at %s — skipping auth.", self.session_file)
+            return True
+
+        logger.info(
+            "Launching browser for QR authentication (headless=%s)...",
+            self.headless,
+        )
+        pw: Playwright | None = None
+        browser: Browser | None = None
+
+        try:
+            pw = sync_playwright().start()
+            browser = pw.chromium.launch(
+                headless=self.headless,
+                slow_mo=self.slow_mo,
+            )
+            context = browser.new_context(
+                viewport={"width": 1280, "height": 900},
+                locale="en-US",
+            )
+            page = context.new_page()
+            page.set_default_timeout(LOGIN_WAIT_TIMEOUT_S * 1000)
+
+            self._navigate_to_login(page)
+            self._wait_for_qr_until_scanned(page)
+            self._save_session(context)
+
+            logger.info(
+                "Authentication successful — session saved to %s",
+                self.session_file,
+            )
+            return True
+
+        except PwTimeout as exc:
+            logger.error("Timeout during authentication: %s", exc)
+            return False
+        except Exception as exc:
+            logger.error("Authentication failed: %s", exc)
+            return False
+        finally:
+            if browser:
+                browser.close()
+            if pw:
+                pw.stop()
+
+    def is_session_valid(self) -> bool:
+        """Check whether a persisted session file exists (quick check).
+
+        A full validity check (making a request with the session) is done
+        later during parsing; here we only verify the file is present.
+        """
+        return self.session_file.exists()
+
+    # ------------------------------------------------------------------
+    # Navigation helpers
+    # ------------------------------------------------------------------
+
+    def _navigate_to_login(self, page: Page) -> None:
+        """Open web.telegram.org and handle the landing / login redirect."""
+        page.goto("https://web.telegram.org/k/", wait_until="domcontentloaded")
+        logger.info("Opened web.telegram.org/k/ — waiting for QR code...")
+
+    def _wait_for_qr_until_scanned(self, page: Page) -> None:
+        """Loop: wait for QR canvas, if it expires click Retry and re-wait.
+
+        Raises PwTimeout if the user never scans within the overall time budget.
+        """
+        for attempt in range(1, QR_RETRY_COUNT + 1):
+            logger.info(
+                "QR attempt %d/%d — waiting up to %ds...",
+                attempt,
+                QR_RETRY_COUNT,
+                QR_WAIT_TIMEOUT_S,
+            )
+            try:
+                self._wait_for_qr_appear(page)
+                self._wait_for_login_complete(page)
+                return
+            except PwTimeout:
+                logger.warning("QR timed out (attempt %d/%d).", attempt, QR_RETRY_COUNT)
+                if attempt < QR_RETRY_COUNT and self._retry_qr(page):
+                    logger.info("QR refreshed — retrying...")
+                    continue
+                raise
+
+        raise PwTimeout(f"QR authentication failed after {QR_RETRY_COUNT} attempts.")
+
+    def _wait_for_qr_appear(self, page: Page) -> None:
+        """Wait until the QR <canvas> element is visible on the login page."""
+        page.wait_for_selector("canvas.qr-canvas", timeout=QR_WAIT_TIMEOUT_S * 1000)
+        logger.info("QR code canvas detected — scan it with your phone.")
+
+    def _wait_for_login_complete(self, page: Page) -> None:
+        """Wait for a URL change indicating successful login (redirect to /chat)."""
+        page.wait_for_url("**/k/**", timeout=LOGIN_WAIT_TIMEOUT_S * 1000)
+        # Additional confirmation: wait for the chat list container
+        page.wait_for_selector(".chatlist", timeout=10_000)
+        logger.info("Login confirmed — chat list visible.")
+
+    def _retry_qr(self, page: Page) -> bool:
+        """Look for a Retry/refresh button on the expired QR screen and click it.
+
+        Returns True if a retry element was found and clicked.
+        """
+        retry_selectors = [
+            "button.btn-primary:has-text('Retry')",
+            "button:has-text('Try again')",
+            ".qr-retry-button",
+            "button[title='Retry']",
+        ]
+        for sel in retry_selectors:
+            try:
+                btn = page.wait_for_selector(sel, timeout=3_000)
+                if btn:
+                    btn.click()
+                    return True
+            except PwTimeout:
+                continue
+        return False
+
+    # ------------------------------------------------------------------
+    # Session persistence
+    # ------------------------------------------------------------------
+
+    def _save_session(self, context: BrowserContext) -> None:
+        """Extract cookies and localStorage, write to JSON file."""
+        cookies = context.cookies()
+        local_storage: dict[str, Any] = {}
+        page = context.pages[0] if context.pages else None
+        if page:
+            try:
+                local_storage = page.evaluate(
+                    """() => {
+                        const items = {};
+                        for (let i = 0; i < localStorage.length; i++) {
+                            const key = localStorage.key(i);
+                            if (key) items[key] = localStorage.getItem(key);
+                        }
+                        return items;
+                    }"""
+                )
+            except Exception as exc:
+                logger.warning("Could not extract localStorage: %s", exc)
+
+        session_data: dict[str, Any] = {
+            "cookies": cookies,
+            "local_storage": local_storage,
+            "saved_at": time.time(),
+        }
+        self.session_file.write_text(
+            json.dumps(session_data, indent=2, ensure_ascii=False),
+            encoding="utf-8",
+        )
+        logger.debug(
+            "Session saved: %d cookies, %d localStorage keys.",
+            len(cookies),
+            len(local_storage),
+        )
+
+    def load_session(self) -> dict[str, Any] | None:
+        """Load persisted session data from JSON file.
+
+        Returns dict with 'cookies' and 'local_storage' keys, or None.
+        """
+        if not self.session_file.exists():
+            return None
+        try:
+            return json.loads(self.session_file.read_text(encoding="utf-8"))
+        except (json.JSONDecodeError, OSError) as exc:
+            logger.warning("Failed to load session file: %s", exc)
+            return None
+
+    def restore_session(self, context: BrowserContext) -> bool:
+        """Restore cookies and localStorage into a browser context.
+
+        Returns True if at least one cookie was restored.
+        """
+        data = self.load_session()
+        if not data:
+            logger.info("No session data to restore.")
+            return False
+
+        cookies = data.get("cookies", [])
+        if cookies:
+            context.add_cookies(cookies)
+            logger.debug("Restored %d cookies.", len(cookies))
+        else:
+            logger.warning("Session file contains no cookies.")
+            return False
+
+        # Restore localStorage (requires a page on the right origin)
+        ls_data = data.get("local_storage", {})
+        if ls_data:
+            page = context.new_page()
+            try:
+                page.goto("https://web.telegram.org/k/", wait_until="domcontentloaded")
+                for key, value in ls_data.items():
+                    page.evaluate(
+                        """([k, v]) => localStorage.setItem(k, v)""",
+                        [key, value],
+                    )
+                page.close()
+                logger.debug("Restored %d localStorage keys.", len(ls_data))
+            except Exception as exc:
+                logger.warning("Failed to restore localStorage: %s", exc)
+                page.close()
+
+        return True