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

hh_applicant_tool/__init__.py

@@ -0,0 +1 @@
+from .main import HHApplicantTool

hh_applicant_tool/__main__.py

@@ -1,6 +1,6 @@
 import sys
 
-from .main import main
+from .hh_applicant import main
 
 if __name__ == "__main__":
     sys.exit(main())

hh_applicant_tool/ai/base.py

@@ -0,0 +1,2 @@
+class AIError(Exception):
+    pass

hh_applicant_tool/ai/openai.py

@@ -1,67 +1,61 @@
 import logging
+from dataclasses import dataclass, field
+from typing import ClassVar
 
 import requests
 
+from .base import AIError
+
 logger = logging.getLogger(__package__)
 
 
-class OpenAIError(Exception):
+class OpenAIError(AIError):
     pass
 
 
-class OpenAIChat:
-    chat_endpoint: str = "https://api.openai.com/v1/chat/completions"
+@dataclass
+class ChatOpenAI:
+    chat_endpoint: ClassVar[str] = "https://api.openai.com/v1/chat/completions"
 
-    def __init__(
-        self,
-        token: str,
-        model: str,
-        system_prompt: str,
-        proxies: dict[str, str] = {}
-    ):
-        self.token = token
-        self.model = model
-        self.system_prompt = system_prompt
-        self.proxies = proxies
+    token: str
+    model: str
+    system_prompt: str | None = None
+    temperature: float = 0.7
+    max_completion_tokens: int = 1000
+    session: requests.Session = field(default_factory=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:
-
         payload = {
             "model": self.model,
             "messages": [
-                {
-                    "role": "system",
-                    "content": self.system_prompt
-                },
-                {
-                    "role": "user",
-                    "content": message
-                }
+                {"role": "system", "content": self.system_prompt},
+                {"role": "user", "content": message},
             ],
-            "temperature": 0.7,
-            "max_completion_tokens": 1000
+            "temperature": self.temperature,
+            "max_completion_tokens": self.max_completion_tokens,
         }
 
         try:
-            response = requests.post(
+            response = self.session.post(
                 self.chat_endpoint,
                 json=payload,
                 headers=self.default_headers(),
-                proxies=self.proxies,
-                timeout=30
+                timeout=30,
             )
             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(f"Network error: {ex}") from ex

hh_applicant_tool/api/client.py

@@ -3,31 +3,28 @@ from __future__ import annotations
 import dataclasses
 import json
 import logging
-import uuid
 import time
 from dataclasses import dataclass
-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
+from threading import Lock
+from typing import Any, Literal, TypeVar
+from urllib.parse import urlencode, urljoin
+
 import requests
-from requests import Response, Session
+from requests import Session
 
-from ..constants import (
-    ANDROID_CLIENT_ID,
-    ANDROID_CLIENT_SECRET,
-)
-from ..types import AccessToken
+from ..datatypes import AccessToken
 from . import errors
 
 __all__ = ("ApiClient", "OAuthClient")
 
-logger = logging.getLogger(__package__)
+DEFAULT_DELAY = 0.334
 
+AllowedMethods = Literal["GET", "POST", "PUT", "DELETE"]
+T = TypeVar("T")
 
-ALLOWED_METHODS = Literal["GET", "POST", "PUT", "DELETE"]
+
+logger = logging.getLogger(__package__)
 
 
 # Thread-safe
@@ -35,51 +32,42 @@ 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
-    previous_request_time: float = 0.0
-    delay: float = 0.334
+    delay: float = DEFAULT_DELAY
+    _previous_request_time: float = 0.0
 
     def __post_init__(self) -> None:
+        assert self.base_url.endswith("/"), "base_url must end with /"
         self.lock = Lock()
+        # logger.debug(f"user agent: {self.user_agent}")
         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)
+            logger.debug("create new session")
+            self.session = requests.session()
+        # if self.proxies:
+        #     logger.debug(f"client proxies: {self.proxies}")
 
-    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()})"
+    @property
+    def proxies(self):
+        return self.session.proxies
 
