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

hh_applicant_tool/storage/repositories/base.py

@@ -0,0 +1,230 @@
+from __future__ import annotations
+
+import logging
+import sqlite3
+from collections.abc import Sequence
+from dataclasses import dataclass
+from typing import Any, ClassVar, Iterator, Mapping, Self, Type
+
+from ..models.base import BaseModel
+from .errors import wrap_db_errors
+
+DEFAULT_PRIMARY_KEY = "id"
+
+logger = logging.getLogger(__package__)
+
+
+@dataclass
+class BaseRepository:
+    model: ClassVar[Type[BaseModel] | None] = None
+    pkey: ClassVar[str] = DEFAULT_PRIMARY_KEY
+    conflict_columns: ClassVar[tuple[str, ...] | None] = None
+    update_excludes: ClassVar[tuple[str, ...]] = ("created_at", "updated_at")
+    __table__: ClassVar[str | None] = None
+
+    conn: sqlite3.Connection
+    auto_commit: bool = True
+
+    @property
+    def table_name(self) -> str:
+        return self.__table__ or self.model.__name__
+
+    @wrap_db_errors
+    def commit(self):
+        if self.conn.in_transaction:
+            self.conn.commit()
+
+    @wrap_db_errors
+    def rollback(self):
+        if self.conn.in_transaction:
+            self.conn.rollback()
+
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if exc_type is None:
+            self.commit()
+        else:
+            self.rollback()
+        return False
+
+    def maybe_commit(self, commit: bool | None = None) -> bool:
+        if commit is not None and commit or self.auto_commit:
+            self.commit()
+
+    def _row_to_model(self, cursor: sqlite3.Cursor, row: tuple) -> BaseModel:
+        data = {col[0]: value for col, value in zip(cursor.description, row)}  # noqa: B905
+        return self.model.from_db(data)
+
+    @wrap_db_errors
+    def find(self, **kwargs: Any) -> Iterator[BaseModel]:
+        # logger.debug(kwargs)
+        operators = {
+            "lt": "<",
+            "le": "<=",
+            "gt": ">",
+            "ge": ">=",
+            "ne": "!=",
+            "eq": "=",
+            "like": "LIKE",
+            "is": "IS",
+            "is_not": "IS NOT",
+            "in": "IN",
+            "not_in": "NOT IN",
+        }
+        conditions = []
+        sql_params = {}
+        for key, value in kwargs.items():
+            try:
+                key, op = key.rsplit("__", 1)
+            except ValueError:
+                op = "eq"
+            if op in ("in", "not_in"):
+                if not isinstance(value, (list, tuple)):
+                    value = [value]
+                in_placeholders = []
+                for i, v in enumerate(value, 1):
+                    p_name = f"{key}_{i}"
+                    in_placeholders.append(f":{p_name}")
+                    sql_params[p_name] = v
+                conditions.append(
+                    f"{key} {operators[op]} ({', '.join(in_placeholders)})"
+                )
+            else:
+                placeholder = f":{key}"
+                sql_params[key] = value
+                conditions.append(f"{key} {operators[op]} {placeholder}")
+        sql = f"SELECT * FROM {self.table_name}"
+        if conditions:
+            sql += f" WHERE {' AND '.join(conditions)}"
+        sql += " ORDER BY rowid DESC;"
+        try:
+            cur = self.conn.execute(sql, sql_params)
+        except sqlite3.Error:
+            logger.warning("SQL ERROR: %s", sql)
+            raise
+
+        yield from (self._row_to_model(cur, row) for row in cur.fetchall())
+
+    @wrap_db_errors
+    def get(self, pk: Any) -> BaseModel | None:
+        return next(self.find(**{f"{self.pkey}": pk}), None)
+
+    @wrap_db_errors
+    def count_total(self) -> int:
+        cur = self.conn.execute(f"SELECT count(*) FROM {self.table_name};")
+        return cur.fetchone()[0]
+
+    @wrap_db_errors
+    def delete(self, obj_or_pkey: Any, /, commit: bool | None = None) -> None:
+        sql = f"DELETE FROM {self.table_name} WHERE {self.pkey} = ?"
+        pk_value = (
+            getattr(obj_or_pkey, self.pkey)
+            if isinstance(obj_or_pkey, BaseModel)
+            else obj_or_pkey
+        )
+        self.conn.execute(sql, (pk_value,))
+        self.maybe_commit(commit=commit)
+
+    remove = delete
+
+    @wrap_db_errors
+    def clear(self, commit: bool | None = None):
+        self.conn.execute(f"DELETE FROM {self.table_name};")
+        self.maybe_commit(commit)
+
+    clean = clear
+
+    def _insert(
+        self,
+        data: Mapping[str, Any] | list[Mapping[str, Any]],
+        /,
+        batch: bool = False,
+        upsert: bool = True,
+        conflict_columns: Sequence[str] | None = None,
+        update_excludes: Sequence[str] | None = None,
+        commit: bool | None = None,
+    ):
+        conflict_columns = conflict_columns or self.conflict_columns
+        update_excludes = update_excludes or self.update_excludes
+
+        if batch and not data:
+            return
+
+        columns = list(dict(data[0] if batch else data).keys())
+        sql = (
+            f"INSERT INTO {self.table_name} ({', '.join(columns)})"
+            f" VALUES (:{', :'.join(columns)})"
+        )
+
+        if upsert:
+            cols_set = set(columns)
+
+            # Определяем поля конфликта: или переданные, или pkey
+            if conflict_columns:
+                conflict_set = set(conflict_columns) & cols_set
+            else:
+                conflict_set = {self.pkey} & cols_set
+
+            if conflict_set:
+                sql += f" ON CONFLICT({', '.join(conflict_set)})"
+
+                # Исключаем из обновления:
+                # 1. Поля конфликта (нельзя обновлять по законам SQL)
+                # 2. Primary key (никогда не меняем)
+                # 3. Технические поля (created_at и т.д.)
+                update_set = (
+                    cols_set
+                    - conflict_set
+                    - {self.pkey}
+                    - set(update_excludes or [])
+                )
+
+                if update_set:
+                    update_clause = ", ".join(
+                        f"{c} = excluded.{c}" for c in update_set
+                    )
+                    sql += f" DO UPDATE SET {update_clause}"
+                else:
+                    sql += " DO NOTHING"
+
+        sql += ";"
+        # logger.debug("%.2000s", sql)
+        try:
+            if batch:
+                self.conn.executemany(sql, data)
+            else:
+                self.conn.execute(sql, data)
+        except sqlite3.Error:
+            logger.warning("SQL ERROR: %s", sql)
+
+            raise
+        self.maybe_commit(commit)
+
+    @wrap_db_errors
+    def save(
+        self,
+        obj: BaseModel | Mapping[str, Any],
+        /,
+        **kwargs: Any,
+    ) -> None:
+        if isinstance(obj, Mapping):
+            obj = self.model.from_api(obj)
+        data = obj.to_db()
+        self._insert(data, **kwargs)
+
+    @wrap_db_errors
+    def save_batch(
+        self,
+        items: list[BaseModel | Mapping[str, Any]],
+        /,
+        **kwargs: Any,
+    ) -> None:
+        if not items:
+            return
+        data = [
+            (self.model.from_api(i) if isinstance(i, Mapping) else i).to_db()
+            for i in items
+        ]
+        self._insert(data, batch=True, **kwargs)

