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

hh_applicant_tool/telemetry_client.py

@@ -1,106 +0,0 @@
-from __future__ import annotations
-
-import json
-import logging
-import os
-import time
-import warnings
-from functools import partialmethod
-from typing import Any, Dict, Optional
-from urllib.parse import urljoin
-import requests
-from .utils import Config
-
-# Сертификат на сервере давно истек, но его обновлять мне лень...
-warnings.filterwarnings("ignore", message="Unverified HTTPS request")
-
-logger = logging.getLogger(__package__)
-
-
-class TelemetryError(Exception):
-    """Исключение, возникающее при ошибках в работе TelemetryClient."""
-
-    pass
-
-
-class TelemetryClient:
-    """Клиент для отправки телеметрии на сервер."""
-
-    server_address: str = "https://hh-applicant-tool.mooo.com:54157/"
-    default_delay: float = 0.56  # Задержка по умолчанию в секундах
-
-    def __init__(
-        self,
-        telemetry_client_id: str,
-        server_address: Optional[str] = None,
-        *,
-        session: Optional[requests.Session] = None,
-        user_agent: str = "Mozilla/5.0 (HHApplicantTelemetry/1.0)",
-        proxies: dict | None = None,
-        delay: Optional[float] = None,
-    ) -> None:
-        self.send_telemetry_id = telemetry_client_id
-        self.server_address = os.getenv(
-            "TELEMETRY_SERVER", server_address or self.server_address
-        )
-        self.session = session or requests.Session()
-        self.user_agent = user_agent
-        self.proxies = proxies
-        self.delay = delay if delay is not None else self.default_delay
-        self.last_request_time = time.monotonic()  # Время последнего запроса
-
-    def request(
-        self,
-        method: str,
-        endpoint: str,
-        data: Dict[str, Any] | None = None,
-        **kwargs: Any,
-    ) -> Dict[str, Any]:
-        method = method.upper()
-        url = urljoin(self.server_address, endpoint)
-        has_body = method in ["POST", "PUT", "PATCH"]
-
-        # Вычисляем время, прошедшее с последнего запроса
-        current_time = time.monotonic()
-        time_since_last_request = current_time - self.last_request_time
-
-        # Если прошло меньше времени, чем задержка, ждем оставшееся время
-        if time_since_last_request < self.delay:
-            time.sleep(self.delay - time_since_last_request)
-
-        try:
-            response = self.session.request(
-                method,
-                url,
-                headers={
-                    "User-Agent": self.user_agent,
-                    "X-Telemetry-Client-ID": self.send_telemetry_id,
-                },
-                proxies=self.proxies,
-                params=data if not has_body else None,
-                json=data if has_body else None,
-                verify=False,  # Игнорирование истекшего сертификата
-                **kwargs,
-            )
-            # response.raise_for_status()
-            result = response.json()
-            if 200 > response.status_code >= 300:
-                raise TelemetryError(result)
-            return result
-
-        except (
-            requests.exceptions.RequestException,
-            json.JSONDecodeError,
-        ) as ex:
-            raise TelemetryError(str(ex)) from ex
-        finally:
-            # Обновляем время последнего запроса
-            self.last_request_time = time.monotonic()
-
-    get_telemetry = partialmethod(request, "GET")
-    send_telemetry = partialmethod(request, "POST")
-
-    @classmethod
-    def create_from_config(cls, config: Config) -> "TelemetryClient":
-        assert "telemetry_client_id" in config
-        return cls(config["telemetry_client_id"])

hh_applicant_tool/types.py

@@ -1,45 +0,0 @@
-from typing import TypedDict, Literal
-
-
-class AccessToken(TypedDict):
-    access_token: str
-    refresh_token: str
-    expires_in: int
-    token_type: Literal["bearer"]
-
-
-class ApiListResponse(TypedDict):
-    ...
-    items: list
-    found: int
-    page: int
-    pages: int
-    per_page: int
-
-
-class VacancyItem(TypedDict):
-    accept_incomplete_resumes: bool
-    address: dict
-    alternate_url: str
-    apply_alternate_url: str
-    area: dict
-    contacts: dict
-    counters: dict
-    department: dict
-    employer: dict
-    has_test: bool
-    id: int
-    insider_interview: dict
-    name: str
-    professional_roles: list
-    published_at: str
-    relations: list
-    response_letter_required: bool
-    response_url: str | None
-    salary: dict
-    schedule: dict
-    snippet: dict
-    sort_point_distance: float
-    type: dict
-    url: str
-    experience: dict

hh_applicant_tool/utils.py

@@ -1,119 +0,0 @@
-from __future__ import annotations
-
-import hashlib
-import json
-import platform
-import random
-import re
-import sys
-import uuid
-from datetime import datetime
-from functools import partial
-from os import getenv
-from pathlib import Path
-from threading import Lock
-from typing import Any
-
-from .constants import INVALID_ISO8601_FORMAT
-
-print_err = partial(print, file=sys.stderr, flush=True)
-
-
-def get_config_path() -> Path:
-    match platform.system():
-        case "Windows":
-            return Path(getenv("APPDATA", Path.home() / "AppData" / "Roaming"))
-        case "Darwin":  # macOS
-            return Path.home() / "Library" / "Application Support"
-        case _:  # Linux and etc
-            return Path(getenv("XDG_CONFIG_HOME", Path.home() / ".config"))
-
-
-class AttrDict(dict):
-    __getattr__ = dict.get
-    __setattr__ = dict.__setitem__
-    __delattr__ = dict.__delitem__
-
-
-# TODO: добавить defaults
-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,
-                    ensure_ascii=True,
-                    indent=2,
-                    sort_keys=True,
-                )
-
-    __getitem__ = dict.get
-
-
-def truncate_string(s: str, limit: int = 75, ellipsis: str = "…") -> str:
-    return s[:limit] + bool(s[limit:]) * ellipsis
-
-
-def make_hash(data: str) -> str:
-    # Вычисляем хеш SHA-256
-    return hashlib.sha256(data.encode()).hexdigest()
-
-
-def parse_invalid_datetime(dt: str) -> datetime:
-    return datetime.strptime(dt, INVALID_ISO8601_FORMAT)
-
-
-def fix_datetime(dt: str | None) -> str | None:
-    return parse_invalid_datetime(dt).isoformat() if dt is not None else None
-
-
-def random_text(s: str) -> str:
-    while (
-        temp := re.sub(
-            r"{([^{}]+)}",
-            lambda m: random.choice(
-                m.group(1).split("|"),
-            ),
-            s,
-        )
-    ) != s:
-        s = temp
-    return s
-
-
-def parse_interval(interval: str) -> tuple[float, float]:
-    """Парсит строку интервала и возвращает кортеж с минимальным и максимальным значениями."""
-    if "-" in interval:
-        min_interval, max_interval = map(float, interval.split("-"))
-    else:
-        min_interval = max_interval = float(interval)
-    return min(min_interval, max_interval), max(min_interval, max_interval)
-
-
-def android_user_agent() -> str:
-    """Android Default"""
-    devices = "23053RN02A, 23053RN02Y, 23053RN02I, 23053RN02L, 23077RABDC".split(", ")
-    device = random.choice(devices)
-    minor = random.randint(100, 150)
-    patch = random.randint(10000, 15000)
-    android = random.randint(11, 15)
-    return (
-        f"ru.hh.android/7.{minor}.{patch}, Device: {device}, "
-        f"Android OS: {android} (UUID: {uuid.uuid4()})"
-    )