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

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 ..datatypes import PaginatedItems
+from ..main import BaseNamespace, BaseOperation
+from ..utils.string import shorten
+
+if TYPE_CHECKING:
+    from .. import datatypes
+    from ..main import HHApplicantTool
+
 
 logger = logging.getLogger(__package__)
 
@@ -20,20 +25,29 @@ 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()
+        storage = tool.storage
+        for resume in resumes["items"]:
+            storage.resumes.save(resume)
+
+        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"]
             ]
         )
         print(t)
+        print(f"\nНайдено резюме: {resumes['found']}")

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

hh_applicant_tool/operations/query.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+import argparse
+import csv
+import logging
+import sqlite3
+import sys
+from typing import TYPE_CHECKING
+
+from prettytable import PrettyTable
+
+from ..main import BaseNamespace, BaseOperation
+
+if TYPE_CHECKING:
+    from ..main import HHApplicantTool
+
+try:
+    import readline
+
+    readline.parse_and_bind("tab: complete")
+except ImportError:
+    readline = None
+
+MAX_RESULTS = 10
+
+
+logger = logging.getLogger(__package__)
+
+
+class Namespace(BaseNamespace):
+    pass
+
+
+class Operation(BaseOperation):
+    """Выполняет SQL-запрос. Поддерживает вывод в консоль или CSV файл."""
+
+    __aliases__: list[str] = ["sql"]
+
+    def setup_parser(self, parser: argparse.ArgumentParser) -> None:
+        parser.add_argument("sql", nargs="?", help="SQL запрос")
+        parser.add_argument(
+            "--csv", action="store_true", help="Вывести результат в формате CSV"
+        )
+        parser.add_argument(
+            "-o",
+            "--output",
+            type=argparse.FileType("w", encoding="utf-8"),
+            help="Файл для сохранения",
+        )
+
+    def run(self, tool: HHApplicantTool) -> None:
+        def execute(sql_query: str) -> None:
+            sql_query = sql_query.strip()
+            if not sql_query:
+                return
+            try:
+                cursor = tool.db.cursor()
+                cursor.execute(sql_query)
+
+                if cursor.description:
+                    columns = [d[0] for d in cursor.description]
+
+                    if tool.args.csv or tool.args.output:
+                        # Если -o не задан, используем sys.stdout
+                        output = tool.args.output or sys.stdout
+                        writer = csv.writer(output)
+                        writer.writerow(columns)
+                        writer.writerows(cursor.fetchall())
+
+                        if tool.args.output:
+                            print(f"✅ Exported to {tool.args.output.name}")
+                        return
+
+                    rows = cursor.fetchmany(MAX_RESULTS + 1)
+                    if not rows:
+                        print("No results found.")
+                        return
+
+                    table = PrettyTable()
+                    table.field_names = columns
+                    for row in rows[:MAX_RESULTS]:
+                        table.add_row(row)
+
+                    print(table)
+                    if len(rows) > MAX_RESULTS:
+                        print(
+                            f"⚠️  Warning: Showing only first {MAX_RESULTS} results."
+                        )
+                else:
+                    tool.db.commit()
+                    print(f"OK. Rows affected: {cursor.rowcount}")
+
+            except sqlite3.Error as ex:
+                print(f"❌ SQL Error: {ex}")
+                return 1
+
+        if initial_sql := tool.args.sql:
+            return execute(initial_sql)
+
+        if not sys.stdin.isatty():
+            return execute(sys.stdin.read())
+
+        print("SQL Console (q or ^D to exit)")
+        try:
+            while True:
+                try:
+                    user_input = input("query> ").strip()
+                    if user_input.lower() in (
+                        "exit",
+                        "quit",
+                        "q",
+                    ):
+                        break
+                    execute(user_input)
+                    print()
+                except KeyboardInterrupt:
+                    print("^C")
+                    continue
+        except EOFError:
+            print()

hh_applicant_tool/operations/refresh_token.py

@@ -1,11 +1,14 @@
-# Этот модуль можно использовать как образец для других
+from __future__ import annotations
+
 import argparse
 import logging
-from typing import Any
-from ..api import ApiError, ApiClient
-from ..main import BaseOperation
-from ..main import Namespace as BaseNamespace
-from ..utils import print_err
+from typing import TYPE_CHECKING
+
+from ..main import BaseNamespace, BaseOperation
+
+if TYPE_CHECKING:
+    from ..main import HHApplicantTool
+
 
 logger = logging.getLogger(__package__)
 
@@ -17,13 +20,11 @@ class Namespace(BaseNamespace):
 class Operation(BaseOperation):
     """Получает новый access_token."""
 
+    __aliases__ = ["refresh"]
+
     def setup_parser(self, parser: argparse.ArgumentParser) -> None:
         pass
 
-    def run(self, _, api_client: ApiClient, *args: Any) -> None:
-        try:
-            api_client.refresh_access_token()
-            print("✅ Токен обновлен!")
-        except ApiError as ex:
-            print_err("❗ Ошибка:", ex)
-            return 1
+    def run(self, tool: HHApplicantTool) -> None:
+        tool.api_client.refresh_access_token()
+        print("✅ Токен обновлен!")