hh-applicant-tool 0.5.7__py3-none-any.whl → 0.5.9__py3-none-any.whl

hh_applicant_tool/api/client.py

@@ -10,7 +10,8 @@ from functools import partialmethod
 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
 
@@ -47,14 +48,22 @@ class BaseClient:
             self.session = session = requests.session()
             session.headers.update(
                 {
-                    "User-Agent": self.user_agent or self.default_user_agent(),
+                    "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:
-        return f"ru.hh.android/7.122.11395, Device: 23053RN02Y, Android OS: 13 (UUID: {uuid.uuid4()})"
+        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()})"
 
     def additional_headers(
         self,
@@ -65,7 +74,7 @@ class BaseClient:
         self,
         method: ALLOWED_METHODS,
         endpoint: str,
-        params: dict | None = None,
+        params: dict[str, Any] | None = None,
         delay: float | None = None,
         **kwargs: Any,
     ) -> dict:
@@ -84,10 +93,11 @@ class BaseClient:
                 logger.debug("wait %fs before request", delay)
                 time.sleep(delay)
             has_body = method in ["POST", "PUT"]
+            payload = {"data" if has_body else "params": params}
             response = self.session.request(
                 method,
                 url,
-                **{"data" if has_body else "params": params},
+                **payload,
                 proxies=self.proxies,
                 allow_redirects=False,
             )
@@ -107,29 +117,27 @@ class BaseClient:
                     "%d %-6s %s",
                     response.status_code,
                     method,
-                    url
-                    + (
-                        "?" + urlencode(params)
-                        if not has_body and params
-                        else ""
-                    ),
+                    url + ("?" + urlencode(params) if not has_body and params else ""),
                 )
                 self.previous_request_time = time.monotonic()
         self.raise_for_status(response, rv)
         assert 300 > response.status_code >= 200
         return rv
 
-    get = partialmethod(request, "GET")
-    post = partialmethod(request, "POST")
-    put = partialmethod(request, "PUT")
-    delete = partialmethod(request, "DELETE")
+    def get(self, *args, **kwargs):
+        return self.request("GET", *args, **kwargs)
+
+    def post(self, *args, **kwargs):
+        return self.request("POST", *args, **kwargs)
+
+    def put(self, *args, **kwargs):
+        return self.request("PUT", *args, **kwargs)
+
+    def delete(self, *args, **kwargs):
+        return self.request("DELETE", *args, **kwargs)
 
     def resolve_url(self, url: str) -> str:
-        return (
-            url
-            if "://" in url
-            else f"{self.base_url.rstrip('/')}/{url.lstrip('/')}"
-        )
+        return url if "://" in url else f"{self.base_url.rstrip('/')}/{url.lstrip('/')}"
 
     @staticmethod
     def raise_for_status(response: Response, data: dict) -> None:
@@ -137,6 +145,8 @@ class BaseClient:
             case 301 | 302:
                 raise errors.Redirect(response, data)
             case 400:
+                if errors.ApiError.is_limit_exceeded(data):
+                    raise errors.LimitExceeded(response=response, data=data)
                 raise errors.BadRequest(response, data)
             case 403:
                 raise errors.Forbidden(response, data)
@@ -152,8 +162,8 @@ class BaseClient:
 
 @dataclass
 class OAuthClient(BaseClient):
-    client_id: str = ANDROID_CLIENT_ID
-    client_secret: str = ANDROID_CLIENT_SECRET
+    client_id: str
+    client_secret: str
     _: dataclasses.KW_ONLY
     base_url: str = "https://hh.ru/oauth"
     state: str = ""
@@ -172,6 +182,16 @@ class OAuthClient(BaseClient):
         params_qs = urlencode({k: v for k, v in params.items() if v})
         return self.resolve_url(f"/authorize?{params_qs}")
 
+    def request_access_token(
+        self, endpoint: str, params: dict[str, Any] | None = None, **kw: Any
+    ) -> AccessToken:
+        tok = self.post(endpoint, params, **kw)
+        return {
+            "access_token": tok.get("access_token"),
+            "refresh_token": tok.get("refresh_token"),
+            "access_expires_at": int(time.time()) + tok.pop("expires_in", 0),
+        }
+
     def authenticate(self, code: str) -> AccessToken:
         params = {
             "client_id": self.client_id,
@@ -179,11 +199,11 @@ class OAuthClient(BaseClient):
             "code": code,
             "grant_type": "authorization_code",
         }
