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

hh_applicant_tool/__init__.py

@@ -0,0 +1 @@
+from .main import HHApplicantTool

hh_applicant_tool/__main__.py

@@ -1,6 +1,6 @@
 import sys
 
-from .main import main
+from . import main
 
 if __name__ == "__main__":
     sys.exit(main())

hh_applicant_tool/ai/base.py

@@ -0,0 +1,2 @@
+class AIError(Exception):
+    pass

hh_applicant_tool/ai/openai.py

@@ -1,71 +1,61 @@
 import logging
+from dataclasses import dataclass, field
+from typing import ClassVar
 
 import requests
 
+from .base import AIError
+
 logger = logging.getLogger(__package__)
 
 
-class OpenAIError(Exception):
+class OpenAIError(AIError):
     pass
 
 
-class OpenAIChat:
-    chat_endpoint: str = "https://api.openai.com/v1/chat/completions"
+@dataclass
+class ChatOpenAI:
+    chat_endpoint: ClassVar[str] = "https://api.openai.com/v1/chat/completions"
 
-    def __init__(
-        self,
-        token: str,
-        model: str,
-        system_prompt: str,
-        proxies: dict[str, str] | None = None,
-        session: requests.Session | None = None
-    ):
-        self.token = token
-        self.model = model
-        self.system_prompt = system_prompt
-        self.proxies = proxies
-        self.session = session or requests.session()
+    token: str
+    model: str
+    system_prompt: str | None = None
+    temperature: float = 0.7
+    max_completion_tokens: int = 1000
+    session: requests.Session = field(default_factory=requests.Session)
 
-    def default_headers(self) -> dict[str, str]:
+    def _default_headers(self) -> dict[str, str]:
         return {
             "Authorization": f"Bearer {self.token}",
         }
 
     def send_message(self, message: str) -> str:
-
         payload = {
             "model": self.model,
             "messages": [
-                {
-                    "role": "system",
-                    "content": self.system_prompt
-                },
-                {
-                    "role": "user",
-                    "content": message
-                }
+                {"role": "system", "content": self.system_prompt},
+                {"role": "user", "content": message},
             ],
-            "temperature": 0.7,
-            "max_completion_tokens": 1000
+            "temperature": self.temperature,
+            "max_completion_tokens": self.max_completion_tokens,
         }
 
         try:
             response = self.session.post(
                 self.chat_endpoint,
                 json=payload,
-                headers=self.default_headers(),
-                proxies=self.proxies,
-                timeout=30
+                headers=self._default_headers(),
+                timeout=30,
             )
             response.raise_for_status()
 
             data = response.json()
-            if 'error' in data:
-                raise OpenAIError(data['error']['message'])
-            
+            if "error" in data:
+                raise OpenAIError(data["error"]["message"])
+
             assistant_message = data["choices"][0]["message"]["content"]
 
             return assistant_message
 
         except requests.exceptions.RequestException as ex:
-            raise OpenAIError(str(ex)) from ex
+            raise OpenAIError(f"Network error: {ex}") from ex

hh_applicant_tool/api/__init__.py

@@ -1,3 +1,5 @@
 """See <https://github.com/hhru/api>"""
-from .client import *
-from .errors import *
+
+from .client import *  # noqa: F403
+from .datatypes import *  # noqa: F403
+from .errors import *  # noqa: F403

hh_applicant_tool/api/client.py

@@ -7,21 +7,31 @@ import time
 from dataclasses import dataclass
 from functools import cached_property
 from threading import Lock
-from typing import Any, Literal
-from urllib.parse import urlencode
+from typing import Any, Literal, TypeVar
+from urllib.parse import urlencode, urljoin
 
 import requests
-from requests import Response, Session
+from requests import Session
 
-from ..types import AccessToken
 from . import errors
+from .client_keys import (
+    ANDROID_CLIENT_ID,
+    ANDROID_CLIENT_SECRET,
+)
+from .datatypes import AccessToken
+from .user_agent import generate_android_useragent
 
 __all__ = ("ApiClient", "OAuthClient")
 
-logger = logging.getLogger(__package__)
+HH_API_URL = "https://api.hh.ru/"
+HH_OAUTH_URL = "https://hh.ru/oauth/"
+DEFAULT_DELAY = 0.334
+
+AllowedMethods = Literal["GET", "POST", "PUT", "DELETE"]
+T = TypeVar("T")
 
 
-ALLOWED_METHODS = Literal["GET", "POST", "PUT", "DELETE"]
+logger = logging.getLogger(__package__)
 
 
 # Thread-safe
@@ -30,39 +40,40 @@ class BaseClient:
     base_url: str
     _: dataclasses.KW_ONLY
     user_agent: str | None = None
-    proxies: dict | None = None
     session: Session | None = None
-    previous_request_time: float = 0.0
-    delay: float = 0.334
+    delay: float = DEFAULT_DELAY
+    _previous_request_time: float = 0.0
 
     def __post_init__(self) -> None:
+        assert self.base_url.endswith("/"), "base_url must ends with /"
         self.lock = Lock()
+        # logger.debug(f"user agent: {self.user_agent}")
         if not self.session:
+            logger.debug("create new session")
             self.session = requests.session()
-        if self.proxies:
-            logger.debug(f"client proxies: {self.proxies}")
+        # if self.proxies:
+        #     logger.debug(f"client proxies: {self.proxies}")
 
-    def default_headers(self) -> dict[str, str]:
+    @property
+    def proxies(self):
+        return self.session.proxies
+
+    def _default_headers(self) -> dict[str, str]:
         return {
-            "user-agent": self.user_agent or "Mozilla/5.0",
+            "user-agent": self.user_agent or generate_android_useragent(),
             "x-hh-app-active": "true",
         }
-    
-    def additional_headers(
-        self,
-    ) -> dict[str, str]:
-        return {}
 
     def request(
         self,
-        method: ALLOWED_METHODS,
+        method: AllowedMethods,
         endpoint: str,
         params: dict[str, Any] | None = None,
         delay: float | None = None,
         **kwargs: Any,
-    ) -> dict:
+    ) -> T:
         # Не знаю насколько это "правильно"
-        assert method in ALLOWED_METHODS.__args__
+        assert method in AllowedMethods.__args__
         params = dict(params or {})
         params.update(kwargs)
         url = self.resolve_url(endpoint)
@@ -71,20 +82,18 @@ class BaseClient:
             if (
                 delay := (self.delay if delay is None else delay)
                 - time.monotonic()
-                + self.previous_request_time
+                + self._previous_request_time
             ) > 0:
                 logger.debug("wait %fs before request", delay)
                 time.sleep(delay)
             has_body = method in ["POST", "PUT"]
             payload = {"data" if has_body else "params": params}
-            headers = self.default_headers() | self.additional_headers()
-            logger.debug(f"request info: {method = }, {url = }, {headers = }, params = {repr(params)[:255]}")
+            # logger.debug(f"request info: {method = }, {url = }, {headers = }, params = {repr(params)[:255]}")
             response = self.session.request(
                 method,
                 url,
                 **payload,
-                headers=headers,
-                proxies=self.proxies,
+                headers=self._default_headers(),
                 allow_redirects=False,
             )
             try:
@@ -102,67 +111,53 @@ class BaseClient:
                     ) from ex
             finally:
                 log_url = url
-                if not has_body and params:
-                    log_url += "?" + urlencode(params)
+                if params and not has_body:
+                    encoded_params = urlencode(params)
+                    log_url += ("?", "&")["?" in url] + encoded_params
                 logger.debug(
-                    "%s %s: %d",
+                    "%d %s %.1000s",
+                    response.status_code,
                     method,
                     log_url,
-                    response.status_code,
                 )
-                self.previous_request_time = time.monotonic()
-        self.raise_for_status(response, rv)
+                self._previous_request_time = time.monotonic()
+        errors.ApiError.raise_for_status(response, rv)
         assert 300 > response.status_code >= 200, (
             f"Unexpected status code for {method} {url}: {response.status_code}"
         )
         return rv
 
-    def get(self, *args, **kwargs):
+    def get(self, *args, **kwargs) -> T:
         return self.request("GET", *args, **kwargs)
 
-    def post(self, *args, **kwargs):
+    def post(self, *args, **kwargs) -> T:
         return self.request("POST", *args, **kwargs)
 
-    def put(self, *args, **kwargs):
+    def put(self, *args, **kwargs) -> T:
         return self.request("PUT", *args, **kwargs)
 
-    def delete(self, *args, **kwargs):
+    def delete(self, *args, **kwargs) -> T:
         return self.request("DELETE", *args, **kwargs)
 
     def resolve_url(self, url: str) -> str:
-        return url if "://" in url else f"{self.base_url.rstrip('/')}/{url.lstrip('/')}"
-
-    @staticmethod
-    def raise_for_status(response: Response, data: dict) -> None:
-        match response.status_code:
-            case 301 | 302:
-                raise errors.Redirect(response, data)
-            case 400:
-                if errors.ApiError.is_limit_exceeded(data):
-                    raise errors.LimitExceeded(response=response, data=data)
-                raise errors.BadRequest(response, data)
-            case 403:
-                raise errors.Forbidden(response, data)
-            case 404:
-                raise errors.ResourceNotFound(response, data)
-            case status if 500 > status >= 400:
-                raise errors.ClientError(response, data)
-            case 502:
-                raise errors.BadGateway(response, data)
-            case status if status >= 500:
-                raise errors.InternalServerError(response, data)
+        return urljoin(self.base_url, url.lstrip("/"))
 
 
 @dataclass
 class OAuthClient(BaseClient):
-    client_id: str
-    client_secret: str
+    client_id: str | None = None
+    client_secret: str | None = None
     _: dataclasses.KW_ONLY
-    base_url: str = "https://hh.ru/oauth"
+    base_url: str = HH_OAUTH_URL
     state: str = ""
     scope: str = ""
     redirect_uri: str = ""
 
+    def __post_init__(self) -> None:
+        super().__post_init__()
+        self.client_id = self.client_id or ANDROID_CLIENT_ID
+        self.client_secret = self.client_secret or ANDROID_CLIENT_SECRET
+
     @property
     def authorize_url(self) -> str:
         params = dict(
@@ -213,7 +208,7 @@ class ApiClient(BaseClient):
     _: dataclasses.KW_ONLY
     client_id: str | None = None
     client_secret: str | None = None
-    base_url: str = "https://api.hh.ru/"
+    base_url: str = HH_API_URL
 
     @property
     def is_access_expired(self) -> bool:
@@ -225,30 +220,32 @@ class ApiClient(BaseClient):
             client_id=self.client_id,
             client_secret=self.client_secret,
             user_agent=self.user_agent,
-            proxies=dict(self.proxies or {}),
             session=self.session,
         )
 
-    def additional_headers(
+    def _default_headers(
         self,
     ) -> dict[str, str]:
+        headers = super()._default_headers()
         if not self.access_token:
-            return {}
+            return headers
         # Это очень интересно, что access token'ы начинаются с USER, т.е. API может содержать какую-то уязвимость, связанную с этим
         assert self.access_token.startswith("USER")
-        return {"authorization": f"Bearer {self.access_token}"}
+        return headers | {"authorization": f"Bearer {self.access_token}"}
 
     # Реализовано автоматическое обновление токена
     def request(
         self,
-        method: ALLOWED_METHODS,
+        method: AllowedMethods,
         endpoint: str,
         params: dict[str, Any] | None = None,
         delay: float | None = None,
         **kwargs: Any,
-    ) -> dict:
+    ) -> T:
         def do_request():
-            return BaseClient.request(self, method, endpoint, params, delay, **kwargs)
+            return BaseClient.request(
+                self, method, endpoint, params, delay, **kwargs
+            )
 
         try:
             return do_request()

hh_applicant_tool/{constants.py → api/client_keys.py}

@@ -1,6 +1,6 @@
-# USER_AGENT_TEMPLATE = "Mozilla/5.0 (Linux; Android %s; %s) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/%s.0.0.0 Mobile Safari/537.36"
-
-ANDROID_CLIENT_ID = "HIOMIAS39CA9DICTA7JIO64LQKQJF5AGIK74G9ITJKLNEDAOH5FHS5G1JI7FOEGD"
+ANDROID_CLIENT_ID = (
+    "HIOMIAS39CA9DICTA7JIO64LQKQJF5AGIK74G9ITJKLNEDAOH5FHS5G1JI7FOEGD"
+)
 
 ANDROID_CLIENT_SECRET = (
     "V9M870DE342BGHFRUJ5FTCGCUA1482AN0DI8C5TFI9ULMA89H10N60NOP8I4JMVS"
@@ -9,6 +9,3 @@ ANDROID_CLIENT_SECRET = (
 # Используется для прямой авторизации. Этот способ мной не используется, так как
 # для отображения капчи все равно нужен webview.
 # K811HJNKQA8V1UN53I6PN1J1CMAD2L1M3LU6LPAU849BCT031KDSSM485FDPJ6UF
-
-# Кривой формат, который используют эти долбоебы
-INVALID_ISO8601_FORMAT = "%Y-%m-%dT%H:%M:%S%z"

hh_applicant_tool/api/datatypes.py

@@ -0,0 +1,293 @@
+from __future__ import annotations
+
+from typing import Any, Generic, List, Literal, Optional, TypedDict, TypeVar
+
+NegotiationStateId = Literal[
+    "discard",  # отказ
+    "interview",  # собес
+    "response",  # отклик
+    "invitation",  # приглашение
+    "hired",  # выход на работу
+]
+
+
+class AccessToken(TypedDict):
+    access_token: str
+    refresh_token: str
+    expires_in: int
+    token_type: Literal["bearer"]
+
+
+Item = TypeVar("T")
+
+
+class PaginatedItems(TypedDict, Generic[Item]):
+    items: list[Item]
+    found: int
+    page: int
+    pages: int
+    per_page: int
+    # Это не все поля
+    clusters: Optional[Any]
+    arguments: Optional[Any]
+    fixes: Optional[Any]
+    suggests: Optional[Any]
+    # Это выглядит как глюк. Я нейронке скармливал выхлоп апи, а она писала эти
+    # типы
+    alternate_url: str
+
+
+class IdName(TypedDict):
+    id: str
+    name: str
+
+
+class Snippet(TypedDict):
+    requirement: Optional[str]
+    responsibility: Optional[str]
+
+
+class ManagerActivity(TypedDict):
+    last_activity_at: str
+
+
+Salary = TypedDict(
+    "Salary",
+    {
+        "from": Optional[int],
+        "to": Optional[int],
+        "currency": str,
+        "gross": bool,
+    },
+)
+
+SalaryRange = TypedDict(
+    "SalaryRange",
+    {
+        "from": Optional[int],
+        "to": Optional[int],
+        "currency": str,
+        "gross": bool,
+        "mode": IdName,
+        "frequency": IdName,
+    },
+)
+
+
+LogoUrls = TypedDict(
+    "LogoUrls",
+    {
+        "original": str,
+        "90": str,
+        "240": str,
+    },
+)
+
+
+class EmployerShort(TypedDict):
+    id: str
+    name: str
+    url: str
+    alternate_url: str
+    logo_urls: Optional[LogoUrls]
+    vacancies_url: str
+    accredited_it_employer: bool
+    trusted: bool
+
+
+class SearchEmployer(EmployerShort):
+    country_id: Optional[int]
+
+
+class NegotiationEmployer(EmployerShort):
+    pass
+
+
+class VacancyShort(TypedDict):
+    id: str
+    premium: bool
+    name: str
+    department: Optional[dict]
+    has_test: bool
+    # HH API fields
+    response_letter_required: bool
+    area: IdName
+    salary: Optional[Salary]
+    salary_range: Optional[SalaryRange]
+    type: IdName
+    address: Optional[dict]
+    response_url: Optional[str]
+    sort_point_distance: Optional[float]
+    published_at: str
+    created_at: str
+    archived: bool
+    apply_alternate_url: str
+    show_contacts: bool
+    benefits: List[Any]
+    insider_interview: Optional[dict]
+    url: str
+    alternate_url: str
+    professional_roles: List[IdName]
+
+
+class NegotiationVacancy(VacancyShort):
+    employer: NegotiationEmployer
+    show_logo_in_search: Optional[bool]
+
+
+class SearchVacancy(VacancyShort):
+    employer: SearchEmployer
+    relations: List[Any]
+    experimental_modes: List[str]
+    manager_activity: Optional[ManagerActivity]
+    snippet: Snippet
+    contacts: Optional[dict]
+    schedule: IdName
+    working_days: List[Any]
+    working_time_intervals: List[Any]
+    working_time_modes: List[Any]
+    accept_temporary: bool
+    fly_in_fly_out_duration: List[Any]
+    work_format: List[IdName]
+    working_hours: List[IdName]
+    work_schedule_by_days: List[IdName]
+    accept_labor_contract: bool
+    civil_law_contracts: List[Any]
+    night_shifts: bool
+    accept_incomplete_resumes: bool
+    experience: IdName
+    employment: IdName
+    employment_form: IdName
+    internship: bool
+    adv_response_url: Optional[str]
+    is_adv_vacancy: bool
+    adv_context: Optional[dict]
+    allow_chat_with_manager: bool
+
+
+class Phone(TypedDict):
+    country: str
+    city: str
+    number: str
+    formatted: str
+    comment: Optional[str]
+
+
+class ContactData(TypedDict):
+    name: Optional[str]
+    email: Optional[str]
+    phones: List[Phone]
+    call_tracking_enabled: bool
+
+
+class ResumeShort(TypedDict):
+    id: str
+    title: str
+    url: str
+    alternate_url: str
+
+
+class ResumeCounters(TypedDict):
+    total_views: int
+    new_views: int
+    invitations: int
+    new_invitations: int
+
+
+class Resume(ResumeShort):
+    status: IdName
+    created_at: str
+    updated_at: str
+    can_publish_or_update: bool
+    counters: ResumeCounters
+
+
+class UserCounters(TypedDict):
+    resumes_count: int
+    new_resume_views: int
+    unread_negotiations: int
+    # ... and more
+
+
+class User(TypedDict):
+    id: int
+    first_name: str
+    last_name: str
+    middle_name: Optional[str]
+    email: Optional[str]
+    phone: Optional[str]
+    is_applicant: bool
+    is_employer: bool
+    is_admin: bool
+    is_anonymous: bool
+    is_application: bool
+    counters: UserCounters
+    # ... and more
+
+
+class Message(TypedDict):
+    id: str
+    text: str
+    author: dict  # Could be more specific, e.g. Participant(TypedDict)
+    created_at: str
+    viewed_by_opponent: bool
+
+
+class Counters(TypedDict):
+    messages: int
+    unread_messages: int
+
+
+class ChatStates(TypedDict):
+    # response_reminder_state: {"allowed": bool}
+    response_reminder_state: dict[str, bool]
+
+
+class NegotiaionState(IdName):
+    id: NegotiationStateId
+
+
+class Negotiation(TypedDict):
+    id: str
+    state: IdName
+    created_at: str
+    updated_at: str
+    resume: ResumeShort
+    viewed_by_opponent: bool
+    has_updates: bool
+    messages_url: str
+    url: str
+    counters: Counters
+    chat_states: ChatStates
+    source: str
+    chat_id: int
+    messaging_status: str
+    decline_allowed: bool
+    read: bool
+    has_new_messages: bool
+    applicant_question_state: bool
+    hidden: bool
+    vacancy: NegotiationVacancy
+    tags: List[Any]
+
+
+class EmployerApplicantServices(TypedDict):
+    target_employer: dict[str, int]
+
+
+class Employer(EmployerShort):
+    has_divisions: bool
+    type: str
+    description: Optional[str]
+    site_url: str
+    relations: List[Any]
+    area: IdName
+    country_code: str
+    industries: List[Any]
+    is_identified_by_esia: bool
+    badges: List[Any]
+    branded_description: Optional[str]
+    branding: Optional[dict]
+    insider_interviews: List[Any]
+    open_vacancies: int
+    applicant_services: EmployerApplicantServices