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

hh_applicant_tool/datatypes.py

@@ -0,0 +1,291 @@
+from __future__ import annotations
+
+from typing import Any, Generic, List, Literal, Optional, TypedDict, TypeVar
+
+NegotiationStateId = Literal[
+    "discard",  # отказ
+    "interview",  # собес
+    "response",  # отклик
+    "invitation",  # приглашение
+    "hired",  # выход на работу
+]
+
+
+class AccessToken(TypedDict):
+    access_token: str
+    refresh_token: str
+    expires_in: int
+    token_type: Literal["bearer"]
+
+
+Item = TypeVar("T")
+
+
+class PaginatedItems(TypedDict, Generic[Item]):
+    items: list[Item]
+    found: int
+    page: int
+    pages: int
+    per_page: int
+    # Это не все поля
+    clusters: Optional[Any]
+    arguments: Optional[Any]
+    fixes: Optional[Any]
+    suggests: Optional[Any]
+    alternate_url: str
+
+
+class IdName(TypedDict):
+    id: str
+    name: str
+
+
+class Snippet(TypedDict):
+    requirement: Optional[str]
+    responsibility: Optional[str]
+
+
+class ManagerActivity(TypedDict):
+    last_activity_at: str
+
+
+Salary = TypedDict(
+    "Salary",
+    {
+        "from": Optional[int],
+        "to": Optional[int],
+        "currency": str,
+        "gross": bool,
+    },
+)
+
+SalaryRange = TypedDict(
+    "SalaryRange",
+    {
+        "from": Optional[int],
+        "to": Optional[int],
+        "currency": str,
+        "gross": bool,
+        "mode": IdName,
+        "frequency": IdName,
+    },
+)
+
+
+LogoUrls = TypedDict(
+    "LogoUrls",
+    {
+        "original": str,
+        "90": str,
+        "240": str,
+    },
+)
+
+
+class EmployerShort(TypedDict):
+    id: str
+    name: str
+    url: str
+    alternate_url: str
+    logo_urls: Optional[LogoUrls]
+    vacancies_url: str
+    accredited_it_employer: bool
+    trusted: bool
+
+
+class SearchEmployer(EmployerShort):
+    country_id: Optional[int]
+
+
+class NegotiationEmployer(EmployerShort):
+    pass
+
+
+class VacancyShort(TypedDict):
+    id: str
+    premium: bool
+    name: str
+    department: Optional[dict]
+    has_test: bool
+    # HH API fields
+    response_letter_required: bool
+    area: IdName
+    salary: Optional[Salary]
+    salary_range: Optional[SalaryRange]
+    type: IdName
+    address: Optional[dict]
+    response_url: Optional[str]
+    sort_point_distance: Optional[float]
+    published_at: str
+    created_at: str
+    archived: bool
+    apply_alternate_url: str
+    show_contacts: bool
+    benefits: List[Any]
+    insider_interview: Optional[dict]
+    url: str
+    alternate_url: str
+    professional_roles: List[IdName]
+
+
+class NegotiationVacancy(VacancyShort):
+    employer: NegotiationEmployer
+    show_logo_in_search: Optional[bool]
+
+
+class SearchVacancy(VacancyShort):
+    employer: SearchEmployer
+    relations: List[Any]
+    experimental_modes: List[str]
+    manager_activity: Optional[ManagerActivity]
+    snippet: Snippet
+    contacts: Optional[dict]
+    schedule: IdName
+    working_days: List[Any]
+    working_time_intervals: List[Any]
+    working_time_modes: List[Any]
+    accept_temporary: bool
+    fly_in_fly_out_duration: List[Any]
+    work_format: List[IdName]
+    working_hours: List[IdName]
+    work_schedule_by_days: List[IdName]
+    accept_labor_contract: bool
+    civil_law_contracts: List[Any]
+    night_shifts: bool
+    accept_incomplete_resumes: bool
+    experience: IdName
+    employment: IdName
+    employment_form: IdName
+    internship: bool
+    adv_response_url: Optional[str]
+    is_adv_vacancy: bool
+    adv_context: Optional[dict]
+    allow_chat_with_manager: bool
+
+
+class Phone(TypedDict):
+    country: str
+    city: str
+    number: str
+    formatted: str
+    comment: Optional[str]
+
+
+class ContactData(TypedDict):
+    name: Optional[str]
+    email: Optional[str]
+    phones: List[Phone]
+    call_tracking_enabled: bool
+
+
+class ResumeShort(TypedDict):
+    id: str
+    title: str
+    url: str
+    alternate_url: str
+
+
+class ResumeCounters(TypedDict):
+    total_views: int
+    new_views: int
+    invitations: int
+    new_invitations: int
+
+
+class Resume(ResumeShort):
+    status: IdName
+    created_at: str
+    updated_at: str
+    can_publish_or_update: bool
+    counters: ResumeCounters
+
+
+class UserCounters(TypedDict):
+    resumes_count: int
+    new_resume_views: int
+    unread_negotiations: int
+    # ... and more
+
+
+class User(TypedDict):
+    id: int
+    first_name: str
+    last_name: str
+    middle_name: Optional[str]
+    email: Optional[str]
+    phone: Optional[str]
+    is_applicant: bool
+    is_employer: bool
+    is_admin: bool
+    is_anonymous: bool
+    is_application: bool
+    counters: UserCounters
+    # ... and more
+
+
+class Message(TypedDict):
+    id: str
+    text: str
+    author: dict  # Could be more specific, e.g. Participant(TypedDict)
+    created_at: str
+    viewed_by_opponent: bool
+
+
+class Counters(TypedDict):
+    messages: int
+    unread_messages: int
+
+
+class ChatStates(TypedDict):
+    # response_reminder_state: {"allowed": bool}
+    response_reminder_state: dict[str, bool]
+
+
+class NegotiaionState(IdName):
+    id: NegotiationStateId
+
+
+class Negotiation(TypedDict):
+    id: str
+    state: IdName
+    created_at: str
+    updated_at: str
+    resume: ResumeShort
+    viewed_by_opponent: bool
+    has_updates: bool
+    messages_url: str
+    url: str
+    counters: Counters
+    chat_states: ChatStates
+    source: str
+    chat_id: int
+    messaging_status: str
+    decline_allowed: bool
+    read: bool
+    has_new_messages: bool
+    applicant_question_state: bool
+    hidden: bool
+    vacancy: NegotiationVacancy
+    tags: List[Any]
+
+
+class EmployerApplicantServices(TypedDict):
+    target_employer: dict[str, int]
+
+
+class Employer(EmployerShort):
+    has_divisions: bool
+    type: str
+    description: Optional[str]
+    site_url: str
+    relations: List[Any]
+    area: IdName
+    country_code: str
+    industries: List[Any]
+    is_identified_by_esia: bool
+    badges: List[Any]
+    branded_description: Optional[str]
+    branding: Optional[dict]
+    insider_interviews: List[Any]
+    open_vacancies: int
+    applicant_services: EmployerApplicantServices