-        return self.post("/token", params)
+        return self.request_access_token("/token", params)
 
-    def refresh_access(self, refresh_token: str) -> AccessToken:
+    def refresh_access_token(self, refresh_token: str) -> AccessToken:
         # refresh_token можно использовать только один раз и только по истечению срока действия access_token.
-        return self.post(
+        return self.request_access_token(
             "/token", grant_type="refresh_token", refresh_token=refresh_token
         )
 
@@ -193,32 +213,71 @@ 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
     base_url: str = "https://api.hh.ru/"
-    # oauth_client: OAuthClient | None = None
 
-    # def __post_init__(self) -> None:
-    #     super().__post_init__()
-    #     self.oauth_client = self.oauth_client or OAuthClient(
-    #         session=self.session
-    #     )
+    @property
+    def is_access_expired(self) -> bool:
+        return time.time() > self.access_expires_at
+
+    @cached_property
+    def oauth_client(self) -> OAuthClient:
+        return OAuthClient(
+            client_id=self.client_id,
+            client_secret=self.client_secret,
+            session=self.session,
+        )
 
     def additional_headers(
         self,
     ) -> dict[str, str]:
         return (
-            {"Authorization": f"Bearer {self.access_token}"}
+            {"authorization": f"Bearer {self.access_token}"}
             if self.access_token
             else {}
         )
 
-    # def refresh_access(self) -> AccessToken:
-    #     tok = self.oauth_client.refresh_access(self.refresh_token)
-    #     (
-    #         self.access_token,
-    #         self.refresh_access,
-    #     ) = (
-    #         tok["access_token"],
-    #         tok["refresh_token"],
-    #     )
-    #     return tok
+    # Реализовано автоматическое обновление токена
+    def request(
+        self,
+        method: ALLOWED_METHODS,
+        endpoint: str,
+        params: dict[str, Any] | None = None,
+        delay: float | None = None,
+        **kwargs: Any,
+    ) -> dict:
+        def do_request():
+            return BaseClient.request(self, method, endpoint, params, delay, **kwargs)
+
+        try:
+            return do_request()
+        # TODO: добавить класс для ошибок типа AccessTokenExpired
+        except errors.Forbidden as ex:
+            if not self.is_access_expired or not self.refresh_token:
+                raise ex
+            logger.info("try 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"]:
+            if field in token and hasattr(self, field):
+                setattr(self, field, token[field])
+
+    def refresh_access_token(self) -> None:
+        if not self.refresh_token:
+            raise ValueError("Refresh token required.")
+        token = self.oauth_client.refresh_access_token(self.refresh_token)
+        self.handle_access_token(token)
+
+    def get_access_token(self) -> AccessToken:
+        return {
+            "access_token": self.access_token,
+            "refresh_token": self.refresh_token,
+            "access_expires_at": self.access_expires_at,
+        }

hh_applicant_tool/api/errors.py

@@ -37,15 +37,19 @@ class ApiError(Exception):
     def response_headers(self) -> CaseInsensitiveDict:
         return self._response.headers
 
-#     def __getattr__(self, name: str) -> Any:
-#         try:
-#             return self._raw[name]
-#         except KeyError as ex:
-#             raise AttributeError(name) from ex
+    #     def __getattr__(self, name: str) -> Any:
+    #         try:
+    #             return self._raw[name]
+    #         except KeyError as ex:
+    #             raise AttributeError(name) from ex
 
     def __str__(self) -> str:
         return str(self._raw)
 
+    @staticmethod
+    def is_limit_exceeded(data) -> bool:
+        return any(x["value"] == "limit_exceeded" for x in data.get("errors", []))
+
 
 class Redirect(ApiError):
     pass
@@ -56,9 +60,11 @@ class ClientError(ApiError):
 
 
 class BadRequest(ClientError):
-    @property
-    def limit_exceeded(self) -> bool:
-        return any(x["value"] == "limit_exceeded" for x in self._raw["errors"])
+    pass
+
+
+class LimitExceeded(ClientError):
+    pass
 
 
 class Forbidden(ClientError):

hh_applicant_tool/constants.py

@@ -1,12 +1,14 @@
-USER_AGENT_TEMPLATE = "Mozilla/5.0 (Linux; Android %s; %s) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/%s.0.0.0 Mobile Safari/537.36"
+# USER_AGENT_TEMPLATE = "Mozilla/5.0 (Linux; Android %s; %s) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/%s.0.0.0 Mobile Safari/537.36"
 
-ANDROID_CLIENT_ID = (
-    "HIOMIAS39CA9DICTA7JIO64LQKQJF5AGIK74G9ITJKLNEDAOH5FHS5G1JI7FOEGD"
-)
+ANDROID_CLIENT_ID = "HIOMIAS39CA9DICTA7JIO64LQKQJF5AGIK74G9ITJKLNEDAOH5FHS5G1JI7FOEGD"
 
 ANDROID_CLIENT_SECRET = (
     "V9M870DE342BGHFRUJ5FTCGCUA1482AN0DI8C5TFI9ULMA89H10N60NOP8I4JMVS"
 )
 
+# Используется для прямой авторизации. Этот способ мной не используется, так как
+# для отображения капчи все равно нужен webview.
+# K811HJNKQA8V1UN53I6PN1J1CMAD2L1M3LU6LPAU849BCT031KDSSM485FDPJ6UF
+
 # Кривой формат, который используют эти долбоебы
 INVALID_ISO8601_FORMAT = "%Y-%m-%dT%H:%M:%S%z"

hh_applicant_tool/jsonc.py

@@ -1,16 +1,19 @@
+# Unused
+"""Парсер JSON с комментариями"""
+
 import re
 import enum
 from dataclasses import dataclass
 import ast
 from typing import Any, Iterator
-from collections import OrderedDict
+# from collections import OrderedDict
 
 
 class TokenType(enum.Enum):
     WHITESPACE = r"\s+"
     COMMENT = r"//.*|/\*[\s\S]*?\*/"
     NUMBER = r"-?\d+(?:\.\d+)?"
-    STRING = r'"(?:\\"|[^"]+)*"'
+    STRING = r'"(?:\\.|[^"]+)*"'
     KEYWORD = r"null|true|false"
     OPEN_CURLY = r"\{"
     CLOSE_CURLY = r"\}"
@@ -42,7 +45,8 @@ class JSONCParser:
             lambda t: t.token_type not in [TokenType.COMMENT, TokenType.WHITESPACE],
             tokenize(s),
         )
