hh-applicant-tool 0.7.10__py3-none-any.whl → 1.4.12__py3-none-any.whl

hh_applicant_tool/operations/authorize.py

@@ -1,137 +1,330 @@
+from __future__ import annotations
+
 import argparse
+import asyncio
 import logging
+from concurrent.futures import ThreadPoolExecutor
+from datetime import datetime
+from typing import TYPE_CHECKING
 from urllib.parse import parse_qs, urlsplit
-import sys
-from typing import Any
-from ..utils import print_err
 
-from ..api import ApiClient  # noqa: E402
-from ..main import BaseOperation, Namespace  # noqa: E402
+try:
+    from playwright.async_api import async_playwright
+except ImportError:
+    pass
+
+from ..main import BaseOperation
+from ..utils.terminal import print_kitty_image
+
+if TYPE_CHECKING:
+    from ..main import HHApplicantTool
+
 
 HH_ANDROID_SCHEME = "hhandroid"
 
-logger = logging.getLogger(__package__)
+logger = logging.getLogger(__name__)
+_executor = ThreadPoolExecutor()
 
-QT_IMPORTED = False
 
-try:
-    from PyQt6.QtCore import QUrl
-    from PyQt6.QtWidgets import QApplication, QMainWindow
-    from PyQt6.QtWebEngineCore import QWebEngineUrlScheme
-    from PyQt6.QtWebEngineCore import QWebEngineUrlSchemeHandler
-    from PyQt6.QtWebEngineWidgets import QWebEngineView
-    from PyQt6.QtWebEngineCore import QWebEngineSettings
-
-    QT_IMPORTED = True
-except ImportError as ex:
-    logger.debug(ex)
-    # Заглушки чтобы на сервере не нужно было ставить сотни мегабайт qt-говна
-
-    class QUrl:
-        pass
-
-    class QApplication:
-        pass
-
-    class QMainWindow:
-        pass
-
-    class QWebEngineUrlSchemeHandler:
-        pass
-
-    class QWebEngineView:
-        pass
-
-
-
-class HHAndroidUrlSchemeHandler(QWebEngineUrlSchemeHandler):
-    def __init__(self, parent: "WebViewWindow") -> None:
-        super().__init__()
-        self.parent = parent
-
-    def requestStarted(self, info: Any) -> None:
-        url = info.requestUrl().toString()
-        if url.startswith(f"{HH_ANDROID_SCHEME}://"):
-            self.parent.handle_redirect_uri(url)
-
-def register_hhandroid_scheme() -> None:
-    scheme = QWebEngineUrlScheme(HH_ANDROID_SCHEME.encode())
-    scheme.setSyntax(QWebEngineUrlScheme.Syntax.Path)
-    scheme.setFlags(
-        QWebEngineUrlScheme.Flag.SecureScheme |
-        QWebEngineUrlScheme.Flag.LocalScheme |
-        QWebEngineUrlScheme.Flag.LocalAccessAllowed |
-        QWebEngineUrlScheme.Flag.CorsEnabled
-    )
-    QWebEngineUrlScheme.registerScheme(scheme)
-
-
-class WebViewWindow(QMainWindow):
-    def __init__(self, api_client: ApiClient) -> None:
-        super().__init__()
-        self.api_client = api_client
-        
-        self.web_view = QWebEngineView()
-        self.web_view.settings().setUnknownUrlSchemePolicy(
-            QWebEngineSettings.UnknownUrlSchemePolicy.AllowAllUnknownUrlSchemes
-        )
-        
-        self.setCentralWidget(self.web_view)
-        self.setWindowTitle("Авторизация на HH.RU")
-        self.hhandroid_handler = HHAndroidUrlSchemeHandler(self)
-        
-        profile = self.web_view.page().profile()
-        profile.installUrlSchemeHandler(HH_ANDROID_SCHEME.encode(), self.hhandroid_handler)
-        
-        self.web_view.page().acceptNavigationRequest = self._filter_http_requests
-
-        self.resize(480, 800)
-        oauth_url = api_client.oauth_client.authorize_url
-        logger.debug(f"{oauth_url = }")
-        self.web_view.setUrl(QUrl(oauth_url))
-
-    def _filter_http_requests(self, url: QUrl, _type, is_main_frame):
-        """Блокирует любые переходы по протоколу HTTP"""
-        if url.scheme().lower() == "http":
-            logger.warning(f"🚫 Заблокирован небезопасный запрос: {url.toString()}")
-            return False
-        return True
-
-    def handle_redirect_uri(self, redirect_uri: str) -> None:
-        logger.debug(f"handle redirect uri: {redirect_uri}")
-        sp = urlsplit(redirect_uri)
-        code = parse_qs(sp.query).get("code", [None])[0]
-        if code:
-            token = self.api_client.oauth_client.authenticate(code)
-            self.api_client.handle_access_token(token)
-            print("🔓 Авторизация прошла успешно!")
-            self.close()
+async def ainput(prompt: str) -> str:
+    loop = asyncio.get_running_loop()
+    return await loop.run_in_executor(_executor, input, prompt)
 
 
 class Operation(BaseOperation):
