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

hh_applicant_tool/storage/__init__.py

@@ -0,0 +1,4 @@
+from .facade import StorageFacade
+from .utils import apply_migration, list_migrations
+
+__all__ = ["StorageFacade", "apply_migration", "list_migrations"]

hh_applicant_tool/storage/facade.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+import sqlite3
+
+from .repositories.contacts import EmployerContactsRepository
+from .repositories.employers import EmployersRepository
+from .repositories.negotiations import NegotiationRepository
+from .repositories.resumes import ResumesRepository
+from .repositories.settings import SettingsRepository
+from .repositories.vacancies import VacanciesRepository
+from .utils import init_db
+
+
+class StorageFacade:
+    """Единая точка доступа к persistence-слою."""
+
+    def __init__(self, conn: sqlite3.Connection):
+        init_db(conn)
+        self.employers = EmployersRepository(conn)
+        self.vacancies = VacanciesRepository(conn)
+        self.employer_contacts = EmployerContactsRepository(conn)
+        self.negotiations = NegotiationRepository(conn)
+        self.settings = SettingsRepository(conn)
+        self.resumes = ResumesRepository(conn)

hh_applicant_tool/storage/models/base.py

@@ -0,0 +1,169 @@
+import builtins
+from dataclasses import Field, asdict, dataclass, field, fields
+from datetime import datetime
+from logging import getLogger
+from typing import Any, Callable, Mapping, Self, dataclass_transform, get_origin
+
+from hh_applicant_tool.utils import jsonutil
+from hh_applicant_tool.utils.dateutil import try_parse_datetime
+
+logger = getLogger(__package__)
+
+MISSING = object()
+
+
+def mapped(
+    path: str | None = None,
+    transform: Callable[[Any], Any] | None = None,
+    store_json: bool = False,
+    **kwargs: Any,
+):
+    metadata = kwargs.get("metadata", {})
+    metadata.setdefault("path", path)
+    metadata.setdefault("transform", transform)
+    metadata.setdefault("store_json", store_json)
+    return field(metadata=metadata, **kwargs)
+
+
+@dataclass_transform(field_specifiers=(field, mapped))
+class BaseModel:
+    def __init_subclass__(cls, /, **kwargs: Any):
+        super().__init_subclass__()
+        dataclass(cls, kw_only=True, **kwargs)
+
+    @classmethod
+    def from_db(cls, data: Mapping[str, Any]) -> Self:
+        return cls._from_mapping(data)
+
+    @classmethod
+    def from_api(cls, data: Mapping[str, Any]) -> Self:
+        return cls._from_mapping(data, from_source=True)
+
+    def to_db(self) -> dict[str, Any]:
+        data = self.to_dict()
+        for f in fields(self):
+            # Если какого-то значения нет в словаре, то не ставим его или
+            # ломается установка дефолтных значений.
+            value = data.get(f.name, MISSING)
+            if value is MISSING:
+                continue
+            if f.metadata.get("store_json"):
+                value = jsonutil.dumps(value)
+            # Точно не нужно типы приводить перед сохранением
+            # else:
+            #     value = self._coerce_type(value, f)
+            data[f.name] = value
+        return data
+
+    @classmethod
+    def _coerce_type(cls, value: Any, f: Field) -> Any:
+        # Лишь создатель знает, что с тобой делать
+        if get_origin(f.type):
+            return value
+
+        type_name = f.type if isinstance(f.type, str) else f.type.__name__
+        if value is not None and type_name in (
+            "bool",
+            "str",
+            "int",
+            "float",
+            "datetime",
+        ):
+            if type_name == "datetime":
+                return try_parse_datetime(value)
+            try:
+                t = getattr(builtins, type_name)
+                if not isinstance(value, t):
+                    value = t(value)
+            except (TypeError, ValueError):
+                pass
+        return value
+
+    @classmethod
+    def _from_mapping(
+        cls,
+        data: Mapping[str, Any],
+        /,
+        from_source: bool = False,
+    ) -> Self:
+        kwargs = {}
+        for f in fields(cls):
+            if from_source:
+                if path := f.metadata.get("path"):
+                    found = True
+                    v = data
+                    for key in path.split("."):
+                        if isinstance(v, Mapping):
+                            v = v.get(key)
+                        else:
+                            found = False
+                            break
+                    if not found:
+                        continue
+                    value = v
+                else:
+                    value = data.get(f.name, MISSING)
+                    if value is MISSING:
+                        continue
+
+                if value is not None and (t := f.metadata.get("transform")):
+                    if isinstance(t, str):
+                        t = getattr(cls, t)
+                    value = t(value)
+
+                value = cls._coerce_type(value, f)
+            else:
+                value = data.get(f.name, MISSING)
+                if value is MISSING:
+                    continue
+
+                if f.metadata.get("store_json"):
+                    value = jsonutil.loads(value)
+                else:
+                    value = cls._coerce_type(value, f)
+
+            kwargs[f.name] = value
+        return cls(**kwargs)
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)  # pyright: ignore[reportArgumentType]
+
+    # def to_json(self, **kwargs: Any) -> str:
+    #     """Serializes the model to a JSON string."""
+    #     kwargs.setdefault("ensure_ascii", False)
+    #     return json_utils.dumps(self.to_dict(), **kwargs)
+
+    # @classmethod
+    # def from_json(cls, json_str: str, **kwargs: Any) -> Self:
+    #     """Deserializes a model from a JSON string."""
+    #     data = json_utils.loads(json_str, **kwargs)
+    #     # from_api is probably more appropriate as JSON is a common API format
+    #     # and it handles nested data sources.
+    #     return cls.from_api(data)
+
+
+if __name__ == "__main__":
+
+    class CompanyModel(BaseModel):
+        id: "int"
+        name: str
+        city_id: int = mapped(path="location.city.id")
+        city: str = mapped(path="location.city.name")
+        created_at: datetime
+
+    c = CompanyModel.from_api(
+        {
+            "id": "42",
+            "name": "ACME",
+            "location": {
+                "city": {
+                    "id": "1",
+                    "name": "Moscow",
+                },
+            },
+            "created_at": "2026-01-09T04:12:00.114858",
+        }
+    )
+
+    print(c)
+    # assert c == CompanyModel(id=42, name="ACME", city_id=1, city="Moscow")

