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

hh_applicant_tool/operations/apply_similar.py

@@ -1,41 +1,34 @@
+from __future__ import annotations
+
 import argparse
 import logging
 import random
-import time
-from collections import defaultdict
-from datetime import datetime, timedelta, timezone
 from pathlib import Path
-from typing import Any, TextIO
-
-from ..ai.blackbox import BlackboxChat
-from ..ai.openai import OpenAIChat
-from ..api import ApiClient, BadResponse
-from ..api.errors import LimitExceeded
-from ..main import BaseOperation
-from ..main import Namespace as BaseNamespace
-from ..mixins import GetResumeIdMixin
-from ..telemetry_client import TelemetryClient, TelemetryError
-from ..types import ApiListResponse, VacancyItem
-from ..utils import (
-    fix_datetime,
-    parse_interval,
-    parse_invalid_datetime,
-    random_text,
-    truncate_string,
-)
+from typing import TYPE_CHECKING, Iterator
+
+from ..ai.base import AIError
+from ..api import BadResponse, Redirect, datatypes
+from ..api.datatypes import PaginatedItems, SearchVacancy
+from ..api.errors import ApiError, LimitExceeded
+from ..main import BaseNamespace, BaseOperation
+from ..storage.repositories.errors import RepositoryError
+from ..utils import bool2str, list2str, rand_text, shorten
+
+if TYPE_CHECKING:
+    from ..main import HHApplicantTool
+
 
 logger = logging.getLogger(__package__)
 
 
 class Namespace(BaseNamespace):
     resume_id: str | None
-    message_list: TextIO
+    message_list_path: Path
     ignore_employers: Path | None
     force_message: bool
     use_ai: bool
-    pre_prompt: str
-    apply_interval: tuple[float, float]
-    page_interval: tuple[float, float]
+    first_prompt: str
+    prompt: str
     order_by: str
     search: str
     schedule: str
@@ -64,70 +57,79 @@ class Namespace(BaseNamespace):
     sort_point_lng: float | None
     no_magic: bool
     premium: bool
+    per_page: int
+    total_pages: int
 
 
-def _bool(v: bool) -> str:
-    return str(v).lower()
-
-
-def _join_list(items: list[Any] | None) -> str:
-    return ",".join(f"{v}" for v in items) if items else ""
+class Operation(BaseOperation):
+    """Откликнуться на все подходящие вакансии."""
 
-
-class Operation(BaseOperation, GetResumeIdMixin):
-    """Откликнуться на все подходящие вакансии.
-
-    Описание фильтров для поиска вакансий: <https://api.hh.ru/openapi/redoc#tag/Poisk-vakansij-dlya-soiskatelya/operation/get-vacancies-similar-to-resume>
-    """
+    __aliases__ = ("apply",)
 
     def setup_parser(self, parser: argparse.ArgumentParser) -> None:
         parser.add_argument("--resume-id", help="Идентефикатор резюме")
         parser.add_argument(
-            "-L",
-            "--message-list",
-            help="Путь до файла, где хранятся сообщения для отклика на вакансии. Каждое сообщение — с новой строки.",
-            type=argparse.FileType("r", encoding="utf-8", errors="replace"),
+            "--search",
+            help="Строка поиска для фильтрации вакансий, например, 'москва бухгалтер 100500'",  # noqa: E501
+            type=str,
         )
         parser.add_argument(
-            "--ignore-employers",
-            help="Путь к файлу со списком ID игнорируемых работодателей (по одному ID на строку)",
+            "-L",
+            "--message-list-path",
+            "--message-list",
+            help="Путь до файла, где хранятся сообщения для отклика на вакансии. Каждое сообщение — с новой строки.",  # noqa: E501
             type=Path,
-            default=None,
         )
         parser.add_argument(
             "-f",
             "--force-message",
             "--force",
             help="Всегда отправлять сообщение при отклике",
-            default=False,
             action=argparse.BooleanOptionalAction,
         )
         parser.add_argument(
             "--use-ai",
             "--ai",
             help="Использовать AI для генерации сообщений",
-            default=False,
             action=argparse.BooleanOptionalAction,
         )
         parser.add_argument(
-            "--pre-prompt",
+            "--first-prompt",
+            help="Начальный помпт чата для генерации сопроводительного письма",
+            default="Напиши сопроводительное письмо для отклика на эту вакансию. Не используй placeholder'ы, твой ответ будет отправлен без обработки.",  # noqa: E501
+        )
+        parser.add_argument(
             "--prompt",
-            help="Добавочный промпт для генерации сопроводительного письма",
-            default="Сгенерируй сопроводительное письмо не более 5-7 предложений от моего имени для вакансии",
+            help="Промпт для генерации сопроводительного письма",
+            default="Сгенерируй сопроводительное письмо не более 5-7 предложений от моего имени для вакансии",  # noqa: E501
         )
         parser.add_argument(
-            "--apply-interval",
-            help="Интервал перед отправкой откликов в секундах (X, X-Y)",
-            default="1-5",
-            type=parse_interval,
+            "--total-pages",
+            "--pages",
+            help="Количество обрабатываемых страниц поиска",  # noqa: E501
+            default=20,
+            type=int,
         )
         parser.add_argument(
-            "--page-interval",
-            help="Интервал перед получением следующей страницы рекомендованных вакансий в секундах (X, X-Y)",
-            default="1-3",
-            type=parse_interval,
+            "--per-page",
+            help="Сколько должно быть результатов на странице",  # noqa: E501
+            default=100,
+            type=int,
         )
         parser.add_argument(
+            "--dry-run",
+            help="Не отправлять отклики, а только выводить информацию",
+            action=argparse.BooleanOptionalAction,
+        )
+
+        # Дальше идут параметры в точности соответствующие параметрам запроса
+        # при поиске подходящих вакансий
+        search_params_group = parser.add_argument_group(
+            "Параметры поиска вакансий",
+            "Эти параметры напрямую соответствуют фильтрам поиска HeadHunter API",
+        )
+
+        search_params_group.add_argument(
             "--order-by",
             help="Сортировка вакансий",
             choices=[
@@ -137,246 +139,240 @@ class Operation(BaseOperation, GetResumeIdMixin):
                 "relevance",
                 "distance",
             ],
-            default="relevance",
+            # default="relevance",
         )