-    """Авторизоваться на сайте"""
+    """Авторизация через Playwright"""
+
+    __aliases__: list = ["auth", "authen", "authenticate"]
+
+    # Селекторы
+    SELECT_LOGIN_INPUT = 'input[data-qa="login-input-username"]'
+    SELECT_EXPAND_PASSWORD = 'button[data-qa="expand-login-by_password"]'
+    SELECT_PASSWORD_INPUT = 'input[data-qa="login-input-password"]'
+    SELECT_CODE_CONTAINER = 'div[data-qa="account-login-code-input"]'
+    SELECT_PIN_CODE_INPUT = 'input[data-qa="magritte-pincode-input-field"]'
+    SELECT_CAPTCHA_IMAGE = 'img[data-qa="account-captcha-picture"]'
+    SELECT_CAPTCHA_INPUT = 'input[data-qa="account-captcha-input"]'
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._args = None
+
+    @property
+    def is_headless(self) -> bool:
+        """Свойство, определяющее режим работы браузера"""
+        return not self._args.no_headless and self.is_automated
+
+    @property
+    def is_automated(self) -> bool:
+        return not self._args.manual
+
+    @property
+    def selector_timeout(self) -> int | None:
+        """Вспомогательное свойство для таймаутов: None если headless, иначе 500мс"""
+        return None if self.is_headless else 5000
 
     def setup_parser(self, parser: argparse.ArgumentParser) -> None:
-        pass
+        parser.add_argument(
+            "username",
+            nargs="?",
+            help="Email или телефон",
+        )
+        parser.add_argument(
+            "--password",
+            "-p",
+            help="Пароль для входа (если не указать, то вход будет по одноразовому коду)",
+        )
+        parser.add_argument(
+            "--no-headless",
+            "-n",
+            action="store_true",
+            help="Показать окно браузера для отладки (отключает headless режим).",
+        )
+        parser.add_argument(
+            "-m",
+            "--manual",
+            action="store_true",
+            help="Ручной режим ввода кредов, редирект будет перехвачен.",
+        )
+        parser.add_argument(
+            "-k",
+            "--use-kitty",
+            "--kitty",
+            action="store_true",
+            help="Использовать kitty protocol для вывода изображения в терминал. Гуглите поддерживает ли ваш терминал его",
+        )
 
-    def run(self, args: Namespace, api_client: ApiClient, *_) -> None:
-        if not QT_IMPORTED:
-            print_err(
-                "❗Ошибка: PyQt6 не был импортирован, возможно, вы забыли его установить, либо же это ошибка самой библиотеки."
-            )
-            sys.exit(1)
+    def run(self, tool: HHApplicantTool) -> None:
+        self._args = tool.args
+        try:
+            asyncio.run(self._main(tool))
+        except (KeyboardInterrupt, asyncio.TimeoutError):
+            # _executor.shutdown(wait=False, cancel_futures=True)
+            logger.warning("Что-то пошло не так")
+            # os._exit(1)
+            return 1
+
+    async def _main(self, tool: HHApplicantTool) -> None:
+        args = tool.args
+        api_client = tool.api_client
+        storage = tool.storage
+
+        if self.is_automated:
+            username = (
+                args.username
+                or storage.settings.get_value("auth.username")
+                or (await ainput("👤 Введите email или телефон: "))
+            ).strip()
+
+            if not username:
+                raise RuntimeError("Empty username")
+
+            logger.debug(f"authenticate with: {username}")
 
         proxies = api_client.proxies
