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

hh_applicant_tool/operations/apply_similar.py

@@ -4,11 +4,13 @@ import random
 import time
 from collections import defaultdict
 from datetime import datetime, timedelta, timezone
-from typing import TextIO
+from pathlib import Path
+from typing import Any, TextIO
 
+from ..ai.blackbox import BlackboxChat
+from ..ai.openai import OpenAIChat
+from ..api import ApiClient, BadResponse
 from ..api.errors import LimitExceeded
-from ..ai.blackbox import BlackboxChat, BlackboxError
-from ..api import ApiError, ApiClient
 from ..main import BaseOperation
 from ..main import Namespace as BaseNamespace
 from ..mixins import GetResumeIdMixin
@@ -28,6 +30,7 @@ logger = logging.getLogger(__package__)
 class Namespace(BaseNamespace):
     resume_id: str | None
     message_list: TextIO
+    ignore_employers: Path | None
     force_message: bool
     use_ai: bool
     pre_prompt: str
@@ -35,11 +38,47 @@ class Namespace(BaseNamespace):
     page_interval: tuple[float, float]
     order_by: str
     search: str
+    schedule: str
     dry_run: bool
+    # Пошли доп фильтры, которых не было
+    experience: str
+    employment: list[str] | None
+    area: list[str] | None
+    metro: list[str] | None
+    professional_role: list[str] | None
+    industry: list[str] | None
+    employer_id: list[str] | None
+    excluded_employer_id: list[str] | None
+    currency: str | None
+    salary: int | None
+    only_with_salary: bool
+    label: list[str] | None
+    period: int | None
+    date_from: str | None
+    date_to: str | None
+    top_lat: float | None
+    bottom_lat: float | None
+    left_lng: float | None
+    right_lng: float | None
+    sort_point_lat: float | None
+    sort_point_lng: float | None
+    no_magic: bool
+    premium: bool
+
+
+def _bool(v: bool) -> str:
+    return str(v).lower()
+
+
+def _join_list(items: list[Any] | None) -> str:
+    return ",".join(f"{v}" for v in items) if items else ""
 
 
 class Operation(BaseOperation, GetResumeIdMixin):
-    """Откликнуться на все подходящие вакансии."""
+    """Откликнуться на все подходящие вакансии.
+
+    Описание фильтров для поиска вакансий: <https://api.hh.ru/openapi/redoc#tag/Poisk-vakansij-dlya-soiskatelya/operation/get-vacancies-similar-to-resume>
+    """
 
     def setup_parser(self, parser: argparse.ArgumentParser) -> None:
         parser.add_argument("--resume-id", help="Идентефикатор резюме")
@@ -49,6 +88,12 @@ class Operation(BaseOperation, GetResumeIdMixin):
             help="Путь до файла, где хранятся сообщения для отклика на вакансии. Каждое сообщение — с новой строки.",
             type=argparse.FileType("r", encoding="utf-8", errors="replace"),
         )
+        parser.add_argument(
+            "--ignore-employers",
+            help="Путь к файлу со списком ID игнорируемых работодателей (по одному ID на строку)",
+            type=Path,
+            default=None,
+        )
         parser.add_argument(
             "-f",
             "--force-message",
@@ -100,12 +145,79 @@ class Operation(BaseOperation, GetResumeIdMixin):
             type=str,
             default=None,
         )
+
+        parser.add_argument(
+            "--schedule",
+            help="Тип графика. Возможные значения: fullDay, shift, flexible, remote, flyInFlyOut для полного дня, сменного графика, гибкого графика, удаленной работы и вахтового метода",
+            type=str,
+            default=None,
+        )
         parser.add_argument(
             "--dry-run",
             help="Не отправлять отклики, а только выводить параметры запроса",
             default=False,
             action=argparse.BooleanOptionalAction,
         )
