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

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,14 @@ class ApiError(BadResponse):
     def response_headers(self) -> CaseInsensitiveDict:
         return self._response.headers
 
+    @property
+    def message(self) -> str:
+        return (
+            self._data.get("error_description")
+            or self._data.get("description")
+            or str(self._data)
+        )
+
     #     def __getattr__(self, name: str) -> Any:
     #         try:
     #             return self._raw[name]
@@ -49,11 +59,35 @@ 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 +110,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/api/user_agent.py

@@ -0,0 +1,17 @@
+import random
+import uuid
+
+
+def generate_android_useragent() -> str:
+    """Generates Android App User-Agent"""
+    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}, "
+        f"Android OS: {android} (UUID: {uuid.uuid4()})"
+    )

hh_applicant_tool/main.py

@@ -2,22 +2,34 @@ from __future__ import annotations
 
 import argparse
 import logging
+import os
+import sqlite3
 import sys
+from collections.abc import Sequence
+from functools import cached_property
 from importlib import import_module
+from itertools import count
 from os import getenv
 from pathlib import Path
 from pkgutil import iter_modules
-from typing import Literal, Sequence
+from typing import Any, Iterable
 
-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, android_user_agent, get_config_path
+import requests
+import urllib3
 
-DEFAULT_CONFIG_PATH = (
-    get_config_path() / (__package__ or "").replace("_", "-") / "config.json"
+from . import utils
+from .api import ApiClient, datatypes
+from .storage import StorageFacade
+from .utils.log import setup_logger
+from .utils.mixins import MegaTool
+
+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__)
 
@@ -25,15 +37,19 @@ logger = logging.getLogger(__package__)
 class BaseOperation:
     def setup_parser(self, parser: argparse.ArgumentParser) -> None: ...
 
-    def run(self, args: argparse.Namespace, api_client: ApiClient, telemetry_client: TelemetryClient) -> None | int:
+    def run(
+        self,
+        tool: HHApplicantTool,
+    ) -> None | int:
         raise NotImplementedError()
 
 
 OPERATIONS = "operations"
 
 
-class Namespace(argparse.Namespace):
-    config: Config
+class BaseNamespace(argparse.Namespace):
+    profile_id: str
+    config_dir: Path
     verbosity: int
     delay: float
     user_agent: str
@@ -41,44 +57,7 @@ class Namespace(argparse.Namespace):
     disable_telemetry: bool
 
 
