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

hh_applicant_tool/utils/json.py

@@ -0,0 +1,61 @@
+import datetime as dt
+import json
+from typing import Any
+
+# class DateAwareJSONEncoder(json.JSONEncoder):
+#     def default(self, o):
+#         if isinstance(o, dt.datetime):
+#             return o.isoformat()
+
+#         return super().default(o)
+
+
+# Костыль чтобы в key-value хранить даты
+class DateAwareJSONEncoder(json.JSONEncoder):
+    def default(self, o):
+        if isinstance(o, dt.datetime):
+            return int(o.timestamp())
+
+        return super().default(o)
+
+
+# def date_parser_hook(dct):
+#     for k, v in dct.items():
+#         if isinstance(v, str):
+#             try:
+#                 dct[k] = dt.datetime.fromisoformat(v)
+#             except (ValueError, TypeError):
+#                 pass
+#     return dct
+
+
+# class DateAwareJSONDecoder(json.JSONDecoder):
+#     def __init__(self, *args, **kwargs):
+#         super().__init__(*args, object_hook=date_parser_hook, **kwargs)
+
+
+def dumps(obj, *args: Any, **kwargs: Any) -> str:
+    kwargs.setdefault("cls", DateAwareJSONEncoder)
+    kwargs.setdefault("ensure_ascii", False)
+    return json.dumps(obj, *args, **kwargs)
+
+
+def dump(fp, obj, *args: Any, **kwargs: Any) -> None:
+    kwargs.setdefault("cls", DateAwareJSONEncoder)
+    kwargs.setdefault("ensure_ascii", False)
+    json.dump(fp, obj, *args, **kwargs)
+
+
+def loads(s, *args: Any, **kwargs: Any) -> Any:
+    # kwargs.setdefault("object_hook", date_parser_hook)
+    return json.loads(s, *args, **kwargs)
+
+
+def load(fp, *args: Any, **kwargs: Any) -> Any:
+    # kwargs.setdefault("object_hook", date_parser_hook)
+    return json.load(fp, *args, **kwargs)
+
+
+if __name__ == "__main__":
+    d = {"created_at": dt.datetime.now()}
+    print(loads(dumps(d)))

hh_applicant_tool/{jsonc.py → utils/jsonc.py}

@@ -1,11 +1,11 @@
-# Unused
 """Парсер JSON с комментариями"""
 
-import re
+import ast
 import enum
+import re
 from dataclasses import dataclass
-import ast
 from typing import Any, Iterator
+
 # from collections import OrderedDict
 
 
@@ -42,7 +42,8 @@ def tokenize(s: str) -> Iterator[Token]:
 class JSONCParser:
     def parse(self, s: str) -> Any:
         self.token_it = filter(
-            lambda t: t.token_type not in [TokenType.COMMENT, TokenType.WHITESPACE],
+            lambda t: t.token_type
+            not in [TokenType.COMMENT, TokenType.WHITESPACE],
             tokenize(s),
         )
         self.token: Token
@@ -90,7 +91,9 @@ class JSONCParser:
             num = self.token.value
             return float(num) if "." in num else int(num)
         elif self.match(TokenType.KEYWORD):
-            return {"null": None, "true": True, "false": False}[self.token.value]
+            return {"null": None, "true": True, "false": False}[
+                self.token.value
+            ]
         else:
             raise SyntaxError(f"Unexpected token: {self.token.token_type.name}")
 
@@ -103,7 +106,10 @@ class JSONCParser:
         # print(f"{self.token =}, {self.next_token =}")
 
     def match(self, token_type: TokenType) -> bool:
-        if self.next_token is not None and self.next_token.token_type == token_type:
+        if (
+            self.next_token is not None
+            and self.next_token.token_type == token_type
+        ):
             self.advance()
             return True
         return False

hh_applicant_tool/utils/log.py

@@ -0,0 +1,147 @@
+import enum
+import logging
+import re
+from collections import deque
+from datetime import datetime
+from enum import auto
+from logging.handlers import RotatingFileHandler
+from os import PathLike
+from typing import Callable, TextIO
+
+# 10MB
+MAX_LOG_SIZE = 10 << 20
+
+
+class Color(enum.Enum):
+    BLACK = 30
+    RED = auto()
+    GREEN = auto()
+    YELLOW = auto()
+    BLUE = auto()
+    PURPLE = auto()
+    CYAN = auto()
+    WHITE = auto()
+
+    def __str__(self) -> str:
+        return str(self.value)
+
+
+class ColorHandler(logging.StreamHandler):
+    _color_map = {
+        "CRITICAL": Color.RED,
+        "ERROR": Color.RED,
+        "WARNING": Color.RED,
+        "INFO": Color.GREEN,
+        "DEBUG": Color.BLUE,
+    }
+
+    def format(self, record: logging.LogRecord) -> str:
+        # Подавляем вывод подробного сообщения об ошибке
+        orig_exc_info = record.exc_info
+
+        # Детали ошибки показываем только при отладке
+        if self.level > logging.DEBUG:
+            record.exc_info = None
+
+        message = super().format(record)
+        # Обязательно нужно восстановить оригинальное значение или в файловом
+        # логе не будет деталей ошибки
+        record.exc_info = orig_exc_info
+        # isatty = getattr(self.stream, "isatty", None)
+        # if isatty and isatty():
+        color_code = self._color_map[record.levelname]
+        return f"\033[{color_code}m{message}\033[0m"
+        # return message
+
+
+class RedactingFilter(logging.Filter):
+    def __init__(
+        self,
+        patterns: list[str],
+        # По умолчанию количество звездочек равно оригинальной строке
+        placeholder: str | Callable = lambda m: "*" * len(m.group(0)),
+    ):
+        super().__init__()
+        self.pattern = (
+            re.compile(f"({'|'.join(patterns)})") if patterns else None
+        )
+        self.placeholder = placeholder
+
+    def filter(self, record: logging.LogRecord) -> bool:
+        if self.pattern:
+            msg = record.getMessage()
+            msg = self.pattern.sub(self.placeholder, msg)
+            record.msg, record.args = msg, ()
+
+        return True
+
+
+def setup_logger(
+    logger: logging.Logger,
+    verbosity_level: int,
+    log_file: PathLike,
+) -> None:
+    # В лог-файл пишем все!
+    logger.setLevel(logging.DEBUG)
+    color_handler = ColorHandler()
+    # [C] Critical Error Occurred
+    color_handler.setFormatter(
+        logging.Formatter("[%(levelname).1s] %(message)s")
+    )
+    color_handler.setLevel(verbosity_level)
+
+    # Логи
+    file_handler = RotatingFileHandler(
+        log_file,
+        maxBytes=MAX_LOG_SIZE,
+        # backupCount=1,
+        encoding="utf-8",
+    )
+    file_handler.setFormatter(
+        logging.Formatter("%(asctime)s - %(levelname)s - %(message)s")
+    )
+    file_handler.setLevel(logging.DEBUG)
+
+    redactor = RedactingFilter(
+        [
+            r"\b[A-Z0-9]{64,}\b",
+            r"\b[a-fA-F0-9]{32,}\b",  # request_id, resume_id
+        ]
+    )
+
+    file_handler.addFilter(redactor)
+
+    for h in [color_handler, file_handler]:
+        logger.addHandler(h)
+
+
+TS_RE = re.compile(r"^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}")
+
+
+def collect_traceback_logs(
+    fp: TextIO,
+    after_dt: datetime,
+    maxlen: int = 1000,
+) -> str:
+    error_lines = deque(maxlen=maxlen)
+    prev_line = ""
+    log_dt = None
+    collecting_traceback = False
+    for line in fp:
+        if ts_match := TS_RE.match(line):
+            log_dt = datetime.strptime(ts_match.group(0), "%Y-%m-%d %H:%M:%S")
+            collecting_traceback = False
+
+        if (
+            line.startswith("Traceback (most recent call last):")
+            and log_dt
+            and log_dt >= after_dt
+        ):
+            error_lines.append(prev_line)
+            collecting_traceback = True
+
+        if collecting_traceback:
+            error_lines.append(line)
+
+        prev_line = line
+    return "".join(error_lines)

hh_applicant_tool/utils/misc.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+import hashlib
+import sys
+from functools import partial
+
+
+def calc_hash(data: str) -> str:
+    return hashlib.sha256(data.encode()).hexdigest()
+
+
+print_err = partial(print, file=sys.stderr, flush=True)

hh_applicant_tool/utils/mixins.py

