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

hh_applicant_tool/operations/authorize.py

@@ -14,6 +14,7 @@ except ImportError:
     pass
 
 from ..main import BaseOperation
+from ..utils.terminal import print_kitty_image
 
 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,30 @@ 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 для вывода изображения в терминал. Гуглите поддерживает ли ваш терминал его",
+        )
 
     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
@@ -179,22 +192,21 @@ 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)
                     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 +249,82 @@ 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:
+            raise RuntimeError(
+                "Используйте флаг --use-kitty/-k для вывода капчи в терминал."
+                "Работает не во всех терминалах!",
+            )
+
+        logger.info("Обнаружена капча!")
+
+        # box = await captcha_element.bounding_box()
+
+        # width = int(box["width"])
+        # height = int(box["height"])
+
+        img_bytes = await captcha_element.screenshot()
+
+        print(
+            "Если вы не видите картинку ниже, то ваш терминал не поддерживает"
+            " kitty protocol."
+        )
+        print()
+        print_kitty_image(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,33 @@ 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:
+    def clear(self) -> None:
+        blacklisted = set(self.tool.get_blacklisted())
         storage = self.tool.storage
         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 +87,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 +114,4 @@ class Operation(BaseOperation):
             except ApiError as err:
                 logger.error(err)
 
-        print("✅ Синхронизация завершена.")
+        print("✅ Удаление откликов завершено.")

hh_applicant_tool/operations/list_resumes.py

@@ -6,12 +6,12 @@ from typing import TYPE_CHECKING
 
 from prettytable import PrettyTable
 
-from ..datatypes import PaginatedItems
+from ..api.datatypes import PaginatedItems
 from ..main import BaseNamespace, BaseOperation
 from ..utils.string import shorten
 
 if TYPE_CHECKING:
-    from .. import datatypes
+    from ..api import datatypes
     from ..main import HHApplicantTool
 
 
@@ -32,9 +32,8 @@ class Operation(BaseOperation):
 
     def run(self, tool: HHApplicantTool) -> None:
         resumes: PaginatedItems[datatypes.Resume] = tool.get_resumes()
-        storage = tool.storage
-        for resume in resumes["items"]:
-            storage.resumes.save(resume)
+        logger.debug(resumes)
+        tool.storage.resumes.save_batch(resumes)
 
         t = PrettyTable(
             field_names=["ID", "Название", "Статус"], align="l", valign="t"
@@ -46,8 +45,7 @@ class Operation(BaseOperation):
                     shorten(x["title"]),
                     x["status"]["name"].title(),
                 )
-                for x in resumes["items"]
+                for x in resumes
             ]
         )
         print(t)
-        print(f"\nНайдено резюме: {resumes['found']}")

hh_applicant_tool/operations/query.py

@@ -88,7 +88,9 @@ class Operation(BaseOperation):
                         )
                 else:
                     tool.db.commit()
-                    print(f"OK. Rows affected: {cursor.rowcount}")
+
+                    if cursor.rowcount > 0:
+                        print(f"Rows affected: {cursor.rowcount}")
 
             except sqlite3.Error as ex:
                 print(f"❌ SQL Error: {ex}")

hh_applicant_tool/operations/reply_employers.py

@@ -3,13 +3,13 @@ from __future__ import annotations
 import argparse
 import logging
 import random
+from datetime import datetime
 from typing import TYPE_CHECKING
 
-from .. import datatypes
 from ..ai.base import AIError
-from ..api import ApiError
+from ..api import ApiError, datatypes
 from ..main import BaseNamespace, BaseOperation
-from ..utils.dateutil import parse_api_datetime
+from ..utils.date import parse_api_datetime
 from ..utils.string import rand_text
 
 if TYPE_CHECKING:
@@ -37,21 +37,30 @@ class Namespace(BaseNamespace):
     use_ai: bool
     first_prompt: str
     prompt: str
+    period: int
 
 
 class Operation(BaseOperation):
     """Ответ всем работодателям."""
 
-    __aliases__ = ["reply-chats", "reply-all"]
+    __aliases__ = ["reply-empls", "reply-chats", "reall"]
 
     def setup_parser(self, parser: argparse.ArgumentParser) -> None:
-        parser.add_argument("--resume-id", help="Идентификатор резюме")
+        parser.add_argument(
+            "--resume-id",
+            help="Идентификатор резюме. Если не указан, то просматриваем чаты для всех резюме",
+        )
         parser.add_argument(
             "-m",
             "--reply-message",
             "--reply",
             help="Отправить сообщение во все чаты. Если не передать сообщение, то нужно будет вводить его в интерактивном режиме.",  # noqa: E501
         )
