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

hh_applicant_tool/ai/openai.py

@@ -17,17 +17,18 @@ class OpenAIChat:
         token: str,
         model: str,
         system_prompt: str,
-        proxies: dict[str, str] = {}
+        proxies: dict[str, str] | None = None,
+        session: requests.Session | None = None
     ):
         self.token = token
         self.model = model
         self.system_prompt = system_prompt
         self.proxies = proxies
+        self.session = session or requests.session()
 
     def default_headers(self) -> dict[str, str]:
         return {
             "Authorization": f"Bearer {self.token}",
-            "Content-Type": "application/json",
         }
 
     def send_message(self, message: str) -> str:
@@ -49,7 +50,7 @@ class OpenAIChat:
         }
 
         try:
-            response = requests.post(
+            response = self.session.post(
                 self.chat_endpoint,
                 json=payload,
                 headers=self.default_headers(),
@@ -59,9 +60,12 @@ class OpenAIChat:
             response.raise_for_status()
 
             data = response.json()
+            if 'error' in data:
+                raise OpenAIError(data['error']['message'])
+            
             assistant_message = data["choices"][0]["message"]["content"]
 
             return assistant_message
 
         except requests.exceptions.RequestException as ex:
-            raise OpenAIError(f"OpenAI API Error: {str(ex)}") from ex
+            raise OpenAIError(str(ex)) from ex

hh_applicant_tool/api/client.py

@@ -3,22 +3,16 @@ from __future__ import annotations
 import dataclasses
 import json
 import logging
-import uuid
 import time
 from dataclasses import dataclass
-from functools import partialmethod
+from functools import cached_property
 from threading import Lock
 from typing import Any, Literal
 from urllib.parse import urlencode
-from functools import cached_property
-import random
+
 import requests
 from requests import Response, Session
 
-from ..constants import (
-    ANDROID_CLIENT_ID,
-    ANDROID_CLIENT_SECRET,
-)
 from ..types import AccessToken
 from . import errors
 
@@ -35,7 +29,6 @@ ALLOWED_METHODS = Literal["GET", "POST", "PUT", "DELETE"]
 class BaseClient:
     base_url: str
     _: dataclasses.KW_ONLY
-    # TODO: сделать генерацию User-Agent'а как в приложении
     user_agent: str | None = None
     proxies: dict | None = None
     session: Session | None = None
@@ -45,26 +38,16 @@ class BaseClient:
     def __post_init__(self) -> None:
         self.lock = Lock()
         if not self.session:
-            self.session = session = requests.session()
-            session.headers.update(
-                {
-                    "user-agent": self.user_agent or self.default_user_agent(),
-                    "x-hh-app-active": "true",
-                    **self.additional_headers(),
-                }
-            )
-            logger.debug("Default Headers: %r", session.headers)
-
-    def default_user_agent(self) -> str:
-        devices = "23053RN02A, 23053RN02Y, 23053RN02I, 23053RN02L, 23077RABDC".split(
-            ", "
-        )
-        device = random.choice(devices)
-        minor = random.randint(100, 150)
-        patch = random.randint(10000, 15000)
-        android = random.randint(11, 15)
-        return f"ru.hh.android/7.{minor}.{patch}, Device: {device}, Android OS: {android} (UUID: {uuid.uuid4()})"
+            self.session = requests.session()
+        if self.proxies:
+            logger.debug(f"client proxies: {self.proxies}")
 
+    def default_headers(self) -> dict[str, str]:
+        return {
+            "user-agent": self.user_agent or "Mozilla/5.0",
+            "x-hh-app-active": "true",
+        }
+    
     def additional_headers(
         self,
     ) -> dict[str, str]:
@@ -94,34 +77,44 @@ class BaseClient:
                 time.sleep(delay)
             has_body = method in ["POST", "PUT"]
             payload = {"data" if has_body else "params": params}
+            headers = self.default_headers() | self.additional_headers()
+            logger.debug(f"request info: {method = }, {url = }, {headers = }, params = {repr(params)[:255]}")
             response = self.session.request(
                 method,
                 url,
                 **payload,
+                headers=headers,
                 proxies=self.proxies,
                 allow_redirects=False,
             )
             try:
-                # У этих лошков сервер не отдает Content-Length, а кривое API отдает пустые ответы, например, при отклике на вакансии, и мы не можем узнать содержит ли ответ тело
+                # У этих лошков сервер не отдает Content-Length, а кривое API
+                # отдает пустые ответы, например, при отклике на вакансии,
+                # и мы не можем узнать содержит ли ответ тело
                 # 'Server': 'ddos-guard'
                 # ...
                 # 'Transfer-Encoding': 'chunked'
                 try:
-                    rv = response.json()
-                except json.decoder.JSONDecodeError:
-                    # if response.status_code not in [201, 204]:
-                    #     raise
-                    rv = {}
+                    rv = response.json() if response.text else {}
+                except json.decoder.JSONDecodeError as ex:
+                    raise errors.BadResponse(
+                        f"Can't decode JSON: {method} {url} ({response.status_code})"
+                    ) from ex
             finally:
+                log_url = url
+                if not has_body and params:
+                    log_url += "?" + urlencode(params)
                 logger.debug(
-                    "%d %-6s %s",
-                    response.status_code,
+                    "%s %s: %d",
                     method,
-                    url + ("?" + urlencode(params) if not has_body and params else ""),
+                    log_url,
+                    response.status_code,
                 )
                 self.previous_request_time = time.monotonic()
         self.raise_for_status(response, rv)
-        assert 300 > response.status_code >= 200
+        assert 300 > response.status_code >= 200, (
+            f"Unexpected status code for {method} {url}: {response.status_code}"
+        )
         return rv
 
     def get(self, *args, **kwargs):
@@ -202,9 +195,12 @@ class OAuthClient(BaseClient):
         return self.request_access_token("/token", params)
 
     def refresh_access_token(self, refresh_token: str) -> AccessToken:
-        # refresh_token можно использовать только один раз и только по истечению срока действия access_token.
+        # refresh_token можно использовать только один раз и только по
+        # истечению срока действия access_token.
         return self.request_access_token(
-            "/token", grant_type="refresh_token", refresh_token=refresh_token
+            "/token",
+            grant_type="refresh_token",
+            refresh_token=refresh_token,
         )
 
 
@@ -214,31 +210,33 @@ class ApiClient(BaseClient):
     access_token: str | None = None
     refresh_token: str | None = None
     access_expires_at: int = 0
-    client_id: str = ANDROID_CLIENT_ID
-    client_secret: str = ANDROID_CLIENT_SECRET
     _: dataclasses.KW_ONLY
+    client_id: str | None = None
+    client_secret: str | None = None
     base_url: str = "https://api.hh.ru/"
 
     @property
     def is_access_expired(self) -> bool:
-        return time.time() > self.access_expires_at
+        return time.time() >= (self.access_expires_at or 0)
 
     @cached_property
     def oauth_client(self) -> OAuthClient:
         return OAuthClient(
             client_id=self.client_id,
             client_secret=self.client_secret,
+            user_agent=self.user_agent,
+            proxies=dict(self.proxies or {}),
             session=self.session,
         )
 
     def additional_headers(
         self,
     ) -> dict[str, str]:
-        return (
-            {"authorization": f"Bearer {self.access_token}"}
-            if self.access_token
-            else {}
-        )
+        if not self.access_token:
+            return {}
+        # Это очень интересно, что access token'ы начинаются с USER, т.е. API может содержать какую-то уязвимость, связанную с этим
+        assert self.access_token.startswith("USER")
+        return {"authorization": f"Bearer {self.access_token}"}
 
     # Реализовано автоматическое обновление токена
     def request(
@@ -258,14 +256,14 @@ class ApiClient(BaseClient):
         except errors.Forbidden as ex:
             if not self.is_access_expired or not self.refresh_token:
                 raise ex
-            logger.info("try refresh access_token")
+            logger.info("try to refresh access_token")
             # Пробуем обновить токен
             self.refresh_access_token()
             # И повторно отправляем запрос
             return do_request()
 
     def handle_access_token(self, token: AccessToken) -> None:
-        for field in ["access_token", "refresh_token", "access_expires_at"]:
+        for field in ("access_token", "refresh_token", "access_expires_at"):
             if field in token and hasattr(self, field):
                 setattr(self, field, token[field])
 

hh_applicant_tool/api/errors.py

@@ -5,6 +5,7 @@ from requests import Request, Response
 from requests.adapters import CaseInsensitiveDict
 
 __all__ = (
+    "BadResponse",
     "ApiError",
     "BadGateway",
     "BadRequest",
@@ -16,7 +17,11 @@ __all__ = (
 )
 
 
-class ApiError(Exception):
+class BadResponse(Exception):
+    pass
+
+
+class ApiError(BadResponse):
     def __init__(self, response: Response, data: dict[str, Any]) -> None:
         self._response = response
         self._raw = data

hh_applicant_tool/color_log.py

@@ -1,6 +1,18 @@
 import enum
 import logging
 from enum import auto
+import os, sys
+
+
+if sys.platform == "win32":
+    import ctypes
+    kernel32 = ctypes.windll.kernel32
+    # 0x0004 = ENABLE_VIRTUAL_TERMINAL_PROCESSING
+    # Берем дескриптор стандартного вывода (stdout)
+    handle = kernel32.GetStdHandle(-11) 
+    mode = ctypes.c_uint()
+    kernel32.GetConsoleMode(handle, ctypes.byref(mode))
+    kernel32.SetConsoleMode(handle, mode.value | 0x0004)
 
 
 class Color(enum.Enum):

hh_applicant_tool/main.py

@@ -11,8 +11,9 @@ from typing import Literal, Sequence
 
 from .api import ApiClient
 from .color_log import ColorHandler
+from .constants import ANDROID_CLIENT_ID, ANDROID_CLIENT_SECRET
 from .telemetry_client import TelemetryClient
-from .utils import Config, get_config_path
+from .utils import Config, android_user_agent, get_config_path
 
 DEFAULT_CONFIG_PATH = (
     get_config_path() / (__package__ or "").replace("_", "-") / "config.json"
@@ -24,7 +25,7 @@ logger = logging.getLogger(__package__)
 class BaseOperation:
     def setup_parser(self, parser: argparse.ArgumentParser) -> None: ...
 
-    def run(self, args: argparse.Namespace) -> None | int:
+    def run(self, args: argparse.Namespace, api_client: ApiClient, telemetry_client: TelemetryClient) -> None | int:
         raise NotImplementedError()
 
 
@@ -40,21 +41,38 @@ class Namespace(argparse.Namespace):
     disable_telemetry: bool
 
 
-def get_proxies(args: Namespace) -> dict[Literal["http", "https"], str | None]:
-    return {
-        "http": args.config["proxy_url"] or getenv("HTTP_PROXY"),
-        "https": args.config["proxy_url"] or getenv("HTTPS_PROXY"),
-    }
+def get_proxies(args: Namespace) -> dict[str, str]:
+    proxy_url = args.proxy_url or args.config.get("proxy_url")
+    
+    if proxy_url:
+        return {
+            "http": proxy_url,
+            "https": proxy_url,
+        }
+    
+    proxies = {}
+    http_env = getenv("HTTP_PROXY") or getenv("http_proxy")
+    https_env = getenv("HTTPS_PROXY") or getenv("https_proxy") or http_env
+    
+    if http_env:
+        proxies["http"] = http_env
+    if https_env:
+        proxies["https"] = https_env
+        
+    return proxies
 
 
 def get_api_client(args: Namespace) -> ApiClient:
-    token = args.config.get("token", {})
+    config = args.config
+    token = config.get("token", {})
     api = ApiClient(
+        client_id=config.get("client_id", ANDROID_CLIENT_ID),
+        client_secret=config.get("client_id", ANDROID_CLIENT_SECRET),
         access_token=token.get("access_token"),
         refresh_token=token.get("refresh_token"),
         access_expires_at=token.get("access_expires_at"),
         delay=args.delay,
-        user_agent=args.config["user_agent"],
+        user_agent=config["user_agent"] or android_user_agent(),
         proxies=get_proxies(args),
     )
     return api
@@ -65,7 +83,7 @@ class HHApplicantTool:
 
     Исходники и предложения: <https://github.com/s3rgeym/hh-applicant-tool>
 
-    Группа поддержки: <https://t.me/otzyvy_headhunter>
+    Группа поддержки: <https://t.me/hh_applicant_tool>
     """
 
     class ArgumentFormatter(
@@ -115,8 +133,22 @@ class HHApplicantTool:
         for _, module_name, _ in iter_modules([str(package_dir)]):
             mod = import_module(f"{__package__}.{OPERATIONS}.{module_name}")
             op: BaseOperation = mod.Operation()
+            # 1. Разбиваем имя модуля на части
+            words = module_name.split("_")
+
+            # 2. Формируем варианты имен
+            kebab_name = "-".join(words)  # call-api
+            
+            # camelCase: первое слово маленькими, остальные с большой
+            camel_case_name = words[0] + "".join(word.title() for word in words[1:])
+            
+            # flatcase: всё слитно и в нижнем регистре
+            flat_name = "".join(words)  # callapi
+
             op_parser = subparsers.add_parser(
-                module_name.replace("_", "-"),
+                kebab_name,
+                # Добавляем остальные варианты в псевдонимы
+                aliases=[camel_case_name, flat_name],
                 description=op.__doc__,
                 formatter_class=self.ArgumentFormatter,
             )
@@ -154,7 +186,7 @@ class HHApplicantTool:
                 logger.warning("Interrupted by user")
                 return 1
             except Exception as e:
-                logger.exception(e)
+                logger.exception(e, exc_info=log_level <= logging.DEBUG)
                 return 1
         parser.print_help(file=sys.stderr)
         return 2

hh_applicant_tool/operations/apply_similar.py

@@ -4,11 +4,12 @@ import random
 import time
 from collections import defaultdict
 from datetime import datetime, timedelta, timezone
+from pathlib import Path
 from typing import Any, TextIO
 
 from ..ai.blackbox import BlackboxChat
 from ..ai.openai import OpenAIChat
-from ..api import ApiClient, ApiError
+from ..api import ApiClient, BadResponse
 from ..api.errors import LimitExceeded
 from ..main import BaseOperation
 from ..main import Namespace as BaseNamespace
@@ -29,6 +30,7 @@ logger = logging.getLogger(__package__)
 class Namespace(BaseNamespace):
     resume_id: str | None
     message_list: TextIO
+    ignore_employers: Path | None
     force_message: bool
     use_ai: bool
     pre_prompt: str
@@ -86,6 +88,12 @@ class Operation(BaseOperation, GetResumeIdMixin):
             help="Путь до файла, где хранятся сообщения для отклика на вакансии. Каждое сообщение — с новой строки.",
             type=argparse.FileType("r", encoding="utf-8", errors="replace"),
         )
+        parser.add_argument(
+            "--ignore-employers",
+            help="Путь к файлу со списком ID игнорируемых работодателей (по одному ID на строку)",
+            type=Path,
+            default=None,
+        )
         parser.add_argument(
             "-f",
             "--force-message",
@@ -192,8 +200,7 @@ class Operation(BaseOperation, GetResumeIdMixin):
         )
         parser.add_argument(
             "--no-magic",
-            default=False,
-            action=argparse.BooleanOptionalAction,
+            action="store_true",
             help="Отключить авторазбор текста запроса",
         )
         parser.add_argument(
@@ -235,6 +242,7 @@ class Operation(BaseOperation, GetResumeIdMixin):
         self.telemetry_client = telemetry_client
         self.resume_id = args.resume_id or self._get_resume_id()
         self.application_messages = self._get_application_messages(args.message_list)
+        self.ignored_employers = self._get_ignored_employers(args.ignore_employers)
         self.chat = None
 
         if config := args.config.get("blackbox"):
@@ -305,6 +313,16 @@ class Operation(BaseOperation, GetResumeIdMixin):
             ]
         return application_messages
 
+    def _get_ignored_employers(self, file_path: Path | None) -> set[str]:
+        ignored = set()
+        if file_path is not None:
+            with file_path.open("r", encoding="utf-8") as f:
+                for line in f:
+                    if clean_id := line.strip():
+                        ignored.add(int(clean_id))
+            logger.info("Загружено %d ID игнорируемых работодателей", len(ignored))
+        return ignored
+
     def _apply_similar(self) -> None:
         telemetry_client = self.telemetry_client
         telemetry_data = defaultdict(dict)
@@ -346,7 +364,6 @@ class Operation(BaseOperation, GetResumeIdMixin):
         }
 
         do_apply = True
-        complained_employers = set()
 
         for vacancy in vacancies:
             try:
@@ -376,13 +393,13 @@ class Operation(BaseOperation, GetResumeIdMixin):
                     continue
 
                 relations = vacancy.get("relations", [])
-                employer_id = vacancy.get("employer", {}).get("id")
+                employer_id = int(vacancy.get("employer", {}).get("id", 0))
 
                 if (
                     self.enable_telemetry
                     and employer_id
                     and employer_id not in telemetry_data["employers"]
-                    and employer_id not in complained_employers
+                    and employer_id not in self.ignored_employers
                     and (
                         not relations
                         or parse_invalid_datetime(vacancy["created_at"])
@@ -405,7 +422,7 @@ class Operation(BaseOperation, GetResumeIdMixin):
                             % employer_id
                         )
 
-                        complained_employers.add(employer_id)
+                        self.ignored_employers.add(employer_id)
 
                     elif do_apply:
                         telemetry_data["employers"][employer_id] = employer_data
@@ -474,7 +491,7 @@ class Operation(BaseOperation, GetResumeIdMixin):
             except LimitExceeded:
                 print("⚠️ Достигли лимита рассылки")
                 do_apply = False
-            except ApiError as ex:
+            except BadResponse as ex:
                 logger.error(ex)
 
         print("📝 Отклики на вакансии разосланы!")
@@ -582,4 +599,3 @@ class Operation(BaseOperation, GetResumeIdMixin):
                 time.sleep(interval)
 
         return rv
-

hh_applicant_tool/operations/authorize.py

@@ -5,17 +5,26 @@ import sys
 from typing import Any
 from ..utils import print_err
 
+from ..api import ApiClient  # noqa: E402
+from ..main import BaseOperation, Namespace  # noqa: E402
+
+HH_ANDROID_SCHEME = "hhandroid"
+
+logger = logging.getLogger(__package__)
 
 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:
+except ImportError as ex:
+    logger.debug(ex)
     # Заглушки чтобы на сервере не нужно было ставить сотни мегабайт qt-говна
 
     class QUrl:
@@ -34,11 +43,6 @@ except ImportError:
         pass
 
 
-from ..api import ApiClient  # noqa: E402
-from ..main import BaseOperation, Namespace  # noqa: E402
-
-logger = logging.getLogger(__package__)
-
 
 class HHAndroidUrlSchemeHandler(QWebEngineUrlSchemeHandler):
     def __init__(self, parent: "WebViewWindow") -> None:
@@ -47,25 +51,51 @@ class HHAndroidUrlSchemeHandler(QWebEngineUrlSchemeHandler):
 
     def requestStarted(self, info: Any) -> None:
         url = info.requestUrl().toString()
-        if url.startswith("hhandroid://"):
+        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
-        # Настройка WebEngineView
+        
         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(b"hhandroid", self.hhandroid_handler)
-        # Настройки окна для мобильного вида
+        profile.installUrlSchemeHandler(HH_ANDROID_SCHEME.encode(), self.hhandroid_handler)
+        
+        self.web_view.page().acceptNavigationRequest = self._filter_http_requests
+
         self.resize(480, 800)
-        self.web_view.setUrl(QUrl(api_client.oauth_client.authorize_url))
+        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}")
@@ -87,10 +117,19 @@ class Operation(BaseOperation):
     def run(self, args: Namespace, api_client: ApiClient, *_) -> None:
         if not QT_IMPORTED:
             print_err(
-                "❗Критиническая Ошибка: PyQt6 не был импортирован, возможно, вы долбоеб и забыли его установить, либо же криворукие разрабы этой либы опять все сломали..."
+                "❗Ошибка: PyQt6 не был импортирован, возможно, вы забыли его установить, либо же это ошибка самой библиотеки."
             )
             sys.exit(1)
 
+        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()

hh_applicant_tool/operations/clear_negotiations.py

@@ -31,16 +31,12 @@ class Operation(BaseOperation):
         )
         parser.add_argument(
             "--all",
-            type=bool,
-            default=False,
             action=argparse.BooleanOptionalAction,
             help="Удалить все отклики в тч с приглашениями",
         )
         parser.add_argument(
             "--blacklist-discard",
             help="Если установлен, то заблокирует работодателя в случае отказа, чтобы его вакансии не отображались в возможных",
-            type=bool,
-            default=False,
             action=argparse.BooleanOptionalAction,
         )
 

hh_applicant_tool/operations/config.py

@@ -33,8 +33,6 @@ class Operation(BaseOperation):
             "-p",
             "--show-path",
             "--path",
-            type=bool,
-            default=False,
             action=argparse.BooleanOptionalAction,
             help="Вывести полный путь к конфигу",
         )