hh_applicant_tool/storage/models/contact.py

@@ -0,0 +1,16 @@
+from .base import BaseModel, mapped
+
+
+# Из вакансии извлекается
+class EmployerContactModel(BaseModel):
+    id: int
+    employer_id: int = mapped(path="employer.id")
+    email: str = mapped(path="contacts.email")
+    name: str = mapped(path="contacts.name", default=None)
+    phone_numbers: str = mapped(
+        path="contacts.phones",
+        transform=lambda phones: ", ".join(
+            p["formatted"] for p in phones if p.get("number")
+        ),
+        default=None,
+    )

hh_applicant_tool/storage/models/employer.py

@@ -0,0 +1,12 @@
+from .base import BaseModel, mapped
+
+
+class EmployerModel(BaseModel):
+    id: int
+    name: str
+    type: str | None = None
+    description: str | None = None
+    site_url: str | None = None
+    alternate_url: str | None = None
+    area_id: int = mapped(path="area.id", default=None)
+    area_name: str = mapped(path="area.name", default=None)

hh_applicant_tool/storage/models/negotiation.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from datetime import datetime
+
+from .base import BaseModel, mapped
+
+
+class NegotiationModel(BaseModel):
+    id: int
+    chat_id: int
+    state: str = mapped(path="state.id")
+    vacancy_id: int = mapped(path="vacancy.id")
+    employer_id: int = mapped(path="vacancy.employer.id", default=None)
+    resume_id: str = mapped(path="resume.id")
+    created_at: datetime | None = None
+    updated_at: datetime | None = None

hh_applicant_tool/storage/models/resume.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from datetime import datetime
+
+from .base import BaseModel, mapped
+
+
+class ResumeModel(BaseModel):
+    id: str
+    title: str
+    url: str
+    alternate_url: str
+    status_id: str = mapped(path="status.id")
+    status_name: str = mapped(path="status.name")
+    can_publish_or_update: bool = False
+    total_views: int = mapped(path="counters.total_views", default=0)
+    new_views: int = mapped(path="counters.new_views", default=0)
+    created_at: datetime | None = None
+    updated_at: datetime | None = None

hh_applicant_tool/storage/models/setting.py

@@ -0,0 +1,6 @@
+from .base import BaseModel, mapped
+
+
+class SettingModel(BaseModel):
+    key: str
+    value: str = mapped(store_json=True)