hh_applicant_tool/main.py

@@ -2,21 +2,35 @@ 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
 
+import requests
+import urllib3
+
+from . import datatypes, utils
 from .api import ApiClient
-from .color_log import ColorHandler
-from .telemetry_client import TelemetryClient
-from .utils import Config, get_config_path
+from .constants import ANDROID_CLIENT_ID, ANDROID_CLIENT_SECRET
+from .storage import StorageFacade
+from .utils.log import setup_logger
+from .utils.mixins import MegaTool
 
-DEFAULT_CONFIG_PATH = (
-    get_config_path() / (__package__ or "").replace("_", "-") / "config.json"
+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__)
 
@@ -24,15 +38,19 @@ logger = logging.getLogger(__package__)
 class BaseOperation:
     def setup_parser(self, parser: argparse.ArgumentParser) -> None: ...
 
-    def run(self, args: argparse.Namespace) -> 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
@@ -40,32 +58,12 @@ class Namespace(argparse.Namespace):
     disable_telemetry: bool
 
 
-def get_proxies(args: Namespace) -> dict[Literal["http", "https"], str | None]:
-    return {
-        "http": args.config["proxy_url"] or getenv("HTTP_PROXY"),
-        "https": args.config["proxy_url"] or getenv("HTTPS_PROXY"),
-    }
-
-
-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),
-    )
-    return api
-
-
-class HHApplicantTool:
+class HHApplicantTool(MegaTool):
     """Утилита для автоматизации действий соискателя на сайте hh.ru.
 
     Исходники и предложения: <https://github.com/s3rgeym/hh-applicant-tool>
 
-    Группа поддержки: <https://t.me/otzyvy_headhunter>
+    Группа поддержки: <https://t.me/hh_applicant_tool>
     """
 
     class ArgumentFormatter(
@@ -74,49 +72,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()
+            kebab_name = module_name.replace("_", "-")
             op_parser = subparsers.add_parser(
-                module_name.replace("_", "-"),
+                kebab_name,
+                aliases=getattr(op, "__aliases__", []),
                 description=op.__doc__,
                 formatter_class=self.ArgumentFormatter,
             )
@@ -125,40 +132,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", 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 utils.hh_android_useragent(),
+            session=self.session,
+        )
+        return api
+
+    def get_me(self) -> datatypes.User:
+        return self.api_client.get("/me")
+
+    def get_resumes(self) -> datatypes.PaginatedItems[datatypes.Resume]:
+        return self.api_client.get("/resumes/mine")
+
+    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 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)
-                return 1
-        parser.print_help(file=sys.stderr)
-        return 2
+                self.check_system()
+            except Exception:
+                pass
+
+    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()