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

hh_applicant_tool/operations/clear_negotiations.py

@@ -1,109 +1,117 @@
-# Этот модуль можно использовать как образец для других
+from __future__ import annotations
+
 import argparse
+import datetime as dt
 import logging
-from datetime import datetime, timedelta, timezone
+from typing import TYPE_CHECKING
+
+from ..api.errors import ApiError
+from ..main import BaseNamespace, BaseOperation
+from ..utils.date import parse_api_datetime
 
-from ..api import ApiClient, ClientError
-from ..constants import INVALID_ISO8601_FORMAT
-from ..main import BaseOperation
-from ..main import Namespace as BaseNamespace
-from ..types import ApiListResponse
-from ..utils import print_err, truncate_string
+if TYPE_CHECKING:
+    from ..main import HHApplicantTool
 
 logger = logging.getLogger(__package__)
 
 
 class Namespace(BaseNamespace):
-    older_than: int
+    cleanup: bool
     blacklist_discard: bool
-    all: bool
+    older_than: int
+    dry_run: bool
 
 
 class Operation(BaseOperation):
-    """Отменяет старые отклики, скрывает отказы с опциональной блокировкой работодателя."""
+    """Удаляет отказы либо старые отклики."""
+
+    __aliases__ = ["clear-negotiations", "delete-negotiations"]
 
     def setup_parser(self, parser: argparse.ArgumentParser) -> None:
         parser.add_argument(
-            "--older-than",
-            type=int,
-            default=30,
-            help="Удалить отклики старше опр. кол-ва дней. По умолчанию: %(default)d",
+            "-b",
+            "--blacklist-discard",
+            "--blacklist",
+            action=argparse.BooleanOptionalAction,
+            help="Блокировать работодателя за отказ",
         )
         parser.add_argument(
-            "--all",
-            action=argparse.BooleanOptionalAction,
-            help="Удалить все отклики в тч с приглашениями",
+            "-o",
+            "--older-than",
+            type=int,
+            help="С флагом --clean удаляет любые отклики старше N дней",
         )
         parser.add_argument(
-            "--blacklist-discard",
-            help="Если установлен, то заблокирует работодателя в случае отказа, чтобы его вакансии не отображались в возможных",
+            "-n",
+            "--dry-run",
             action=argparse.BooleanOptionalAction,
+            help="Тестовый запуск без реального удаления",
         )
 