hh_applicant_tool/storage/models/vacancy.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from datetime import datetime
+
+from .base import BaseModel, mapped
+
+
+class VacancyModel(BaseModel):
+    id: int
+    name: str
+    alternate_url: str
+    area_id: int = mapped(path="area.id")
+    area_name: str = mapped(path="area.name")
+    salary_from: int = mapped(path="salary.from", default=None)
+    salary_to: int = mapped(path="salary.to", default=None)
+    currency: str = mapped(path="salary.currency", default="RUR")
+    gross: bool = mapped(path="salary.gross", default=False)
+
+    remote: bool = mapped(
+        path="schedule.id",
+        transform=lambda v: v == "remote",
+        default=False,
+    )
+
+    experience: str = mapped(path="experience.id", default=None)
+    professional_roles: list[dict] = mapped(
+        store_json=True, default_factory=list
+    )
+
+    created_at: datetime | None = None
+    published_at: datetime | None = None
+    updated_at: datetime | None = None
+
+    def __post_init__(self):
+        self.salary_from = self.salary_from or self.salary_to or 0
+        self.salary_to = self.salary_to or self.salary_from or 0

hh_applicant_tool/storage/queries/schema.sql

@@ -0,0 +1,119 @@
+PRAGMA foreign_keys = OFF;
+-- На всякий случай выключаем проверки
+BEGIN;
+/* ===================== employers ===================== */
+CREATE TABLE IF NOT EXISTS employers (
+    id INTEGER PRIMARY KEY,
+    name TEXT NOT NULL,
+    type TEXT,
+    description TEXT,
+    site_url TEXT,
+    area_id INTEGER,
+    area_name TEXT,
+    alternate_url TEXT,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+/* ===================== employer_contacts ===================== */
+CREATE TABLE IF NOT EXISTS employer_contacts (
+    id TEXT PRIMARY KEY DEFAULT (lower(hex(randomblob(16)))),
+    employer_id INTEGER NOT NULL,
+    -- Просто поле, без REFERENCES
+    name TEXT,
+    email TEXT,
+    phone_numbers TEXT NOT NULL,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    UNIQUE (employer_id, email)
+);
+/* ===================== vacancies ===================== */
+CREATE TABLE IF NOT EXISTS vacancies (
+    id INTEGER PRIMARY KEY,
+    name TEXT NOT NULL,
+    area_id INTEGER,
+    area_name TEXT,
+    salary_from INTEGER,
+    salary_to INTEGER,
+    currency VARCHAR(3),
+    gross BOOLEAN,
+    published_at DATETIME,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    remote BOOLEAN,
+    experience TEXT,
+    professional_roles TEXT,
+    alternate_url TEXT
+);
+/* ===================== negotiations ===================== */
+CREATE TABLE IF NOT EXISTS negotiations (
+    id INTEGER PRIMARY KEY,
+    state TEXT NOT NULL,
+    vacancy_id INTEGER NOT NULL,
+    employer_id INTEGER NOT NULL,
+    chat_id INTEGER NOT NULL,
+    resume_id TEXT,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+/* ===================== settings ===================== */
+CREATE TABLE IF NOT EXISTS settings (
+    key TEXT PRIMARY KEY,
+    value TEXT NOT NULL
+);
+/* ===================== resumes ===================== */
+CREATE TABLE IF NOT EXISTS resumes (
+    id TEXT PRIMARY KEY,
+    title TEXT NOT NULL,
+    url TEXT,
+    alternate_url TEXT,
+    status_id TEXT,
+    status_name TEXT,
+    can_publish_or_update BOOLEAN,
+    total_views INTEGER DEFAULT 0,
+    new_views INTEGER DEFAULT 0,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+/* ===================== ИНДЕКСЫ ДЛЯ СТАТИСТИКИ ===================== */
+-- Чтобы выборка для отправки на сервер по updated_at не тормозила
+CREATE INDEX IF NOT EXISTS idx_vac_upd ON vacancies(updated_at);
+CREATE INDEX IF NOT EXISTS idx_emp_upd ON employers(updated_at);
+CREATE INDEX IF NOT EXISTS idx_neg_upd ON negotiations(updated_at);
+/* ===================== ТРИГГЕРЫ (Всегда обновляют дату) ===================== */
+-- Убрал условие WHEN. Теперь при любом UPDATE дата актуализируется принудительно.
+CREATE TRIGGER IF NOT EXISTS trg_resumes_updated
+AFTER
+UPDATE ON resumes BEGIN
+UPDATE resumes
+SET updated_at = CURRENT_TIMESTAMP
+WHERE id = OLD.id;
+END;
+CREATE TRIGGER IF NOT EXISTS trg_employers_updated
+AFTER
+UPDATE ON employers BEGIN
+UPDATE employers
+SET updated_at = CURRENT_TIMESTAMP
+WHERE id = OLD.id;
+END;
+CREATE TRIGGER IF NOT EXISTS trg_employer_contacts_updated
+AFTER
+UPDATE ON employer_contacts BEGIN
+UPDATE employer_contacts
+SET updated_at = CURRENT_TIMESTAMP
+WHERE id = OLD.id;
+END;
+CREATE TRIGGER IF NOT EXISTS trg_vacancies_updated
+AFTER
+UPDATE ON vacancies BEGIN
+UPDATE vacancies
+SET updated_at = CURRENT_TIMESTAMP
+WHERE id = OLD.id;
+END;
+CREATE TRIGGER IF NOT EXISTS trg_negotiations_updated
+AFTER
+UPDATE ON negotiations BEGIN
+UPDATE negotiations
+SET updated_at = CURRENT_TIMESTAMP
+WHERE id = OLD.id;
+END;
+COMMIT;

hh_applicant_tool/storage/repositories/base.py

@@ -0,0 +1,176 @@
+from __future__ import annotations
+
+import logging
+import sqlite3
+from collections.abc import Sequence
+from dataclasses import dataclass
+from functools import cached_property
+from typing import Any, ClassVar, Iterator, Mapping, Self, Type
+
+from ..models.base import BaseModel
+from ..utils import model2table
+
+DEFAULT_PRIMARY_KEY = "id"
+
+logger = logging.getLogger(__package__)
+
+
+@dataclass
+class BaseRepository:
+    model: ClassVar[Type[BaseModel] | None] = None
+    pkey: ClassVar[str] = DEFAULT_PRIMARY_KEY
+
+    conn: sqlite3.Connection
+    auto_commit: bool = True
+
+    @cached_property
+    def table_name(self) -> str:
+        return model2table(self.model)
+
+    def commit(self):
+        if self.conn.in_transaction:
+            self.conn.commit()
+
+    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)
+
+    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;"
+        logger.debug("%.2000s", sql)
+        cur = self.conn.execute(sql, sql_params)
+        yield from (self._row_to_model(cur, row) for row in cur.fetchall())
+
+    def get(self, pk: Any) -> BaseModel | None:
+        return next(self.find(**{f"{self.pkey}": pk}), None)
+
+    def count_total(self) -> int:
+        cur = self.conn.execute(f"SELECT count(*) FROM {self.table_name};")
+        return cur.fetchone()[0]
+
+    def delete(self, o: BaseModel, /, commit: bool | None = None) -> None:
+        sql = f"DELETE FROM {self.table_name} WHERE {self.pkey} = ?"
+        pk_value = getattr(o, self.pkey)
+        self.conn.execute(sql, (pk_value,))
+        self.maybe_commit(commit=commit)
+
+    remove = delete
+
+    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],
+        /,
+        upsert: bool = True,
+        conflict_columns: Sequence[str] | None = None,
+        update_excludes: Sequence[str] = ("created_at", "updated_at"),
+        commit: bool | None = None,
+    ):
+        columns = list(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)
+                )
+
+                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)
+        self.conn.execute(sql, data)
+        self.maybe_commit(commit)
+
+    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)

hh_applicant_tool/storage/repositories/contacts.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+import logging
+
+from ..models.contact import EmployerContactModel
+from .base import BaseRepository
+
+logger = logging.getLogger(__package__)
+
+
+class EmployerContactsRepository(BaseRepository):
+    model = EmployerContactModel
+
+    def save(self, contact: EmployerContactModel) -> None:
+        # logger.debug(contact)
+        super().save(
+            contact,
+            conflict_columns=["employer_id", "email"],
+        )

hh_applicant_tool/storage/repositories/employers.py

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

hh_applicant_tool/storage/repositories/negotiations.py

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

hh_applicant_tool/storage/repositories/resumes.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+import sqlite3
+
+from ..models.resume import ResumeModel
+from .base import BaseRepository
+
+
+class ResumesRepository(BaseRepository):
+    """Репозиторий для хранения резюме."""
+
+    def __init__(self, conn: sqlite3.Connection):
+        super().__init__(conn)
+        self.model = ResumeModel