hh_applicant_tool/storage/repositories/contacts.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+import logging
+
+from ..models.contacts import VacancyContactsModel
+from .base import BaseRepository
+
+logger = logging.getLogger(__package__)
+
+
+class VacancyContactsRepository(BaseRepository):
+    __table__ = "vacancy_contacts"
+    model = VacancyContactsModel
+    conflict_columns = ("vacancy_id", "email")

hh_applicant_tool/storage/repositories/employers.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from typing import Iterator
+
+from ..models.employer import EmployerModel
+from .base import BaseRepository
+
+
+class EmployersRepository(BaseRepository):
+    __table__ = "employers"
+    model = EmployerModel
+
+    def find(self, **kwargs) -> Iterator[EmployerModel]:
+        return super().find(**kwargs)

hh_applicant_tool/storage/repositories/errors.py

@@ -0,0 +1,19 @@
+import sqlite3
+from functools import wraps
+
+
+class RepositoryError(sqlite3.Error):
+    pass
+
+
+def wrap_db_errors(func):
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except sqlite3.Error as e:
+            raise RepositoryError(
+                f"Database error in {func.__name__}: {e}"
+            ) from e
+
+    return wrapper

hh_applicant_tool/storage/repositories/negotiations.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from logging import getLogger
+
+from ..models.negotiation import NegotiationModel
+from .base import BaseRepository
+
+logger = getLogger(__package__)
+
+
+class NegotiationRepository(BaseRepository):
+    __table__ = "negotiations"
+    model = NegotiationModel

hh_applicant_tool/storage/repositories/resumes.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from ..models.resume import ResumeModel
+from .base import BaseRepository
+
+
+class ResumesRepository(BaseRepository):
+    __table__ = "resumes"
+    model = ResumeModel

hh_applicant_tool/storage/repositories/settings.py

@@ -0,0 +1,35 @@
+from typing import TypeVar
+
+from ..models.setting import SettingModel
+from .base import BaseRepository
+
+Default = TypeVar("Default")
+
+
+class SettingsRepository(BaseRepository):
+    __table__ = "settings"
+    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,9 @@
+from __future__ import annotations
+
+from ..models.vacancy import VacancyModel
+from .base import BaseRepository
+
+
+class VacanciesRepository(BaseRepository):
+    __table__ = "vacancies"
+    model = VacancyModel

hh_applicant_tool/storage/utils.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+import logging
+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 initialized")
+
+
+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]
+#     return re.sub(r"(?<!^)(?=[A-Z])", "_", name).lower()

hh_applicant_tool/utils/__init__.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from ..api.user_agent import generate_android_useragent
+from .attrdict import AttrDict
+from .config import Config, get_config_path
+from .date 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
+
+# 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",
+    "generate_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 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/date.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