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

hh_applicant_tool/operations/apply_similar.py

@@ -4,15 +4,21 @@ import argparse
 import logging
 import random
 from pathlib import Path
-from typing import TYPE_CHECKING, Iterator, TextIO
+from typing import TYPE_CHECKING, Iterator
 
-from .. import datatypes
 from ..ai.base import AIError
-from ..api import BadResponse, Redirect
+from ..api import BadResponse, Redirect, datatypes
+from ..api.datatypes import PaginatedItems, SearchVacancy
 from ..api.errors import ApiError, LimitExceeded
-from ..datatypes import PaginatedItems, SearchVacancy
 from ..main import BaseNamespace, BaseOperation
-from ..utils import bool2str, list2str, rand_text, shorten
+from ..storage.repositories.errors import RepositoryError
+from ..utils.string import (
+    bool2str,
+    list2str,
+    rand_text,
+    shorten,
+    unescape_string,
+)
 
 if TYPE_CHECKING:
     from ..main import HHApplicantTool
@@ -23,7 +29,7 @@ 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
@@ -62,10 +68,9 @@ class Namespace(BaseNamespace):
 
 
 class Operation(BaseOperation):
-    """Откликнуться на все подходящие вакансии.
+    """Откликнуться на все подходящие вакансии."""
 
-    Описание фильтров для поиска вакансий: <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="Идентефикатор резюме")
@@ -76,9 +81,10 @@ class Operation(BaseOperation):
         )
         parser.add_argument(
             "-L",
+            "--message-list-path",
             "--message-list",
-            help="Путь до файла, где хранятся сообщения для отклика на вакансии. Каждое сообщение — с новой строки.",  # noqa: E501
-            type=argparse.FileType("r", encoding="utf-8", errors="replace"),
+            help="Путь до файла, где хранятся сообщения для отклика на вакансии. Каждое сообщение — с новой строки. Символы \\n будут заменены на переносы.",  # noqa: E501
+            type=Path,
         )
         parser.add_argument(
             "-f",
@@ -243,7 +249,7 @@ class Operation(BaseOperation):
         self.api_client = tool.api_client
         args: Namespace = tool.args
         self.application_messages = self._get_application_messages(
-            args.message_list
+            args.message_list_path
         )
         self.area = args.area
         self.bottom_lat = args.bottom_lat
@@ -268,7 +274,7 @@ class Operation(BaseOperation):
         self.pre_prompt = args.prompt
         self.premium = args.premium
         self.professional_role = args.professional_role
-        self.resume_id = args.resume_id or tool.first_resume_id()
+        self.resume_id = args.resume_id
         self.right_lng = args.right_lng
         self.salary = args.salary
         self.schedule = args.schedule
@@ -283,52 +289,96 @@ class Operation(BaseOperation):
         )
         self._apply_similar()
 
-    def _get_application_messages(
-        self, message_list: TextIO | None
-    ) -> list[str]:
-        return (
-            list(filter(None, map(str.strip, message_list)))
-            if message_list
-            else [
-                "{Меня заинтересовала|Мне понравилась} ваша вакансия %(vacancy_name)s",
-                "{Прошу рассмотреть|Предлагаю рассмотреть} {мою кандидатуру|мое резюме} на вакансию %(vacancy_name)s",  # noqa: E501
-            ]
-        )
-
     def _apply_similar(self) -> None:
+        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,
+            )
+
+        # Синхронизация откликов
+        # for neg in self.tool.get_negotiations():
+        #     try:
+        #         self.tool.storage.negotiations.save(neg)
+        #     except RepositoryError as e:
+        #         logger.warning(e)
+
+        print("📝 Отклики на вакансии разосланы!")
 
-        basic_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 "",
         }
 
-        seen_employers = set()
-        for vacancy in self._get_vacancies():
+        for vacancy in self._get_similar_vacancies(resume_id=resume["id"]):
             try:
                 employer = vacancy.get("employer", {})
 
-                placeholders = {
+                message_placeholders = {
                     "vacancy_name": vacancy.get("name", ""),
                     "employer_name": employer.get("name", ""),
-                    **basic_placeholders,
+                    **placeholders,
                 }
 
                 storage = self.tool.storage
-                storage.vacancies.save(vacancy)
+
+                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}")
                         )
-                        storage.employers.save(employer_profile)
+
+                        try:
+                            storage.employers.save(employer_profile)
+                        except RepositoryError as ex:
+                            logger.exception(ex)
 
                 # По факту контакты можно получить только здесь?!
                 if vacancy.get("contacts"):
-                    storage.employer_contacts.save(vacancy)
+                    try:
+                        # logger.debug(vacancy)
+                        storage.vacancy_contacts.save(vacancy)
+                    except RecursionError as ex:
+                        logger.exception(ex)
 
                 if vacancy.get("has_test"):
                     logger.debug(
@@ -363,13 +413,20 @@ class Operation(BaseOperation):
                     )
                     if "got_rejection" in relations:
                         logger.debug(
-                            "Вы получили отказ: %s", vacancy["alternate_url"]
+                            "Вы получили отказ от %s на резюме %s",
+                            vacancy["alternate_url"],
+                            resume["alternate_url"],
+                        )
+                        print(
+                            "⛔ Пришел отказ от",
+                            vacancy["alternate_url"],
+                            "на резюме",
+                            resume["alternate_url"],
                         )
-                        print("⛔  Пришел отказ", vacancy["alternate_url"])
                     continue
 
                 params = {
-                    "resume_id": self.resume_id,
+                    "resume_id": resume["id"],
                     "vacancy_id": vacancy_id,
                     "message": "",
                 }
@@ -379,13 +436,19 @@ class Operation(BaseOperation):
                 ):
                     if self.openai_chat:
                         msg = self.pre_prompt + "\n\n"
-                        msg += placeholders["vacancy_name"]
+                        msg += (
+                            "Название вакансии: "
+                            + message_placeholders["vacancy_name"]
+                        )
+                        msg += (
+                            "Мое резюме:" + message_placeholders["resume_title"]
+                        )
                         logger.debug("prompt: %s", msg)
                         msg = self.openai_chat.send_message(msg)
                     else:
-                        msg = (
+                        msg = unescape_string(
                             rand_text(random.choice(self.application_messages))
-                            % placeholders
+                            % message_placeholders
                         )
 
                     logger.debug(msg)
@@ -400,12 +463,18 @@ class Operation(BaseOperation):
                         )
                         assert res == {}
                         logger.debug(
-                            "Отправили отклик: %s", vacancy["alternate_url"]
+                            "Откликнулись на %s с резюме %s",
+                            vacancy["alternate_url"],
+                            resume["alternate_url"],
                         )
                     print(
-                        "📨 Отправили отклик:",
+                        "📨 Отправили отклик для резюме",
+                        resume["alternate_url"],
+                        "на вакансию",
                         vacancy["alternate_url"],
+                        "(",
                         shorten(vacancy["name"]),
+                        ")",
                     )
                 except Redirect:
                     logger.warning(
@@ -414,22 +483,19 @@ class Operation(BaseOperation):
             except LimitExceeded:
                 logger.info("Достигли лимита на отклики")
                 print("⚠️ Достигли лимита рассылки")
-                # self.tool.storage.settings.set_value("_")
                 break
             except ApiError as ex:
                 logger.warning(ex)
             except (BadResponse, AIError) as ex:
                 logger.error(ex)
 
-        print("📝 Отклики на вакансии разосланы!")
-
     def _get_search_params(self, page: int) -> dict:
         params = {
             "page": page,
             "per_page": self.per_page,
-            "order_by": self.order_by,
         }
-
+        if self.order_by:
+            params |= {"order_by": self.order_by}
         if self.search:
             params["text"] = self.search
         if self.schedule:
@@ -489,11 +555,11 @@ class Operation(BaseOperation):
 
         return params
 
-    def _get_vacancies(self) -> Iterator[SearchVacancy]:
+    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/{self.resume_id}/similar_vacancies",
+                f"/resumes/{resume_id}/similar_vacancies",
                 params,
             )
             if not res["items"]:
@@ -503,3 +569,21 @@ class Operation(BaseOperation):
 
             if page >= res["pages"] - 1:
                 return
+
+    def _get_application_messages(self, path: Path | None) -> list[str]:
+        return (
+            list(
+                filter(
+                    None,
+                    map(
+                        str.strip,
+                        path.open(encoding="utf-8", errors="replace"),
+                    ),
+                )
+            )
+            if path
+            else [
+                "Здравствуйте, меня зовут %(first_name)s. {Меня заинтересовала|Мне понравилась} ваша вакансия «%(vacancy_name)s». Хотелось бы {пообщаться|задать вопросы} о ней.",
+                "{Прошу|Предлагаю} рассмотреть {мою кандидатуру|мое резюме «%(resume_title)s»} на вакансию «%(vacancy_name)s». С уважением, %(first_name)s.",  # noqa: E501
+            ]
+        )

hh_applicant_tool/operations/authorize.py

@@ -14,6 +14,7 @@ except ImportError:
     pass
 
 from ..main import BaseOperation
+from ..utils.terminal import print_kitty_image, print_sixel_mage
 
 if TYPE_CHECKING:
     from ..main import HHApplicantTool
@@ -36,11 +37,13 @@ class Operation(BaseOperation):
     __aliases__: list = ["auth", "authen", "authenticate"]
 
     # Селекторы
-    SEL_LOGIN_INPUT = 'input[data-qa="login-input-username"]'
-    SEL_EXPAND_PASSWORD_BTN = 'button[data-qa="expand-login-by_password"]'
-    SEL_PASSWORD_INPUT = 'input[data-qa="login-input-password"]'
-    SEL_CODE_CONTAINER = 'div[data-qa="account-login-code-input"]'
-    SEL_PIN_CODE_INPUT = 'input[data-qa="magritte-pincode-input-field"]'
+    SELECT_LOGIN_INPUT = 'input[data-qa="login-input-username"]'
+    SELECT_EXPAND_PASSWORD = 'button[data-qa="expand-login-by_password"]'
+    SELECT_PASSWORD_INPUT = 'input[data-qa="login-input-password"]'
+    SELECT_CODE_CONTAINER = 'div[data-qa="account-login-code-input"]'
+    SELECT_PIN_CODE_INPUT = 'input[data-qa="magritte-pincode-input-field"]'
+    SELECT_CAPTCHA_IMAGE = 'img[data-qa="account-captcha-picture"]'
+    SELECT_CAPTCHA_INPUT = 'input[data-qa="account-captcha-input"]'
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
@@ -73,20 +76,37 @@ class Operation(BaseOperation):
         )
         parser.add_argument(
             "--no-headless",
+            "-n",
             action="store_true",
             help="Показать окно браузера для отладки (отключает headless режим).",
         )
         parser.add_argument(
+            "-m",
             "--manual",
             action="store_true",
             help="Ручной режим ввода кредов, редирект будет перехвачен.",
         )
+        parser.add_argument(
+            "-k",
+            "--use-kitty",
+            "--kitty",
+            action="store_true",
+            help="Использовать kitty protocol для вывода капчи в терминал.",
+        )
+        parser.add_argument(
+            "-s",
+            "--use-sixel",
+            "--sixel",
+            action="store_true",
+            help="Использовать sixel protocol для вывода капчи в терминал.",
+        )
 
     def run(self, tool: HHApplicantTool) -> None:
         self._args = tool.args
         try:
             asyncio.run(self._main(tool))
         except (KeyboardInterrupt, asyncio.TimeoutError):
+            # _executor.shutdown(wait=False, cancel_futures=True)
             logger.warning("Что-то пошло не так")
             # os._exit(1)
             return 1
@@ -139,7 +159,7 @@ class Operation(BaseOperation):
 
                 #      # Блокировка сканирования локальных портов
                 #      if any(d in url for d in ["localhost", "127.0.0.1", "::1"]):
-                #           logger.debug(f"🛑 Блокировка запроса на локальный порт: {url}")
+                #           logger.debug(f"🛑  Блокировка запроса на локальный порт: {url}")
                 #           return await route.abort()
 
                 #      # Оптимизация трафика в headless
@@ -179,22 +199,24 @@ class Operation(BaseOperation):
                 )
 
                 if self.is_automated:
-                    # Шаг 1: Логин
-                    logger.debug(f"Ожидание поля логина {self.SEL_LOGIN_INPUT}")
+                    logger.debug(
+                        f"Ожидание поля логина {self.SELECT_LOGIN_INPUT}"
+                    )
                     await page.wait_for_selector(
-                        self.SEL_LOGIN_INPUT, timeout=self.selector_timeout
+                        self.SELECT_LOGIN_INPUT, timeout=self.selector_timeout
                     )
-                    await page.fill(self.SEL_LOGIN_INPUT, username)
+                    await page.fill(self.SELECT_LOGIN_INPUT, username)
                     logger.debug("Логин введен")
 
-                    # Шаг 2: Выбор метода входа
-                    if args.password:
-                        await self._direct_login(page, args.password)
+                    password = args.password or storage.settings.get_value(
+                        "auth.password"
+                    )
+                    if password:
+                        await self._direct_login(page, password)
                     else:
                         await self._onetime_code_login(page)
 
-                # Шаг 3: Ожидание OAuth кода
-                logger.debug("Ожидание появления OAuth кода в трафике...")
+                logger.debug("Ожидание OAuth-кода...")
 
                 auth_code = await asyncio.wait_for(
                     code_future, timeout=[None, 30.0][self.is_automated]
@@ -237,37 +259,84 @@ class Operation(BaseOperation):
 
     async def _direct_login(self, page, password: str) -> None:
         logger.info("Вход по паролю...")
+
         logger.debug(
-            f"Клик по кнопке развертывания пароля: {self.SEL_EXPAND_PASSWORD_BTN}"
+            f"Клик по кнопке развертывания пароля: {self.SELECT_EXPAND_PASSWORD}"
         )
-        await page.click(self.SEL_EXPAND_PASSWORD_BTN)
+        await page.click(self.SELECT_EXPAND_PASSWORD)
+
+        await self._handle_captcha(page)
 
-        logger.debug(f"Ожидание поля пароля: {self.SEL_PASSWORD_INPUT}")
+        logger.debug(f"Ожидание поля пароля: {self.SELECT_PASSWORD_INPUT}")
         await page.wait_for_selector(
-            self.SEL_PASSWORD_INPUT, timeout=self.selector_timeout
+            self.SELECT_PASSWORD_INPUT, timeout=self.selector_timeout
         )
-        await page.fill(self.SEL_PASSWORD_INPUT, password)
-        await page.press(self.SEL_PASSWORD_INPUT, "Enter")
+        await page.fill(self.SELECT_PASSWORD_INPUT, password)
+        await page.press(self.SELECT_PASSWORD_INPUT, "Enter")
         logger.debug("Форма с паролем отправлена")
 
     async def _onetime_code_login(self, page) -> None:
         logger.info("Вход по одноразовому коду...")
-        await page.press(self.SEL_LOGIN_INPUT, "Enter")
+
+        await page.press(self.SELECT_LOGIN_INPUT, "Enter")
+
+        await self._handle_captcha(page)
 
         logger.debug(
-            f"Ожидание контейнера ввода кода: {self.SEL_CODE_CONTAINER}"
+            f"Ожидание контейнера ввода кода: {self.SELECT_CODE_CONTAINER}"
         )
+
         await page.wait_for_selector(
-            self.SEL_CODE_CONTAINER, timeout=self.selector_timeout
+            self.SELECT_CODE_CONTAINER, timeout=self.selector_timeout
         )
 
         print("📨 Код был отправлен. Проверьте почту или SMS.")
         code = (await ainput("📩 Введите полученный код: ")).strip()
 
         if not code:
-            raise RuntimeError("Код подтверждения не может быть пустым")
+            raise RuntimeError("Код подтверждения не может быть пустым.")
 
-        logger.debug(f"Ввод кода в {self.SEL_PIN_CODE_INPUT}")
-        await page.fill(self.SEL_PIN_CODE_INPUT, code)
-        await page.press(self.SEL_PIN_CODE_INPUT, "Enter")
+        logger.debug(f"Ввод кода в {self.SELECT_PIN_CODE_INPUT}")
+        await page.fill(self.SELECT_PIN_CODE_INPUT, code)
+        await page.press(self.SELECT_PIN_CODE_INPUT, "Enter")
         logger.debug("Форма с кодом отправлена")
+
+    async def _handle_captcha(self, page):
+        try:
+            captcha_element = await page.wait_for_selector(
+                self.SELECT_CAPTCHA_IMAGE,
+                timeout=self.selector_timeout,
+                state="visible",
+            )
+        except Exception:
+            logger.debug("Капчи нет, продолжаем как обычно.")
+            return
+
+        if not (self._args.use_kitty or self._args.use_sixel):
+            raise RuntimeError(
+                "Требуется ввод капчи!",
+            )
+
+        # box = await captcha_element.bounding_box()
+
+        # width = int(box["width"])
+        # height = int(box["height"])
+
+        img_bytes = await captcha_element.screenshot()
+
+        print(
+            "Если вы не видите картинку ниже, то ваш терминал не поддерживает"
+            " вывод изображений."
+        )
+        print()
+
+        if self._args.use_kitty:
+            print_kitty_image(img_bytes)
+
+        if self._args.use_sixel:
+            print_sixel_mage(img_bytes)
+
+        captcha_text = (await ainput("Введите текст с картинки: ")).strip()
+
+        await page.fill(self.SELECT_CAPTCHA_INPUT, captcha_text)
+        await page.press(self.SELECT_CAPTCHA_INPUT, "Enter")

hh_applicant_tool/operations/call_api.py

@@ -39,9 +39,9 @@ class Operation(BaseOperation):
             "-m", "--method", "--meth", "-X", default="GET", help="HTTP Метод"
         )
 
-    def run(self, applicant_tool: HHApplicantTool) -> None:
-        args = applicant_tool.args
-        api_client = applicant_tool.api_client
+    def run(self, tool: HHApplicantTool) -> None:
+        args = tool.args
+        api_client = tool.api_client
         params = dict(x.split("=", 1) for x in args.param)
         try:
             result = api_client.request(

hh_applicant_tool/operations/{check_negotiations.py → clear_negotiations.py}

@@ -1,12 +1,13 @@
 from __future__ import annotations
 
 import argparse
+import datetime as dt
 import logging
 from typing import TYPE_CHECKING
 
 from ..api.errors import ApiError
-from ..datatypes import NegotiationStateId
 from ..main import BaseNamespace, BaseOperation
+from ..utils.date import parse_api_datetime
 
 if TYPE_CHECKING:
     from ..main import HHApplicantTool
@@ -17,21 +18,16 @@ logger = logging.getLogger(__package__)
 class Namespace(BaseNamespace):
     cleanup: bool
     blacklist_discard: bool
+    older_than: int
     dry_run: bool
 
 
 class Operation(BaseOperation):
-    """Проверяет и синхронизирует отклики с локальной базой и опционально удаляет отказы."""
+    """Удаляет отказы либо старые отклики."""
 
-    __aliases__ = ["sync-negotiations"]
+    __aliases__ = ["clear-negotiations", "delete-negotiations"]
 
     def setup_parser(self, parser: argparse.ArgumentParser) -> None:
-        parser.add_argument(
-            "--cleanup",
-            "--clean",
-            action=argparse.BooleanOptionalAction,
-            help="Удалить отклики с отказами",
-        )
         parser.add_argument(
             "-b",
             "--blacklist-discard",
@@ -39,6 +35,12 @@ class Operation(BaseOperation):
             action=argparse.BooleanOptionalAction,
             help="Блокировать работодателя за отказ",
         )
+        parser.add_argument(
+            "-o",
+            "--older-than",
+            type=int,
+            help="С флагом --clean удаляет любые отклики старше N дней",
+        )
         parser.add_argument(
             "-n",
             "--dry-run",
@@ -48,26 +50,32 @@ class Operation(BaseOperation):
 
     def run(self, tool: HHApplicantTool) -> None:
         self.tool = tool
-        self.args = tool.args
-        self._sync()
+        self.args: Namespace = tool.args
+        self.clear()
 
-    def _sync(self) -> None:
-        storage = self.tool.storage
+    def clear(self) -> None:
+        blacklisted = set(self.tool.get_blacklisted())
         for negotiation in self.tool.get_negotiations():
             vacancy = negotiation["vacancy"]
-            employer = vacancy.get("employer", {})
-            employer_id = employer.get("id")
 
             # Если работодателя блокируют, то он превращается в null
             # ХХ позволяет скрывать компанию, когда id нет, а вместо имени "Крупная российская компания"
             # sqlite3.IntegrityError: NOT NULL constraint failed: negotiations.employer_id
-            if employer_id:
-                storage.negotiations.save(negotiation)
-
-            state_id: NegotiationStateId = negotiation["state"]["id"]
-            if not self.args.cleanup:
-                continue
-            if state_id != "discard":
+            # try:
+            #     storage.negotiations.save(negotiation)
+            # except RepositoryError as e:
+            #     logger.exception(e)
+
+            if self.args.older_than:
+                updated_at = parse_api_datetime(negotiation["updated_at"])
+                # А хз какую временную зону сайт возвращает
+                days_passed = (
+                    dt.datetime.now(updated_at.tzinfo) - updated_at
+                ).days
+                logger.debug(f"{days_passed = }")
+                if days_passed <= self.args.older_than:
+                    continue
+            elif negotiation["state"]["id"] != "discard":
                 continue
             try:
                 if not self.args.dry_run:
@@ -78,18 +86,24 @@ class Operation(BaseOperation):
 
                 print(
                     "🗑️ Отменили отклик на вакансию:",
-                    vacancy["name"],
                     vacancy["alternate_url"],
+                    vacancy["name"],
                 )
 
+                employer = vacancy.get("employer", {})
+                employer_id = employer.get("id")
+
                 if (
-                    employer_id
-                    and employer_id not in self.args.blacklist_discard
+                    self.args.blacklist_discard
+                    and employer
+                    and employer_id
+                    and employer_id not in blacklisted
                 ):
                     if not self.args.dry_run:
                         self.tool.api_client.put(
                             f"/employers/blacklisted/{employer_id}"
                         )
+                        blacklisted.add(employer_id)
 
                     print(
                         "🚫 Работодатель заблокирован:",
@@ -99,4 +113,4 @@ class Operation(BaseOperation):
             except ApiError as err:
                 logger.error(err)
 
-        print("✅ Синхронизация завершена.")
+        print("✅ Удаление откликов завершено.")