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

hh_applicant_tool/__main__.py

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

hh_applicant_tool/ai/__init__.py

@@ -0,0 +1 @@
+from .openai import ChatOpenAI, OpenAIError

hh_applicant_tool/ai/openai.py

@@ -1,6 +1,5 @@
 import logging
-from dataclasses import dataclass, field
-from typing import ClassVar
+from dataclasses import KW_ONLY, dataclass, field
 
 import requests
 
@@ -9,43 +8,60 @@ from .base import AIError
 logger = logging.getLogger(__package__)
 
 
+DEFAULT_COMPLETION_ENDPOINT = "https://api.openai.com/v1/chat/completions"
+
+
 class OpenAIError(AIError):
     pass
 
 
 @dataclass
 class ChatOpenAI:
-    chat_endpoint: ClassVar[str] = "https://api.openai.com/v1/chat/completions"
-
     token: str
-    model: str
+    _: KW_ONLY
     system_prompt: str | None = None
+    timeout: float = 15.0
     temperature: float = 0.7
     max_completion_tokens: int = 1000
+    model: str | None = None
+    completion_endpoint: str = None
     session: requests.Session = field(default_factory=requests.Session)
 
-    def default_headers(self) -> dict[str, str]:
+    def __post_init__(self) -> None:
+        self.completion_endpoint = (
+            self.completion_endpoint or DEFAULT_COMPLETION_ENDPOINT
+        )
+
+    def _default_headers(self) -> dict[str, str]:
         return {
             "Authorization": f"Bearer {self.token}",
         }
 
     def send_message(self, message: str) -> str:
+        messages = []
+
+        # Добавляем системный промпт только если он не пустой и не None
+        if self.system_prompt:
+            messages.append({"role": "system", "content": self.system_prompt})
+
+        # Пользовательское сообщение всегда обязательно
+        messages.append({"role": "user", "content": message})
+
         payload = {
-            "model": self.model,
-            "messages": [
-                {"role": "system", "content": self.system_prompt},
-                {"role": "user", "content": message},
-            ],
+            "messages": messages,
             "temperature": self.temperature,
             "max_completion_tokens": self.max_completion_tokens,
         }
 
+        if self.model:
+            payload["model"] = self.model
+
         try:
             response = self.session.post(
-                self.chat_endpoint,
+                self.completion_endpoint,
                 json=payload,
-                headers=self.default_headers(),
-                timeout=30,
+                headers=self._default_headers(),
+                timeout=self.timeout,
             )
             response.raise_for_status()
 

hh_applicant_tool/api/__init__.py

@@ -1,3 +1,5 @@
 """See <https://github.com/hhru/api>"""
-from .client import *
-from .errors import *
+
+from .client import *  # noqa: F403
+from .datatypes import *  # noqa: F403
+from .errors import *  # noqa: F403

hh_applicant_tool/api/client.py

@@ -13,12 +13,20 @@ from urllib.parse import urlencode, urljoin
 import requests
 from requests import Session
 
-from ..datatypes import AccessToken
+from hh_applicant_tool.api.user_agent import generate_android_useragent
+
 from . import errors
+from .client_keys import (
+    ANDROID_CLIENT_ID,
+    ANDROID_CLIENT_SECRET,
+)
+from .datatypes import AccessToken
 
 __all__ = ("ApiClient", "OAuthClient")
 
-DEFAULT_DELAY = 0.334
+HH_API_URL = "https://api.hh.ru/"
+HH_OAUTH_URL = "https://hh.ru/oauth/"
+DEFAULT_DELAY = 0.345
 
 AllowedMethods = Literal["GET", "POST", "PUT", "DELETE"]
 T = TypeVar("T")
@@ -34,27 +42,29 @@ class BaseClient:
     _: dataclasses.KW_ONLY
     user_agent: str | None = None
     session: Session | None = None