+        parser.add_argument(
+            "--experience",
+            help="Уровень опыта работы в вакансии. Возможные значения: noExperience, between1And3, between3And6, moreThan6",
+            type=str,
+            default=None,
+        )
+        parser.add_argument(
+            "--employment", nargs="+", help="Тип занятости (employment)"
+        )
+        parser.add_argument("--area", nargs="+", help="Регион (area id)")
+        parser.add_argument("--metro", nargs="+", help="Станции метро (metro id)")
+        parser.add_argument("--professional-role", nargs="+", help="Проф. роль (id)")
+        parser.add_argument("--industry", nargs="+", help="Индустрия (industry id)")
+        parser.add_argument("--employer-id", nargs="+", help="ID работодателей")
+        parser.add_argument(
+            "--excluded-employer-id", nargs="+", help="Исключить работодателей"
+        )
+        parser.add_argument("--currency", help="Код валюты (RUR, USD, EUR)")
+        parser.add_argument("--salary", type=int, help="Минимальная зарплата")
+        parser.add_argument(
+            "--only-with-salary", default=False, action=argparse.BooleanOptionalAction
+        )
+        parser.add_argument("--label", nargs="+", help="Метки вакансий (label)")
+        parser.add_argument("--period", type=int, help="Искать вакансии за N дней")
+        parser.add_argument("--date-from", help="Дата публикации с (YYYY-MM-DD)")
+        parser.add_argument("--date-to", help="Дата публикации по (YYYY-MM-DD)")
+        parser.add_argument("--top-lat", type=float, help="Гео: верхняя широта")
+        parser.add_argument("--bottom-lat", type=float, help="Гео: нижняя широта")
+        parser.add_argument("--left-lng", type=float, help="Гео: левая долгота")
+        parser.add_argument("--right-lng", type=float, help="Гео: правая долгота")
+        parser.add_argument(
+            "--sort-point-lat",
+            type=float,
+            help="Координата lat для сортировки по расстоянию",
+        )
+        parser.add_argument(
+            "--sort-point-lng",
+            type=float,
+            help="Координата lng для сортировки по расстоянию",
+        )
+        parser.add_argument(
+            "--no-magic",
+            action="store_true",
+            help="Отключить авторазбор текста запроса",
+        )
+        parser.add_argument(
+            "--premium",
+            default=False,
+            action=argparse.BooleanOptionalAction,
+            help="Только премиум вакансии",
+        )
+        parser.add_argument(
+            "--search-field", nargs="+", help="Поля поиска (name, company_name и т.п.)"
+        )
+        parser.add_argument(
+            "--clusters",
+            action=argparse.BooleanOptionalAction,
+            help="Включить кластеры (по умолчанию None)",
+        )
+        # parser.add_argument("--describe-arguments", action=argparse.BooleanOptionalAction, help="Вернуть описание параметров запроса")
 
     def run(
         self, args: Namespace, api_client: ApiClient, telemetry_client: TelemetryClient
@@ -130,6 +242,7 @@ class Operation(BaseOperation, GetResumeIdMixin):
         self.telemetry_client = telemetry_client
         self.resume_id = args.resume_id or self._get_resume_id()
         self.application_messages = self._get_application_messages(args.message_list)
+        self.ignored_employers = self._get_ignored_employers(args.ignore_employers)
         self.chat = None
 
         if config := args.config.get("blackbox"):
@@ -138,6 +251,19 @@ class Operation(BaseOperation, GetResumeIdMixin):
                 chat_payload=config["chat_payload"],
                 proxies=self.api_client.proxies or {},
             )
+        elif config := args.config.get("openai"):
+            model = "gpt-5.1"
+            system_prompt = "Напиши сопроводительное письмо для отклика на эту вакансию. Не используй placeholder'ы, твой ответ будет отправлен без обработки."
+            if "model" in config.keys():
+                model = config["model"]
+            if "system_prompt" in config.keys():
+                system_prompt = config["system_prompt"]
+            self.chat = OpenAIChat(
+                token=config["token"],
+                model=model,
+                system_prompt=system_prompt,
+                proxies=self.api_client.proxies or {},
+            )
 
         self.pre_prompt = args.pre_prompt
 
@@ -147,7 +273,34 @@ class Operation(BaseOperation, GetResumeIdMixin):
         self.force_message = args.force_message
         self.order_by = args.order_by
         self.search = args.search
+        self.schedule = args.schedule
         self.dry_run = args.dry_run
+        self.experience = args.experience
+        self.search_field = args.search_field
+        self.employment = args.employment
+        self.area = args.area
+        self.metro = args.metro
+        self.professional_role = args.professional_role
+        self.industry = args.industry
+        self.employer_id = args.employer_id
+        self.excluded_employer_id = args.excluded_employer_id
+        self.currency = args.currency
+        self.salary = args.salary
+        self.only_with_salary = args.only_with_salary
+        self.label = args.label
+        self.period = args.period
+        self.date_from = args.date_from
+        self.date_to = args.date_to
+        self.top_lat = args.top_lat
+        self.bottom_lat = args.bottom_lat
+        self.left_lng = args.left_lng
+        self.right_lng = args.right_lng
+        self.sort_point_lat = args.sort_point_lat
+        self.sort_point_lng = args.sort_point_lng
+        self.clusters = args.clusters
+        # self.describe_arguments = args.describe_arguments
+        self.no_magic = args.no_magic
+        self.premium = args.premium
         self._apply_similar()
 
     def _get_application_messages(self, message_list: TextIO | None) -> list[str]:
@@ -160,6 +313,16 @@ class Operation(BaseOperation, GetResumeIdMixin):
             ]
         return application_messages
 
+    def _get_ignored_employers(self, file_path: Path | None) -> set[str]:
+        ignored = set()
+        if file_path is not None:
+            with file_path.open("r", encoding="utf-8") as f:
+                for line in f:
+                    if clean_id := line.strip():
+                        ignored.add(int(clean_id))
+            logger.info("Загружено %d ID игнорируемых работодателей", len(ignored))
+        return ignored
+
     def _apply_similar(self) -> None:
         telemetry_client = self.telemetry_client
         telemetry_data = defaultdict(dict)
@@ -201,7 +364,6 @@ class Operation(BaseOperation, GetResumeIdMixin):
         }
 
         do_apply = True
-        complained_employers = set()
 
         for vacancy in vacancies:
             try:
@@ -231,13 +393,13 @@ class Operation(BaseOperation, GetResumeIdMixin):
                     continue
 
                 relations = vacancy.get("relations", [])
-                employer_id = vacancy.get("employer", {}).get("id")
+                employer_id = int(vacancy.get("employer", {}).get("id", 0))
 
                 if (
                     self.enable_telemetry
                     and employer_id
                     and employer_id not in telemetry_data["employers"]
-                    and employer_id not in complained_employers
+                    and employer_id not in self.ignored_employers
                     and (
                         not relations
                         or parse_invalid_datetime(vacancy["created_at"])
@@ -260,17 +422,16 @@ class Operation(BaseOperation, GetResumeIdMixin):
                             % employer_id
                         )
 
-                        complained_employers.add(employer_id)
+                        self.ignored_employers.add(employer_id)
 
                     elif do_apply:
                         telemetry_data["employers"][employer_id] = employer_data
 
                 if not do_apply:
                     logger.debug(
-                        "Пропускаем вакансию так как достигла лимита заявок: %s",
-                        vacancy["alternate_url"],
+                        "Останавливаем рассылку откликов, так как достигли лимита, попробуйте через сутки."
                     )
-                    continue
+                    break
 
                 if relations:
                     logger.debug(
@@ -292,7 +453,7 @@ class Operation(BaseOperation, GetResumeIdMixin):
                             msg += message_placeholders["vacancy_name"]
                             logger.debug(msg)
                             msg = self.chat.send_message(msg)
-                        except BlackboxError as ex:
+                        except Exception as ex:
                             logger.error(ex)
                             continue
                     else:
@@ -330,7 +491,7 @@ class Operation(BaseOperation, GetResumeIdMixin):
             except LimitExceeded:
                 print("⚠️ Достигли лимита рассылки")
                 do_apply = False
-            except ApiError as ex:
+            except BadResponse as ex:
                 logger.error(ex)
 
         print("📝 Отклики на вакансии разосланы!")
@@ -352,16 +513,77 @@ class Operation(BaseOperation, GetResumeIdMixin):
             except TelemetryError as ex:
                 logger.error(ex)
 
+    def _get_search_params(self, page: int, per_page: int) -> dict:
+        params = {
+            "page": page,
+            "per_page": per_page,
+            "order_by": self.order_by,
+        }
+
+        if self.search:
+            params["text"] = self.search
+        if self.schedule:
+            params["schedule"] = self.schedule
+        if self.experience:
+            params["experience"] = self.experience
+        if self.currency:
+            params["currency"] = self.currency
+        if self.salary:
+            params["salary"] = self.salary
+        if self.period:
+            params["period"] = self.period
+        if self.date_from:
+            params["date_from"] = self.date_from
+        if self.date_to:
+            params["date_to"] = self.date_to
+        if self.top_lat:
+            params["top_lat"] = self.top_lat
+        if self.bottom_lat:
+            params["bottom_lat"] = self.bottom_lat
+        if self.left_lng:
+            params["left_lng"] = self.left_lng
+        if self.right_lng:
+            params["right_lng"] = self.right_lng
+        if self.sort_point_lat:
+            params["sort_point_lat"] = self.sort_point_lat
+        if self.sort_point_lng:
+            params["sort_point_lng"] = self.sort_point_lng
+        if self.search_field:
+            params["search_field"] = _join_list(self.search_field)
+        if self.employment:
+            params["employment"] = _join_list(self.employment)
+        if self.area:
+            params["area"] = _join_list(self.area)
+        if self.metro:
+            params["metro"] = _join_list(self.metro)
+        if self.professional_role:
+            params["professional_role"] = _join_list(self.professional_role)
+        if self.industry:
+            params["industry"] = _join_list(self.industry)
+        if self.employer_id:
+            params["employer_id"] = _join_list(self.employer_id)
+        if self.excluded_employer_id:
+            params["excluded_employer_id"] = _join_list(self.excluded_employer_id)
+        if self.label:
+            params["label"] = _join_list(self.label)
+        if self.only_with_salary is not None:
+            params["only_with_salary"] = _bool(self.only_with_salary)
+        if self.clusters is not None:
+            params["clusters"] = _bool(self.clusters)
+        if self.no_magic is not None:
+            params["no_magic"] = _bool(self.no_magic)
+        if self.premium is not None:
+            params["premium"] = _bool(self.premium)
+        # if self.responses_count_enabled is not None:
+        #     params["responses_count_enabled"] = _bool(self.responses_count_enabled)
+
+        return params
+
     def _get_vacancies(self, per_page: int = 100) -> list[VacancyItem]:
         rv = []
+        # API отдает только 2000 результатов
         for page in range(20):
-            params = {
-                "page": page,
-                "per_page": per_page,
-                "order_by": self.order_by,
-            }
-            if self.search:
-                params["text"] = self.search
+            params = self._get_search_params(page, per_page)
             res: ApiListResponse = self.api_client.get(
                 f"/resumes/{self.resume_id}/similar_vacancies", params
             )

hh_applicant_tool/operations/authorize.py

@@ -5,17 +5,26 @@ import sys
 from typing import Any
 from ..utils import print_err
 
+from ..api import ApiClient  # noqa: E402
+from ..main import BaseOperation, Namespace  # noqa: E402
+
+HH_ANDROID_SCHEME = "hhandroid"
+
+logger = logging.getLogger(__package__)
 
 QT_IMPORTED = False
 
 try:
     from PyQt6.QtCore import QUrl
     from PyQt6.QtWidgets import QApplication, QMainWindow
+    from PyQt6.QtWebEngineCore import QWebEngineUrlScheme
     from PyQt6.QtWebEngineCore import QWebEngineUrlSchemeHandler
     from PyQt6.QtWebEngineWidgets import QWebEngineView
+    from PyQt6.QtWebEngineCore import QWebEngineSettings
 
     QT_IMPORTED = True
-except ImportError:
+except ImportError as ex:
+    logger.debug(ex)
     # Заглушки чтобы на сервере не нужно было ставить сотни мегабайт qt-говна
 
     class QUrl:
@@ -34,11 +43,6 @@ except ImportError:
         pass
 
 
-from ..api import ApiClient  # noqa: E402
-from ..main import BaseOperation, Namespace  # noqa: E402
-
-logger = logging.getLogger(__package__)
-
 
 class HHAndroidUrlSchemeHandler(QWebEngineUrlSchemeHandler):
     def __init__(self, parent: "WebViewWindow") -> None:
@@ -47,25 +51,51 @@ class HHAndroidUrlSchemeHandler(QWebEngineUrlSchemeHandler):
 
     def requestStarted(self, info: Any) -> None:
         url = info.requestUrl().toString()
-        if url.startswith("hhandroid://"):
+        if url.startswith(f"{HH_ANDROID_SCHEME}://"):
             self.parent.handle_redirect_uri(url)
 
+def register_hhandroid_scheme() -> None:
+    scheme = QWebEngineUrlScheme(HH_ANDROID_SCHEME.encode())
+    scheme.setSyntax(QWebEngineUrlScheme.Syntax.Path)
+    scheme.setFlags(
+        QWebEngineUrlScheme.Flag.SecureScheme |
+        QWebEngineUrlScheme.Flag.LocalScheme |
+        QWebEngineUrlScheme.Flag.LocalAccessAllowed |
+        QWebEngineUrlScheme.Flag.CorsEnabled
+    )
+    QWebEngineUrlScheme.registerScheme(scheme)
+
 
 class WebViewWindow(QMainWindow):
     def __init__(self, api_client: ApiClient) -> None:
         super().__init__()
         self.api_client = api_client
-        # Настройка WebEngineView
+        
         self.web_view = QWebEngineView()
+        self.web_view.settings().setUnknownUrlSchemePolicy(
+            QWebEngineSettings.UnknownUrlSchemePolicy.AllowAllUnknownUrlSchemes
+        )
+        
         self.setCentralWidget(self.web_view)
         self.setWindowTitle("Авторизация на HH.RU")
         self.hhandroid_handler = HHAndroidUrlSchemeHandler(self)
-        # Установка перехватчика запросов и обработчика кастомной схемы
+        
         profile = self.web_view.page().profile()
-        profile.installUrlSchemeHandler(b"hhandroid", self.hhandroid_handler)
-        # Настройки окна для мобильного вида
+        profile.installUrlSchemeHandler(HH_ANDROID_SCHEME.encode(), self.hhandroid_handler)
+        
+        self.web_view.page().acceptNavigationRequest = self._filter_http_requests
+
         self.resize(480, 800)
-        self.web_view.setUrl(QUrl(api_client.oauth_client.authorize_url))
+        oauth_url = api_client.oauth_client.authorize_url
+        logger.debug(f"{oauth_url = }")
+        self.web_view.setUrl(QUrl(oauth_url))
+
+    def _filter_http_requests(self, url: QUrl, _type, is_main_frame):
+        """Блокирует любые переходы по протоколу HTTP"""
+        if url.scheme().lower() == "http":
+            logger.warning(f"🚫 Заблокирован небезопасный запрос: {url.toString()}")
+            return False
+        return True
 
     def handle_redirect_uri(self, redirect_uri: str) -> None:
         logger.debug(f"handle redirect uri: {redirect_uri}")
@@ -87,10 +117,19 @@ class Operation(BaseOperation):
     def run(self, args: Namespace, api_client: ApiClient, *_) -> None:
         if not QT_IMPORTED:
             print_err(
-                "❗Критиническая Ошибка: PyQt6 не был импортирован, возможно, вы долбоеб и забыли его установить, либо же криворукие разрабы этой либы опять все сломали..."
+                "❗Ошибка: PyQt6 не был импортирован, возможно, вы забыли его установить, либо же это ошибка самой библиотеки."
             )
             sys.exit(1)
 
+        proxies = api_client.proxies
+        if proxy_url := proxies.get("https"):
+            import os
+            
+            qtwebengine_chromium_flags = f"--proxy-server={proxy_url}"
+            logger.debug(f"set {qtwebengine_chromium_flags = }")
+            os.environ["QTWEBENGINE_CHROMIUM_FLAGS"] = qtwebengine_chromium_flags
+
+        register_hhandroid_scheme()
         app = QApplication(sys.argv)
         window = WebViewWindow(api_client=api_client)
         window.show()

hh_applicant_tool/operations/clear_negotiations.py

@@ -16,6 +16,7 @@ logger = logging.getLogger(__package__)
 class Namespace(BaseNamespace):
     older_than: int
     blacklist_discard: bool
+    all: bool
 
 
 class Operation(BaseOperation):
@@ -30,16 +31,12 @@ class Operation(BaseOperation):
         )
         parser.add_argument(
             "--all",
-            type=bool,
-            default=False,
             action=argparse.BooleanOptionalAction,
             help="Удалить все отклики в тч с приглашениями",
         )
         parser.add_argument(
             "--blacklist-discard",
             help="Если установлен, то заблокирует работодателя в случае отказа, чтобы его вакансии не отображались в возможных",
-            type=bool,
-            default=False,
             action=argparse.BooleanOptionalAction,
         )
 
@@ -93,7 +90,10 @@ class Operation(BaseOperation):
                     ")",
                 )
                 if is_discard and args.blacklist_discard:
-                    employer = vacancy["employer"]
+                    employer = vacancy.get("employer", {})
+                    if not employer or 'id' not in employer:
+                        # Работодатель удален или скрыт
+                        continue
                     try:
                         r = api_client.put(f"/employers/blacklisted/{employer['id']}")
                         assert not r

hh_applicant_tool/operations/config.py

@@ -33,8 +33,6 @@ class Operation(BaseOperation):
             "-p",
             "--show-path",
             "--path",
-            type=bool,
-            default=False,
             action=argparse.BooleanOptionalAction,
             help="Вывести полный путь к конфигу",
         )

hh_applicant_tool/operations/get_employer_contacts.py

@@ -57,7 +57,7 @@ class Operation(BaseOperation):
             "-f",
             "--format",
             default="html",
-            choices=["html", "jsonl"],
+            choices=["html", "json", "jsonl"],
             help="Формат вывода",
         )
 
@@ -76,13 +76,26 @@ class Operation(BaseOperation):
                 if per_page * page >= res["total"]:
                     break
                 page += 1
-            if args.format == "jsonl":
+            if args.format.startswith("json"):
                 import json, sys
 
-                for contact in contact_persons:
+                is_json = args.format == "json"
+                total_contacts = len(contact_persons)
+
+                if is_json:
+                    sys.stdout.write("[")
+
+                for index, contact in enumerate(contact_persons):
+                    if is_json and index > 0:
+                        sys.stdout.write(",")
+
                     json.dump(contact, sys.stdout, ensure_ascii=False)
-                    sys.stdout.write("\n")
-                    sys.stdout.flush()
+
+                    if not is_json:
+                        sys.stdout.write("\n")
+
+                if is_json:
+                    sys.stdout.write("]\n")
             else:
                 print(generate_html_report(contact_persons))
             return
@@ -192,6 +205,17 @@ def generate_html_report(data: list[dict]) -> str:
             color: #6c757d;
             font-style: italic;
         }
+        .scam-warning {
+            background-color: #f8d7da;
+            color: #721c24;
+            border: 1px solid #f5c6cb;
+            padding: 10px;
+            border-radius: 5px;
+            margin-bottom: 15px;
+            font-weight: bold;
+            text-align: center;
+            text-transform: uppercase;
+        }
     </style>
 </head>
 <body>
@@ -219,8 +243,12 @@ def generate_html_report(data: list[dict]) -> str:
             if "username" in tu
         ]
 
+        html_content += '<div class="person-card">'
+
+        if item.get("is_scam"):
+            html_content += '<div class="scam-warning">⚠️ ВНИМАНИЕ: Подозрение на мошенничество!</div>'
+
         html_content += f"""\
-        <div class="person-card">
             <h2>{name}</h2>
             <p><strong>Email:</strong> <a href="mailto:{email}">{email}</a></p>
         """
