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

hh_applicant_tool/storage/repositories/settings.py

@@ -0,0 +1,34 @@
+from typing import TypeVar
+
+from ..models.setting import SettingModel
+from .base import BaseRepository
+
+Default = TypeVar("Default")
+
+
+class SettingsRepository(BaseRepository):
+    pkey: str = "key"
+    model = SettingModel
+
+    def get_value(
+        self,
+        key: str,
+        /,
+        default: Default = None,
+    ) -> str | Default:
+        setting = self.get(key)
+        return setting.value if setting else default
+
+    def set_value(
+        self,
+        key: str,
+        value: str,
+        /,
+        commit: bool | None = None,
+    ) -> None:
+        self.save(self.model(key=key, value=value), commit=commit)
+
+    def delete_value(self, key: str, /, commit: bool | None = None) -> None:
+        setting = self.get(key)
+        if setting:
+            self.delete(setting, commit=commit)

hh_applicant_tool/storage/repositories/vacancies.py

@@ -0,0 +1,8 @@
+from __future__ import annotations
+
+from ..models.vacancy import VacancyModel
+from .base import BaseRepository
+
+
+class VacanciesRepository(BaseRepository):
+    model = VacancyModel

hh_applicant_tool/storage/utils.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+import logging
+import re
+import sqlite3
+from pathlib import Path
+
+QUERIES_PATH: Path = Path(__file__).parent / "queries"
+MIGRATION_PATH: Path = QUERIES_PATH / "migrations"
+
+
+logger: logging.Logger = logging.getLogger(__package__)
+
+
+def init_db(conn: sqlite3.Connection) -> None:
+    """Создает схему БД"""
+    conn.executescript(
+        (QUERIES_PATH / "schema.sql").read_text(encoding="utf-8")
+    )
+    logger.debug("Database unitialized")
+
+
+def list_migrations() -> list[str]:
+    """Выводит имена миграций без расширения, отсортированные по дате"""
+    if not MIGRATION_PATH.exists():
+        return []
+    return sorted([f.stem for f in MIGRATION_PATH.glob("*.sql")])
+
+
+def apply_migration(conn: sqlite3.Connection, name: str) -> None:
+    """Находит файл по имени и выполняет его содержимое"""
+    conn.executescript(
+        (MIGRATION_PATH / f"{name}.sql").read_text(encoding="utf-8")
+    )
+
+
+def model2table(o: type) -> str:
+    name: str = o.__name__
+    if name.endswith("Model"):
+        name = name[:-5]
+    name = re.sub(r"(?<!^)(?=[A-Z])", "_", name).lower()
+    # y -> ies (если перед y согласная: vacancy -> vacancies)
+    if name.endswith("y") and not name.endswith(("ay", "ey", "iy", "oy", "uy")):
+        return name[:-1] + "ies"
+    # s, x, z, ch, sh -> +es (bus -> buses, match -> matches)
+    if name.endswith(("s", "x", "z", "ch", "sh")):
+        return name + "es"
+    # Обычный случай
+    return name + "s"

hh_applicant_tool/utils/__init__.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from .attrdict import AttrDict
+from .config import Config, get_config_path
+from .dateutil import (
+    DATETIME_FORMAT,
+    parse_api_datetime,
+    try_parse_datetime,
+)
+from .misc import calc_hash, print_err
+from .string import bool2str, list2str, rand_text, shorten
+from .terminal import setup_terminal
+from .user_agent import hh_android_useragent
+
+# Add all public symbols to __all__ for consistent import behavior
+__all__ = [
+    "AttrDict",
+    "Config",
+    "get_config_path",
+    "DATETIME_FORMAT",
+    "parse_api_datetime",
+    "try_parse_datetime",
+    "shorten",
+    "rand_text",
+    "bool2str",
+    "list2str",
+    "calc_hash",
+    "hh_android_useragent",
+    "setup_terminal",
+    "print_err",
+]

hh_applicant_tool/utils/attrdict.py

