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

hh_applicant_tool/storage/repositories/base.py

@@ -4,11 +4,10 @@ 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
+from .errors import wrap_db_errors
 
 DEFAULT_PRIMARY_KEY = "id"
 
@@ -19,18 +18,23 @@ logger = logging.getLogger(__package__)
 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
 
-    @cached_property
+    @property
     def table_name(self) -> str:
-        return model2table(self.model)
+        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()
@@ -53,6 +57,7 @@ class BaseRepository:
         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 = {
@@ -94,25 +99,37 @@ class BaseRepository:
         if conditions:
             sql += f" WHERE {' AND '.join(conditions)}"
         sql += " ORDER BY rowid DESC;"
-        logger.debug("%.2000s", sql)
-        cur = self.conn.execute(sql, sql_params)
+        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]
 
-    def delete(self, o: BaseModel, /, commit: bool | None = None) -> None:
+    @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(o, 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)
@@ -121,14 +138,21 @@ class BaseRepository:
 
     def _insert(
         self,
-        data: Mapping[str, Any],
+        data: Mapping[str, Any] | list[Mapping[str, Any]],
         /,
+        batch: bool = False,
         upsert: bool = True,
         conflict_columns: Sequence[str] | None = None,
-        update_excludes: Sequence[str] = ("created_at", "updated_at"),
+        update_excludes: Sequence[str] | None = None,
         commit: bool | None = None,
     ):
-        columns = list(data.keys())
+        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)})"
@@ -151,7 +175,10 @@ class BaseRepository:
                 # 2. Primary key (никогда не меняем)
                 # 3. Технические поля (created_at и т.д.)
                 update_set = (
-                    cols_set - conflict_set - {self.pkey} - set(update_excludes)
+                    cols_set
+                    - conflict_set
+                    - {self.pkey}
+                    - set(update_excludes or [])
                 )
 
                 if update_set:
@@ -163,14 +190,41 @@ class BaseRepository:
                     sql += " DO NOTHING"
 
         sql += ";"
-        logger.debug("%.2000s", sql)
-        self.conn.execute(sql, data)
+        # 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
+        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

@@ -2,18 +2,13 @@ from __future__ import annotations
 
 import logging
 
-from ..models.contact import EmployerContactModel
+from ..models.contacts import VacancyContactsModel
 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"],
-        )
+class VacancyContactsRepository(BaseRepository):
+    __table__ = "vacancy_contacts"
+    model = VacancyContactsModel
+    conflict_columns = ("vacancy_id", "email")

hh_applicant_tool/storage/repositories/employers.py

@@ -7,6 +7,7 @@ from .base import BaseRepository
 
 
 class EmployersRepository(BaseRepository):
+    __table__ = "employers"
     model = EmployerModel
 
     def find(self, **kwargs) -> Iterator[EmployerModel]:

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

@@ -9,4 +9,5 @@ logger = getLogger(__package__)
 
 
 class NegotiationRepository(BaseRepository):
+    __table__ = "negotiations"
     model = NegotiationModel

hh_applicant_tool/storage/repositories/resumes.py

@@ -1,14 +1,9 @@
 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
+    __table__ = "resumes"
+    model = ResumeModel

hh_applicant_tool/storage/repositories/settings.py

@@ -7,6 +7,7 @@ Default = TypeVar("Default")
 
 
 class SettingsRepository(BaseRepository):
+    __table__ = "settings"
     pkey: str = "key"
     model = SettingModel
 

hh_applicant_tool/storage/repositories/vacancies.py

@@ -5,4 +5,5 @@ from .base import BaseRepository
 
 
 class VacanciesRepository(BaseRepository):
+    __table__ = "vacancies"
     model = VacancyModel

hh_applicant_tool/storage/utils.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import logging
-import re
 import sqlite3
 from pathlib import Path
 
@@ -14,10 +13,16 @@ logger: logging.Logger = logging.getLogger(__package__)
 
 def init_db(conn: sqlite3.Connection) -> None:
     """Создает схему БД"""
+    changes_before = conn.total_changes
+
     conn.executescript(
         (QUERIES_PATH / "schema.sql").read_text(encoding="utf-8")
     )
-    logger.debug("Database unitialized")
+
+    if conn.total_changes > changes_before:
+        logger.info("Применена схема бд")
+    # else:
+    #     logger.debug("База данных не изменилась.")
 
 
 def list_migrations() -> list[str]:
@@ -34,16 +39,8 @@ def apply_migration(conn: sqlite3.Connection, name: str) -> None:
     )
 
 
-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"
+# 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

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
+from ..api.user_agent import generate_android_useragent
 from .attrdict import AttrDict
 from .config import Config, get_config_path