-    def _get_active_negotiations(self, api_client: ApiClient) -> list[dict]:
-        rv = []
-        page = 0
-        per_page = 100
-        while True:
-            r: ApiListResponse = api_client.get(
-                "/negotiations", page=page, per_page=per_page, status="active"
-            )
-            rv.extend(r["items"])
-            page += 1
-            if page >= r["pages"]:
-                break
-        return rv
-
-    def run(self, args: Namespace, api_client: ApiClient, *_) -> None:
-        negotiations = self._get_active_negotiations(api_client)
-        print("Всего активных:", len(negotiations))
-        for item in negotiations:
-            state = item["state"]
-            # messaging_status archived
-            # decline_allowed False
-            # hidden True
-            is_discard = state["id"] == "discard"
-            if not item["hidden"] and (
-                args.all
-                or is_discard
-                or (
-                    state["id"] == "response"
-                    and (datetime.utcnow() - timedelta(days=args.older_than)).replace(
-                        tzinfo=timezone.utc
+    def run(self, tool: HHApplicantTool) -> None:
+        self.tool = tool
+        self.args: Namespace = tool.args
+        self.clear()
+
+    def clear(self) -> None:
+        blacklisted = set(self.tool.get_blacklisted())
+        storage = self.tool.storage
+        for negotiation in self.tool.get_negotiations():
+            vacancy = negotiation["vacancy"]
+
+            # Если работодателя блокируют, то он превращается в null
+            # ХХ позволяет скрывать компанию, когда id нет, а вместо имени "Крупная российская компания"
+            # sqlite3.IntegrityError: NOT NULL constraint failed: negotiations.employer_id
+            # 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:
+                    self.tool.api_client.delete(
+                        f"/negotiations/active/{negotiation['id']}",
+                        with_decline_message=True,
                     )
-                    > datetime.strptime(item["updated_at"], INVALID_ISO8601_FORMAT)
-                )
-            ):
-                decline_allowed = item.get("decline_allowed") or False
-                r = api_client.delete(
-                    f"/negotiations/active/{item['id']}",
-                    with_decline_message=decline_allowed,
-                )
-                assert {} == r
-                vacancy = item["vacancy"]
+
                 print(
-                    "❌ Удалили",
-                    state["name"].lower(),
+                    "🗑️ Отменили отклик на вакансию:",
                     vacancy["alternate_url"],
-                    "(",
-                    truncate_string(vacancy["name"]),
-                    ")",
+                    vacancy["name"],
                 )
-                if is_discard and args.blacklist_discard:
-                    employer = vacancy.get("employer", {})
-                    if not employer or 'id' not in employer:
-                        # Работодатель удален или скрыт
-                        continue
-                    try:
-                        r = api_client.put(f"/employers/blacklisted/{employer['id']}")
-                        assert not r
-                        print(
-                            "🚫 Заблокировали",
-                            employer["alternate_url"],
-                            "(",
-                            truncate_string(employer["name"]),
-                            ")",
+
+                employer = vacancy.get("employer", {})
+                employer_id = employer.get("id")
+
+                if (
+                    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}"
                         )
-                    except ClientError as ex:
-                        print_err("❗ Ошибка:", ex)
-        print("🧹 Чистка заявок завершена!")
+                        blacklisted.add(employer_id)
+
+                    print(
+                        "🚫 Работодатель заблокирован:",
+                        employer["name"],
+                        employer["alternate_url"],
+                    )
+            except ApiError as err:
+                logger.error(err)
+
+        print("✅ Удаление откликов завершено.")

hh_applicant_tool/operations/config.py

@@ -1,49 +1,152 @@
+from __future__ import annotations
+
 import argparse
+import json
 import logging
 import os
+import platform
 import subprocess
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
-from ..main import BaseOperation
-from ..main import Namespace as BaseNamespace
+from ..main import BaseNamespace, BaseOperation
 
-logger = logging.getLogger(__package__)
+if TYPE_CHECKING:
+    from ..main import HHApplicantTool
 
-EDITOR = os.getenv("EDITOR", "nano")
+
+logger = logging.getLogger(__package__)
 
 
 class Namespace(BaseNamespace):
     show_path: bool
     key: str
+    set: list[str]
+    edit: bool
+    unset: str
 
 
 def get_value(data: dict[str, Any], path: str) -> Any:
     for key in path.split("."):
-        if key not in data:
+        if isinstance(data, dict):
+            data = data.get(key)
+        else:
             return None
-        data = data[key]
     return data
 
 
+def set_value(data: dict[str, Any], path: str, value: Any) -> None:
+    """Устанавливает значение во вложенном словаре по ключу в виде строки."""
+    keys = path.split(".")
+    for key in keys[:-1]:
+        data = data.setdefault(key, {})
+    data[keys[-1]] = value
+
+
+def del_value(data: dict[str, Any], path: str) -> None:
+    """Удаляет значение из вложенного словаря по ключу в виде строки."""
+    keys = path.split(".")
+    for key in keys[:-1]:
+        if not isinstance(data, dict) or key not in data:
+            return False
+        data = data[key]
+
+    try:
+        del data[keys[-1]]
+        return True
+    except KeyError:
+        return False
+
+
+def parse_scalar(value: str) -> bool | int | float | str:
+    if value == "null":
+        return None
+    if value in ["true", "false"]:
+        return "t" in value
+    try:
+        return float(value) if "." in value else int(value)
+    except ValueError:
+        return value
+
+
 class Operation(BaseOperation):
-    """Операции с конфигурационным файлом"""
+    """
+    Операции с конфигурационным файлом.
+    По умолчанию выводит содержимое конфига.
+    """
 
     def setup_parser(self, parser: argparse.ArgumentParser) -> None:
-        parser.add_argument(
+        group = parser.add_mutually_exclusive_group()
+        group.add_argument(
+            "-e",
+            "--edit",
+            action="store_true",
+            help="Открыть конфигурационный файл в редакторе",
+        )
+        group.add_argument(
+            "-k", "--key", help="Вывести отдельное значение из конфига"
+        )
+        group.add_argument(
+            "-s",
+            "--set",
+            nargs=2,
+            metavar=("KEY", "VALUE"),
+            help="Установить значение в конфиг, например, --set openai.model gpt-4o",
+        )
+        group.add_argument(
+            "-u", "--unset", metavar="KEY", help="Удалить ключ из конфига"
+        )
+        group.add_argument(
             "-p",
             "--show-path",
             "--path",
-            action=argparse.BooleanOptionalAction,
+            action="store_true",
             help="Вывести полный путь к конфигу",
         )
-        parser.add_argument("-k", "--key", help="Вывести отдельное значение из конфига")
 
-    def run(self, args: Namespace, *_) -> None:
+    def run(self, applicant_tool: HHApplicantTool) -> None:
+        args = applicant_tool.args
+        config = applicant_tool.config
+        if args.set:
+            key, value = args.set
+            set_value(config, key, parse_scalar(value))
+            config.save()
+            logger.info("Значение '%s' для ключа '%s' сохранено.", value, key)
+            return
+
+        if args.unset:
+            key = args.unset
+            if del_value(config, key):
+                config.save()
+                logger.info("Ключ '%s' удален из конфига.", key)
+            else:
+                logger.warning("Ключ '%s' не найден в конфиге.", key)
+            return
+
         if args.key:
-            print(get_value(args.config, args.key))
+            value = get_value(config, args.key)
+            if value is not None:
+                print(value)
             return
-        config_path = str(args.config._config_path)
+
+        config_path = str(config._config_path)
         if args.show_path:
             print(config_path)
-        else:
-            subprocess.call([EDITOR, config_path])
+            return
+
+        if args.edit:
+            self._open_editor(config_path)
+            return
+
+        # Default action: show content
+        print(json.dumps(config, indent=2, ensure_ascii=False))
+
+    def _open_editor(self, filepath: str) -> None:
+        """Открывает файл в редакторе по умолчанию в зависимости от ОС."""
+        match platform.system():
+            case "Windows":
+                os.startfile(filepath)
+            case "Darwin":  # macOS
+                subprocess.run(["open", filepath], check=True)
+            case _:  # Linux и остальные (аналог else)
+                editor = os.getenv("EDITOR", "xdg-open")
+                subprocess.run([editor, filepath], check=True)

hh_applicant_tool/operations/install.py

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

hh_applicant_tool/operations/list_resumes.py

@@ -1,14 +1,19 @@
-# Этот модуль можно использовать как образец для других
+from __future__ import annotations
+
 import argparse
 import logging
+from typing import TYPE_CHECKING
 
 from prettytable import PrettyTable
 
-from ..api import ApiClient
-from ..main import BaseOperation
-from ..main import Namespace as BaseNamespace
-from ..types import ApiListResponse
-from ..utils import truncate_string
+from ..api.datatypes import PaginatedItems
+from ..main import BaseNamespace, BaseOperation
+from ..utils.string import shorten
+
+if TYPE_CHECKING:
+    from ..api import datatypes
+    from ..main import HHApplicantTool
+
 
 logger = logging.getLogger(__package__)
 
@@ -20,20 +25,27 @@ class Namespace(BaseNamespace):
 class Operation(BaseOperation):
     """Список резюме"""
 
+    __aliases__ = ("ls-resumes", "resumes")
+
     def setup_parser(self, parser: argparse.ArgumentParser) -> None:
         pass
 
-    def run(self, args: Namespace, api_client: ApiClient, *_) -> None:
-        resumes: ApiListResponse = api_client.get("/resumes/mine")
-        t = PrettyTable(field_names=["ID", "Название", "Статус"], align="l", valign="t")
+    def run(self, tool: HHApplicantTool) -> None:
+        resumes: PaginatedItems[datatypes.Resume] = tool.get_resumes()
+        logger.debug(resumes)
+        tool.storage.resumes.save_batch(resumes)
+
+        t = PrettyTable(
+            field_names=["ID", "Название", "Статус"], align="l", valign="t"
+        )
         t.add_rows(
             [
                 (
                     x["id"],
-                    truncate_string(x["title"]),
+                    shorten(x["title"]),
                     x["status"]["name"].title(),
                 )
-                for x in resumes["items"]
+                for x in resumes
             ]
         )
         print(t)

hh_applicant_tool/operations/log.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+import argparse
+import logging
+import os
+import shutil
+import subprocess
+import sys
+from typing import TYPE_CHECKING
+
+from ..main import BaseNamespace, BaseOperation
+
+if TYPE_CHECKING:
+    from ..main import HHApplicantTool
+
+
+logger = logging.getLogger(__package__)
+
+
+class Namespace(BaseNamespace):
+    follow: bool
+
+
+class Operation(BaseOperation):
+    """Просмотр файла-лога"""
+
+    def setup_parser(self, parser: argparse.ArgumentParser) -> None:
+        # Изменено на -F для соответствия стандарту less/tail
+        parser.add_argument(
+            "-f",
+            "--follow",
+            action="store_true",
+            help="Следить за файлом (режим follow, аналог less +F)",
+        )
+
+    def run(self, tool: HHApplicantTool) -> None:
+        log_path = tool.log_file
+
+        if not os.path.exists(log_path):
+            logger.error("Файл лога не найден: %s", log_path)
+            return 1
+
+        if sys.platform == "win32":
+            os.startfile(log_path)
+            return
+
+        pager = os.getenv("PAGER", "less")
+        if not shutil.which(pager):
+            logger.error("Не найден просмотрщик '%s'", pager)
+            if pager == "less":
+                logger.error(
+                    'Попробуйте установить less: "sudo apt install less" или "sudo yum install less"'
+                )
+            return 1
+
+        cmd = [pager]
+
+        if pager == "less":
+            # -R позволяет отображать цвета (ANSI codes)
+            # -S отключает перенос строк (удобно для логов)
+            cmd.extend(["-R", "-S"])
+            if tool.args.follow:
+                # В less режим слежения включается через команду +F
+                cmd.append("+F")
+
+        cmd.append(str(log_path))
+
+        try:
+            # Запускаем процесс. check=False, так как выход из pager
+            # по Ctrl+C может вернуть ненулевой код.
+            subprocess.run(cmd, check=False)
+        except FileNotFoundError:
+            logger.error("Не удалось запустить просмотрщик '%s'", pager)
+            return 1
+        except KeyboardInterrupt:
+            # Обработка прерывания, чтобы не выводить traceback в консоль
+            pass

hh_applicant_tool/operations/migrate_db.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+import argparse
+import logging
+import os
+import sqlite3
+import sys
+from typing import TYPE_CHECKING
+
+from ..main import BaseNamespace, BaseOperation
+from ..storage import apply_migration, list_migrations
+
+if TYPE_CHECKING:
+    from ..main import HHApplicantTool
+
+SUCKASS = "✅ Success!"
+
+logger = logging.getLogger(__package__)
+
+
+class Namespace(BaseNamespace):
+    pass
+
+
+class Operation(BaseOperation):
+    """Выполняет миграцию БД. Если первым аргументом имя миграции не передано, выведет их список."""  # noqa: E501
+
+    __aliases__: list[str] = ["migrate"]
+
+    def setup_parser(self, parser: argparse.ArgumentParser) -> None:
+        parser.add_argument("name", nargs="?", help="Имя миграции")
+
+    def run(self, tool: HHApplicantTool) -> None:
+        def apply(name: str) -> None:
+            apply_migration(tool.db, name)
+            print(SUCKASS)
+
+        try:
+            if a := tool.args.name:
+                return apply(a)
+            if not (migrations := list_migrations()):
+                return
+            if not sys.stdout.isatty():
+                print(*list_migrations(), sep=os.sep)
+                return
+            print("List of migrations:")
+            print()
+            for n, migration in enumerate(migrations, 1):
+                print(f"  [{n}]: {migration}")
+            print()
+            L = len(migrations)
+            if n := int(
+                input(
+                    f"Choose migration [1{f'-{L}' if L > 1 else ''}] (Keep empty to exit): "  # noqa: E501
+                )
+                or 0
+            ):
+                apply(migrations[n - 1])
+        except sqlite3.OperationalError as ex:
+            logger.exception(ex)
+            logger.warning(
+                f"Если ничего не помогает, то вы можете просто удалить базу, сделав бекап:\n\n"
+                f"  $ mv {tool.db_path}{{,.bak}}"
+            )
+            return 1