-        parser.add_argument(
-            "--search",
-            help="Строка поиска для фильтрации вакансий, например, 'москва бухгалтер 100500'",
+        search_params_group.add_argument(
+            "--experience",
+            help="Уровень опыта работы (noExperience, between1And3, between3And6, moreThan6)",
             type=str,
             default=None,
         )
-
-        parser.add_argument(
+        search_params_group.add_argument(
             "--schedule",
-            help="Тип графика. Возможные значения: fullDay, shift, flexible, remote, flyInFlyOut для полного дня, сменного графика, гибкого графика, удаленной работы и вахтового метода",
+            help="Тип графика (fullDay, shift, flexible, remote, flyInFlyOut)",
             type=str,
-            default=None,
         )
-        parser.add_argument(
-            "--dry-run",
-            help="Не отправлять отклики, а только выводить параметры запроса",
+        search_params_group.add_argument(
+            "--employment", nargs="+", help="Тип занятости"
+        )
+        search_params_group.add_argument(
+            "--area", nargs="+", help="Регион (area id)"
+        )
+        search_params_group.add_argument(
+            "--metro", nargs="+", help="Станции метро (metro id)"
+        )
+        search_params_group.add_argument(
+            "--professional-role", nargs="+", help="Проф. роль (id)"
+        )
+        search_params_group.add_argument(
+            "--industry", nargs="+", help="Индустрия (industry id)"
+        )
+        search_params_group.add_argument(
+            "--employer-id", nargs="+", help="ID работодателей"
+        )
+        search_params_group.add_argument(
+            "--excluded-employer-id", nargs="+", help="Исключить работодателей"
+        )
+        search_params_group.add_argument(
+            "--currency", help="Код валюты (RUR, USD, EUR)"
+        )
+        search_params_group.add_argument(
+            "--salary", type=int, help="Минимальная зарплата"
+        )
+        search_params_group.add_argument(
+            "--only-with-salary",
             default=False,
             action=argparse.BooleanOptionalAction,
         )
-        parser.add_argument(
-            "--experience",
-            help="Уровень опыта работы в вакансии. Возможные значения: noExperience, between1And3, between3And6, moreThan6",
-            type=str,
-            default=None,
+        search_params_group.add_argument(
+            "--label", nargs="+", help="Метки вакансий (label)"
         )
-        parser.add_argument(
-            "--employment", nargs="+", help="Тип занятости (employment)"
+        search_params_group.add_argument(
+            "--period", type=int, help="Искать вакансии за N дней"
         )
-        parser.add_argument("--area", nargs="+", help="Регион (area id)")
-        parser.add_argument("--metro", nargs="+", help="Станции метро (metro id)")
-        parser.add_argument("--professional-role", nargs="+", help="Проф. роль (id)")
-        parser.add_argument("--industry", nargs="+", help="Индустрия (industry id)")
-        parser.add_argument("--employer-id", nargs="+", help="ID работодателей")
-        parser.add_argument(
-            "--excluded-employer-id", nargs="+", help="Исключить работодателей"
+        search_params_group.add_argument(
+            "--date-from", help="Дата публикации с (YYYY-MM-DD)"
         )
-        parser.add_argument("--currency", help="Код валюты (RUR, USD, EUR)")
-        parser.add_argument("--salary", type=int, help="Минимальная зарплата")
-        parser.add_argument(
-            "--only-with-salary", default=False, action=argparse.BooleanOptionalAction
-        )
-        parser.add_argument("--label", nargs="+", help="Метки вакансий (label)")
-        parser.add_argument("--period", type=int, help="Искать вакансии за N дней")
-        parser.add_argument("--date-from", help="Дата публикации с (YYYY-MM-DD)")
-        parser.add_argument("--date-to", help="Дата публикации по (YYYY-MM-DD)")
-        parser.add_argument("--top-lat", type=float, help="Гео: верхняя широта")
-        parser.add_argument("--bottom-lat", type=float, help="Гео: нижняя широта")
-        parser.add_argument("--left-lng", type=float, help="Гео: левая долгота")
-        parser.add_argument("--right-lng", type=float, help="Гео: правая долгота")
-        parser.add_argument(
+        search_params_group.add_argument(
+            "--date-to", help="Дата публикации по (YYYY-MM-DD)"
+        )
+        search_params_group.add_argument(
+            "--top-lat", type=float, help="Гео: верхняя широта"
+        )
+        search_params_group.add_argument(
+            "--bottom-lat", type=float, help="Гео: нижняя широта"
+        )
+        search_params_group.add_argument(
+            "--left-lng", type=float, help="Гео: левая долгота"
+        )
+        search_params_group.add_argument(
+            "--right-lng", type=float, help="Гео: правая долгота"
+        )
+        search_params_group.add_argument(
             "--sort-point-lat",
             type=float,
             help="Координата lat для сортировки по расстоянию",
         )
-        parser.add_argument(
+        search_params_group.add_argument(
             "--sort-point-lng",
             type=float,
             help="Координата lng для сортировки по расстоянию",
         )
-        parser.add_argument(
+        search_params_group.add_argument(
             "--no-magic",
             action="store_true",
             help="Отключить авторазбор текста запроса",
         )
-        parser.add_argument(
+        search_params_group.add_argument(
             "--premium",
             default=False,
             action=argparse.BooleanOptionalAction,
             help="Только премиум вакансии",
         )
-        parser.add_argument(
-            "--search-field", nargs="+", help="Поля поиска (name, company_name и т.п.)"
-        )
-        parser.add_argument(
-            "--clusters",
-            action=argparse.BooleanOptionalAction,
-            help="Включить кластеры (по умолчанию None)",
+        search_params_group.add_argument(
+            "--search-field",
+            nargs="+",
+            help="Поля поиска (name, company_name и т.п.)",
         )
-        # parser.add_argument("--describe-arguments", action=argparse.BooleanOptionalAction, help="Вернуть описание параметров запроса")
 
     def run(
-        self, args: Namespace, api_client: ApiClient, telemetry_client: TelemetryClient
+        self,
+        tool: HHApplicantTool,
     ) -> None:
-        self.enable_telemetry = True
-        if args.disable_telemetry:
-            # print(
-            #     "👁️ Телеметрия используется только для сбора данных о работодателях и их вакансиях, персональные данные пользователей не передаются на сервер."
-            # )
-            # if (
-            #     input("Вы действительно хотите отключить телеметрию (д/Н)? ")
-            #     .lower()
-            #     .startswith(("д", "y"))
-            # ):
-            #     self.enable_telemetry = False
-            #     logger.info("Телеметрия отключена.")
-            # else:
-            #     logger.info("Спасибо за то что оставили телеметрию включенной!")
-            self.enable_telemetry = False
-
-        self.api_client = api_client
-        self.telemetry_client = telemetry_client
-        self.resume_id = args.resume_id or self._get_resume_id()
-        self.application_messages = self._get_application_messages(args.message_list)
-        self.ignored_employers = self._get_ignored_employers(args.ignore_employers)
-        self.chat = None
-
-        if config := args.config.get("blackbox"):
-            self.chat = BlackboxChat(
-                session_id=config["session_id"],
-                chat_payload=config["chat_payload"],
-                proxies=self.api_client.proxies or {},
-            )
-        elif config := args.config.get("openai"):
-            model = "gpt-5.1"
-            system_prompt = "Напиши сопроводительное письмо для отклика на эту вакансию. Не используй placeholder'ы, твой ответ будет отправлен без обработки."
-            if "model" in config.keys():
-                model = config["model"]
-            if "system_prompt" in config.keys():
-                system_prompt = config["system_prompt"]
-            self.chat = OpenAIChat(
-                token=config["token"],
-                model=model,
-                system_prompt=system_prompt,
-                proxies=self.api_client.proxies or {},
-            )
-
-        self.pre_prompt = args.pre_prompt
-
-        self.apply_min_interval, self.apply_max_interval = args.apply_interval
-        self.page_min_interval, self.page_max_interval = args.page_interval
-
-        self.force_message = args.force_message
-        self.order_by = args.order_by
-        self.search = args.search
-        self.schedule = args.schedule
-        self.dry_run = args.dry_run
-        self.experience = args.experience
-        self.search_field = args.search_field
-        self.employment = args.employment
+        self.tool = tool
+        self.api_client = tool.api_client
+        args: Namespace = tool.args
+        self.application_messages = self._get_application_messages(
+            args.message_list_path
+        )
         self.area = args.area
-        self.metro = args.metro
-        self.professional_role = args.professional_role
-        self.industry = args.industry
-        self.employer_id = args.employer_id
-        self.excluded_employer_id = args.excluded_employer_id
+        self.bottom_lat = args.bottom_lat
         self.currency = args.currency
-        self.salary = args.salary
-        self.only_with_salary = args.only_with_salary
-        self.label = args.label
-        self.period = args.period
         self.date_from = args.date_from
         self.date_to = args.date_to
-        self.top_lat = args.top_lat
-        self.bottom_lat = args.bottom_lat
+        self.dry_run = args.dry_run
+        self.employer_id = args.employer_id
+        self.employment = args.employment
+        self.excluded_employer_id = args.excluded_employer_id
+        self.experience = args.experience
+        self.force_message = args.force_message
+        self.industry = args.industry
+        self.label = args.label
         self.left_lng = args.left_lng
+        self.metro = args.metro
+        self.no_magic = args.no_magic
+        self.only_with_salary = args.only_with_salary
+        self.order_by = args.order_by
+        self.per_page = args.per_page
+        self.period = args.period
+        self.pre_prompt = args.prompt
+        self.premium = args.premium
+        self.professional_role = args.professional_role
+        self.resume_id = args.resume_id
         self.right_lng = args.right_lng
+        self.salary = args.salary
+        self.schedule = args.schedule
+        self.search = args.search
+        self.search_field = args.search_field
         self.sort_point_lat = args.sort_point_lat
         self.sort_point_lng = args.sort_point_lng
-        self.clusters = args.clusters
-        # self.describe_arguments = args.describe_arguments
-        self.no_magic = args.no_magic
-        self.premium = args.premium
+        self.top_lat = args.top_lat
+        self.total_pages = args.total_pages
+        self.openai_chat = (
+            tool.get_openai_chat(args.first_prompt) if args.use_ai else None
+        )
         self._apply_similar()
 
-    def _get_application_messages(self, message_list: TextIO | None) -> list[str]:
-        if message_list:
-            application_messages = list(filter(None, map(str.strip, message_list)))
-        else:
-            application_messages = [
-                "{Меня заинтересовала|Мне понравилась} ваша вакансия %(vacancy_name)s",
-                "{Прошу рассмотреть|Предлагаю рассмотреть} {мою кандидатуру|мое резюме} на вакансию %(vacancy_name)s",
-            ]
-        return application_messages
-
-    def _get_ignored_employers(self, file_path: Path | None) -> set[str]:
-        ignored = set()
-        if file_path is not None:
-            with file_path.open("r", encoding="utf-8") as f:
-                for line in f:
-                    if clean_id := line.strip():
-                        ignored.add(int(clean_id))
-            logger.info("Загружено %d ID игнорируемых работодателей", len(ignored))
-        return ignored
-
     def _apply_similar(self) -> None:
-        telemetry_client = self.telemetry_client
-        telemetry_data = defaultdict(dict)
+        resumes: list[datatypes.Resume] = self.tool.get_resumes()
+        try:
+            self.tool.storage.resumes.save_batch(resumes)
+        except RepositoryError as ex:
+            logger.exception(ex)
+        resumes = (
+            list(filter(lambda x: x["id"] == self.resume_id, resumes))
+            if self.resume_id
+            else resumes
+        )
+        # Выбираем только опубликованные
+        resumes = list(
+            filter(lambda x: x["status"]["id"] == "published", resumes)
+        )
+        if not resumes:
+            logger.warning("У вас нет опубликованных резюме")
+            return
+
+        me: datatypes.User = self.tool.get_me()
+        seen_employers = set()
+
+        for resume in resumes:
+            self._apply_resume(
+                resume=resume,
+                user=me,
+                seen_employers=seen_employers,
+            )
 
-        vacancies = self._get_vacancies()
+        # Синхронизация откликов
+        # for neg in self.tool.get_negotiations():
+        #     try:
+        #         self.tool.storage.negotiations.save(neg)
+        #     except RepositoryError as e:
+        #         logger.warning(e)
 
-        if self.enable_telemetry:
-            for vacancy in vacancies:
-                vacancy_id = vacancy["id"]
-                telemetry_data["vacancies"][vacancy_id] = {
-                    "name": vacancy.get("name"),
-                    "type": vacancy.get("type", {}).get("id"),  # open/closed
-                    "area": vacancy.get("area", {}).get("name"),  # город
-                    "salary": vacancy.get("salary"),  # from, to, currency, gross
-                    "direct_url": vacancy.get("alternate_url"),  # ссылка на вакансию
-                    "created_at": fix_datetime(
-                        vacancy.get("created_at")
-                    ),  # будем вычислять говно-вакансии, которые по полгода висят
-                    "published_at": fix_datetime(vacancy.get("published_at")),
-                    "contacts": vacancy.get(
-                        "contacts"
-                    ),  # пиздорванки там телеграм для связи указывают
-                    # HH с точки зрения перфикциониста — кусок говна, где кривые
-                    # форматы даты, у вакансий может не быть работодателя...
-                    "employer_id": int(vacancy["employer"]["id"])
-                    if "employer" in vacancy and "id" in vacancy["employer"]
-                    else None,
-                    # "relations": vacancy.get("relations", []),
-                    # Остальное неинтересно
-                }
-
-        me = self.api_client.get("/me")
+        print("📝 Отклики на вакансии разосланы!")
 
-        basic_message_placeholders = {
-            "first_name": me.get("first_name", ""),
-            "last_name": me.get("last_name", ""),
-            "email": me.get("email", ""),
-            "phone": me.get("phone", ""),
+    def _apply_resume(
+        self,
+        resume: datatypes.Resume,
+        user: datatypes.User,
+        seen_employers: set[str],
+    ) -> None:
+        logger.info("Начинаю рассылку откликов для резюме: %s", resume["title"])
+
+        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 "",
+            "resume_title": resume.get("title") or "",
         }
 
-        do_apply = True
-
-        for vacancy in vacancies:
+        for vacancy in self._get_similar_vacancies(resume_id=resume["id"]):
             try:
+                employer = vacancy.get("employer", {})
+
                 message_placeholders = {
                     "vacancy_name": vacancy.get("name", ""),
-                    "employer_name": vacancy.get("employer", {}).get("name", ""),
-                    **basic_message_placeholders,
+                    "employer_name": employer.get("name", ""),
+                    **placeholders,
                 }
 
-                logger.debug(
-                    "Вакансия %(vacancy_name)s от %(employer_name)s"
-                    % message_placeholders
-                )
+                storage = self.tool.storage
+
+                try:
+                    storage.vacancies.save(vacancy)
+                except RepositoryError as ex:
+                    logger.debug(ex)
+
+                if employer := vacancy.get("employer"):
+                    employer_id = employer.get("id")
+                    if employer_id and employer_id not in seen_employers:
+                        employer_profile: datatypes.Employer = (
+                            self.api_client.get(f"/employers/{employer_id}")
+                        )
+
+                        try:
+                            storage.employers.save(employer_profile)
+                        except RepositoryError as ex:
+                            logger.exception(ex)
+
+                # По факту контакты можно получить только здесь?!
+                if vacancy.get("contacts"):
+                    try:
+                        # logger.debug(vacancy)
+                        storage.vacancy_contacts.save(vacancy)
+                    except RecursionError as ex:
+                        logger.exception(ex)
 
                 if vacancy.get("has_test"):
                     logger.debug(
@@ -386,137 +382,111 @@ class Operation(BaseOperation, GetResumeIdMixin):
                     continue
 
                 if vacancy.get("archived"):
-                    logger.warning(
+                    logger.debug(
                         "Пропускаем вакансию в архиве: %s",
                         vacancy["alternate_url"],
                     )
                     continue
 
-                relations = vacancy.get("relations", [])
-                employer_id = int(vacancy.get("employer", {}).get("id", 0))
-
-                if (
-                    self.enable_telemetry
-                    and employer_id
-                    and employer_id not in telemetry_data["employers"]
-                    and employer_id not in self.ignored_employers
-                    and (
-                        not relations
-                        or parse_invalid_datetime(vacancy["created_at"])
-                        + timedelta(days=7)
-                        > datetime.now(tz=timezone.utc)
+                if redirect_url := vacancy.get("response_url"):
+                    logger.debug(
+                        "Пропускаем вакансию %s с перенаправлением: %s",
+                        vacancy["alternate_url"],
+                        redirect_url,
                     )
-                ):
-                    employer = self.api_client.get(f"/employers/{employer_id}")
-
-                    employer_data = {
-                        "name": employer.get("name"),
-                        "type": employer.get("type"),
-                        "description": employer.get("description"),
-                        "site_url": employer.get("site_url"),
-                        "area": employer.get("area", {}).get("name"),  # город
-                    }
-                    if "got_rejection" in relations:
-                        print(
-                            "🚨 Вы получили отказ от https://hh.ru/employer/%s"
-                            % employer_id
-                        )
-
-                        self.ignored_employers.add(employer_id)
+                    continue
 
-                    elif do_apply:
-                        telemetry_data["employers"][employer_id] = employer_data
+                vacancy_id = vacancy["id"]
 
-                if not do_apply:
-                    logger.debug(
-                        "Останавливаем рассылку откликов, так как достигли лимита, попробуйте через сутки."
-                    )
-                    break
+                relations = vacancy.get("relations", [])
 
                 if relations:
                     logger.debug(
                         "Пропускаем вакансию с откликом: %s",
                         vacancy["alternate_url"],
                     )
+                    if "got_rejection" in relations:
+                        logger.debug(
+                            "Вы получили отказ от %s на резюме %s",
+                            vacancy["alternate_url"],
+                            resume["alternate_url"],
+                        )
+                        print(
+                            "⛔  Пришел отказ от",
+                            vacancy["alternate_url"],
+                            "на резюме",
+                            resume["alternate_url"],
+                        )
                     continue
 
                 params = {
-                    "resume_id": self.resume_id,
-                    "vacancy_id": vacancy["id"],
+                    "resume_id": resume["id"],
+                    "vacancy_id": vacancy_id,
                     "message": "",
                 }
 
-                if self.force_message or vacancy.get("response_letter_required"):
-                    if self.chat:
-                        try:
-                            msg = self.pre_prompt + "\n\n"
-                            msg += message_placeholders["vacancy_name"]
-                            logger.debug(msg)
-                            msg = self.chat.send_message(msg)
-                        except Exception as ex:
-                            logger.error(ex)
-                            continue
+                if self.force_message or vacancy.get(
+                    "response_letter_required"
+                ):
+                    if self.openai_chat:
+                        msg = self.pre_prompt + "\n\n"
+                        msg += (
+                            "Название вакансии: "
+                            + message_placeholders["vacancy_name"]
+                        )
+                        msg += (
+                            "Мое резюме:" + message_placeholders["resume_title"]
+                        )
+                        logger.debug("prompt: %s", msg)
+                        msg = self.openai_chat.send_message(msg)
                     else:
                         msg = (
-                            random_text(random.choice(self.application_messages))
+                            rand_text(random.choice(self.application_messages))
                             % message_placeholders
                         )
 
                     logger.debug(msg)
                     params["message"] = msg
 
-                if self.dry_run:
-                    logger.info(
-                        "Dry Run: Отправка отклика на вакансию %s с параметрами: %s",
+                try:
+                    if not self.dry_run:
+                        res = self.api_client.post(
+                            "/negotiations",
+                            params,
+                            delay=random.uniform(1, 3),
+                        )
+                        assert res == {}
+                        logger.debug(
+                            "Откликнулись на %s с резюме %s",
+                            vacancy["alternate_url"],
+                            resume["alternate_url"],
+                        )
+                    print(
+                        "📨 Отправили отклик для резюме",
+                        resume["alternate_url"],
+                        "на вакансию",
                         vacancy["alternate_url"],
-                        params,
+                        "(",
+                        shorten(vacancy["name"]),
+                        ")",
+                    )
+                except Redirect:
+                    logger.warning(
+                        f"Игнорирую перенаправление на форму: {vacancy['alternate_url']}"  # noqa: E501
                     )
-                    continue
-
-                # Задержка перед отправкой отклика
-                interval = random.uniform(
-                    self.apply_min_interval, self.apply_max_interval
-                )
-                time.sleep(interval)
-
-                res = self.api_client.post("/negotiations", params)
-                assert res == {}
-                print(
-                    "📨 Отправили отклик",
-                    vacancy["alternate_url"],
-                    "(",
-                    truncate_string(vacancy["name"]),
-                    ")",
-                )
             except LimitExceeded:
+                logger.info("Достигли лимита на отклики")
                 print("⚠️ Достигли лимита рассылки")
-                do_apply = False
-            except BadResponse as ex:
-                logger.error(ex)
-
-        print("📝 Отклики на вакансии разосланы!")
-
-        if self.enable_telemetry:
-            if self.dry_run:
-                # С --dry-run можно посмотреть что отправляется
-                logger.info(
-                    "Dry Run: Данные телеметрии для отправки на сервер: %r",
-                    telemetry_data,
-                )
-                return
-
-            try:
-                response = telemetry_client.send_telemetry(
-                    "/collect", dict(telemetry_data)
-                )
-                logger.debug(response)
-            except TelemetryError as ex:
+                break
+            except ApiError as ex:
+                logger.warning(ex)
+            except (BadResponse, AIError) as ex:
                 logger.error(ex)
 
-    def _get_search_params(self, page: int, per_page: int) -> dict:
+    def _get_search_params(self, page: int) -> dict:
         params = {
             "page": page,
-            "per_page": per_page,
+            "per_page": self.per_page,
             "order_by": self.order_by,
         }
 
@@ -549,53 +519,65 @@ class Operation(BaseOperation, GetResumeIdMixin):
         if self.sort_point_lng:
             params["sort_point_lng"] = self.sort_point_lng
         if self.search_field:
-            params["search_field"] = _join_list(self.search_field)
+            params["search_field"] = list2str(self.search_field)
         if self.employment:
-            params["employment"] = _join_list(self.employment)
+            params["employment"] = list2str(self.employment)
         if self.area:
-            params["area"] = _join_list(self.area)
+            params["area"] = list2str(self.area)
         if self.metro:
-            params["metro"] = _join_list(self.metro)
+            params["metro"] = list2str(self.metro)
         if self.professional_role:
-            params["professional_role"] = _join_list(self.professional_role)
+            params["professional_role"] = list2str(self.professional_role)
         if self.industry:
-            params["industry"] = _join_list(self.industry)
+            params["industry"] = list2str(self.industry)
         if self.employer_id:
-            params["employer_id"] = _join_list(self.employer_id)
+            params["employer_id"] = list2str(self.employer_id)
         if self.excluded_employer_id:
-            params["excluded_employer_id"] = _join_list(self.excluded_employer_id)
+            params["excluded_employer_id"] = list2str(self.excluded_employer_id)
         if self.label:
-            params["label"] = _join_list(self.label)
-        if self.only_with_salary is not None:
-            params["only_with_salary"] = _bool(self.only_with_salary)
-        if self.clusters is not None:
-            params["clusters"] = _bool(self.clusters)
-        if self.no_magic is not None:
-            params["no_magic"] = _bool(self.no_magic)
-        if self.premium is not None:
-            params["premium"] = _bool(self.premium)
+            params["label"] = list2str(self.label)
+        if self.only_with_salary:
+            params["only_with_salary"] = bool2str(self.only_with_salary)
+        # if self.clusters:
+        #     params["clusters"] = bool2str(self.clusters)
+        if self.no_magic:
+            params["no_magic"] = bool2str(self.no_magic)
+        if self.premium:
+            params["premium"] = bool2str(self.premium)
         # if self.responses_count_enabled is not None:
-        #     params["responses_count_enabled"] = _bool(self.responses_count_enabled)
+        #     params["responses_count_enabled"] = bool2str(self.responses_count_enabled)
 
         return params
 
-    def _get_vacancies(self, per_page: int = 100) -> list[VacancyItem]:
-        rv = []
-        # API отдает только 2000 результатов
-        for page in range(20):
-            params = self._get_search_params(page, per_page)
-            res: ApiListResponse = self.api_client.get(
-                f"/resumes/{self.resume_id}/similar_vacancies", params
+    def _get_similar_vacancies(self, resume_id: str) -> Iterator[SearchVacancy]:
+        for page in range(self.total_pages):
+            params = self._get_search_params(page)
+            res: PaginatedItems[SearchVacancy] = self.api_client.get(
+                f"/resumes/{resume_id}/similar_vacancies",
+                params,
             )
-            rv.extend(res["items"])
+            if not res["items"]:
+                return
+
+            yield from res["items"]
+
             if page >= res["pages"] - 1:
-                break
+                return
 
-            # Задержка перед получением следующей страницы
-            if page > 0:
-                interval = random.uniform(
-                    self.page_min_interval, self.page_max_interval
+    def _get_application_messages(self, path: Path | None) -> list[str]:
+        return (
+            list(
+                filter(
+                    None,
+                    map(
+                        str.strip,
+                        path.open(encoding="utf-8", errors="replace"),
+                    ),
                 )
-                time.sleep(interval)
-
-        return rv
+            )
+            if path
+            else [
+                "Здравствуйте, меня зовут %(first_name)s. {Меня заинтересовала|Мне понравилась} ваша вакансия «%(vacancy_name)s». Хотелось бы {пообщаться|задать вопросы} о ней.",
+                "{Прошу|Предлагаю} рассмотреть {мою кандидатуру|мое резюме «%(resume_title)s»} на вакансию «%(vacancy_name)s». С уважением, %(first_name)s.",  # noqa: E501
+            ]
+        )