-from .dateutil import (
+from .date import (
     DATETIME_FORMAT,
     parse_api_datetime,
     try_parse_datetime,
@@ -10,7 +11,6 @@ from .dateutil import (
 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__ = [
@@ -25,7 +25,7 @@ __all__ = [
     "bool2str",
     "list2str",
     "calc_hash",
-    "hh_android_useragent",
+    "generate_android_useragent",
     "setup_terminal",
     "print_err",
 ]

hh_applicant_tool/utils/config.py

@@ -7,7 +7,7 @@ from pathlib import Path
 from threading import Lock
 from typing import Any
 
-from . import jsonutil as json
+from . import json
 
 
 @cache

hh_applicant_tool/utils/log.py

@@ -38,9 +38,11 @@ class ColorHandler(logging.StreamHandler):
     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)
         # Обязательно нужно восстановить оригинальное значение или в файловом
         # логе не будет деталей ошибки
@@ -107,8 +109,9 @@ def setup_logger(
         ]
     )
 
+    file_handler.addFilter(redactor)
+
     for h in [color_handler, file_handler]:
-        h.addFilter(redactor)
         logger.addHandler(h)
 
 
@@ -118,9 +121,9 @@ 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,
+    maxlines: int = 1000,
 ) -> str:
-    error_lines = deque(maxlen=maxlen)
+    error_lines = deque(maxlen=maxlines)
     prev_line = ""
     log_dt = None
     collecting_traceback = False

hh_applicant_tool/utils/mixins.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import platform
 import socket
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 from functools import cache
 from importlib.metadata import version
 from logging import getLogger
@@ -11,7 +11,6 @@ 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
 
@@ -31,26 +30,25 @@ def get_package_version() -> str | None:
 
 
 class ErrorReporter:
-    def build_report(
+    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
-                )
+                error_logs = collect_traceback_logs(fp, last_report)
 
-        # Эти данные нужны для воспроизведения ошибок. Среди них ваших нет
-        contacts = [
+        # Эти данные нужны для воспроизведения ошибок. Среди них ваших
+        # персональных данных нет
+        vacancy_contacts = [
             c.to_dict()
-            for c in self.storage.employer_contacts.find(
+            for c in self.storage.vacancy_contacts.find(
                 updated_at__ge=last_report
             )
-        ][-10000:]
+        ]
 
-        for c in contacts:
+        for c in vacancy_contacts:
             c.pop("id", 0)
 
         employers = [
@@ -70,7 +68,7 @@ class ErrorReporter:
                 ]
             }
             for emp in self.storage.employers.find(updated_at__ge=last_report)
-        ][-10000:]
+        ]
 
         vacancies = [
             {
@@ -93,7 +91,7 @@ class ErrorReporter:
                 ]
             }
             for vac in self.storage.vacancies.find(updated_at__ge=last_report)
-        ][-10000:]
+        ]
 
         # log.info("num vacncies: %d", len(vacancies))
 
@@ -105,16 +103,16 @@ class ErrorReporter:
         }
 
         return dict(
-            error_logs=error_logs,
-            contacts=contacts,
-            employers=employers,
-            vacancies=vacancies,
+            error_logs=error_logs[-100000:],
+            vacancy_contacts=vacancy_contacts[-10000:],
+            employers=employers[-10000:],
+            vacancies=vacancies[-10000:],
             package_version=get_package_version(),
             system_info=system_info,
-            report_created=datetime.now(),
+            report_created=datetime.now(timezone.utc),
         )
 
-    def send_report(self: HHApplicantTool, data: bytes) -> int:
+    def __send_report(self: HHApplicantTool, data: bytes) -> int:
         try:
             r = self.session.post(
                 # "http://localhost:8000/report",
@@ -128,7 +126,7 @@ class ErrorReporter:
             # log.error("Network error: %s", e)
             return False
 
-    def process_reporting(self):
+    def _process_reporting(self):
         # Получаем timestamp последнего репорта
         last_report = datetime.fromtimestamp(
             self.storage.settings.get_value("_last_report", 0)
@@ -136,12 +134,12 @@ class ErrorReporter:
 
         if datetime.now() >= last_report + timedelta(hours=72):
             try:
-                report_dict = self.build_report(last_report)
+                report_dict = self.__build_report(last_report)
                 has_data = any(
                     [
                         report_dict.get("error_logs"),
                         report_dict.get("employers"),
-                        report_dict.get("contacts"),
+                        report_dict.get("vacancy_contacts"),
                         report_dict.get("vacancies"),
                     ]
                 )
@@ -149,7 +147,7 @@ class ErrorReporter:
                     data = binpack.serialize(report_dict)
                     log.debug("Report body size: %d", len(data))
                     # print(binpack.deserialize(data))
-                    if self.send_report(data):
+                    if self.__send_report(data):
                         log.debug("Report was sent")
                     else:
                         log.debug("Report failed")
@@ -161,7 +159,7 @@ class ErrorReporter:
 
 
 class VersionChecker:
-    def get_latest_version(self: HHApplicantTool) -> Literal[False] | str:
+    def __get_latest_version(self: HHApplicantTool) -> Literal[False] | str:
         try:
             response = self.session.get(
                 "https://pypi.org/pypi/hh-applicant-tool/json", timeout=15
@@ -172,11 +170,11 @@ class VersionChecker:
         except requests.RequestException:
             return False
 
-    def check_version(self: HHApplicantTool) -> bool:
+    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():
+            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)
@@ -193,28 +191,12 @@ class VersionChecker:
                 )
 
 
-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):
+class MegaTool(ErrorReporter, VersionChecker):
+    def _check_system(self: HHApplicantTool):
         if not self.storage.settings.get_value("disable_version_check", False):
-            self.check_version()
+            self._check_version()
 
         if self.storage.settings.get_value("send_error_reports", True):
-            self.process_reporting()
+            self._process_reporting()
         else:
             log.warning("ОТКЛЮЧЕНА ОТПРАВКА СООБЩЕНИЙ ОБ ОШИБКАХ!")

hh_applicant_tool/utils/string.py

@@ -4,9 +4,11 @@ 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(
@@ -20,8 +22,21 @@ def rand_text(s: str) -> str:
         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 ""
+
+
+def unescape_string(text: str) -> str:
+    if not text:
+        return ""
+    return (
+        text.replace(r"\n", "\n")
+        .replace(r"\r", "\r")
+        .replace(r"\t", "\t")
+        .replace(r"\\", "\\")
+    )