hh-applicant-tool 0.7.10__py3-none-any.whl → 1.4.12__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 datetime import datetime
+from typing import TYPE_CHECKING
+
+from ..ai.base import AIError
+from ..api import ApiError, datatypes
+from ..main import BaseNamespace, BaseOperation
+from ..utils.date import parse_api_datetime
+from ..utils.string import rand_text
+
+if TYPE_CHECKING:
+    from ..main import HHApplicantTool
+
 
 try:
     import readline
@@ -25,43 +26,40 @@ 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
+    period: int
 
 
-class Operation(BaseOperation, GetResumeIdMixin):
+class Operation(BaseOperation):
     """Ответ всем работодателям."""
 
+    __aliases__ = ["reply-empls", "reply-chats", "reall"]
+
     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,
+            "--resume-id",
+            help="Идентификатор резюме. Если не указан, то просматриваем чаты для всех резюме",
         )
         parser.add_argument(
             "-m",
             "--reply-message",
             "--reply",
-            help="Отправить сообщение во все чаты, где ожидают ответа либо не прочитали ответ. Если не передать сообщение, то нужно будет вводить его в интерактивном режиме.",
+            help="Отправить сообщение во все чаты. Если не передать сообщение, то нужно будет вводить его в интерактивном режиме.",  # noqa: E501
+        )
+        parser.add_argument(
+            "--period",
+            type=int,
+            help="Игнорировать отклики, которые не обновлялись больше N дней",
         )
         parser.add_argument(
             "-p",
@@ -77,7 +75,6 @@ class Operation(BaseOperation, GetResumeIdMixin):
             default=False,
             action=argparse.BooleanOptionalAction,
         )
-
         parser.add_argument(
             "--dry-run",
             "--dry",
@@ -85,240 +82,264 @@ 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.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
+        )
+        self.period = args.period
+
         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")
-
-        telemetry_data = {"links": []}
-
-        basic_message_placeholders = {
-            "first_name": me.get("first_name", ""),
-            "last_name": me.get("last_name", ""),
-            "email": me.get("email", ""),
-            "phone": me.get("phone", ""),
+        self.reply_employers()
+
+    def reply_employers(self):
+        blacklist = set(self.tool.get_blacklisted())
+        me: datatypes.User = self.tool.get_me()
+        resumes = self.tool.get_resumes()
+        resumes = (
+            list(filter(lambda x: x["id"] == self.resume_id, resumes))
+            if self.resume_id
+            else resumes
+        )
+        resumes = list(
+            filter(
+                lambda resume: resume["status"]["id"] == "published", resumes
+            )
+        )
+        self._reply_chats(user=me, resumes=resumes, blacklist=blacklist)
+
+    def _reply_chats(
+        self,
+        user: datatypes.User,
+        resumes: list[datatypes.Resume],
+        blacklist: set[str],
+    ) -> None:
+        resume_map = {r["id"]: r for r in resumes}
+
+        base_placeholders = {
+            "first_name": user.get("first_name") or "",
+            "last_name": user.get("last_name") or "",
+            "email": user.get("email") or "",
+            "phone": user.get("phone") or "",
         }
 
-        for negotiation in self._get_negotiations():
+        for negotiation in self.tool.get_negotiations():
             try:
-                # Пропускаем другие резюме
-                if self.resume_id != negotiation["resume"]["id"]:
+                # try:
+                #     self.tool.storage.negotiations.save(negotiation)
+                # except RepositoryError as e:
+                #     logger.exception(e)
+
+                if not (resume := resume_map.get(negotiation["resume"]["id"])):
                     continue
 
-                state_id = negotiation["state"]["id"]
+                updated_at = parse_api_datetime(negotiation["updated_at"])
+
+                # Пропуск откликов, которые не обновлялись более N дней (при просмотре они обновляются вроде)
+                if (
+                    self.period
+                    and (datetime().now(updated_at.tzinfo) - updated_at).days
+                    > self.period
+                ):
+                    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 {}
                 salary = vacancy.get("salary") or {}
 
-                if employer.get("id") in blacklisted:
+                if employer.get("id") in blacklist:
                     print(
                         "🚫 Пропускаем заблокированного работодателя",
                         employer.get("alternate_url"),
                     )
                     continue
 
-                message_placeholders = {
+                placeholders = {
                     "vacancy_name": vacancy.get("name", ""),
                     "employer_name": employer.get("name", ""),
-                    **basic_message_placeholders,
+                    "resume_title": resume.get("title") or "",
+                    **base_placeholders,
                 }
 
                 logger.debug(
                     "Вакансия %(vacancy_name)s от %(employer_name)s"
-                    % message_placeholders
+                    % placeholders
                 )
 
                 page: int = 0
-                last_message: dict | None = None
+                last_message: datatypes.Message | 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")
+                        ).strftime("%d.%m.%Y %H:%M:%S")
+
+                        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) % placeholders
                         )
-                        logger.debug(send_message)
+                        logger.debug(f"Template message: {send_message}")
+                    elif self.openai_chat:
+                        try:
+                            ai_query = (
+                                f"Вакансия: {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("🏢", placeholders["employer_name"])
+                        print("💼", 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("-" * 40)
+                            print("Активное резюме:", resume.get("title") or "")
                             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.api_client.put(
+                                f"/employers/blacklisted/{employer['id']}"
+                            )
+                            blacklist.add(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 .. import utils
+from ..main import BaseNamespace, BaseOperation
+
+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 utils.json.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__")