-        self.next_token = None
+        self.token: Token
+        self.next_token: Token | None = None
         self.advance()
         result = self.parse_value()
         self.expect(TokenType.EOF)
@@ -91,6 +95,7 @@ class JSONCParser:
             raise SyntaxError(f"Unexpected token: {self.token.token_type.name}")
 
     def advance(self):
+        assert self.next_token is not None
         self.token, self.next_token = (
             self.next_token,
             next(self.token_it, Token(TokenType.EOF, "")),
@@ -98,7 +103,7 @@ class JSONCParser:
         # print(f"{self.token =}, {self.next_token =}")
 
     def match(self, token_type: TokenType) -> bool:
-        if self.next_token.token_type == token_type:
+        if self.next_token is not None and self.next_token.token_type == token_type:
             self.advance()
             return True
         return False
@@ -106,7 +111,7 @@ class JSONCParser:
     def expect(self, token_type: TokenType):
         if not self.match(token_type):
             raise SyntaxError(
-                f"Expected {token_type.name}, got {self.next_token.token_type.name}"
+                f"Expected {token_type.name}, got {self.next_token.token_type.name if self.next_token else '???'}"
             )
 
 

hh_applicant_tool/main.py

@@ -12,6 +12,8 @@ from typing import Literal, Sequence
 from .api import ApiClient
 from .color_log import ColorHandler
 from .utils import Config, get_config_path
+from .telemetry_client import TelemetryClient
+
 
 DEFAULT_CONFIG_PATH = (
     get_config_path() / (__package__ or "").replace("_", "-") / "config.json"
@@ -46,11 +48,12 @@ def get_proxies(args: Namespace) -> dict[Literal["http", "https"], str | None]:
     }
 
 
-def get_api(args: Namespace) -> ApiClient:
+def get_api_client(args: Namespace) -> ApiClient:
     token = args.config.get("token", {})
     api = ApiClient(
         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"],
         proxies=get_proxies(args),
@@ -134,7 +137,20 @@ class HHApplicantTool:
         logger.addHandler(handler)
         if args.run:
             try:
-                return args.run(args)
+                if not args.config["telemetry_client_id"]:
+                    import uuid
+
+                    args.config.save(telemetry_client_id=str(uuid.uuid4()))
+                api_client = get_api_client(args)
+                telemetry_client = TelemetryClient(
+                    telemetry_client_id=args.config["telemetry_client_id"],
+                    proxies=api_client.proxies.copy(),
+                )
+                # 0 or None = success
+                res = args.run(args, api_client, telemetry_client)
+                if (token := api_client.get_access_token()) != args.config["token"]:
+                    args.config.save(token=token)
+                return res
             except Exception as e:
                 logger.exception(e)
                 return 1

hh_applicant_tool/mixins.py

@@ -5,7 +5,7 @@ from .types import ApiListResponse
 class GetResumeIdMixin:
     def _get_resume_id(self) -> str:
         try:
-            resumes: ApiListResponse = self.api.get("/resumes/mine")
+            resumes: ApiListResponse = self.api_client.get("/resumes/mine")
             return resumes["items"][0]["id"]
         except (ApiError, KeyError, IndexError) as ex:
             raise Exception("Не могу получить идентификатор резюме") from ex

hh_applicant_tool/operations/apply_similar.py

@@ -4,19 +4,23 @@ import random
 import time
 from collections import defaultdict
 from datetime import datetime, timedelta, timezone
-from typing import TextIO, Tuple
+from typing import TextIO
 
+from ..api.errors import LimitExceeded
 from ..ai.blackbox import BlackboxChat, BlackboxError
-from ..api import ApiError, BadRequest
+from ..api import ApiError, ApiClient
 from ..main import BaseOperation
 from ..main import Namespace as BaseNamespace
-from ..main import get_api
 from ..mixins import GetResumeIdMixin
 from ..telemetry_client import TelemetryClient, TelemetryError
 from ..types import ApiListResponse, VacancyItem
-from ..utils import (fix_datetime, parse_interval, parse_invalid_datetime,
-                     random_text, truncate_string)
-from hh_applicant_tool.ai import blackbox
+from ..utils import (
+    fix_datetime,
+    parse_interval,
+    parse_invalid_datetime,
+    random_text,
+    truncate_string,
+)
 
 logger = logging.getLogger(__package__)
 
@@ -43,7 +47,7 @@ class Operation(BaseOperation, GetResumeIdMixin):
             "-L",
             "--message-list",
             help="Путь до файла, где хранятся сообщения для отклика на вакансии. Каждое сообщение — с новой строки.",
-            type=argparse.FileType('r', encoding='utf-8', errors='replace'),
+            type=argparse.FileType("r", encoding="utf-8", errors="replace"),
         )
         parser.add_argument(
             "-f",
@@ -103,7 +107,9 @@ class Operation(BaseOperation, GetResumeIdMixin):
             action=argparse.BooleanOptionalAction,
         )
 
-    def run(self, args: Namespace) -> None:
+    def run(
+        self, args: Namespace, api_client: ApiClient, telemetry_client: TelemetryClient
+    ) -> None:
         self.enable_telemetry = True
         if args.disable_telemetry:
             # print(
@@ -120,18 +126,17 @@ class Operation(BaseOperation, GetResumeIdMixin):
             #     logger.info("Спасибо за то что оставили телеметрию включенной!")
             self.enable_telemetry = False
 
-        self.api = get_api(args)
+        self.api_client = api_client
+        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.application_messages = self._get_application_messages(args.message_list)
         self.chat = None
 
         if config := args.config.get("blackbox"):
             self.chat = BlackboxChat(
                 session_id=config["session_id"],
                 chat_payload=config["chat_payload"],
-                proxies=self.api.proxies or {},
+                proxies=self.api_client.proxies or {},
             )
 
         self.pre_prompt = args.pre_prompt
@@ -145,13 +150,9 @@ class Operation(BaseOperation, GetResumeIdMixin):
         self.dry_run = args.dry_run
         self._apply_similar()
 
-    def _get_application_messages(
-        self, message_list: TextIO | None
-    ) -> list[str]:
+    def _get_application_messages(self, message_list: TextIO | None) -> list[str]:
         if message_list:
-            application_messages = list(
-                filter(None, map(str.strip, message_list))
-            )
+            application_messages = list(filter(None, map(str.strip, message_list)))
         else:
             application_messages = [
                 "{Меня заинтересовала|Мне понравилась} ваша вакансия %(vacancy_name)s",
@@ -160,7 +161,7 @@ class Operation(BaseOperation, GetResumeIdMixin):
         return application_messages
 
     def _apply_similar(self) -> None:
-        telemetry_client = TelemetryClient(proxies=self.api.proxies)
+        telemetry_client = self.telemetry_client
         telemetry_data = defaultdict(dict)
 
         vacancies = self._get_vacancies()
@@ -172,12 +173,8 @@ class Operation(BaseOperation, GetResumeIdMixin):
                     "name": vacancy.get("name"),
                     "type": vacancy.get("type", {}).get("id"),  # open/closed
                     "area": vacancy.get("area", {}).get("name"),  # город
-                    "salary": vacancy.get(
-                        "salary"
-                    ),  # from, to, currency, gross
-                    "direct_url": vacancy.get(
-                        "alternate_url"
-                    ),  # ссылка на вакансию
+                    "salary": vacancy.get("salary"),  # from, to, currency, gross
+                    "direct_url": vacancy.get("alternate_url"),  # ссылка на вакансию
                     "created_at": fix_datetime(
                         vacancy.get("created_at")
                     ),  # будем вычислять говно-вакансии, которые по полгода висят
@@ -194,7 +191,7 @@ class Operation(BaseOperation, GetResumeIdMixin):
                     # Остальное неинтересно
                 }
 
-        me = self.api.get("/me")
+        me = self.api_client.get("/me")
 
         basic_message_placeholders = {
             "first_name": me.get("first_name", ""),
@@ -210,9 +207,7 @@ class Operation(BaseOperation, GetResumeIdMixin):
             try:
                 message_placeholders = {
                     "vacancy_name": vacancy.get("name", ""),
-                    "employer_name": vacancy.get("employer", {}).get(
-                        "name", ""
-                    ),
+                    "employer_name": vacancy.get("employer", {}).get("name", ""),
                     **basic_message_placeholders,
                 }
 
@@ -250,7 +245,7 @@ class Operation(BaseOperation, GetResumeIdMixin):
                         > datetime.now(tz=timezone.utc)
                     )
                 ):