-    def additional_headers(
-        self,
-    ) -> dict[str, str]:
-        return {}
+    def default_headers(self) -> dict[str, str]:
+        return {
+            "user-agent": self.user_agent
+            or "Mozilla/5.0 (+https://github.com/s3rgeym/hh-applicant-tool)",
+            "x-hh-app-active": "true",
+        }
 
     def request(
         self,
-        method: ALLOWED_METHODS,
+        method: AllowedMethods,
         endpoint: str,
         params: dict[str, Any] | None = None,
         delay: float | None = None,
         **kwargs: Any,
-    ) -> dict:
+    ) -> T:
         # Не знаю насколько это "правильно"
-        assert method in ALLOWED_METHODS.__args__
+        assert method in AllowedMethods.__args__
         params = dict(params or {})
         params.update(kwargs)
         url = self.resolve_url(endpoint)
@@ -88,76 +76,65 @@ class BaseClient:
             if (
                 delay := (self.delay if delay is None else delay)
                 - time.monotonic()
-                + self.previous_request_time
+                + self._previous_request_time
             ) > 0:
                 logger.debug("wait %fs before request", delay)
                 time.sleep(delay)
             has_body = method in ["POST", "PUT"]
             payload = {"data" if has_body else "params": params}
+            # logger.debug(f"request info: {method = }, {url = }, {headers = }, params = {repr(params)[:255]}")
             response = self.session.request(
                 method,
                 url,
                 **payload,
-                proxies=self.proxies,
+                headers=self.default_headers(),
                 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 params and not has_body:
+                    encoded_params = urlencode(params)
+                    log_url += ("?", "&")["?" in url] + encoded_params
                 logger.debug(
-                    "%d %-6s %s",
+                    "%d %s %.1000s",
                     response.status_code,
                     method,
-                    url + ("?" + urlencode(params) if not has_body and params else ""),
+                    log_url,
                 )
-                self.previous_request_time = time.monotonic()
-        self.raise_for_status(response, rv)
-        assert 300 > response.status_code >= 200
+                self._previous_request_time = time.monotonic()
+        errors.ApiError.raise_for_status(response, rv)
+        assert 300 > response.status_code >= 200, (
+            f"Unexpected status code for {method} {url}: {response.status_code}"
+        )
         return rv
 
-    def get(self, *args, **kwargs):
+    def get(self, *args, **kwargs) -> T:
         return self.request("GET", *args, **kwargs)
 
-    def post(self, *args, **kwargs):
+    def post(self, *args, **kwargs) -> T:
         return self.request("POST", *args, **kwargs)
 
-    def put(self, *args, **kwargs):
+    def put(self, *args, **kwargs) -> T:
         return self.request("PUT", *args, **kwargs)
 
-    def delete(self, *args, **kwargs):
+    def delete(self, *args, **kwargs) -> T:
         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('/')}"
-
-    @staticmethod
-    def raise_for_status(response: Response, data: dict) -> None:
-        match response.status_code:
-            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)
-            case 404:
-                raise errors.ResourceNotFound(response, data)
-            case status if 500 > status >= 400:
-                raise errors.ClientError(response, data)
-            case 502:
-                raise errors.BadGateway(response, data)
-            case status if status >= 500:
-                raise errors.InternalServerError(response, data)
+        return urljoin(self.base_url, url.lstrip("/"))
 
 
 @dataclass
@@ -165,7 +142,7 @@ class OAuthClient(BaseClient):
     client_id: str
     client_secret: str
     _: dataclasses.KW_ONLY
-    base_url: str = "https://hh.ru/oauth"
+    base_url: str = "https://hh.ru/oauth/"
     state: str = ""
     scope: str = ""
     redirect_uri: str = ""
@@ -202,9 +179,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,43 +194,47 @@ 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,
             session=self.session,
         )
 