-        if proxy_url := proxies.get("https"):
-            import os
-            
-            qtwebengine_chromium_flags = f"--proxy-server={proxy_url}"
-            logger.debug(f"set {qtwebengine_chromium_flags = }")
-            os.environ["QTWEBENGINE_CHROMIUM_FLAGS"] = qtwebengine_chromium_flags
-
-        register_hhandroid_scheme()
-        app = QApplication(sys.argv)
-        window = WebViewWindow(api_client=api_client)
-        window.show()
-
-        app.exec()
+        proxy_url = proxies.get("https")
+
+        chromium_args: list[str] = []
+        if proxy_url:
+            chromium_args.append(f"--proxy-server={proxy_url}")
+            logger.debug(f"Используется прокси: {proxy_url}")
+
+        if self.is_headless:
+            logger.debug("Headless режим активен")
+
+        async with async_playwright() as pw:
+            logger.debug("Запуск браузера...")
+
+            browser = await pw.chromium.launch(
+                headless=self.is_headless,
+                args=chromium_args,
+            )
+
+            try:
+                # https://github.com/microsoft/playwright/blob/main/packages/playwright-core/src/server/deviceDescriptorsSource.json
+                android_device = pw.devices["Galaxy A55"]
+                context = await browser.new_context(**android_device)
+                page = await context.new_page()
+
+                # async def route_handler(route):
+                #      req = route.request
+                #      url = req.url.lower()
+
+                #      # Блокировка сканирования локальных портов
+                #      if any(d in url for d in ["localhost", "127.0.0.1", "::1"]):
+                #           logger.debug(f"🛑 Блокировка запроса на локальный порт: {url}")
+                #           return await route.abort()
+
+                #      # Оптимизация трафика в headless
+                #      if is_headless and req.resource_type in [
+                #           "image",
+                #           "stylesheet",
+                #           "font",
+                #           "media",
+                #      ]:
+                #           return await route.abort()
+
+                #      await route.continue_()
+
+                # почему-то добавление этого обработчика вешает все
+                # await page.route("**/*", route_handler)
+
+                code_future: asyncio.Future[str | None] = asyncio.Future()
+
+                def handle_request(request):
+                    url = request.url
+                    if url.startswith(f"{HH_ANDROID_SCHEME}://"):
+                        logger.info(f"Перехвачен OAuth redirect: {url}")
+                        if not code_future.done():
+                            sp = urlsplit(url)
+                            code = parse_qs(sp.query).get("code", [None])[0]
+                            code_future.set_result(code)
+
+                page.on("request", handle_request)
+
+                logger.debug(
+                    f"Переход на страницу OAuth: {api_client.oauth_client.authorize_url}"
+                )
+                await page.goto(
+                    api_client.oauth_client.authorize_url,
+                    timeout=30000,
+                    wait_until="load",
+                )
+
+                if self.is_automated:
+                    logger.debug(
+                        f"Ожидание поля логина {self.SELECT_LOGIN_INPUT}"
+                    )
+                    await page.wait_for_selector(
+                        self.SELECT_LOGIN_INPUT, timeout=self.selector_timeout
+                    )
+                    await page.fill(self.SELECT_LOGIN_INPUT, username)
+                    logger.debug("Логин введен")
+
+                    if args.password:
+                        await self._direct_login(page, args.password)
+                    else:
+                        await self._onetime_code_login(page)
+
+                logger.debug("Ожидание OAuth-кода...")
+
+                auth_code = await asyncio.wait_for(
+                    code_future, timeout=[None, 30.0][self.is_automated]
+                )
+
+                page.remove_listener("request", handle_request)
+
+                logger.debug("Код получен, пробуем получить токен...")
+                token = await asyncio.to_thread(
+                    api_client.oauth_client.authenticate,
+                    auth_code,
+                )
+                api_client.handle_access_token(token)
+
+                print("🔓 Авторизация прошла успешно!")
+
+                # Сохраняем логин и пароль
+                if self.is_automated:
+                    storage.settings.set_value("auth.username", username)
+                    if args.password:
+                        storage.settings.set_value(
+                            "auth.password", args.password
+                        )
+
+                storage.settings.set_value("auth.last_login", datetime.now())
+
+                # storage.settings.set_value(
+                #     "auth.access_token", token["access_token"]
+                # )
+                # storage.settings.set_value(
+                #     "auth.refresh_token", token["refresh_token"]
+                # )
+                # storage.settings.set_value(
+                #     "auth.refresh_token", token["expires_in"]
+                # )
+
+            finally:
+                logger.debug("Закрытие браузера")
+                await browser.close()
+
+    async def _direct_login(self, page, password: str) -> None:
+        logger.info("Вход по паролю...")
+
+        logger.debug(
+            f"Клик по кнопке развертывания пароля: {self.SELECT_EXPAND_PASSWORD}"
+        )
+        await page.click(self.SELECT_EXPAND_PASSWORD)
+
+        await self._handle_captcha(page)
+
+        logger.debug(f"Ожидание поля пароля: {self.SELECT_PASSWORD_INPUT}")
+        await page.wait_for_selector(
+            self.SELECT_PASSWORD_INPUT, timeout=self.selector_timeout
+        )
+        await page.fill(self.SELECT_PASSWORD_INPUT, password)
+        await page.press(self.SELECT_PASSWORD_INPUT, "Enter")
+        logger.debug("Форма с паролем отправлена")
+
+    async def _onetime_code_login(self, page) -> None:
+        logger.info("Вход по одноразовому коду...")
+
+        await page.press(self.SELECT_LOGIN_INPUT, "Enter")
+
+        await self._handle_captcha(page)
+
+        logger.debug(
+            f"Ожидание контейнера ввода кода: {self.SELECT_CODE_CONTAINER}"
+        )
+
+        await page.wait_for_selector(
+            self.SELECT_CODE_CONTAINER, timeout=self.selector_timeout
+        )
+
+        print("📨 Код был отправлен. Проверьте почту или SMS.")
+        code = (await ainput("📩 Введите полученный код: ")).strip()
+
+        if not code:
+            raise RuntimeError("Код подтверждения не может быть пустым.")
+
+        logger.debug(f"Ввод кода в {self.SELECT_PIN_CODE_INPUT}")
+        await page.fill(self.SELECT_PIN_CODE_INPUT, code)
+        await page.press(self.SELECT_PIN_CODE_INPUT, "Enter")
+        logger.debug("Форма с кодом отправлена")
+
+    async def _handle_captcha(self, page):
+        try:
+            captcha_element = await page.wait_for_selector(
+                self.SELECT_CAPTCHA_IMAGE,
+                timeout=self.selector_timeout,
+                state="visible",
+            )
+        except Exception:
+            logger.debug("Капчи нет, продолжаем как обычно.")
+            return
+
+        if not self._args.use_kitty:
+            raise RuntimeError(
+                "Используйте флаг --use-kitty/-k для вывода капчи в терминал."
+                "Работает не во всех терминалах!",
+            )
+
+        logger.info("Обнаружена капча!")
+
+        # box = await captcha_element.bounding_box()
+
+        # width = int(box["width"])
+        # height = int(box["height"])
+
+        img_bytes = await captcha_element.screenshot()
+
+        print(
+            "Если вы не видите картинку ниже, то ваш терминал не поддерживает"
+            " kitty protocol."
+        )
+        print()
+        print_kitty_image(img_bytes)
+
+        captcha_text = (await ainput("Введите текст с картинки: ")).strip()
+
+        await page.fill(self.SELECT_CAPTCHA_INPUT, captcha_text)
+        await page.press(self.SELECT_CAPTCHA_INPUT, "Enter")

