hh-applicant-tool 0.7.10__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,30 +1,28 @@
 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] | 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()
+    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 {
@@ -32,21 +30,14 @@ class OpenAIChat:
         }
 
     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:
@@ -54,18 +45,17 @@ class OpenAIChat:
                 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'])
-            
+            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(str(ex)) from ex
+            raise OpenAIError(f"Network error: {ex}") from ex

hh_applicant_tool/api/client.py

@@ -7,21 +7,24 @@ import time
 from dataclasses import dataclass
 from functools import cached_property
 from threading import Lock
-from typing import Any, Literal
-from urllib.parse import urlencode
+from typing import Any, Literal, TypeVar
+from urllib.parse import urlencode, urljoin
 
 import requests
-from requests import Response, Session
+from requests import Session
 
-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
@@ -30,39 +33,41 @@ class BaseClient:
     base_url: str
     _: dataclasses.KW_ONLY
     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:
+            logger.debug("create new session")
             self.session = requests.session()
-        if self.proxies:
-            logger.debug(f"client proxies: {self.proxies}")
+        # if self.proxies:
+        #     logger.debug(f"client proxies: {self.proxies}")
+
+    @property
+    def proxies(self):
+        return self.session.proxies
 
     def default_headers(self) -> dict[str, str]:
         return {
-            "user-agent": self.user_agent or "Mozilla/5.0",
+            "user-agent": self.user_agent
+            or "Mozilla/5.0 (+https://github.com/s3rgeym/hh-applicant-tool)",
             "x-hh-app-active": "true",
         }
-    
-    def additional_headers(
-        self,
-    ) -> dict[str, str]:
-        return {}
 
     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)
@@ -71,20 +76,18 @@ 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}
-            headers = self.default_headers() | self.additional_headers()
-            logger.debug(f"request info: {method = }, {url = }, {headers = }, params = {repr(params)[:255]}")
+            # logger.debug(f"request info: {method = }, {url = }, {headers = }, params = {repr(params)[:255]}")
             response = self.session.request(
                 method,
                 url,
                 **payload,
-                headers=headers,
-                proxies=self.proxies,
+                headers=self.default_headers(),
                 allow_redirects=False,
             )
             try:
@@ -102,55 +105,36 @@ class BaseClient:
                     ) from ex
             finally:
                 log_url = url
-                if not has_body and params:
-                    log_url += "?" + urlencode(params)
+                if params and not has_body:
+                    encoded_params = urlencode(params)
+                    log_url += ("?", "&")["?" in url] + encoded_params
                 logger.debug(
-                    "%s %s: %d",
+                    "%d %s %.1000s",
+                    response.status_code,
                     method,
                     log_url,
-                    response.status_code,
                 )
-                self.previous_request_time = time.monotonic()
-        self.raise_for_status(response, rv)
+                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
@@ -158,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 = ""
@@ -225,30 +209,32 @@ class ApiClient(BaseClient):
             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(
+    def default_headers(
         self,
     ) -> dict[str, str]:
+        headers = super().default_headers()
         if not self.access_token:
-            return {}
+            return headers
         # Это очень интересно, что access token'ы начинаются с USER, т.е. API может содержать какую-то уязвимость, связанную с этим
         assert self.access_token.startswith("USER")
-        return {"authorization": f"Bearer {self.access_token}"}
+        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()

hh_applicant_tool/api/errors.py

@@ -1,5 +1,7 @@
-# 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
@@ -24,11 +26,11 @@ class BadResponse(Exception):
 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:
@@ -42,6 +44,10 @@ class ApiError(BadResponse):
     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]
@@ -49,11 +55,33 @@ class ApiError(BadResponse):
     #             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):
@@ -76,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"