@@ -0,0 +1,6 @@
+from __future__ import annotations
+
+class AttrDict(dict):
+    __getattr__ = dict.get
+    __setattr__ = dict.__setitem__
+    __delattr__ = dict.__delitem__

hh_applicant_tool/utils/binpack.py

@@ -0,0 +1,167 @@
+# Формат для передачи данных по сети, который лучше сжимается чем JSON
+# Автогенерированный текст по моей спецификации. Из преимуществ поддержка дат
+# и ключи любого типа в Map
+from __future__ import annotations
+
+import gzip
+import io
+import struct
+import zlib
+from datetime import datetime
+from typing import Any, Callable, Final
+
+# ---- Constants ----
+
+BINARY_TYPES: Final = {
+    type(None): 0x00,
+    dict: 0x01,
+    str: 0x02,
+    int: 0x03,
+    float: 0x04,
+    list: 0x05,
+    bool: 0x06,
+    datetime: 0x07,
+}
+
+# Коды типов (для десериализации)
+T_NULL, T_MAP, T_STR, T_INT, T_FLOAT, T_LIST, T_BOOL, T_DT = range(8)
+
+# Сжатие
+COMP_NONE, COMP_ZLIB, COMP_GZIP = range(3)
+
+# Схемы упаковки
+U32 = struct.Struct("<I")
+S64 = struct.Struct("<q")
+F64 = struct.Struct("<d")
+U8 = struct.Struct("<B")
+
+# ---- Compression Logic (Pure functions) ----
+
+
+def gzip_compress(data: bytes) -> bytes:
+    buf = io.BytesIO()
+    with gzip.GzipFile(fileobj=buf, mode="wb") as f:
+        f.write(data)
+    return buf.getvalue()
+
+
+def gzip_decompress(data: bytes) -> bytes:
+    with gzip.GzipFile(fileobj=io.BytesIO(data), mode="rb") as f:
+        return f.read()
+
+
+COMPRESSORS: dict[int, Callable[[bytes], bytes]] = {
+    COMP_ZLIB: zlib.compress,
+    COMP_GZIP: gzip_compress,
+    COMP_NONE: lambda d: d,
+}
+
+DECOMPRESSORS: dict[int, Callable[[bytes], bytes]] = {
+    COMP_ZLIB: zlib.decompress,
+    COMP_GZIP: gzip_decompress,
+    COMP_NONE: lambda d: d,
+}
+
+
+def get_best_algo() -> int:
+    if zlib:
+        return COMP_ZLIB
+    if gzip:
+        return COMP_GZIP
+    return COMP_NONE
+
+
+# ---- Serialization (Recursive Functions) ----
+
+
+def write_value(value: Any) -> bytes:
+    """Рекурсивно преобразует значение в bytes (Pure)"""
+    match value:
+        case None:
+            return bytes([T_NULL])
+
+        case bool():
+            return bytes([T_BOOL]) + U8.pack(1 if value else 0)
+
+        case datetime():
+            return bytes([T_DT]) + F64.pack(value.timestamp())
+
+        case int():
+            return bytes([T_INT]) + S64.pack(value)
+
+        case float():
+            return bytes([T_FLOAT]) + F64.pack(value)
+
+        case str():
+            data = value.encode("utf-8")
+            return bytes([T_STR]) + U32.pack(len(data)) + data
+
+        case list():
+            content = b"".join(map(write_value, value))
+            return bytes([T_LIST]) + U32.pack(len(value)) + content
+
+        case dict():
+            content = b"".join(
+                write_value(k) + write_value(v) for k, v in value.items()
+            )
+            return bytes([T_MAP]) + U32.pack(len(value)) + content
+
+        case _:
+            raise TypeError(f"Unsupported type: {type(value)}")
+
+
+# ---- Deserialization (Stream-based but stateless) ----
+
+
+def read_value(stream: io.BytesIO) -> Any:
+    """Читает значение из потока байт"""
+    type_byte = stream.read(1)
+    if not type_byte:
+        return None
+
+    match type_byte[0]:
+        case 0x00:  # NULL
+            return None
+        case 0x06:  # BOOL
+            return U8.unpack(stream.read(1))[0] == 1
+        case 0x07:  # DT
+            return datetime.fromtimestamp(F64.unpack(stream.read(8))[0])
+        case 0x03:  # INT
+            return S64.unpack(stream.read(8))[0]
+        case 0x04:  # FLOAT
+            return F64.unpack(stream.read(8))[0]
+        case 0x02:  # STR
+            size = U32.unpack(stream.read(4))[0]
+            return stream.read(size).decode("utf-8")
+        case 0x05:  # LIST
+            size = U32.unpack(stream.read(4))[0]
+            return [read_value(stream) for _ in range(size)]
+        case 0x01:  # MAP
+            size = U32.unpack(stream.read(4))[0]
+            return {read_value(stream): read_value(stream) for _ in range(size)}
+        case t:
+            raise TypeError(f"Unknown type code: {t:#x}")
+
+
+# ---- Public API (Composition) ----
+
+
+def serialize(value: Any, compress: bool = True) -> bytes:
+    raw_payload = write_value(value)
+    algo = get_best_algo() if compress else COMP_NONE
+
+    compressor = COMPRESSORS.get(algo, COMPRESSORS[COMP_NONE])
+    return bytes([algo]) + compressor(raw_payload)
+
+
+def deserialize(data: bytes) -> Any:
+    if not data:
+        raise ValueError("Empty payload")
+
+    algo, payload = data[0], data[1:]
+
+    if algo not in DECOMPRESSORS:
+        raise ValueError(f"Unknown compression type: {algo}")
+
+    raw_data = DECOMPRESSORS[algo](payload)
+    return read_value(io.BytesIO(raw_data))

hh_applicant_tool/utils/config.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+import platform
+from functools import cache
+from os import getenv
+from pathlib import Path
+from threading import Lock
+from typing import Any
+
+from . import jsonutil as json
+
+
+@cache
+def get_config_path() -> Path:
+    match platform.system():
+        case "Windows":
+            return Path(getenv("APPDATA", Path.home() / "AppData" / "Roaming"))
+        case "Darwin":
+            return Path.home() / "Library" / "Application Support"
+        case _:
+            return Path(getenv("XDG_CONFIG_HOME", Path.home() / ".config"))
+
+
+class Config(dict):
+    def __init__(self, config_path: str | Path | None = None):
+        self._config_path = Path(config_path or get_config_path())
+        self._lock = Lock()
+        self.load()
+
+    def load(self) -> None:
+        if self._config_path.exists():
+            with self._lock:
+                with self._config_path.open(
+                    "r", encoding="utf-8", errors="replace"
+                ) as f:
+                    self.update(json.load(f))
+
+    def save(self, *args: Any, **kwargs: Any) -> None:
+        self.update(*args, **kwargs)
+        self._config_path.parent.mkdir(exist_ok=True, parents=True)
+        with self._lock:
+            with self._config_path.open(
+                "w+", encoding="utf-8", errors="replace"
+            ) as fp:
+                json.dump(
+                    self,
+                    fp,
+                    indent=2,
+                    sort_keys=True,
+                )
+
+    __getitem__ = dict.get
+
+    def __repr__(self) -> str:
+        return str(self._config_path)

hh_applicant_tool/utils/dateutil.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any
+
+DATETIME_FORMAT = "%Y-%m-%dT%H:%M:%S%z"
+
+
+def parse_api_datetime(dt: str) -> datetime:
+    return datetime.strptime(dt, DATETIME_FORMAT)
+
+
+def try_parse_datetime(dt: Any) -> datetime | Any:
+    for parse in (datetime.fromisoformat, parse_api_datetime):
+        try:
+            return parse(dt)
+        except (ValueError, TypeError):
+            pass
+    return dt

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/jsonutil.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/utils/log.py

@@ -0,0 +1,144 @@
+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
+        ]
+    )
+
+    for h in [color_handler, file_handler]:
+        h.addFilter(redactor)
+        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)