@@ -0,0 +1,221 @@
+from __future__ import annotations
+
+import platform
+import socket
+from datetime import datetime, timedelta, timezone
+from functools import cache
+from importlib.metadata import version
+from logging import getLogger
+from typing import TYPE_CHECKING, Literal
+
+import requests
+from requests.exceptions import RequestException
+
+from ..ai.openai import ChatOpenAI
+from . import binpack
+from .log import collect_traceback_logs
+
+if TYPE_CHECKING:
+    from ..main import HHApplicantTool
+
+log = getLogger(__package__)
+
+
+def parse_version(v: str) -> tuple[int, int, int]:
+    return tuple(map(int, v.split(".")))
+
+
+@cache
+def get_package_version() -> str | None:
+    return version("hh-applicant-tool")
+
+
+class ErrorReporter:
+    def __build_report(
+        self: HHApplicantTool,
+        last_report: datetime,
+    ) -> dict:
+        error_logs = ""
+        if self.log_file.exists():
+            with self.log_file.open(encoding="utf-8", errors="ignore") as fp:
+                error_logs = collect_traceback_logs(
+                    fp, last_report, maxlen=10000
+                )
+
+        # Эти данные нужны для воспроизведения ошибок. Среди них ваших
+        # персональных данных нет
+        vacancy_contacts = [
+            c.to_dict()
+            for c in self.storage.vacancy_contacts.find(
+                updated_at__ge=last_report
+            )
+        ][-10000:]
+
+        for c in vacancy_contacts:
+            c.pop("id", 0)
+
+        employers = [
+            {
+                k: v
+                for k, v in emp.to_dict().items()
+                if k
+                in [
+                    "id",
+                    "type",
+                    "alternate_url",
+                    "area_id",
+                    "area_name",
+                    "name",
+                    "site_url",
+                    "created_at",
+                ]
+            }
+            for emp in self.storage.employers.find(updated_at__ge=last_report)
+        ][-10000:]
+
+        vacancies = [
+            {
+                k: v
+                for k, v in vac.to_dict().items()
+                if k
+                in [
+                    "id",
+                    "alternate_url",
+                    "area_id",
+                    "area_name",
+                    "salary_from",
+                    "salary_to",
+                    "currency",
+                    "name",
+                    "professional_roles",
+                    "experience",
+                    "remote",
+                    "created_at",
+                ]
+            }
+            for vac in self.storage.vacancies.find(updated_at__ge=last_report)
+        ][-10000:]
+
+        # log.info("num vacncies: %d", len(vacancies))
+
+        system_info = {
+            "os": platform.system(),
+            "os_release": platform.release(),
+            "hostname": socket.gethostname(),
+            "python_version": platform.python_version(),
+        }
+
+        return dict(
+            error_logs=error_logs,
+            vacancy_contacts=vacancy_contacts,
+            employers=employers,
+            vacancies=vacancies,
+            package_version=get_package_version(),
+            system_info=system_info,
+            report_created=datetime.now(timezone.utc),
+        )
+
+    def __send_report(self: HHApplicantTool, data: bytes) -> int:
+        try:
+            r = self.session.post(
+                # "http://localhost:8000/report",
+                "https://hh-applicant-tool.mooo.com:54157/report",
+                data=data,
+                timeout=15.0,
+            )
+            r.raise_for_status()
+            return r.status_code == 200
+        except RequestException:
+            # log.error("Network error: %s", e)
+            return False
+
+    def _process_reporting(self):
+        # Получаем timestamp последнего репорта
+        last_report = datetime.fromtimestamp(
+            self.storage.settings.get_value("_last_report", 0)
+        )
+
+        if datetime.now() >= last_report + timedelta(hours=72):
+            try:
+                report_dict = self.__build_report(last_report)
+                has_data = any(
+                    [
+                        report_dict.get("error_logs"),
+                        report_dict.get("employers"),
+                        report_dict.get("vacancy_contacts"),
+                        report_dict.get("vacancies"),
+                    ]
+                )
+                if has_data:
+                    data = binpack.serialize(report_dict)
+                    log.debug("Report body size: %d", len(data))
+                    # print(binpack.deserialize(data))
+                    if self.__send_report(data):
+                        log.debug("Report was sent")
+                    else:
+                        log.debug("Report failed")
+                else:
+                    log.debug("Nothing to report")
+            finally:
+                # Сохраняем время последней попытки/удачного репорта
+                self.storage.settings.set_value("_last_report", datetime.now())
+
+
+class VersionChecker:
+    def __get_latest_version(self: HHApplicantTool) -> Literal[False] | str:
+        try:
+            response = self.session.get(
+                "https://pypi.org/pypi/hh-applicant-tool/json", timeout=15
+            )
+            ver = response.json().get("info", {}).get("version")
+            # log.debug(ver)
+            return ver
+        except requests.RequestException:
+            return False
+
+    def _check_version(self: HHApplicantTool) -> bool:
+        if datetime.now().timestamp() >= self.storage.settings.get_value(
+            "_next_version_check", 0
+        ):
+            if v := self.__get_latest_version():
+                self.storage.settings.set_value("_latest_version", v)
+                self.storage.settings.set_value(
+                    "_next_version_check", datetime.now() + timedelta(hours=1)
+                )
+
+        if (
+            latest_ver := self.storage.settings.get_value("_latest_version")
+        ) and (cur_ver := get_package_version()):
+            if parse_version(latest_ver) > parse_version(cur_ver):
+                log.warning(
+                    "ТЕКУЩАЯ ВЕРСИЯ %s УСТАРЕЛА. РЕКОМЕНДУЕТСЯ ОБНОВИТЬ ЕЁ ДО ВЕРСИИ %s.",
+                    cur_ver,
+                    latest_ver,
+                )
+
+
+class ChatOpenAISupport:
+    def get_openai_chat(
+        self: HHApplicantTool,
+        system_prompt: str,
+    ) -> ChatOpenAI:
+        c = self.config.get("openai", {})
+        if not (token := c.get("token")):
+            raise ValueError("Токен для OpenAI не задан")
+        return ChatOpenAI(
+            token=token,
+            model=c.get("model", "gpt-5.1"),
+            system_prompt=system_prompt,
+            session=self.session,
+        )
+
+
+class MegaTool(ErrorReporter, VersionChecker, ChatOpenAISupport):
+    def _check_system(self: HHApplicantTool):
+        if not self.storage.settings.get_value("disable_version_check", False):
+            self._check_version()
+
+        if self.storage.settings.get_value("send_error_reports", True):
+            self._process_reporting()
+        else:
+            log.warning("ОТКЛЮЧЕНА ОТПРАВКА СООБЩЕНИЙ ОБ ОШИБКАХ!")