-    delay: float = DEFAULT_DELAY
+    delay: float | None = None
     _previous_request_time: float = 0.0
 
     def __post_init__(self) -> None:
-        assert self.base_url.endswith("/"), "base_url must end with /"
-        self.lock = Lock()
+        assert self.base_url.endswith("/"), "base_url must ends with /"
+        self.delay = self.delay or DEFAULT_DELAY
+        self.user_agent = self.user_agent or generate_android_useragent()
+
         # 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}")
+
+        self.lock = Lock()
 
     @property
     def proxies(self):
         return self.session.proxies
 
-    def default_headers(self) -> dict[str, str]:
+    def _default_headers(self) -> dict[str, str]:
         return {
-            "user-agent": self.user_agent
-            or "Mozilla/5.0 (+https://github.com/s3rgeym/hh-applicant-tool)",
+            "user-agent": self.user_agent,
             "x-hh-app-active": "true",
         }
 
@@ -87,7 +97,7 @@ class BaseClient:
                 method,
                 url,
                 **payload,
-                headers=self.default_headers(),
+                headers=self._default_headers(),
                 allow_redirects=False,
             )
             try:
@@ -139,14 +149,19 @@ class BaseClient:
 
 @dataclass
 class OAuthClient(BaseClient):
-    client_id: str
-    client_secret: str
+    client_id: str | None = None
+    client_secret: str | None = None
     _: dataclasses.KW_ONLY
-    base_url: str = "https://hh.ru/oauth/"
+    base_url: str = HH_OAUTH_URL
     state: str = ""
     scope: str = ""
     redirect_uri: str = ""
 
+    def __post_init__(self) -> None:
+        super().__post_init__()
+        self.client_id = self.client_id or ANDROID_CLIENT_ID
+        self.client_secret = self.client_secret or ANDROID_CLIENT_SECRET
+
     @property
     def authorize_url(self) -> str:
         params = dict(
@@ -197,7 +212,7 @@ class ApiClient(BaseClient):
     _: dataclasses.KW_ONLY
     client_id: str | None = None
     client_secret: str | None = None
-    base_url: str = "https://api.hh.ru/"
+    base_url: str = HH_API_URL
 
     @property
     def is_access_expired(self) -> bool:
@@ -212,10 +227,10 @@ class ApiClient(BaseClient):
             session=self.session,
         )
 
-    def default_headers(
+    def _default_headers(
         self,
     ) -> dict[str, str]:
-        headers = super().default_headers()
+        headers = super()._default_headers()
         if not self.access_token:
             return headers
         # Это очень интересно, что access token'ы начинаются с USER, т.е. API может содержать какую-то уязвимость, связанную с этим

hh_applicant_tool/{constants.py → api/client_keys.py}

@@ -1,6 +1,6 @@
-# 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"

hh_applicant_tool/{datatypes.py → api/datatypes.py}

@@ -32,6 +32,8 @@ class PaginatedItems(TypedDict, Generic[Item]):
     arguments: Optional[Any]
     fixes: Optional[Any]
     suggests: Optional[Any]
+    # Это выглядит как глюк. Я нейронке скармливал выхлоп апи, а она писала эти
+    # типы
     alternate_url: str
 
 

hh_applicant_tool/api/errors.py

@@ -46,7 +46,11 @@ class ApiError(BadResponse):
 
     @property
     def message(self) -> str:
-        return self._data.get("description") or str(self._data)
+        return (
+            self._data.get("error_description")
+            or self._data.get("description")
+            or str(self._data)
+        )
 
     #     def __getattr__(self, name: str) -> Any:
     #         try:
@@ -62,7 +66,9 @@ class ApiError(BadResponse):
         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:
+    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)

hh_applicant_tool/{utils → api}/user_agent.py

@@ -2,7 +2,7 @@ import random
 import uuid
 
 
