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

hh_applicant_tool/ai/openai.py

@@ -0,0 +1,71 @@
+import logging
+
+import requests
+
+logger = logging.getLogger(__package__)
+
+
+class OpenAIError(Exception):
+    pass
+
+
+class OpenAIChat:
+    chat_endpoint: 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()
+
+    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
+                }
+            ],
+            "temperature": 0.7,
+            "max_completion_tokens": 1000
+        }
+
+        try:
+            response = self.session.post(
+                self.chat_endpoint,
+                json=payload,
+                headers=self.default_headers(),
+                proxies=self.proxies,
+                timeout=30
+            )
+            response.raise_for_status()
+
+            data = response.json()
+            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

hh_applicant_tool/api/client.py

@@ -3,22 +3,16 @@ from __future__ import annotations
 import dataclasses
 import json
 import logging
-import uuid
 import time
 from dataclasses import dataclass
-from functools import partialmethod
+from functools import cached_property
 from threading import Lock
 from typing import Any, Literal
 from urllib.parse import urlencode
-from functools import cached_property
-import random
+
 import requests
 from requests import Response, Session
 
-from ..constants import (
-    ANDROID_CLIENT_ID,
-    ANDROID_CLIENT_SECRET,
-)
 from ..types import AccessToken
 from . import errors
 
@@ -35,7 +29,6 @@ ALLOWED_METHODS = Literal["GET", "POST", "PUT", "DELETE"]
 class BaseClient:
     base_url: str
     _: dataclasses.KW_ONLY
-    # TODO: сделать генерацию User-Agent'а как в приложении
     user_agent: str | None = None
     proxies: dict | None = None
     session: Session | None = None
@@ -45,26 +38,16 @@ class BaseClient:
     def __post_init__(self) -> None:
         self.lock = Lock()
         if not self.session:
-            self.session = session = requests.session()
-            session.headers.update(
-                {
-                    "user-agent": self.user_agent or self.default_user_agent(),
-                    "x-hh-app-active": "true",
-                    **self.additional_headers(),
-                }
-            )
-            logger.debug("Default Headers: %r", session.headers)
-
-    def default_user_agent(self) -> str:
-        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}, Android OS: {android} (UUID: {uuid.uuid4()})"
+            self.session = requests.session()
+        if self.proxies:
+            logger.debug(f"client proxies: {self.proxies}")
 
+    def default_headers(self) -> dict[str, str]:
+        return {
+            "user-agent": self.user_agent or "Mozilla/5.0",
+            "x-hh-app-active": "true",
+        }
+    
     def additional_headers(
         self,
     ) -> dict[str, str]:
@@ -94,34 +77,44 @@ class BaseClient:
                 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]}")
             response = self.session.request(
                 method,
                 url,
                 **payload,
+                headers=headers,
                 proxies=self.proxies,
                 allow_redirects=False,
             )
             try:
-                # У этих лошков сервер не отдает Content-Length, а кривое API отдает пустые ответы, например, при отклике на вакансии, и мы не можем узнать содержит ли ответ тело
+                # У этих лошков сервер не отдает Content-Length, а кривое API
+                # отдает пустые ответы, например, при отклике на вакансии,
+                # и мы не можем узнать содержит ли ответ тело
                 # 'Server': 'ddos-guard'
                 # ...
                 # 'Transfer-Encoding': 'chunked'
                 try:
-                    rv = response.json()
-                except json.decoder.JSONDecodeError:
-                    # if response.status_code not in [201, 204]:
-                    #     raise
-                    rv = {}
+                    rv = response.json() if response.text else {}
+                except json.decoder.JSONDecodeError as ex:
+                    raise errors.BadResponse(
+                        f"Can't decode JSON: {method} {url} ({response.status_code})"
+                    ) from ex
             finally:
+                log_url = url
+                if not has_body and params:
+                    log_url += "?" + urlencode(params)
                 logger.debug(
-                    "%d %-6s %s",
-                    response.status_code,
+                    "%s %s: %d",
                     method,
-                    url + ("?" + urlencode(params) if not has_body and params else ""),
+                    log_url,
+                    response.status_code,
                 )
                 self.previous_request_time = time.monotonic()
         self.raise_for_status(response, rv)
-        assert 300 > response.status_code >= 200
+        assert 300 > response.status_code >= 200, (
+            f"Unexpected status code for {method} {url}: {response.status_code}"
+        )
         return rv
 
     def get(self, *args, **kwargs):
@@ -202,9 +195,12 @@ class OAuthClient(BaseClient):
         return self.request_access_token("/token", params)
 
     def refresh_access_token(self, refresh_token: str) -> AccessToken:
-        # refresh_token можно использовать только один раз и только по истечению срока действия access_token.
+        # refresh_token можно использовать только один раз и только по
+        # истечению срока действия access_token.
         return self.request_access_token(
-            "/token", grant_type="refresh_token", refresh_token=refresh_token
+            "/token",
+            grant_type="refresh_token",
+            refresh_token=refresh_token,
         )
 
 
@@ -214,31 +210,33 @@ class ApiClient(BaseClient):
     access_token: str | None = None
     refresh_token: str | None = None
     access_expires_at: int = 0
-    client_id: str = ANDROID_CLIENT_ID
-    client_secret: str = ANDROID_CLIENT_SECRET
     _: dataclasses.KW_ONLY
+    client_id: str | None = None
+    client_secret: str | None = None
     base_url: str = "https://api.hh.ru/"
 
     @property
     def is_access_expired(self) -> bool:
-        return time.time() > self.access_expires_at
+        return time.time() >= (self.access_expires_at or 0)
 
     @cached_property
     def oauth_client(self) -> OAuthClient:
         return OAuthClient(
             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(
         self,
     ) -> dict[str, str]:
-        return (
-            {"authorization": f"Bearer {self.access_token}"}
-            if self.access_token
-            else {}
-        )
+        if not self.access_token:
+            return {}
+        # Это очень интересно, что access token'ы начинаются с USER, т.е. API может содержать какую-то уязвимость, связанную с этим
+        assert self.access_token.startswith("USER")
+        return {"authorization": f"Bearer {self.access_token}"}
 
     # Реализовано автоматическое обновление токена
     def request(
@@ -258,14 +256,14 @@ class ApiClient(BaseClient):
         except errors.Forbidden as ex:
             if not self.is_access_expired or not self.refresh_token:
                 raise ex
-            logger.info("try refresh access_token")
+            logger.info("try to refresh access_token")
             # Пробуем обновить токен
             self.refresh_access_token()
             # И повторно отправляем запрос
             return do_request()
 
     def handle_access_token(self, token: AccessToken) -> None:
-        for field in ["access_token", "refresh_token", "access_expires_at"]:
+        for field in ("access_token", "refresh_token", "access_expires_at"):
             if field in token and hasattr(self, field):
                 setattr(self, field, token[field])
 

hh_applicant_tool/api/errors.py

@@ -5,6 +5,7 @@ from requests import Request, Response
 from requests.adapters import CaseInsensitiveDict
 
 __all__ = (
+    "BadResponse",
     "ApiError",
     "BadGateway",
     "BadRequest",
@@ -16,7 +17,11 @@ __all__ = (
 )
 
 
-class ApiError(Exception):
+class BadResponse(Exception):
+    pass
+
+
+class ApiError(BadResponse):
     def __init__(self, response: Response, data: dict[str, Any]) -> None:
         self._response = response
         self._raw = data

hh_applicant_tool/color_log.py

@@ -1,6 +1,18 @@
 import enum
 import logging
 from enum import auto
+import os, sys
+
+
+if sys.platform == "win32":
+    import ctypes
+    kernel32 = ctypes.windll.kernel32
+    # 0x0004 = ENABLE_VIRTUAL_TERMINAL_PROCESSING
+    # Берем дескриптор стандартного вывода (stdout)
+    handle = kernel32.GetStdHandle(-11) 
+    mode = ctypes.c_uint()
+    kernel32.GetConsoleMode(handle, ctypes.byref(mode))
+    kernel32.SetConsoleMode(handle, mode.value | 0x0004)
 
 
 class Color(enum.Enum):

hh_applicant_tool/main.py

@@ -11,8 +11,9 @@ from typing import Literal, Sequence
 
 from .api import ApiClient
 from .color_log import ColorHandler
+from .constants import ANDROID_CLIENT_ID, ANDROID_CLIENT_SECRET
 from .telemetry_client import TelemetryClient
-from .utils import Config, get_config_path
+from .utils import Config, android_user_agent, get_config_path
 
 DEFAULT_CONFIG_PATH = (
     get_config_path() / (__package__ or "").replace("_", "-") / "config.json"
@@ -24,7 +25,7 @@ logger = logging.getLogger(__package__)
 class BaseOperation:
     def setup_parser(self, parser: argparse.ArgumentParser) -> None: ...
 
-    def run(self, args: argparse.Namespace) -> None | int:
+    def run(self, args: argparse.Namespace, api_client: ApiClient, telemetry_client: TelemetryClient) -> None | int:
         raise NotImplementedError()
 
 
@@ -40,21 +41,38 @@ class Namespace(argparse.Namespace):
     disable_telemetry: bool
 
 
-def get_proxies(args: Namespace) -> dict[Literal["http", "https"], str | None]:
-    return {
-        "http": args.config["proxy_url"] or getenv("HTTP_PROXY"),
-        "https": args.config["proxy_url"] or getenv("HTTPS_PROXY"),
-    }
+def get_proxies(args: Namespace) -> dict[str, str]:
+    proxy_url = args.proxy_url or args.config.get("proxy_url")
+    
+    if proxy_url:
+        return {
+            "http": proxy_url,
+            "https": proxy_url,
+        }
+    
+    proxies = {}
+    http_env = getenv("HTTP_PROXY") or getenv("http_proxy")
+    https_env = getenv("HTTPS_PROXY") or getenv("https_proxy") or http_env
+    
+    if http_env:
+        proxies["http"] = http_env
+    if https_env:
+        proxies["https"] = https_env
+        
+    return proxies
 
 
 def get_api_client(args: Namespace) -> ApiClient:
-    token = args.config.get("token", {})
+    config = args.config
+    token = config.get("token", {})
     api = ApiClient(
+        client_id=config.get("client_id", ANDROID_CLIENT_ID),
+        client_secret=config.get("client_id", ANDROID_CLIENT_SECRET),
         access_token=token.get("access_token"),
         refresh_token=token.get("refresh_token"),
         access_expires_at=token.get("access_expires_at"),
         delay=args.delay,
-        user_agent=args.config["user_agent"],
+        user_agent=config["user_agent"] or android_user_agent(),
         proxies=get_proxies(args),
     )
     return api
@@ -65,7 +83,7 @@ class HHApplicantTool:
 
     Исходники и предложения: <https://github.com/s3rgeym/hh-applicant-tool>
 
-    Группа поддержки: <https://t.me/otzyvy_headhunter>
+    Группа поддержки: <https://t.me/hh_applicant_tool>
     """
 
     class ArgumentFormatter(
@@ -115,8 +133,22 @@ class HHApplicantTool:
         for _, module_name, _ in iter_modules([str(package_dir)]):
             mod = import_module(f"{__package__}.{OPERATIONS}.{module_name}")
             op: BaseOperation = mod.Operation()
+            # 1. Разбиваем имя модуля на части
+            words = module_name.split("_")
+
+            # 2. Формируем варианты имен
+            kebab_name = "-".join(words)  # call-api
+            
+            # camelCase: первое слово маленькими, остальные с большой
+            camel_case_name = words[0] + "".join(word.title() for word in words[1:])
+            
+            # flatcase: всё слитно и в нижнем регистре
+            flat_name = "".join(words)  # callapi
+
             op_parser = subparsers.add_parser(
-                module_name.replace("_", "-"),
+                kebab_name,
+                # Добавляем остальные варианты в псевдонимы
+                aliases=[camel_case_name, flat_name],
                 description=op.__doc__,
                 formatter_class=self.ArgumentFormatter,
             )
@@ -154,7 +186,7 @@ class HHApplicantTool:
                 logger.warning("Interrupted by user")
                 return 1
             except Exception as e:
-                logger.exception(e)
+                logger.exception(e, exc_info=log_level <= logging.DEBUG)
                 return 1
         parser.print_help(file=sys.stderr)
         return 2