@@ -282,12 +310,39 @@ def print_contacts(data: dict) -> None:
 
 def print_contact(contact: dict, is_last_contact: bool) -> None:
     """Вывод информации о конкретном контакте."""
+    is_scam = contact.get("is_scam", False)
     prefix = "└──" if is_last_contact else "├──"
-    print(f" {prefix} 🧑 {contact.get('name', 'Имя скрыто')}")
+    scam_label = " ⚠️ [МОШЕННИК]" if is_scam else ""
+
+    print(f" {prefix} 🧑 {contact.get('name', 'Имя скрыто')}{scam_label}")
+
     prefix2 = "    " if is_last_contact else " │   "
+
     print(f"{prefix2}├── 📧 Email: {contact.get('email', 'н/д')}")
+
+    # 📞 Телефоны (вложенный список)
+    phones = contact.get("phone_numbers") or []
+    print(f"{prefix2}├── 📞 Телефоны:")
+    if phones:
+        for i, phone in enumerate(phones):
+            p = "└──" if i == len(phones) - 1 else "├──"
+            print(f"{prefix2}│   {p} {phone['phone_number']}")
+    else:
+        print(f"{prefix2}│   └── н/д")
+
+    # 💬 Telegram (вложенный список)
+    telegram_usernames = contact.get("telegram_usernames") or []
+    print(f"{prefix2}├── 💬 Telegram:")
+    if telegram_usernames:
+        for i, tg in enumerate(telegram_usernames):
+            p = "└──" if i == len(telegram_usernames) - 1 else "├──"
+            print(f"{prefix2}│   {p} {tg['username']}")
+    else:
+        print(f"{prefix2}│   └── н/д")
+
     employer = contact.get("employer") or {}
     print(f"{prefix2}├── 🏢 Работодатель: {employer.get('name', 'н/д')}")
     print(f"{prefix2}├── 🏠 Город: {employer.get('area', 'н/д')}")
     print(f"{prefix2}└── 🌐 Сайт: {employer.get('site_url', 'н/д')}")
+
     print(prefix2)