hh_applicant_tool/operations/call_api.py

@@ -1,12 +1,17 @@
-# Этот модуль можно использовать как образец для других
+from __future__ import annotations
+
 import argparse
 import json
 import logging
 import sys
+from typing import TYPE_CHECKING
+
+from ..api import ApiError
+from ..main import BaseNamespace, BaseOperation
+
+if TYPE_CHECKING:
+    from ..main import HHApplicantTool
 
-from ..api import ApiClient, ApiError
-from ..main import BaseOperation
-from ..main import Namespace as BaseNamespace
 
 logger = logging.getLogger(__package__)
 
@@ -15,12 +20,13 @@ class Namespace(BaseNamespace):
     method: str
     endpoint: str
     params: list[str]
-    pretty_print: bool
 
 
 class Operation(BaseOperation):
     """Вызвать произвольный метод API <https://github.com/hhru/api>."""
 
+    __aliases__ = ("api",)
+
     def setup_parser(self, parser: argparse.ArgumentParser) -> None:
         parser.add_argument("endpoint", help="Путь до эндпоинта API")
         parser.add_argument(
@@ -30,13 +36,17 @@ class Operation(BaseOperation):
             default=[],
         )
         parser.add_argument(
-            "-m", "--method", "--meth", default="GET", help="HTTP Метод"
+            "-m", "--method", "--meth", "-X", default="GET", help="HTTP Метод"
         )
 
-    def run(self, args: Namespace, api_client: ApiClient, *_) -> None:
+    def run(self, tool: HHApplicantTool) -> None:
+        args = tool.args
+        api_client = tool.api_client
         params = dict(x.split("=", 1) for x in args.param)
         try:
-            result = api_client.request(args.method, args.endpoint, params=params)
+            result = api_client.request(
+                args.method, args.endpoint, params=params
+            )
             print(json.dumps(result, ensure_ascii=False))
         except ApiError as ex:
             json.dump(ex.data, sys.stderr, ensure_ascii=False)

hh_applicant_tool/operations/check_proxy.py

@@ -0,0 +1,30 @@
+# Этот модуль можно использовать как образец для других
+from __future__ import annotations
+
+import argparse
+import logging
+from typing import TYPE_CHECKING
+
+from ..main import BaseNamespace, BaseOperation
+
+if TYPE_CHECKING:
+    from ..main import HHApplicantTool
+
+
+logger = logging.getLogger(__package__)
+
+
+class Namespace(BaseNamespace):
+    pass
+
+
+class Operation(BaseOperation):
+    """Проверить прокси"""
+
+    def setup_parser(self, parser: argparse.ArgumentParser) -> None:
+        pass
+
+    def run(self, applicant_tool: HHApplicantTool) -> None:
+        session = applicant_tool.session
+        assert session.proxies, "Прокси не заданы"
+        print(session.get("https://icanhazip.com").text)