hh_applicant_tool/utils/string.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+import random
+import re
+from typing import Any
+
+def shorten(s: str, limit: int = 75, ellipsis: str = "…") -> str:
+    return s[:limit] + bool(s[limit:]) * ellipsis
+
+def rand_text(s: str) -> str:
+    while (
+        temp := re.sub(
+            r"{([^{}]+)}",
+            lambda m: random.choice(
+                m.group(1).split("|"),
+            ),
+            s,
+        )
+    ) != s:
+        s = temp
+    return s
+
+def bool2str(v: bool) -> str:
+    return str(v).lower()
+
+def list2str(items: list[Any] | None) -> str:
+    return ",".join(f"{v}" for v in items) if items else ""

hh_applicant_tool/utils/terminal.py

@@ -0,0 +1,32 @@
+import base64
+import ctypes
+import platform
+import sys
+
+
+def setup_terminal() -> None:
+    if platform.system() != "Windows":
+        return
+    try:
+        kernel32 = ctypes.windll.kernel32
+        # -11 = STD_OUTPUT_HANDLE
+        handle = kernel32.GetStdHandle(-11)
+        mode = ctypes.c_uint()
+        if kernel32.GetConsoleMode(handle, ctypes.byref(mode)):
+            # 0x0004 = ENABLE_VIRTUAL_TERMINAL_PROCESSING
+            kernel32.SetConsoleMode(handle, mode.value | 0x0004)
+    except Exception:
+        # Если что-то пошло не так (старая Windows или нет прав),
+        # просто продолжаем работу без цветов
+        pass
+
+
+def print_kitty_image(data: bytes) -> None:
+    # Кодируем весь файл целиком (он уже сжат в PNG)
+    b64data = base64.b64encode(data).decode("ascii")
+
+    # f=100 говорит терминалу: "это PNG, разберись сам с размерами"
+    # Нам больше не нужно указывать s=... и v=...
+    sys.stdout.write(f"\033_Ga=T,f=100;{b64data}\033\\")
+    sys.stdout.flush()
+    print()