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

hh_applicant_tool/operations/reply_employers.py

@@ -1,19 +1,20 @@
 from __future__ import annotations
-import os
+
 import argparse
 import logging
 import random
-import time
-from typing import Tuple
-
-from ..api import ApiError, ApiClient
-from ..main import BaseOperation
-from ..main import Namespace as BaseNamespace
-from ..mixins import GetResumeIdMixin
-from ..utils import parse_interval, random_text
-from ..telemetry_client import TelemetryClient, TelemetryError
-import re
-from itertools import count
+from typing import TYPE_CHECKING
+
+from .. import datatypes
+from ..ai.base import AIError
+from ..api import ApiError
+from ..main import BaseNamespace, BaseOperation
+from ..utils.dateutil import parse_api_datetime
+from ..utils.string import rand_text
+
+if TYPE_CHECKING:
+    from ..main import HHApplicantTool
+
 
 try:
     import readline
@@ -25,43 +26,31 @@ except ImportError:
     pass
 
 
-GOOGLE_DOCS_RE = re.compile(
-    r"\b(?:https?:\/\/)?(?:docs|forms|sheets|slides|drive)\.google\.com\/(?:document|spreadsheets|presentation|forms|file)\/(?:d|u)\/[a-zA-Z0-9_\-]+(?:\/[a-zA-Z0-9_\-]+)?\/?(?:[?#].*)?\b|\b(?:https?:\/\/)?(?:goo\.gl|forms\.gle)\/[a-zA-Z0-9]+\b",
-    re.I,
-)
-
 logger = logging.getLogger(__package__)
 
 
 class Namespace(BaseNamespace):
     reply_message: str
-    reply_interval: Tuple[float, float]
     max_pages: int
     only_invitations: bool
     dry_run: bool
+    use_ai: bool
+    first_prompt: str
+    prompt: str
 
 
-class Operation(BaseOperation, GetResumeIdMixin):
+class Operation(BaseOperation):
     """Ответ всем работодателям."""
 
+    __aliases__ = ["reply-chats", "reply-all"]
+
     def setup_parser(self, parser: argparse.ArgumentParser) -> None:
-        # parser.add_argument(
-        #     "reply_message",
-        #     help="Сообщение для отправки во все чаты с работодателями, где ожидают ответа либо не прочитали ответ. Если не передать, то его нужно будет вводить интерактивно.",
-        # )
         parser.add_argument("--resume-id", help="Идентификатор резюме")
-        parser.add_argument(
-            "-i",
-            "--reply-interval",
-            help="Интервал перед отправкой сообщения в секундах (X, X-Y)",
-            default="5-10",
-            type=parse_interval,
-        )
         parser.add_argument(
             "-m",
             "--reply-message",
             "--reply",
-            help="Отправить сообщение во все чаты, где ожидают ответа либо не прочитали ответ. Если не передать сообщение, то нужно будет вводить его в интерактивном режиме.",
+            help="Отправить сообщение во все чаты. Если не передать сообщение, то нужно будет вводить его в интерактивном режиме.",  # noqa: E501
         )
         parser.add_argument(
             "-p",
@@ -77,7 +66,6 @@ class Operation(BaseOperation, GetResumeIdMixin):
             default=False,
             action=argparse.BooleanOptionalAction,
         )
-
         parser.add_argument(
             "--dry-run",
             "--dry",
@@ -85,39 +73,47 @@ class Operation(BaseOperation, GetResumeIdMixin):
             default=False,
             action=argparse.BooleanOptionalAction,
         )
+        parser.add_argument(
+            "--use-ai",
+            "--ai",
+            help="Использовать AI для автоматической генерации ответов",
+            action=argparse.BooleanOptionalAction,
+        )
+        parser.add_argument(
+            "--first-prompt",
+            help="Начальный промпт чата для AI",
+            default="Ты — соискатель на HeadHunter. Отвечай вежливо и кратко.",
+        )
+        parser.add_argument(
+            "--prompt",
+            help="Промпт для генерации сообщения",
+            default="Напиши короткий ответ работодателю на основе истории переписки.",
+        )
 