+        parser.add_argument(
+            "--period",
+            type=int,
+            help="Игнорировать отклики, которые не обновлялись больше N дней",
+        )
         parser.add_argument(
             "-p",
             "--max-pages",
@@ -92,7 +101,7 @@ class Operation(BaseOperation):
 
     def run(self, tool: HHApplicantTool) -> None:
         args: Namespace = tool.args
-        self.applicant_tool = tool
+        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(
@@ -106,27 +115,60 @@ class Operation(BaseOperation):
         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 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", ""),
-            "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.applicant_tool.get_negotiations():
+        for negotiation in self.tool.get_negotiations():
             try:
-                self.applicant_tool.storage.negotiations.save(negotiation)
+                # try:
+                #     self.tool.storage.negotiations.save(negotiation)
+                # except RepositoryError as e:
+                #     logger.exception(e)
 
-                if self.resume_id != negotiation["resume"]["id"]:
+                if not (resume := resume_map.get(negotiation["resume"]["id"])):
+                    continue
+
+                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"]
@@ -141,26 +183,27 @@ class Operation(BaseOperation):
                 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: datatypes.PaginatedItems[
@@ -183,7 +226,8 @@ class Operation(BaseOperation):
                         )
                         message_date = parse_api_datetime(
                             message.get("created_at")
-                        ).isoformat()
+                        ).strftime("%d.%m.%Y %H:%M:%S")
+
                         message_history.append(
                             f"[ {message_date} ] {author}: {message['text']}"
                         )
@@ -205,13 +249,13 @@ class Operation(BaseOperation):
                     send_message = ""
                     if self.reply_message:
                         send_message = (
-                            rand_text(self.reply_message) % message_placeholders
+                            rand_text(self.reply_message) % placeholders
                         )
                         logger.debug(f"Template message: {send_message}")
                     elif self.openai_chat:
                         try:
                             ai_query = (
-                                f"Вакансия: {message_placeholders['vacancy_name']}\n"
+                                f"Вакансия: {placeholders['vacancy_name']}\n"
                                 f"История переписки:\n"
                                 + "\n".join(message_history[-10:])
                                 + f"\n\nИнструкция: {self.pre_prompt}"
@@ -226,12 +270,8 @@ class Operation(BaseOperation):
                             )
                             continue
                     else:
-                        print(
-                            "\n🏢",
-                            message_placeholders["employer_name"],
-                            "| 💼",
-                            message_placeholders["vacancy_name"],
-                        )
+                        print("🏢", placeholders["employer_name"])
+                        print("💼", placeholders["vacancy_name"])
                         if salary:
                             print(
                                 "💵 от",
@@ -251,9 +291,10 @@ class Operation(BaseOperation):
                             print(msg)
 
                         try:
-                            print("-" * 10)
+                            print("-" * 40)
+                            print("Активное резюме:", resume.get("title") or "")
                             print(
-                                "Команды: /ban, /cancel <опционально сообщение для отмены>"
+                                "/ban, /cancel необязательное сообщение для отмены"
                             )
                             send_message = input("Ваше сообщение: ").strip()
                         except EOFError:
@@ -264,13 +305,12 @@ class Operation(BaseOperation):
                             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"])
+                            blacklist.add(employer["id"])
                             print(
-                                "🚫 Работодатель в ЧС",
+                                "🚫 Работодатель заблокирован",
                                 employer.get("alternate_url"),
                             )
                             continue

hh_applicant_tool/operations/settings.py

@@ -7,8 +7,8 @@ from typing import TYPE_CHECKING
 
 from prettytable import PrettyTable
 
+from .. import utils
 from ..main import BaseNamespace, BaseOperation
-from ..utils import jsonutil
 
 if TYPE_CHECKING:
     from ..main import HHApplicantTool
@@ -28,7 +28,7 @@ class Namespace(BaseNamespace):
 
 def parse_value(v):
     try:
-        return jsonutil.loads(v)
+        return utils.json.loads(v)
     except json.JSONDecodeError:
         return v
 

hh_applicant_tool/operations/update_resumes.py

@@ -5,8 +5,7 @@ import argparse
 import logging
 from typing import TYPE_CHECKING
 
-from ..api import ApiError
-from ..datatypes import PaginatedItems
+from ..api import ApiError, datatypes
 from ..main import BaseNamespace, BaseOperation
 from ..utils import print_err
 from ..utils.string import shorten
@@ -31,8 +30,10 @@ class Operation(BaseOperation):
         pass
 
     def run(self, tool: HHApplicantTool) -> None:
-        resumes: PaginatedItems = tool.get_resumes()
-        for resume in resumes["items"]:
+        resumes: list[datatypes.Resume] = tool.get_resumes()
+        # Там вызов API меняет поля
+        # tool.storage.resumes.save_batch(resumes)
+        for resume in resumes:
             try:
                 res = tool.api_client.post(
                     f"/resumes/{resume['id']}/publish",

hh_applicant_tool/operations/whoami.py

@@ -5,7 +5,7 @@ import argparse
 import logging
 from typing import TYPE_CHECKING
 
-from .. import datatypes
+from ..api import datatypes
 from ..main import BaseNamespace, BaseOperation
 
 if TYPE_CHECKING: