Не ябучий 3й питон!!!

Поменяли что береться из файла окружения

.gitignore

@@ -1,4 +1,8 @@
 .env
 /.venv
+logs/
 /logs/*
-/__pycache__
+__pycache__/
+*.pyc
+*.pyd
+*.pyo

README.md

@@ -0,0 +1,4 @@
+## Проверка логов
+```shell
+sudo journalctl -t KHL
+```

deploy.sh

@@ -11,6 +11,7 @@ NC='\033[0m' # No Color
 REPO_URL="https://git.tvstart.ru/ychernenko/KHL.git"
 TARGET_DIR="/root/KHL"
 SERVICE_NAME="khl-data.service"
+TARGET_ENV="/mnt/khl/.env"
 
 show_help() {
     echo "Использование: $0 -r <релиз> [-h]"
@@ -41,7 +42,7 @@ log_debug() {
 
 # Функция проверки зависимостей системы
 check_dependencies() {
-    local deps=("git" "python3" "pip3" "netstat" "systemctl")
+    local deps=("git" "python3" "pip" "netstat" "systemctl")
     local missing=()
     
     for dep in "${deps[@]}"; do
@@ -77,13 +78,13 @@ install_packages() {
         exit 1
     fi
     
-    if ! command -v pip3 &> /dev/null; then
+    if ! command -v pip &> /dev/null; then
-        log_error "pip3 не установлен!"
+        log_error "pip не установлен!"
         exit 1
     fi
     
     log_info "Версия Python: $(python3 --version)"
-    log_info "Версия pip: $(pip3 --version)"
+    log_info "Версия pip: $(pip --version)"
 }
 
 # Функция загрузки кода
@@ -206,25 +207,38 @@ create_systemd_service() {
     fi
 
     # Формируем команду для data сервиса
-    local data_command="$TARGET_DIR/.venv/bin/python3 $TARGET_DIR/get_data.py"
     local data_service_file="/etc/systemd/system/$SERVICE_NAME"
     
     log_info "Создание файла сервиса: $data_service_file"
     cat > "$data_service_file" << EOF
 [Unit]
 Description=KHL Data Service
+Documentation=https://git.tvstart.ru/ychernenko/KHL
 After=network.target
+Wants=network.target
 
 [Service]
 Type=simple
 User=root
 WorkingDirectory=$TARGET_DIR
 Environment=PATH=$TARGET_DIR/.venv/bin
-ExecStart=$data_command
+EnvironmentFile=$TARGET_ENV
-Restart=always
+ExecStart=python3 $TARGET_DIR/get_data.py
-RestartSec=30
+
+# Лимиты ресурсов
+MemoryMax=1G
+CPUQuota=80%
+
+# Логирование
 StandardOutput=journal
 StandardError=journal
+SyslogIdentifier=KHL
+
+# Поведение при перезапуске
+Restart=always
+RestartSec=10
+StartLimitInterval=300
+StartLimitBurst=5
 
 [Install]
 WantedBy=multi-user.target
@@ -489,6 +503,7 @@ main() {
     log_info ""
     log_info "Для просмотра логов:"
     log_info "  journalctl -u $SERVICE_NAME -f"
+    log_info "  journalctl -t KHL -f"
     log_info ""
     log_info "Управление сервисом:"
     log_info "  Перезапуск: systemctl restart $SERVICE_NAME"

get_data.py

@@ -1,5 +1,5 @@
-from fastapi import FastAPI, HTTPException, Query
+from fastapi import FastAPI, HTTPException, Query, Request
-from fastapi.responses import Response, JSONResponse, HTMLResponse
+from fastapi.responses import Response, JSONResponse, HTMLResponse, StreamingResponse
 from fastapi.encoders import jsonable_encoder
 import pandas as pd
 import requests, io, os
@@ -10,45 +10,39 @@ import uvicorn
 from threading import Thread, Event, Lock
 import time
 from contextlib import asynccontextmanager
-#from smb_excel import read_excel_from_smb, fetch_smb_file
 import numpy as np
+import nasio
+import logging
+import logging.config
+import platform
+import json
+from pprint import pprint
 
 
 # --- Глобальные переменные ---
 selected_game_id: int | None = None
-current_tournament_id: int | None = None     # будем обновлять при загрузке расписания
+current_tournament_id: int | None = None  # будем обновлять при загрузке расписания
-current_season: str | None = None     # будем обновлять при загрузке расписания
+current_season: str | None = None  # будем обновлять при загрузке расписания
-latest_game_data: dict | None = None         # сюда кладём последние данные по матчу
+latest_game_data: dict | None = None  # сюда кладём последние данные по матчу
 latest_game_error: str | None = None
 _latest_lock = Lock()
 _stop_event = Event()
 _worker_thread: Thread | None = None
 
-# Загружаем переменные из .env
+pprint(f"Локальный файл окружения ={load_dotenv(verbose=True)}")
-if load_dotenv(dotenv_path="/mnt/khl/.env",verbose=True):
-    print("Добавить в лог что был найден файл окружения!!")
-    pass
-else:
-    load_dotenv()
-    print("Добавить в лог что не был найден файл окружения!!")
-    
 api_user = os.getenv("API_USER")
 api_pass = os.getenv("API_PASS")
 league = os.getenv("LEAGUE")
+api_base_url = os.getenv("API_BASE_URL")
 POLL_SEC = int(os.getenv("GAME_POLL_SECONDS"))
-SERVER_NAME = os.getenv("SERVER_NAME")
+SERVER_NAME = os.getenv("SYNO_URL")
-SERVER_IP = os.getenv("SERVER_IP")
+USER = os.getenv("SYNO_USERNAME")
-SHARE = os.getenv("SHARE")
+PASSWORD = os.getenv("SYNO_PASSWORD")
-PATH_IN_SHARE = os.getenv("PATH_IN_SHARE")
+PATH = f'{os.getenv("SYNO_PATH")}MATCH.xlsm'
-USER = os.getenv("USER")
-PASSWORD = os.getenv("PASSWORD")
-DOMAIN = os.getenv("DOMAIN")
-
-
 
 def load_today_schedule():
     """Возвращает DataFrame матчей на сегодня с нужными колонками (или пустой DF)."""
-    url_tournaments = "http://stat2tv.khl.ru/tournaments.xml"
+    url_tournaments = f"{api_base_url}tournaments.xml"
     r = requests.get(
         url_tournaments, auth=HTTPBasicAuth(api_user, api_pass), verify=False
     )
@@ -72,12 +66,22 @@ def load_today_schedule():
     global current_tournament_id, current_season
     current_tournament_id = tournament_id
     current_season = season
-    url_schedule = f"http://stat2tv.khl.ru/{tournament_id}/schedule-{tournament_id}.xml"
+    url_schedule = f"{api_base_url}{tournament_id}/schedule-{tournament_id}.xml"
     r = requests.get(url_schedule, auth=HTTPBasicAuth(api_user, api_pass), verify=False)
     schedule_df = pd.read_xml(io.StringIO(r.text))
 
     # Нужные колонки (скорректируй под реальные имена из XML)
-    needed_columns = ["id", "date", "time", "homeName_en", "visitorName_en", "arena_en", "arena_city_en", "homeCity_en", "visitorCity_en"]
+    needed_columns = [
+        "id",
+        "date",
+        "time",
+        "homeName_en",
+        "visitorName_en",
+        "arena_en",
+        "arena_city_en",
+        "homeCity_en",
+        "visitorCity_en",
+    ]
     exist = [c for c in needed_columns if c in schedule_df.columns]
     schedule_df = schedule_df[exist].copy()
 
@@ -120,17 +124,14 @@ def load_today_schedule():
 def _build_game_url(tournament_id: int, game_id: int) -> str:
     # URL по аналогии с расписанием: .../{tournament_id}/json_en/{game_id}.json
     # Если у тебя другой шаблон — просто поменяй строку ниже.
-    return f"http://stat2tv.khl.ru/{tournament_id}/json_en/{game_id}.json"
+    return f"{api_base_url}{tournament_id}/json_en/{game_id}.json"
 
 
 def _fetch_game_once(tournament_id: int, game_id: int) -> dict:
     """Один запрос к API матча -> чистый JSON из API."""
     url = _build_game_url(tournament_id, game_id)
     r = requests.get(
-        url,
+        url, auth=HTTPBasicAuth(api_user, api_pass), verify=False, timeout=10
-        auth=HTTPBasicAuth(api_user, api_pass),
-        verify=False,
-        timeout=10
     )
     r.raise_for_status()
 
@@ -186,11 +187,12 @@ async def lifespan(app: FastAPI):
         _worker_thread.join(timeout=2)
     print("🛑 Background thread stopped")
 
+
 app = FastAPI(
     lifespan=lifespan,
-    docs_url=None,         # ❌ отключает /docs
+    docs_url=None,  # ❌ отключает /docs
-    redoc_url=None,        # ❌ отключает /redoc
+    redoc_url=None,  # ❌ отключает /redoc
-    openapi_url=None       # ❌ отключает /openapi.json
+    openapi_url=None,  # ❌ отключает /openapi.json
 )
 
 
@@ -205,8 +207,6 @@ async def games():
     return Response(content=json_schedule, media_type="application/json")
 
 
-    
-
 @app.get("/select")
 async def select():
     df = load_today_schedule()
@@ -339,11 +339,13 @@ async def get_selected_game():
 async def game_url():
     if not (selected_game_id and current_tournament_id):
         return JSONResponse({"message": "game_id или tournament_id не задан"})
-    return JSONResponse({
+    return JSONResponse(
-        "url": _build_game_url(current_tournament_id, selected_game_id),
+        {
-        "game_id": selected_game_id,
+            "url": _build_game_url(current_tournament_id, selected_game_id),
-        "tournament_id": current_tournament_id
+            "game_id": selected_game_id,
-    })
+            "tournament_id": current_tournament_id,
+        }
+    )
 
 
 # @app.get("/info")
@@ -359,7 +361,9 @@ async def game_data():
             return JSONResponse(latest_game_data)
         if latest_game_error:
             return JSONResponse({"error": latest_game_error}, status_code=502)
-    return JSONResponse({"message": "Ещё нет данных. Выберите матч и подождите первое обновление."})
+    return JSONResponse(
+        {"message": "Ещё нет данных. Выберите матч и подождите первое обновление."}
+    )
 
 
 @app.get("/referee")
@@ -386,14 +390,13 @@ async def referee():
     return data_referees
 
 
-
+async def team(who: str):
-async def team(who:str):
+    """ "who: A - домашняя команда, B - гостевая"""
-    """"who: A - домашняя команда, B - гостевая"""
     with _latest_lock:
         lgd = latest_game_data
     # print(lgd)
     if not lgd or "data" not in lgd:
-        return [{"details":"Нет данных по матчу!"}]
+        return [{"details": "Нет данных по матчу!"}]
 
     players1_temp = lgd["data"]["players"][who]
     players1 = []
@@ -492,10 +495,12 @@ async def team(who:str):
 async def team1():
     return await team("A")
 
+
 @app.get("/team2")
 async def team2():
     return await team("B")
 
+
 # 👉 метка для первой строки (period row)
 def _period_label(period: str | int) -> str:
     s = str(period).strip().upper()
@@ -519,6 +524,7 @@ def _period_label(period: str | int) -> str:
         return "FINAL"
     return ""
 
+
 # 👉 сортировка периодов: 1,2,3, затем OT/OT2/...
 def _period_sort_key(k: str) -> tuple[int, int]:
     s = str(k).strip().upper()
@@ -585,15 +591,21 @@ def format_team_stat(team1: dict, team2: dict, period: str | None = None) -> lis
     formatted = []
 
     if period is not None:
-        formatted.append({
+        formatted.append(
-            "name0": "period",
+            {
-            "name1": str(period),
+                "name0": "period",
-            "name2": "",
+                "name1": str(period),
-            "StatParameterGFX": _period_label(period) or "Period"
+                "name2": "",
-        })
+                "StatParameterGFX": _period_label(period) or "Period",
+            }
+        )
 
     for key in keys:
-        row = {"name0": key, "name1": teams[0].get(key, ""), "name2": teams[1].get(key, "")}
+        row = {
+            "name0": key,
+            "name1": teams[0].get(key, ""),
+            "name2": teams[1].get(key, ""),
+        }
         # подписи
         for code, eng, _ru in stat_list:
             if key == code:
@@ -611,6 +623,7 @@ def format_team_stat(team1: dict, team2: dict, period: str | None = None) -> lis
             def flip(s: str) -> str:
                 parts = s.split()
                 return f"{parts[1]} {parts[0]}" if len(parts) >= 2 else s
+
             r["name1"] = flip(r["name1"])
             r["name2"] = flip(r["name2"])
 
@@ -625,11 +638,13 @@ def _iter_period_pairs(teams_periods: dict):
     """
     a = teams_periods.get("A", {})
     b = teams_periods.get("B", {})
+
     def _key(k):
         try:
             return int(k)
         except (TypeError, ValueError):
             return k
+
     for k in sorted(a.keys(), key=_key):
         if k in b:
             yield k, a[k], b[k]
@@ -641,41 +656,20 @@ def _build_all_stats(payload: dict) -> dict:
     """
     total_a = payload["teams"]["A"]
     total_b = payload["teams"]["B"]
-    result = {
+    result = {"total": format_team_stat(total_a, total_b), "periods": []}
-        "total": format_team_stat(total_a, total_b),
-        "periods": []
-    }
     for period_key, a_stat, b_stat in _iter_period_pairs(payload["teams_periods"]):
-        result["periods"].append({
+        result["periods"].append(
-            "period": period_key,
+            {"period": period_key, "stats": format_team_stat(a_stat, b_stat)}
-            "stats": format_team_stat(a_stat, b_stat)
+        )
-        })
     return result
 
-def xl():
-    df = read_excel_from_smb(
-    server_name=SERVER_NAME,
-    server_ip=SERVER_IP,
-    share_name=SHARE,
-    file_path_in_share=PATH_IN_SHARE,
-    username=USER,
-    password=PASSWORD,
-    domain=DOMAIN,
-    client_machine_name="KHL_SOFT",
-    sheet_name="TEAMS",        # или None, или список листов
-    )
-    df = df.replace([float("inf"), float("-inf")], pd.NA)
-    columns_to_keep = [
-            "Team", "Logo", "Short", "HexPodl",  # ← укажи свои
-        ]
-    df = df.loc[:, [c for c in columns_to_keep if c in df.columns]]
-    json_text = df.to_json(orient="records", force_ascii=False)  # NaN/NA -> null
-    return Response(content=json_text, media_type="application/json; charset=utf-8")
 
 @app.get("/teams/stats")
 async def teams_stats(
     scope: str = Query("all", pattern="^(all|total|period)$"),
-    n: str | None = Query(None, description="Номер периода (строка или число) при scope=period"),
+    n: str | None = Query(
+        None, description="Номер периода (строка или число) при scope=period"
+    ),
 ):
     """
     Все-в-одном: GET /teams/stats?scope=all
@@ -693,7 +687,9 @@ async def teams_stats(
     payload = lgd["data"]
 
     if scope == "total":
-        data = format_team_stat(payload["teams"]["A"], payload["teams"]["B"], period="Total")
+        data = format_team_stat(
+            payload["teams"]["A"], payload["teams"]["B"], period="Total"
+        )
         return JSONResponse({"scope": "total", "data": data})
 
     if scope == "period":
@@ -710,21 +706,23 @@ async def teams_stats(
         a = payload["teams_periods"]["A"].get(period_key)
         b = payload["teams_periods"]["B"].get(period_key)
         if a is None or b is None:
-            raise HTTPException(status_code=404, detail=f"Период {period_key} не найден.")
+            raise HTTPException(
-        return JSONResponse({
+                status_code=404, detail=f"Период {period_key} не найден."
-            "scope": "period",
+            )
-            "period": period_key,
+        return JSONResponse(
-            "is_current": period_key == _current_period_key(payload),
+            {
-            "data": format_team_stat(a, b, period=period_key)
+                "scope": "period",
-        })
+                "period": period_key,
+                "is_current": period_key == _current_period_key(payload),
+                "data": format_team_stat(a, b, period=period_key),
+            }
+        )
 
     # scope == "all"
     cur = _current_period_key(payload)
-    return JSONResponse({
+    return JSONResponse(
-        "scope": "all",
+        {"scope": "all", "current_period": cur, "data": _build_all_stats(payload)}
-        "current_period": cur,
+    )
-        "data": _build_all_stats(payload)
-    })
 
 
 def _norm_name(s: str | None) -> str:
@@ -733,8 +731,16 @@ def _norm_name(s: str | None) -> str:
         return ""
     return str(s).strip().casefold()
 
+def _load_buf():
+    buf = nasio.load_bio(user=USER, password=PASSWORD,
+                         nas_ip=SERVER_NAME, nas_port="443", path=PATH)
+    if isinstance(buf, (bytes, bytearray, memoryview)):
+        buf = io.BytesIO(buf)
+    buf.seek(0)
+    return buf
+
 @app.get("/info")
-async def info():
+async def info(format: str = "xlsx", sheet: str = "TEAMS"):
     # 1) Проверяем, выбран ли матч
     global current_season
     if not selected_game_id:
@@ -743,76 +749,128 @@ async def info():
     # 2) Берём расписание и ищем строку по выбранному ID
     df = load_today_schedule()
     if df.empty:
-        return JSONResponse({"message": "Сегодня матчей нет", "selected_id": selected_game_id})
+        return JSONResponse(
+            {"message": "Сегодня матчей нет", "selected_id": selected_game_id}
+        )
 
     # безопасно приводим id к int и ищем
     try:
         row = df.loc[df["id"].astype(int) == int(selected_game_id)].iloc[0]
     except Exception:
-        return JSONResponse({"message": "Выбранный матч не найден в расписании на сегодня",
+        return JSONResponse(
-                             "selected_id": selected_game_id}, status_code=404)
+            {
+                "message": "Выбранный матч не найден в расписании на сегодня",
+                "selected_id": selected_game_id,
+            },
+            status_code=404,
+        )
 
     home_name = str(row.get("homeName_en", "")).strip()
     away_name = str(row.get("visitorName_en", "")).strip()
 
     # 3) Подтягиваем справочник команд из Excel (лист TEAMS)
-    teams_df = read_excel_from_smb(
+    src = _load_buf()
-        server_name=SERVER_NAME,
-        server_ip=SERVER_IP,
-        share_name=SHARE,
-        file_path_in_share=PATH_IN_SHARE,
-        username=USER,
-        password=PASSWORD,
-        domain=DOMAIN,
-        client_machine_name="KHL_SOFT",
-        sheet_name="TEAMS",
-    )
 
-    # Оставляем только полезные поля (подгони под свой файл)
+    if format == "xlsx":
-    keep = [ "Team", "Logo", "Short", "HexPodl", "HexBase", "HexText" ]
+        # читаем нужный лист из исходного XLSM
-    keep = [c for c in keep if c in teams_df.columns]
+        df = pd.read_excel(src, sheet_name=sheet, engine="openpyxl")
-    teams_df = teams_df.loc[:, keep].copy()
 
-    # 4) Нормализованные ключи для джоина по имени
+        # пишем НОВЫЙ XLSX (без макросов) — это то, что понимает vMix
-    teams_df["__key"] = teams_df["Team"].apply(_norm_name)
+        out = io.BytesIO()
+        with pd.ExcelWriter(out, engine="openpyxl") as writer:
+            df.to_excel(writer, sheet_name=sheet, index=False)
+        out.seek(0)
 
-    def _pick_team_info(name: str) -> dict:
+        return StreamingResponse(
-        key = _norm_name(name)
+            out,
-        hit = teams_df.loc[teams_df["__key"] == key]
+            media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-        if hit.empty:
+            headers={
-            # не нашли точное совпадение — вернём только название
+                # стабильное имя файла, чтобы vMix не путался
-            return {"Team": name}
+                "Content-Disposition": "inline; filename=vmix.xlsx",
-        rec = hit.iloc[0].to_dict()
+                # отключаем кэш браузера/прокси, vMix сам опрашивает по интервалу
-        rec.pop("__key", None)
+                "Cache-Control": "no-cache, no-store, must-revalidate",
-        # заменим NaN/inf на None, чтобы JSON не падал
+                "Pragma": "no-cache",
-        for k, v in list(rec.items()):
+            },
-            if pd.isna(v) or v in (np.inf, -np.inf):
+        )
-                rec[k] = None
-        return rec
 
-    home_info = _pick_team_info(home_name)
+    elif format == "csv":
-    away_info = _pick_team_info(away_name)
+        df = pd.read_excel(src, sheet_name=sheet, engine="openpyxl")
-    date_obj = datetime.strptime(row.get("datetime_str", ""), "%d.%m.%Y %H:%M")
+        csv_bytes = df.to_csv(index=False, encoding="utf-8-sig").encode("utf-8")
-    try:
+        return StreamingResponse(
-        full_format = date_obj.strftime("%B %-d, %Y")
+            io.BytesIO(csv_bytes),
-    except ValueError:
+            media_type="text/csv; charset=utf-8",
-        full_format = date_obj.strftime("%B %#d, %Y")
+            headers={
+                "Content-Disposition": "inline; filename=vmix.csv",
+                "Cache-Control": "no-cache, no-store, must-revalidate",
+                "Pragma": "no-cache",
+            },
+        )
 
+    elif format == "json":
+        df = pd.read_excel(src, sheet_name=sheet, engine="openpyxl")
+        payload = json.dumps(df.to_dict(orient="records"), ensure_ascii=False)
+        return Response(
+            content=payload,
+            media_type="application/json; charset=utf-8",
+            headers={
+                "Cache-Control": "no-cache, no-store, must-revalidate",
+                "Pragma": "no-cache",
+            },
+        )
 
-    payload = [{
+    return Response("Unsupported format", status_code=400)  
-        "selected_id": int(selected_game_id),
+      
-        "tournament_id": int(current_tournament_id) if current_tournament_id else None,
+    #     # Оставляем только полезные поля (подгони под свой файл)
-        "datetime": str(full_format),
+    #     keep = ["Team", "Logo", "Short", "HexPodl", "HexBase", "HexText"]
-        "arena": str(row.get("arena_en", "")),
+    #     keep = [c for c in keep if c in teams_df.columns]
-        "arena_city": str(row.get("arena_city_en", "")),
+    #     teams_df = teams_df.loc[:, keep].copy()
-        "home": home_info,
+
-        "home_city": str(row.get("homeCity_en", "")),
+    #     # 4) Нормализованные ключи для джоина по имени
-        "away": away_info,
+    #     teams_df["__key"] = teams_df["Team"].apply(_norm_name)
-        "away_city": str(row.get("visitorCity_en", "")),
+
-        "season": current_season,
+    #     def _pick_team_info(name: str) -> dict:
-    }]
+    #         key = _norm_name(name)
+    #         hit = teams_df.loc[teams_df["__key"] == key]
+    #         if hit.empty:
+    #             # не нашли точное совпадение — вернём только название
+    #             return {"Team": name}
+    #         rec = hit.iloc[0].to_dict()
+    #         rec.pop("__key", None)
+    #         # заменим NaN/inf на None, чтобы JSON не падал
+    #         for k, v in list(rec.items()):
+    #             if pd.isna(v) or v in (np.inf, -np.inf):
+    #                 rec[k] = None
+    #         return rec
+
+    #     home_info = _pick_team_info(home_name)
+    #     away_info = _pick_team_info(away_name)
+    #     date_obj = datetime.strptime(row.get("datetime_str", ""), "%d.%m.%Y %H:%M")
+    #     try:
+    #         full_format = date_obj.strftime("%B %-d, %Y")
+    #     except ValueError:
+    #         full_format = date_obj.strftime("%B %#d, %Y")
+
+    #     payload = [
+    #         {
+    #             "selected_id": int(selected_game_id),
+    #             "tournament_id": (
+    #                 int(current_tournament_id) if current_tournament_id else None
+    #             ),
+    #             "datetime": str(full_format),
+    #             "arena": str(row.get("arena_en", "")),
+    #             "arena_city": str(row.get("arena_city_en", "")),
+    #             "home": home_info,
+    #             "home_city": str(row.get("homeCity_en", "")),
+    #             "away": away_info,
+    #             "away_city": str(row.get("visitorCity_en", "")),
+    #             "season": current_season,
+    #         }
+    #     ]
+
+    #     return JSONResponse(content=payload)
+    # except Exception as ex:
+    #     pprint(ex)
 
-    return JSONResponse(content=payload)
 
 if __name__ == "__main__":
     uvicorn.run(

requirements.txt

@@ -8,3 +8,5 @@ python-telegram-handler
 python-dotenv>=1.1.0
 lxml
 python-dotenv
+--extra-index-url https://git.tvstart.ru/api/packages/lexx/pypi/simple
+nasio

smb_excel.py

@@ -1,154 +0,0 @@
-# smb_excel.py (обновлённый фрагмент)
-from io import BytesIO
-from typing import Optional, Union, Any, Dict
-#from smb.SMBConnection import SMBConnection
-import pandas as pd
-import re
-
-class SMBDownloadError(Exception):
-    pass
-
-def _normalize_path(p: str) -> str:
-    """Убирает случайные r"..."/"...", лишние кавычки и ставит прямые слэши."""
-    if p is None:
-        return p
-    # уберём обрамляющие кавычки/префикс r"..."
-    m = re.fullmatch(r"""r?["'](.*)["']""", p.strip())
-    if m:
-        p = m.group(1)
-    # заменим \ на /
-    p = p.replace("\\", "/").lstrip("/")  # путь внутри шары не должен начинаться с /
-    return p
-
-def _try_connect(
-    remote_name: str,
-    server_ip: str,
-    username: str,
-    password: str,
-    *,
-    client_machine_name: str,
-    domain: str,
-    port: int
-) -> Optional[SMBConnection]:
-    conn = SMBConnection(
-        username,
-        password,
-        client_machine_name,
-        remote_name,          # ВАЖНО: remote_name — имя сервера (или IP как fallback)
-        domain=domain,
-        use_ntlm_v2=True,
-        is_direct_tcp=True
-    )
-    try:
-        if conn.connect(server_ip, port):
-            return conn
-    except Exception:
-        pass
-    return None
-
-def _connect_smb(
-    server_name: str,
-    server_ip: str,
-    username: str,
-    password: str,
-    *,
-    client_machine_name: str = "client",
-    domain: str = "",
-    port: int = 445,
-) -> SMBConnection:
-    """
-    Пробуем два варианта remote_name: (1) реальное имя сервера, (2) IP.
-    """
-    for remote_name in (server_name, server_ip):
-        if not remote_name:
-            continue
-        conn = _try_connect(
-            remote_name=remote_name,
-            server_ip=server_ip,
-            username=username,
-            password=password,
-            client_machine_name=client_machine_name,
-            domain=domain,
-            port=port,
-        )
-        if conn:
-            return conn
-    raise SMBDownloadError(
-        f"Не удалось подключиться к SMB {server_ip}:{port}. "
-        f"Проверь server_name (реальное имя хоста), домен/логин и доступность порта 445."
-    )
-
-def fetch_smb_file(
-    *,
-    server_name: str,
-    server_ip: str,
-    share_name: str,
-    file_path_in_share: str,
-    username: str,
-    password: str,
-    client_machine_name: str = "client",
-    domain: str = "",
-    port: int = 445,
-) -> BytesIO:
-    """
-    Возвращает содержимое файла из SMB как BytesIO.
-    """
-    file_path_in_share = _normalize_path(file_path_in_share)
-    conn: Optional[SMBConnection] = None
-    try:
-        conn = _connect_smb(
-            server_name=server_name,
-            server_ip=server_ip,
-            username=username,
-            password=password,
-            client_machine_name=client_machine_name,
-            domain=domain,
-            port=port,
-        )
-        # Быстрая проверка существования каталога/файла
-        parent = "/".join(file_path_in_share.split("/")[:-1]) or ""
-        # listPath кидает исключение, если каталога/шары нет — получим понятную ошибку
-        if parent:
-            conn.listPath(share_name, parent)
-
-        buf = BytesIO()
-        conn.retrieveFile(share_name, file_path_in_share, buf)
-        buf.seek(0)
-        return buf
-    except Exception as e:
-        raise SMBDownloadError(
-            f"Ошибка скачивания {share_name}/{file_path_in_share}: {e}"
-        ) from e
-    finally:
-        if conn:
-            try:
-                conn.close()
-            except Exception:
-                pass
-
-def read_excel_from_smb(
-    *,
-    server_name: str,
-    server_ip: str,
-    share_name: str,
-    file_path_in_share: str,
-    username: str,
-    password: str,
-    client_machine_name: str = "client",
-    domain: str = "",
-    port: int = 445,
-    sheet_name: Optional[Union[str, int, list]] = None,
-    **read_excel_kwargs: Dict[str, Any],
-) -> pd.DataFrame:
-    file_obj = fetch_smb_file(
-        server_name=server_name,
-        server_ip=server_ip,
-        share_name=share_name,
-        file_path_in_share=file_path_in_share,
-        username=username,
-        password=password,
-        client_machine_name=client_machine_name,
-        domain=domain,
-        port=port,
-    )
-    return pd.read_excel(file_obj, sheet_name=sheet_name, **read_excel_kwargs)