-def hh_android_useragent() -> str:
+def generate_android_useragent() -> str:
     """Generates Android App User-Agent"""
     devices = (
         "23053RN02A, 23053RN02Y, 23053RN02I, 23053RN02L, 23077RABDC".split(", ")

hh_applicant_tool/main.py

@@ -17,9 +17,7 @@ from typing import Any, Iterable
 import requests
 import urllib3
 
-from . import datatypes, utils
-from .api import ApiClient
-from .constants import ANDROID_CLIENT_ID, ANDROID_CLIENT_SECRET
+from . import ai, api, utils
 from .storage import StorageFacade
 from .utils.log import setup_logger
 from .utils.mixins import MegaTool
@@ -30,7 +28,6 @@ DEFAULT_CONFIG_DIR = utils.get_config_path() / (__package__ or "").replace(
 DEFAULT_CONFIG_FILENAME = "config.json"
 DEFAULT_LOG_FILENAME = "log.txt"
 DEFAULT_DATABASE_FILENAME = "data"
-DEFAULT_PROFILE_ID = "."
 
 logger = logging.getLogger(__package__)
 
@@ -55,7 +52,6 @@ class BaseNamespace(argparse.Namespace):
     delay: float
     user_agent: str
     proxy_url: str
-    disable_telemetry: bool
 
 
 class HHApplicantTool(MegaTool):
@@ -90,19 +86,18 @@ class HHApplicantTool(MegaTool):
             "--config",
             help="Путь до директории с конфигом",
             type=Path,
-            default=DEFAULT_CONFIG_DIR,
+            default=None,
         )
         parser.add_argument(
             "--profile-id",
             "--profile",
-            help="Используемый профиль — подкаталог в --config-dir",
-            default=DEFAULT_PROFILE_ID,
+            help="Используемый профиль — подкаталог в --config-dir. Так же можно передать через переменную окружения HH_PROFILE_ID.",
         )
         parser.add_argument(
             "-d",
+            "--api-delay",
             "--delay",
             type=float,
-            default=0.654,
             help="Задержка между запросами к API HH по умолчанию",
         )
         parser.add_argument(
@@ -169,14 +164,20 @@ class HHApplicantTool(MegaTool):
         session.verify = False
 
         if proxies := self._get_proxies():
-            logger.info("Use proxies: %r", proxies)
+            logger.info("Use proxies for requests: %r", proxies)
             session.proxies = proxies
 
         return session
 
-    @property
+    @cached_property
     def config_path(self) -> Path:
-        return (self.args.config_dir / self.args.profile_id).resolve()
+        return (
+            (
+                self.args.config_dir
+                or Path(getenv("CONFIG_DIR", DEFAULT_CONFIG_DIR))
+            )
+            / (self.args.profile_id or getenv("HH_PROFILE_ID", "."))
+        ).resolve()
 
     @cached_property
     def config(self) -> utils.Config:
@@ -200,37 +201,35 @@ class HHApplicantTool(MegaTool):
         return StorageFacade(self.db)
 
     @cached_property
-    def api_client(self) -> ApiClient:
+    def api_client(self) -> api.client.ApiClient:
         args = self.args
         config = self.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),
+        return api.client.ApiClient(
+            client_id=config.get("client_id"),
+            client_secret=config.get("client_id"),
             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=config["user_agent"] or utils.hh_android_useragent(),
+            delay=args.api_delay or config.get("api_delay"),
+            user_agent=args.user_agent or config.get("user_agent"),
             session=self.session,
         )
-        return api
 
-    def get_me(self) -> datatypes.User:
+    def get_me(self) -> api.datatypes.User:
         return self.api_client.get("/me")
 
-    def get_resumes(self) -> datatypes.PaginatedItems[datatypes.Resume]:
-        return self.api_client.get("/resumes/mine")
+    def get_resumes(self) -> list[api.datatypes.Resume]:
+        return self.api_client.get("/resumes/mine")["items"]
 
-    def first_resume_id(self):
-        resumes = self.api_client.get("/resumes/mine")
-        assert len(resumes["items"]), "Empty resume list"
-        return resumes["items"][0]["id"]
+    def first_resume_id(self) -> str:
+        resume = self.get_resumes()[0]
+        return resume["id"]
 
     def get_blacklisted(self) -> list[str]:
         rv = []
         for page in count():
-            r: datatypes.PaginatedItems[datatypes.EmployerShort] = (
+            r: api.datatypes.PaginatedItems[api.datatypes.EmployerShort] = (
                 self.api_client.get("/employers/blacklisted", page=page)
             )
             rv += [item["id"] for item in r["items"]]
@@ -240,7 +239,7 @@ class HHApplicantTool(MegaTool):
 
     def get_negotiations(
         self, status: str = "active"
-    ) -> Iterable[datatypes.Negotiation]:
+    ) -> Iterable[api.datatypes.Negotiation]:
         for page in count():
             r: dict[str, Any] = self.api_client.get(
                 "/negotiations",
@@ -259,6 +258,8 @@ class HHApplicantTool(MegaTool):
             if page + 1 >= r.get("pages", 0):
                 break
 
+    # TODO: добавить еще методов или те удалить?
+
     def save_token(self) -> bool:
         if self.api_client.access_token != self.config.get("token", {}).get(
             "access_token"
@@ -267,6 +268,20 @@ class HHApplicantTool(MegaTool):
             return True
         return False
 
+    def get_openai_chat(self, system_prompt: str) -> ai.ChatOpenAI:
+        c = self.config.get("openai", {})
+        if not (token := c.get("token")):
+            raise ValueError("Токен для OpenAI не задан")
+        return ai.ChatOpenAI(
+            token=token,
+            model=c.get("model"),
+            temperature=c.get("temperature", 0.7),
+            max_completion_tokens=c.get("max_completion_tokens", 1000),
+            system_prompt=system_prompt,
+            completion_endpoint=c.get("completion_endpoint"),
+            session=self.session,
+        )
+
     def run(self) -> None | int:
         verbosity_level = max(
             logging.DEBUG,
@@ -275,19 +290,25 @@ class HHApplicantTool(MegaTool):
 
         setup_logger(logger, verbosity_level, self.log_file)
 
-        if sys.platform == "win32":
-            utils.setup_terminal()
+        logger.debug("Путь до профиля: %s", self.config_path)
+
+        utils.setup_terminal()
 
         try:
             if self.args.run:
                 try:
-                    res = self.args.run(self)
-                    if self.save_token():
-                        logger.info("Токен был обновлен.")
-                    return res
+                    return self.args.run(self)
                 except KeyboardInterrupt:
                     logger.warning("Выполнение прервано пользователем!")
-                    return 1
+                except api.errors.CaptchaRequired as ex:
+                    logger.error(f"Требуется ввод капчи: {ex.captcha_url}")
+                except api.errors.InternalServerError:
+                    logger.error(
+                        "Сервер HH.RU не смог обработать запрос из-за высокой"
+                        " нагрузки или по иной причине"
+                    )
+                except api.errors.Forbidden:
+                    logger.error("Требуется авторизация")
                 except sqlite3.Error as ex:
                     logger.exception(ex)
 
@@ -297,17 +318,21 @@ class HHApplicantTool(MegaTool):
                         f"Возможно база данных повреждена, попробуйте выполнить команду:\n\n"  # noqa: E501
                         f"  {script_name} migrate-db"
                     )
-                    return 1
                 except Exception as e:
                     logger.exception(e)
-                    return 1
+                finally:
+                    # Токен мог автоматически обновиться
+                    if self.save_token():
+                        logger.info("Токен был сохранен после обновления.")
+                return 1
             self._parser.print_help(file=sys.stderr)
             return 2
         finally:
             try:
-                self.check_system()
+                self._check_system()
             except Exception:
                 pass
+                # raise
 
     def _parse_args(self, argv) -> None:
         self._parser = self._create_parser()