-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:
-    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=config["user_agent"] or android_user_agent(),
-        proxies=get_proxies(args),
-    )
-    return api
-
-
-class HHApplicantTool:
+class HHApplicantTool(MegaTool):
     """Утилита для автоматизации действий соискателя на сайте hh.ru.
 
     Исходники и предложения: <https://github.com/s3rgeym/hh-applicant-tool>
@@ -92,63 +71,58 @@ class HHApplicantTool:
     ):
         pass
 
-    def create_parser(self) -> argparse.ArgumentParser:
+    def _create_parser(self) -> argparse.ArgumentParser:
         parser = argparse.ArgumentParser(
             description=self.__doc__,
             formatter_class=self.ArgumentFormatter,
         )
-        parser.add_argument(
-            "-c",
-            "--config",
-            help="Путь до файла конфигурации",
-            type=Config,
-            default=Config(DEFAULT_CONFIG_PATH),
-        )
         parser.add_argument(
             "-v",
             "--verbosity",
-            help="При использовании от одного и более раз увеличивает количество отладочной информации в выводе",
+            help="При использовании от одного и более раз увеличивает количество отладочной информации в выводе",  # noqa: E501
             action="count",
             default=0,
         )
+        parser.add_argument(
+            "-c",
+            "--config-dir",
+            "--config",
+            help="Путь до директории с конфигом",
+            type=Path,
+            default=DEFAULT_CONFIG_DIR,
+        )
+        parser.add_argument(
+            "--profile-id",
+            "--profile",
+            help="Используемый профиль — подкаталог в --config-dir",
+            default=DEFAULT_PROFILE_ID,
+        )
         parser.add_argument(
             "-d",
             "--delay",
             type=float,
-            default=0.334,
-            help="Задержка между запросами к API HH",
+            default=0.654,
+            help="Задержка между запросами к API HH по умолчанию",
         )
-        parser.add_argument("--user-agent", help="User-Agent для каждого запроса")
         parser.add_argument(
-            "--proxy-url", help="Прокси, используемый для запросов к API"
+            "--user-agent",
+            help="User-Agent для каждого запроса",
         )
         parser.add_argument(
-            "--disable-telemetry",
-            default=False,
-            action=argparse.BooleanOptionalAction,
-            help="Отключить телеметрию",
+            "--proxy-url",
+            help="Прокси, используемый для запросов и авторизации",
         )
         subparsers = parser.add_subparsers(help="commands")
         package_dir = Path(__file__).resolve().parent / OPERATIONS
         for _, module_name, _ in iter_modules([str(package_dir)]):
+            if module_name.startswith("_"):
+                continue
             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
-
+            kebab_name = module_name.replace("_", "-")
             op_parser = subparsers.add_parser(
                 kebab_name,
-                # Добавляем остальные варианты в псевдонимы
-                aliases=[camel_case_name, flat_name],
+                aliases=getattr(op, "__aliases__", []),
                 description=op.__doc__,
                 formatter_class=self.ArgumentFormatter,
             )
@@ -157,40 +131,187 @@ class HHApplicantTool:
         parser.set_defaults(run=None)
         return parser
 
-    def run(self, argv: Sequence[str] | None) -> None | int:
-        parser = self.create_parser()
-        args = parser.parse_args(argv, namespace=Namespace())
-        log_level = max(logging.DEBUG, logging.WARNING - args.verbosity * 10)
-        logger.setLevel(log_level)
-        handler = ColorHandler()
-        # [C] Critical Error Occurred
-        handler.setFormatter(logging.Formatter("[%(levelname).1s] %(message)s"))
-        logger.addHandler(handler)
-        if args.run:
+    def __init__(self, argv: Sequence[str] | None):
+        self._parse_args(argv)
+
+        # Создаем путь до конфига
+        self.config_path.mkdir(
+            parents=True,
+            exist_ok=True,
+        )
+
+    def _get_proxies(self) -> dict[str, str]:
+        proxy_url = self.args.proxy_url or self.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
+
+    @cached_property
+    def session(self) -> requests.Session:
+        urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+
+        session = requests.session()
+        session.verify = False
+
+        if proxies := self._get_proxies():
+            logger.info("Use proxies: %r", proxies)
+            session.proxies = proxies
+
+        return session
+
+    @property
+    def config_path(self) -> Path:
+        return (self.args.config_dir / self.args.profile_id).resolve()
+
+    @cached_property
+    def config(self) -> utils.Config:
+        return utils.Config(self.config_path / DEFAULT_CONFIG_FILENAME)
+
+    @cached_property
+    def log_file(self) -> Path:
+        return self.config_path / DEFAULT_LOG_FILENAME
+
+    @cached_property
+    def db_path(self) -> Path:
+        return self.config_path / DEFAULT_DATABASE_FILENAME
+
+    @cached_property
+    def db(self) -> sqlite3.Connection:
+        conn = sqlite3.connect(self.db_path)
+        return conn
+
+    @cached_property
+    def storage(self) -> StorageFacade:
+        return StorageFacade(self.db)
+
+    @cached_property
+    def api_client(self) -> ApiClient:
+        args = self.args
+        config = self.config
+        token = config.get("token", {})
+        api = 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.get("user_agent"),
+            session=self.session,
+        )
+        return api
+
+    def get_me(self) -> datatypes.User:
+        return self.api_client.get("/me")
+
+    def get_resumes(self) -> list[datatypes.Resume]:
+        return self.api_client.get("/resumes/mine")["items"]
+
+    def first_resume_id(self) -> str:
+        resumes = self.get_resumes()
+        return resumes[0]["id"]
+
+    def get_blacklisted(self) -> list[str]:
+        rv = []
+        for page in count():
+            r: datatypes.PaginatedItems[datatypes.EmployerShort] = (
+                self.api_client.get("/employers/blacklisted", page=page)
+            )
+            rv += [item["id"] for item in r["items"]]
+            if page + 1 >= r["pages"]:
+                break
+        return rv
+
+    def get_negotiations(
+        self, status: str = "active"
+    ) -> Iterable[datatypes.Negotiation]:
+        for page in count():
+            r: dict[str, Any] = self.api_client.get(
+                "/negotiations",
+                page=page,
+                per_page=100,
+                status=status,
+            )
+
+            items = r.get("items", [])
+
+            if not items:
+                break
+
+            yield from items
+
+            if page + 1 >= r.get("pages", 0):
+                break
+
+    def save_token(self) -> bool:
+        if self.api_client.access_token != self.config.get("token", {}).get(
+            "access_token"
+        ):
+            self.config.save(token=self.api_client.get_access_token())
+            return True
+        return False
+
+    def run(self) -> None | int:
+        verbosity_level = max(
+            logging.DEBUG,
+            logging.WARNING - self.args.verbosity * 10,
+        )
+
+        setup_logger(logger, verbosity_level, self.log_file)
+
+        if sys.platform == "win32":
+            utils.setup_terminal()
+
+        try:
+            if self.args.run:
+                try:
+                    res = self.args.run(self)
+                    if self.save_token():
+                        logger.info("Токен был обновлен.")
+                    return res
+                except KeyboardInterrupt:
+                    logger.warning("Выполнение прервано пользователем!")
+                    return 1
+                except sqlite3.Error as ex:
+                    logger.exception(ex)
+
+                    script_name = sys.argv[0].split(os.sep)[-1]
+
+                    logger.warning(
+                        f"Возможно база данных повреждена, попробуйте выполнить команду:\n\n"  # noqa: E501
+                        f"  {script_name} migrate-db"
+                    )
+                    return 1
+                except Exception as e:
+                    logger.exception(e)
+                    return 1
+            self._parser.print_help(file=sys.stderr)
+            return 2
+        finally:
             try:
-                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 KeyboardInterrupt:
-                logger.warning("Interrupted by user")
-                return 1
-            except Exception as e:
-                logger.exception(e, exc_info=log_level <= logging.DEBUG)
-                return 1
-        parser.print_help(file=sys.stderr)
-        return 2
+                self._check_system()
+            except Exception:
+                pass
+                # raise
+
+    def _parse_args(self, argv) -> None:
+        self._parser = self._create_parser()
+        self.args = self._parser.parse_args(argv, namespace=BaseNamespace())
 
 
 def main(argv: Sequence[str] | None = None) -> None | int:
-    return HHApplicantTool().run(argv)
+    return HHApplicantTool(argv).run()