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

hh_applicant_tool/operations/update_resumes.py

@@ -1,12 +1,18 @@
 # Этот модуль можно использовать как образец для других
+from __future__ import annotations
+
 import argparse
 import logging
+from typing import TYPE_CHECKING
+
+from ..api import ApiError, datatypes
+from ..main import BaseNamespace, BaseOperation
+from ..utils import print_err
+from ..utils.string import shorten
+
+if TYPE_CHECKING:
+    from ..main import HHApplicantTool
 
-from ..api import ApiClient, ApiError
-from ..main import BaseOperation
-from ..main import Namespace as BaseNamespace
-from ..types import ApiListResponse
-from ..utils import print_err, truncate_string
 
 logger = logging.getLogger(__package__)
 
@@ -18,15 +24,21 @@ class Namespace(BaseNamespace):
 class Operation(BaseOperation):
     """Обновить все резюме"""
 
+    __aliases__ = ["update"]
+
     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")
-        for resume in resumes["items"]:
+    def run(self, tool: HHApplicantTool) -> None:
+        resumes: list[datatypes.Resume] = tool.get_resumes()
+        # Там вызов API меняет поля
+        # tool.storage.resumes.save_batch(resumes)
+        for resume in resumes:
             try:
-                res = api_client.post(f"/resumes/{resume['id']}/publish")
+                res = tool.api_client.post(
+                    f"/resumes/{resume['id']}/publish",
+                )
                 assert res == {}
-                print("✅ Обновлено", truncate_string(resume["title"]))
+                print("✅ Обновлено", shorten(resume["title"]))
             except ApiError as ex:
-                print_err("❗ Ошибка:", ex)
+                print_err("❗", ex)

hh_applicant_tool/operations/whoami.py

@@ -1,11 +1,16 @@
 # Этот модуль можно использовать как образец для других
+from __future__ import annotations
+
 import argparse
-import json
 import logging
+from typing import TYPE_CHECKING
+
+from ..api import datatypes
+from ..main import BaseNamespace, BaseOperation
+
+if TYPE_CHECKING:
+    from ..main import HHApplicantTool
 
-from ..api import ApiClient
-from ..main import BaseOperation
-from ..main import Namespace as BaseNamespace
 
 logger = logging.getLogger(__package__)
 
@@ -14,12 +19,40 @@ class Namespace(BaseNamespace):
     pass
 
 
+def fmt_plus(n: int) -> str:
+    assert n >= 0
+    return f"+{n}" if n else "0"
+
+
 class Operation(BaseOperation):
     """Выведет текущего пользователя"""
 
+    __aliases__: list[str] = ["id"]
+
     def setup_parser(self, parser: argparse.ArgumentParser) -> None:
         pass
 
-    def run(self, args: Namespace, api_client: ApiClient, _) -> None:
-        result = api_client.get("/me")
-        print(json.dumps(result, ensure_ascii=False, indent=2, sort_keys=True))
+    def run(self, tool: HHApplicantTool) -> None:
+        api_client = tool.api_client
+        result: datatypes.User = api_client.get("me")
+        full_name = " ".join(
+            filter(
+                None,
+                [
+                    result.get("last_name"),
+                    result.get("first_name"),
+                    result.get("middle_name"),
+                ],
+            )
+        )
+        with tool.storage.settings as s:
+            s.set_value("user.full_name", full_name)
+            s.set_value("user.email", result.get("email"))
+            s.set_value("user.phone", result.get("phone"))
+        counters = result["counters"]
+        print(
+            f"🆔 {result['id']} {full_name or 'Анонимный аккаунт'} "
+            f"[ 📄 {counters['resumes_count']} "
+            f"| 👁️  {fmt_plus(counters['new_resume_views'])} "
+            f"| ✉️  {fmt_plus(counters['unread_negotiations'])} ]"
+        )

hh_applicant_tool/storage/__init__.py

@@ -0,0 +1,8 @@
+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 VacancyContactsRepository
+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.vacancy_contacts = VacancyContactsRepository(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 json
+from hh_applicant_tool.utils.date 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 = json.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 = json.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/contacts.py

@@ -0,0 +1,28 @@
+from .base import BaseModel, mapped
+
+
+# Из вакансии извлекается
+class VacancyContactsModel(BaseModel):
+    id: int
+    vacancy_id: int = mapped(path="id")
+
+    vacancy_name: str = mapped(path="name")
+    vacancy_alternate_url: str = mapped(path="alternate_url", default=None)
+    vacancy_area_id: int = mapped(path="area.id", default=None)
+    vacancy_area_name: str = mapped(path="area.name", default=None)
+    vacancy_salary_from: int = mapped(path="salary.from", default=0)
+    vacancy_salary_to: int = mapped(path="salary.to", default=0)
+    vacancy_currency: str = mapped(path="salary.currency", default="RUR")
+    vacancy_gross: bool = mapped(path="salary.gross", default=False)
+
+    employer_id: int = mapped(path="employer.id", default=None)
+    employer_name: str = mapped(path="employer.name", default=None)
+    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,132 @@
+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
+);
+/* ===================== contacts ===================== */
+CREATE TABLE IF NOT EXISTS vacancy_contacts (
+    id TEXT PRIMARY KEY DEFAULT (lower(hex(randomblob(16)))),
+    vacancy_id INTEGER NOT NULL,
+    -- Все это избыточные поля
+    vacancy_alternate_url TEXT,
+    vacancy_name TEXT,
+    vacancy_area_id INTEGER,
+    vacancy_area_name TEXT,
+    vacancy_salary_from INTEGER,
+    vacancy_salary_to INTEGER,
+    vacancy_currency VARCHAR(3),
+    vacancy_gross BOOLEAN,
+    --
+    employer_id INTEGER,
+    employer_name TEXT,
+    --
+    name TEXT,
+    email TEXT,
+    phone_numbers TEXT NOT NULL,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    UNIQUE (vacancy_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,
+    -- Может обнулиться при блокировке раб-о-тодателя
+    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_vacancy_contacts_updated
+AFTER
+UPDATE ON vacancy_contacts BEGIN
+UPDATE vacancy_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;