-    def additional_headers(
+    def default_headers(
         self,
     ) -> dict[str, str]:
-        return (
-            {"authorization": f"Bearer {self.access_token}"}
-            if self.access_token
-            else {}
-        )
+        headers = super().default_headers()
+        if not self.access_token:
+            return headers
+        # Это очень интересно, что access token'ы начинаются с USER, т.е. API может содержать какую-то уязвимость, связанную с этим
+        assert self.access_token.startswith("USER")
+        return headers | {"authorization": f"Bearer {self.access_token}"}
 
     # Реализовано автоматическое обновление токена
     def request(
         self,
-        method: ALLOWED_METHODS,
+        method: AllowedMethods,
         endpoint: str,
         params: dict[str, Any] | None = None,
         delay: float | None = None,
         **kwargs: Any,
-    ) -> dict:
+    ) -> T:
         def do_request():
-            return BaseClient.request(self, method, endpoint, params, delay, **kwargs)
+            return BaseClient.request(
+                self, method, endpoint, params, delay, **kwargs
+            )
 
         try:
             return do_request()
@@ -258,14 +242,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

@@ -1,10 +1,13 @@
-# from copy import deepcopy
-from typing import Any
+from __future__ import annotations
+
+from functools import cached_property
+from typing import Any, Type
 
 from requests import Request, Response
 from requests.adapters import CaseInsensitiveDict
 
 __all__ = (
+    "BadResponse",
     "ApiError",
     "BadGateway",
     "BadRequest",
@@ -16,14 +19,18 @@ __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
+        self._data = data
 
     @property
     def data(self) -> dict:
-        return self._raw
+        return self._data
 
     @property
     def request(self) -> Request:
@@ -37,6 +44,10 @@ class ApiError(Exception):
     def response_headers(self) -> CaseInsensitiveDict:
         return self._response.headers
 
+    @property
+    def message(self) -> str:
+        return self._data.get("description") or str(self._data)
+
     #     def __getattr__(self, name: str) -> Any:
     #         try:
     #             return self._raw[name]
@@ -44,11 +55,33 @@ class ApiError(Exception):
     #             raise AttributeError(name) from ex
 
     def __str__(self) -> str:
-        return str(self._raw)
+        return self.message
 
     @staticmethod
-    def is_limit_exceeded(data) -> bool:
-        return any(x["value"] == "limit_exceeded" for x in data.get("errors", []))
+    def has_error_value(value: str, data: dict) -> bool:
+        return any(v.get("value") == value for v in data.get("errors", []))
+
+    @classmethod
+    def raise_for_status(cls: Type[ApiError], response: Response, data: dict) -> None:
+        match response.status_code:
+            case status if 300 <= status <= 308:
+                raise Redirect(response, data)
+            case 400:
+                if cls.has_error_value("limit_exceeded", data):
+                    raise LimitExceeded(response, data)
+                raise BadRequest(response, data)
+            case 403:
+                if cls.has_error_value("captcha_required", data):
+                    raise CaptchaRequired(response, data)
+                raise Forbidden(response, data)
+            case 404:
+                raise ResourceNotFound(response, data)
+            case status if 500 > status >= 400:
+                raise ClientError(response, data)
+            case 502:
+                raise BadGateway(response, data)
+            case status if status >= 500:
+                raise InternalServerError(response, data)
 
 
 class Redirect(ApiError):
@@ -71,6 +104,22 @@ class Forbidden(ClientError):
     pass
 
 
+class CaptchaRequired(ClientError):
+    @cached_property
+    def captcha_url(self) -> str:
+        return next(
+            filter(
+                lambda v: v["value"] == "captcha_required",
+                self._data["errors"],
+            ),
+            {},
+        ).get("captcha_url")
+
+    @property
+    def message(self) -> str:
+        return f"Captcha required: {self.captcha_url}"
+
+
 class ResourceNotFound(ClientError):
     pass
 

hh_applicant_tool/constants.py

@@ -9,6 +9,3 @@ ANDROID_CLIENT_SECRET = (
 # Используется для прямой авторизации. Этот способ мной не используется, так как
 # для отображения капчи все равно нужен webview.
 # K811HJNKQA8V1UN53I6PN1J1CMAD2L1M3LU6LPAU849BCT031KDSSM485FDPJ6UF
-
-# Кривой формат, который используют эти долбоебы
-INVALID_ISO8601_FORMAT = "%Y-%m-%dT%H:%M:%S%z"