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

hh_applicant_tool/operations/authorize.py

@@ -1,137 +1,273 @@
+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
+
+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"]
+
+    # Селекторы
+    SEL_LOGIN_INPUT = 'input[data-qa="login-input-username"]'
+    SEL_EXPAND_PASSWORD_BTN = 'button[data-qa="expand-login-by_password"]'
+    SEL_PASSWORD_INPUT = 'input[data-qa="login-input-password"]'
+    SEL_CODE_CONTAINER = 'div[data-qa="account-login-code-input"]'
+    SEL_PIN_CODE_INPUT = 'input[data-qa="magritte-pincode-input-field"]'
+
+    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",
+            action="store_true",
+            help="Показать окно браузера для отладки (отключает headless режим).",
+        )
+        parser.add_argument(
+            "--manual",
+            action="store_true",
+            help="Ручной режим ввода кредов, редирект будет перехвачен.",
+        )
 
-    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):
+            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:
+                    # Шаг 1: Логин
+                    logger.debug(f"Ожидание поля логина {self.SEL_LOGIN_INPUT}")
+                    await page.wait_for_selector(
+                        self.SEL_LOGIN_INPUT, timeout=self.selector_timeout
+                    )
+                    await page.fill(self.SEL_LOGIN_INPUT, username)
+                    logger.debug("Логин введен")
+
+                    # Шаг 2: Выбор метода входа
+                    if args.password:
+                        await self._direct_login(page, args.password)
+                    else:
+                        await self._onetime_code_login(page)
+
+                # Шаг 3: Ожидание OAuth кода
+                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.SEL_EXPAND_PASSWORD_BTN}"
+        )
+        await page.click(self.SEL_EXPAND_PASSWORD_BTN)
+
+        logger.debug(f"Ожидание поля пароля: {self.SEL_PASSWORD_INPUT}")
+        await page.wait_for_selector(
+            self.SEL_PASSWORD_INPUT, timeout=self.selector_timeout
+        )
+        await page.fill(self.SEL_PASSWORD_INPUT, password)
+        await page.press(self.SEL_PASSWORD_INPUT, "Enter")
+        logger.debug("Форма с паролем отправлена")
+
+    async def _onetime_code_login(self, page) -> None:
+        logger.info("Вход по одноразовому коду...")
+        await page.press(self.SEL_LOGIN_INPUT, "Enter")
+
+        logger.debug(
+            f"Ожидание контейнера ввода кода: {self.SEL_CODE_CONTAINER}"
+        )
+        await page.wait_for_selector(
+            self.SEL_CODE_CONTAINER, timeout=self.selector_timeout
+        )
+
+        print("📨 Код был отправлен. Проверьте почту или SMS.")
+        code = (await ainput("📩 Введите полученный код: ")).strip()
+
+        if not code:
+            raise RuntimeError("Код подтверждения не может быть пустым")
+
+        logger.debug(f"Ввод кода в {self.SEL_PIN_CODE_INPUT}")
+        await page.fill(self.SEL_PIN_CODE_INPUT, code)
+        await page.press(self.SEL_PIN_CODE_INPUT, "Enter")
+        logger.debug("Форма с кодом отправлена")

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, applicant_tool: HHApplicantTool) -> None:
+        args = applicant_tool.args
+        api_client = applicant_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_negotiations.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+import argparse
+import logging
+from typing import TYPE_CHECKING
+
+from ..api.errors import ApiError
+from ..datatypes import NegotiationStateId
+from ..main import BaseNamespace, BaseOperation
+
+if TYPE_CHECKING:
+    from ..main import HHApplicantTool
+
+logger = logging.getLogger(__package__)
+
+
+class Namespace(BaseNamespace):
+    cleanup: bool
+    blacklist_discard: bool
+    dry_run: bool
+
+
+class Operation(BaseOperation):
+    """Проверяет и синхронизирует отклики с локальной базой и опционально удаляет отказы."""
+
+    __aliases__ = ["sync-negotiations"]
+
+    def setup_parser(self, parser: argparse.ArgumentParser) -> None:
+        parser.add_argument(
+            "--cleanup",
+            "--clean",
+            action=argparse.BooleanOptionalAction,
+            help="Удалить отклики с отказами",
+        )
+        parser.add_argument(
+            "-b",
+            "--blacklist-discard",
+            "--blacklist",
+            action=argparse.BooleanOptionalAction,
+            help="Блокировать работодателя за отказ",
+        )
+        parser.add_argument(
+            "-n",
+            "--dry-run",
+            action=argparse.BooleanOptionalAction,
+            help="Тестовый запуск без реального удаления",
+        )
+
+    def run(self, tool: HHApplicantTool) -> None:
+        self.tool = tool
+        self.args = tool.args
+        self._sync()
+
+    def _sync(self) -> None:
+        storage = self.tool.storage
+        for negotiation in self.tool.get_negotiations():
+            vacancy = negotiation["vacancy"]
+            employer = vacancy.get("employer", {})
+            employer_id = employer.get("id")
+
+            # Если работодателя блокируют, то он превращается в null
+            # ХХ позволяет скрывать компанию, когда id нет, а вместо имени "Крупная российская компания"
+            # sqlite3.IntegrityError: NOT NULL constraint failed: negotiations.employer_id
+            if employer_id:
+                storage.negotiations.save(negotiation)
+
+            state_id: NegotiationStateId = negotiation["state"]["id"]
+            if not self.args.cleanup:
+                continue
+            if state_id != "discard":
+                continue
+            try:
+                if not self.args.dry_run:
+                    self.tool.api_client.delete(
+                        f"/negotiations/active/{negotiation['id']}",
+                        with_decline_message=True,
+                    )
+
+                print(
+                    "🗑️ Отменили отклик на вакансию:",
+                    vacancy["name"],
+                    vacancy["alternate_url"],
+                )
+
+                if (
+                    employer_id
+                    and employer_id not in self.args.blacklist_discard
+                ):
+                    if not self.args.dry_run:
+                        self.tool.api_client.put(
+                            f"/employers/blacklisted/{employer_id}"
+                        )
+
+                    print(
+                        "🚫 Работодатель заблокирован:",
+                        employer["name"],
+                        employer["alternate_url"],
+                    )
+            except ApiError as err:
+                logger.error(err)
+
+        print("✅ Синхронизация завершена.")

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)