-                    employer = self.api.get(f"/employers/{employer_id}")
+                    employer = self.api_client.get(f"/employers/{employer_id}")
 
                     employer_data = {
                         "name": employer.get("name"),
@@ -275,9 +270,10 @@ class Operation(BaseOperation, GetResumeIdMixin):
                                     response["topic_url"],
                                 )
                             else:
-                                print(
-                                    "Создание темы для обсуждения работодателя добавлено в очередь..."
-                                )
+                                # print(
+                                #     "Создание темы для обсуждения работодателя добавлено в очередь..."
+                                # )
+                                ...
                             complained_employers.add(employer_id)
                         except TelemetryError as ex:
                             logger.error(ex)
@@ -304,9 +300,7 @@ class Operation(BaseOperation, GetResumeIdMixin):
                     "message": "",
                 }
 
-                if self.force_message or vacancy.get(
-                    "response_letter_required"
-                ):
+                if self.force_message or vacancy.get("response_letter_required"):
                     if self.chat:
                         try:
                             msg = self.pre_prompt + "\n\n"
@@ -318,9 +312,7 @@ class Operation(BaseOperation, GetResumeIdMixin):
                             continue
                     else:
                         msg = (
-                            random_text(
-                                random.choice(self.application_messages)
-                            )
+                            random_text(random.choice(self.application_messages))
                             % message_placeholders
                         )
 
@@ -341,7 +333,7 @@ class Operation(BaseOperation, GetResumeIdMixin):
                 )
                 time.sleep(interval)
 
-                res = self.api.post("/negotiations", params)
+                res = self.api_client.post("/negotiations", params)
                 assert res == {}
                 print(
                     "📨 Отправили отклик",
@@ -350,10 +342,11 @@ class Operation(BaseOperation, GetResumeIdMixin):
                     truncate_string(vacancy["name"]),
                     ")",
                 )
+            except LimitExceeded:
+                print("⚠️ Достигли лимита рассылки")
+                do_apply = False
             except ApiError as ex:
                 logger.error(ex)
-                if isinstance(ex, BadRequest) and ex.limit_exceeded:
-                    do_apply = False
 
         print("📝 Отклики на вакансии разосланы!")
 
@@ -384,7 +377,7 @@ class Operation(BaseOperation, GetResumeIdMixin):
             }
             if self.search:
                 params["text"] = self.search
-            res: ApiListResponse = self.api.get(
+            res: ApiListResponse = self.api_client.get(
                 f"/resumes/{self.resume_id}/similar_vacancies", params
             )
             rv.extend(res["items"])