-    def run(
-        self, args: Namespace, api_client: ApiClient, telemetry_client: TelemetryClient
-    ) -> None:
-        self.api_client = api_client
-        self.telemetry_client = telemetry_client
-        self.enable_telemetry = not args.disable_telemetry
-        self.resume_id = self._get_resume_id()
-        self.reply_min_interval, self.reply_max_interval = args.reply_interval
-        self.reply_message = args.reply_message or args.config["reply_message"]
-        # assert self.reply_message, "`reply_message` должен быть передан чеерез аргументы или настройки"
+    def run(self, tool: HHApplicantTool) -> None:
+        args: Namespace = tool.args
+        self.applicant_tool = tool
+        self.api_client = tool.api_client
+        self.resume_id = tool.first_resume_id()
+        self.reply_message = args.reply_message or tool.config.get(
+            "reply_message"
+        )
         self.max_pages = args.max_pages
         self.dry_run = args.dry_run
         self.only_invitations = args.only_invitations
+
+        self.pre_prompt = args.prompt
+        self.openai_chat = (
+            tool.get_openai_chat(args.first_prompt) if args.use_ai else None
+        )
+
         logger.debug(f"{self.reply_message = }")
-        self._reply_chats()
-
-    def _get_blacklisted(self) -> list[str]:
-        rv = []
-        # В этом методе API страницы с 0 начинаются
-        for page in count(0):
-            r = 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 _reply_chats(self) -> None:
-        blacklisted = self._get_blacklisted()
-        logger.debug(f"{blacklisted = }")
-        me = self.me = self.api_client.get("/me")
+        self.reply_chats()
 
-        telemetry_data = {"links": []}
+    def reply_chats(self) -> None:
+        blacklisted = self.applicant_tool.get_blacklisted()
+        logger.debug(f"{blacklisted = }")
+        me: datatypes.User = self.applicant_tool.get_me()
 
         basic_message_placeholders = {
             "first_name": me.get("first_name", ""),
@@ -126,22 +122,20 @@ class Operation(BaseOperation, GetResumeIdMixin):
             "phone": me.get("phone", ""),
         }
 
-        for negotiation in self._get_negotiations():
+        for negotiation in self.applicant_tool.get_negotiations():
             try:
-                # Пропускаем другие резюме
+                self.applicant_tool.storage.negotiations.save(negotiation)
+
                 if self.resume_id != negotiation["resume"]["id"]:
                     continue
 
                 state_id = negotiation["state"]["id"]
-
-                # Пропускаем отказ
                 if state_id == "discard":
                     continue
 
                 if self.only_invitations and not state_id.startswith("inv"):
                     continue
 
-                logger.debug(negotiation)
                 nid = negotiation["id"]
                 vacancy = negotiation["vacancy"]
                 employer = vacancy.get("employer") or {}
@@ -169,156 +163,143 @@ class Operation(BaseOperation, GetResumeIdMixin):
                 last_message: dict | None = None
                 message_history: list[str] = []
                 while True:
-                    messages_res = self.api_client.get(
+                    messages_res: datatypes.PaginatedItems[
+                        datatypes.Message
+                    ] = self.api_client.get(
                         f"/negotiations/{nid}/messages", page=page
                     )
+                    if not messages_res["items"]:
+                        break
 
                     last_message = messages_res["items"][-1]
-                    message_history.extend(
-                        (
-                            "<-"
-                            if item["author"]["participant_type"] == "employer"
-                            else "->"
+                    for message in messages_res["items"]:
+                        if not message.get("text"):
+                            continue
+                        author = (
+                            "Работодатель"
+                            if message["author"]["participant_type"]
+                            == "employer"
+                            else "Я"
                         )
-                        + " "
-                        + item["text"]
-                        for item in messages_res["items"]
-                        if item.get("text")
-                    )
+                        message_date = parse_api_datetime(
+                            message.get("created_at")
+                        ).isoformat()
+                        message_history.append(
+                            f"[ {message_date} ] {author}: {message['text']}"
+                        )
+
                     if page + 1 >= messages_res["pages"]:
                         break
-
                     page = messages_res["pages"] - 1
 
-                if self.enable_telemetry:
-                    # Собираем ссылки на тестовые задания
-                    for message in message_history:
-                        if message.startswith("-> "):
-                            continue
-                        # Тестовые задания и тп
-                        for link in GOOGLE_DOCS_RE.findall(message):
-                            document_data = {
-                                "vacancy_url": vacancy.get("alternate_url"),
-                                "vacancy_name": vacancy.get("name"),
-                                "salary": (
-                                    f"{salary.get('from', '...')}-{salary.get('to', '...')} {salary.get('currency', 'RUR')}"  # noqa: E501
-                                    if salary
-                                    else None
-                                ),
-                                "employer_url": vacancy.get("employer", {}).get(
-                                    "alternate_url"
-                                ),
-                                "link": link,
-                            }
-
-                            telemetry_data["links"].append(document_data)
-
-                if os.getenv("TEST_SEND_TELEMETRY") in ["1", "y", "Y"]:
+                if not last_message:
                     continue
 
-                logger.debug(last_message)
-
                 is_employer_message = (
                     last_message["author"]["participant_type"] == "employer"
                 )
 
-                if is_employer_message or not negotiation.get("viewed_by_opponent"):
+                if is_employer_message or not negotiation.get(
+                    "viewed_by_opponent"
+                ):
+                    send_message = ""
                     if self.reply_message:
                         send_message = (
-                            random_text(self.reply_message) % message_placeholders
+                            rand_text(self.reply_message) % message_placeholders
                         )
-                        logger.debug(send_message)
+                        logger.debug(f"Template message: {send_message}")
+                    elif self.openai_chat:
+                        try:
+                            ai_query = (
+                                f"Вакансия: {message_placeholders['vacancy_name']}\n"
+                                f"История переписки:\n"
+                                + "\n".join(message_history[-10:])
+                                + f"\n\nИнструкция: {self.pre_prompt}"
+                            )
+                            send_message = self.openai_chat.send_message(
+                                ai_query
+                            )
+                            logger.debug(f"AI message: {send_message}")
+                        except AIError as ex:
+                            logger.warning(
+                                f"Ошибка OpenAI для чата {nid}: {ex}"
+                            )
+                            continue
                     else:
-                        print("🏢", message_placeholders["employer_name"])
-                        print("💼", message_placeholders["vacancy_name"])
-                        print("📅", vacancy["created_at"])
+                        print(
+                            "\n🏢",
+                            message_placeholders["employer_name"],
+                            "| 💼",
+                            message_placeholders["vacancy_name"],
+                        )
                         if salary:
-                            salary_from = salary.get("from") or "-"
-                            salary_to = salary.get("to") or "-"
-                            salary_currency = salary.get("currency")
                             print(
-                                "💵 от", salary_from, "до", salary_to, salary_currency
+                                "💵 от",
+                                salary.get("from") or salary.get("to") or 0,
+                                "до",
+                                salary.get("to") or salary.get("from") or 0,
+                                salary.get("currency", "RUR"),
                             )
-                        print("")
-                        print("Последние сообщения:")
+
+                        print("\nПоследние сообщения чата:")
+                        print()
                         for msg in (
-                            message_history[:1] + ["..."] + message_history[-3:]
+                            message_history[-5:]
                             if len(message_history) > 5
                             else message_history
                         ):
                             print(msg)
+
                         try:
                             print("-" * 10)
-                            print()
                             print(
-                                "Отмена отклика: /cancel <необязательное сообщение для отказа>"
+                                "Команды: /ban, /cancel <опционально сообщение для отмены>"
                             )
-                            print("Заблокировать работодателя: /ban")
-                            print()
                             send_message = input("Ваше сообщение: ").strip()
                         except EOFError:
                             continue
+
                         if not send_message:
                             print("🚶 Пропускаем чат")
                             continue
 
+                        if send_message.startswith("/ban"):
+                            self.applicant_tool.storage.employers.save(employer)
+                            self.api_client.put(
+                                f"/employers/blacklisted/{employer['id']}"
+                            )
+                            blacklisted.append(employer["id"])
+                            print(
+                                "🚫 Работодатель в ЧС",
+                                employer.get("alternate_url"),
+                            )
+                            continue
+                        elif send_message.startswith("/cancel"):
+                            _, decline_msg = send_message.split("/cancel", 1)
+                            self.api_client.delete(
+                                f"/negotiations/active/{nid}",
+                                with_decline_message=decline_msg.strip(),
+                            )
+                            print("❌ Отмена заявки", vacancy["alternate_url"])
+                            continue
+
+                    # Финальная отправка текста
                     if self.dry_run:
-                        logger.info(
-                            "Dry Run: Отправка сообщения в чат по вакансии %s: %s",
+                        logger.debug(
+                            "dry-run: отклик на",
                             vacancy["alternate_url"],
                             send_message,
                         )
                         continue
 
-                    time.sleep(
-                        random.uniform(
-                            self.reply_min_interval,
-                            self.reply_max_interval,
-                        )
+                    self.api_client.post(
+                        f"/negotiations/{nid}/messages",
+                        message=send_message,
+                        delay=random.uniform(1, 3),
                     )
+                    print(f"📨 Отправлено для {vacancy['alternate_url']}")
 
-                    if send_message.startswith("/ban"):
-                        self.api_client.put(f"/employers/blacklisted/{employer['id']}")
-                        blacklisted.append(employer["id"])
-                        print(
-                            "🚫 Работодатель добавлен в черный список",
-                            employer.get("alternate_url"),
-                        )
-                    elif send_message.startswith("/cancel"):
-                        _, decline_allowed = send_message.split("/cancel", 1)
-                        self.api_client.delete(
-                            f"/negotiations/active/{negotiation['id']}",
-                            with_decline_message=decline_allowed.strip(),
-                        )
-                        print("❌ Отменили заявку", vacancy["alternate_url"])
-                    else:
-                        self.api_client.post(
-                            f"/negotiations/{nid}/messages",
-                            message=send_message,
-                        )
-                        print(
-                            "📨 Отправили сообщение для",
-                            vacancy["alternate_url"],
-                        )
             except ApiError as ex:
                 logger.error(ex)
 
-        if self.enable_telemetry and len(telemetry_data["links"]) > 0:
-            logger.debug(telemetry_data)
-            try:
-                self.telemetry_client.send_telemetry("/docs", telemetry_data)
-            except TelemetryError as ex:
-                logger.warning(ex, exc_info=True)
-
         print("📝 Сообщения разосланы!")
-
-    def _get_negotiations(self) -> list[dict]:
-        rv = []
-        for page in range(self.max_pages):
-            res = self.api_client.get("/negotiations", page=page, status="active")
-            rv.extend(res["items"])
-            if page >= res["pages"] - 1:
-                break
-            page += 1
-
-        return rv

hh_applicant_tool/operations/settings.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+from typing import TYPE_CHECKING
+
+from prettytable import PrettyTable
+
+from ..main import BaseNamespace, BaseOperation
+from ..utils import jsonutil
+
+if TYPE_CHECKING:
+    from ..main import HHApplicantTool
+
+
+MISSING = type("Missing", (), {"__str__": lambda self: "Не установлено"})()
+
+
+logger = logging.getLogger(__package__)
+
+
+class Namespace(BaseNamespace):
+    key: str | None
+    value: str | None
+    delete: bool
+
+
+def parse_value(v):
+    try:
+        return jsonutil.loads(v)
+    except json.JSONDecodeError:
+        return v
+
+
+class Operation(BaseOperation):
+    """Просмотр и управление настройками"""
+
+    __aliases__: list[str] = ["setting"]
+
+    def setup_parser(self, parser: argparse.ArgumentParser) -> None:
+        parser.add_argument(
+            "-d",
+            "--delete",
+            action="store_true",
+            help="Удалить настройку по ключу либо удалить все насйтроки, если ключ не передан",
+        )
+        parser.add_argument(
+            "key", nargs="?", help="Ключ настройки", default=MISSING
+        )
+        parser.add_argument(
+            "value",
+            nargs="?",
+            type=parse_value,
+            help="Значение настройки",
+            default=MISSING,
+        )
+
+    def run(self, tool: HHApplicantTool) -> None:
+        args: Namespace = tool.args
+        settings = tool.storage.settings
+
+        if args.delete:
+            if args.key is not MISSING:
+                # Delete value
+                settings.delete_value(args.key)
+                print(f"🗑️ Настройка '{args.key}' удалена")
+            else:
+                settings.clear()
+        elif args.key is not MISSING and args.value is not MISSING:
+            settings.set_value(args.key, args.value)
+            print(f"✅ Установлено значение для '{args.key}'")
+        elif args.key is not MISSING:
+            # Get value
+            value = settings.get_value(args.key, MISSING)
+            if value is not MISSING:
+                # print(type(value).__name__, value)
+                print(value)
+            else:
+                print(f"⚠️ Настройка '{args.key}' не найдена")
+        else:
+            # List all settings
+            settings = settings.find()
+            t = PrettyTable(field_names=["Ключ", "Тип", "Значение"], align="l")
+            for setting in settings:
+                if setting.key.startswith("_"):
+                    continue
+                t.add_row(
+                    [
+                        setting.key,
+                        type(setting.value).__name__,
+                        setting.value,
+                    ]
+                )
+            print(t)

hh_applicant_tool/operations/uninstall.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+import argparse
+import logging
+import sys
+from runpy import run_module
+from typing import TYPE_CHECKING
+
+from ..main import BaseOperation
+
+if TYPE_CHECKING:
+    from ..main import HHApplicantTool
+
+
+logger = logging.getLogger(__package__)
+
+
+class Operation(BaseOperation):
+    """Удалит Chromium и другие зависимости"""
+
+    def setup_parser(self, parser: argparse.ArgumentParser) -> None:
+        pass
+
+    def run(self, tool: HHApplicantTool) -> None:
+        sys.argv = ["playwright", "uninstall", "chromium"]
+        run_module("playwright", run_name="__main__")

hh_applicant_tool/operations/update_resumes.py

@@ -1,12 +1,19 @@
 # Этот модуль можно использовать как образец для других
+from __future__ import annotations
+
 import argparse
 import logging
+from typing import TYPE_CHECKING
+
+from ..api import ApiError
+from ..datatypes import PaginatedItems
+from ..main import BaseNamespace, BaseOperation
+from ..utils import print_err
+from ..utils.string import shorten
+
+if TYPE_CHECKING:
+    from ..main import HHApplicantTool
 
-from ..api import ApiClient, ApiError
-from ..main import BaseOperation
-from ..main import Namespace as BaseNamespace
-from ..types import ApiListResponse
-from ..utils import print_err, truncate_string
 
 logger = logging.getLogger(__package__)
 
@@ -18,15 +25,19 @@ class Namespace(BaseNamespace):
 class Operation(BaseOperation):
     """Обновить все резюме"""
 
+    __aliases__ = ["update"]
+
     def setup_parser(self, parser: argparse.ArgumentParser) -> None:
         pass
 
-    def run(self, args: Namespace, api_client: ApiClient, *_) -> None:
-        resumes: ApiListResponse = api_client.get("/resumes/mine")
+    def run(self, tool: HHApplicantTool) -> None:
+        resumes: PaginatedItems = tool.get_resumes()
         for resume in resumes["items"]:
             try:
-                res = api_client.post(f"/resumes/{resume['id']}/publish")
+                res = tool.api_client.post(
+                    f"/resumes/{resume['id']}/publish",
+                )
                 assert res == {}
-                print("✅ Обновлено", truncate_string(resume["title"]))
+                print("✅ Обновлено", shorten(resume["title"]))
             except ApiError as ex:
-                print_err("❗ Ошибка:", ex)
+                print_err("❗", ex)

hh_applicant_tool/operations/whoami.py

@@ -1,11 +1,16 @@
 # Этот модуль можно использовать как образец для других
+from __future__ import annotations
+
 import argparse
-import json
 import logging
+from typing import TYPE_CHECKING
+
+from .. import datatypes
+from ..main import BaseNamespace, BaseOperation
+
+if TYPE_CHECKING:
+    from ..main import HHApplicantTool
 
-from ..api import ApiClient
-from ..main import BaseOperation
-from ..main import Namespace as BaseNamespace
 
 logger = logging.getLogger(__package__)
 
@@ -14,12 +19,40 @@ class Namespace(BaseNamespace):
     pass
 
 
+def fmt_plus(n: int) -> str:
+    assert n >= 0
+    return f"+{n}" if n else "0"
+
+
 class Operation(BaseOperation):
     """Выведет текущего пользователя"""
 
+    __aliases__: list[str] = ["id"]
+
     def setup_parser(self, parser: argparse.ArgumentParser) -> None:
         pass
 
-    def run(self, args: Namespace, api_client: ApiClient, _) -> None:
-        result = api_client.get("/me")
-        print(json.dumps(result, ensure_ascii=False, indent=2, sort_keys=True))
+    def run(self, tool: HHApplicantTool) -> None:
+        api_client = tool.api_client
+        result: datatypes.User = api_client.get("me")
+        full_name = " ".join(
+            filter(
+                None,
+                [
+                    result.get("last_name"),
+                    result.get("first_name"),
+                    result.get("middle_name"),
+                ],
+            )
+        )
+        with tool.storage.settings as s:
+            s.set_value("user.full_name", full_name)
+            s.set_value("user.email", result.get("email"))
+            s.set_value("user.phone", result.get("phone"))
+        counters = result["counters"]
+        print(
+            f"🆔 {result['id']} {full_name or 'Анонимный аккаунт'} "
+            f"[ 📄 {counters['resumes_count']} "
+            f"| 👁️  {fmt_plus(counters['new_resume_views'])} "
+            f"| ✉️  {fmt_plus(counters['unread_negotiations'])} ]"
+        )