Update app/main.py

app/main.py

@@ -1,3 +1,4 @@
+
 import os
 import uuid
 import hashlib
@@ -8,7 +9,7 @@ import re
 import math
 from datetime import datetime, timedelta
 from pathlib import Path
-from typing import Dict, Any, List, Union, Optional
+from typing import Dict, Any, List, Union
 from enum import Enum
 
 from fastapi import FastAPI, File, UploadFile, BackgroundTasks, HTTPException, Path as FastApiPath, Depends, Query, status
@@ -16,50 +17,53 @@ from fastapi.responses import JSONResponse, FileResponse
 from pydantic import BaseModel, Field, validator
 from apscheduler.schedulers.asyncio import AsyncIOScheduler
 
-# --- Configuration and Global Variables ---
+# --- Конфигурация и глобальные переменные ---
 
-# API Key for access
+# Ключ API для доступа
 API_KEY = os.getenv("API_KEY")
 
-# Default parameters for VFR -> CFR conversion
-VFR_TO_CFR_CRF_DEFAULT = 17
-VFR_TO_CFR_PRESET_DEFAULT = 4
+# --- ИЗМЕНЕНИЕ: Параметры для VFR -> CFR вынесены сюда ---
+# Настройки для конвертации видео с переменной частотой кадров (VFR)
+# в видео с постоянной частотой кадров (CFR).
+# Этот шаг выполняется для стабилизации видео перед основным кодированием.
+VFR_TO_CFR_CRF = 17      # Качество (чем ниже, тем лучше). 17 - очень высокое.
+VFR_TO_CFR_PRESET = 4    # Скорость (чем ниже, тем качественнее, но медленнее).
 
-# Directories for data storage
+# Директории для хранения данных
 BASE_DATA_DIR = Path("data")
 UPLOADS_DIR = BASE_DATA_DIR / "uploads"
 OUTPUTS_DIR = BASE_DATA_DIR / "outputs"
 LOGS_DIR = BASE_DATA_DIR / "logs"
 
-# In-memory "databases"
+# "Базы данных" в памяти
 FILES_DB: Dict[str, Dict[str, Any]] = {}
 TASKS_DB: Dict[str, Dict[str, Any]] = {}
 
-# Cleanup settings
+# Настройки для очистки
 MAX_AGE_HOURS = 24
 MAX_TOTAL_SIZE_GB = 50
 CLEANUP_INTERVAL_MINUTES = 30
 
-# Scheduler for the cleanup task
+# Планировщик для задачи очистки
 scheduler = AsyncIOScheduler()
 
-# --- Dependency for Token Verification ---
+# --- Зависимость для проверки токена ---
 
-async def verify_token(token: str = Query(..., description="API token for access.")):
-    """Verifies if the provided token matches the server's API key."""
+async def verify_token(token: str = Query(..., description="Токен для доступа к API.")):
+    """Проверяет, соответствует ли предоставленный токен ключу API сервера."""
     if not API_KEY:
-        print("CRITICAL ERROR: API_KEY environment variable is not set!")
+        print("КРИТИЧЕСКАЯ ОШИБКА: Переменная окружения API_KEY не установлена!")
         raise HTTPException(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail="API key is not configured on the server."
+            detail="Ключ API не сконфигурирован на сервере."
         )
     if token != API_KEY:
         raise HTTPException(
             status_code=status.HTTP_401_UNAUTHORIZED,
-            detail="Invalid or missing API token."
+            detail="Неверный или отсутствующий токен API."
         )
 
-# --- Enumerations and Constants ---
+# --- Перечисления и константы ---
 
 class Encoder(str, Enum):
     av1 = "svt-av1"
@@ -78,104 +82,84 @@ class X265Preset(str, Enum):
     veryslow = "veryslow"
     placebo = "placebo"
 
-class FileOrigin(str, Enum):
-    """Indicates the origin of a file."""
-    UPLOAD = "upload"
-    VFR_TO_CFR = "vfr_to_cfr"
-    ENCODE_OUTPUT = "encode_output"
-
-# --- Data Models for API (Pydantic) ---
+# --- Модели данных для API (Pydantic) ---
 
-class FileInfo(BaseModel):
-    """Detailed information about a managed file."""
+class UploadResponse(BaseModel):
+    message: str
     file_hash: str
     file_path: str
     original_filename: str
-    origin: FileOrigin
-    task_id: Optional[str] = None
-    size: int
-    created_at: datetime
-
-class UploadResponse(BaseModel):
-    message: str
-    file_info: FileInfo
     is_new: bool
 
 class BaseTaskRequest(BaseModel):
-    input_hash: str = Field(..., description="SHA256 hash of the uploaded file.")
-    encoder: Encoder = Field(Encoder.av1, description="Choice of codec.")
-    extra_options: str = Field("", description="Additional options for ab-av1.")
+    input_hash: str = Field(..., description="SHA256 хеш загруженного файла.")
+    encoder: Encoder = Field(Encoder.av1, description="Выбор кодека.")
+    extra_options: str = Field("", description="Дополнительные опции для ab-av1.")
 
 class AutoEncodeRequest(BaseTaskRequest):
-    preset: Union[int, X265Preset] = Field(3, description="Preset for the encoder. For AV1: 0-12 (int). For x265: 'slow', 'medium', etc. (str).")
-    min_vmaf: int = Field(96, description="Target minimum VMAF.", ge=0, le=100)
-    vfr_to_cfr_crf: int = Field(VFR_TO_CFR_CRF_DEFAULT, description="CRF for VFR to CFR conversion.")
-    vfr_to_cfr_preset: int = Field(VFR_TO_CFR_PRESET_DEFAULT, description="Preset for VFR to CFR conversion.")
+    preset: Union[int, X265Preset] = Field(3, description="Пресет для кодировщика. Для AV1: 0-12 (int). Для x265: 'slow', 'medium' и т.д. (str).")
+    min_vmaf: int = Field(96, description="Целевой минимальный VMAF.", ge=0, le=100)
 
     @validator('preset')
     def preset_must_match_encoder(cls, v, values):
         encoder = values.get('encoder')
         if encoder == Encoder.av1 and not isinstance(v, int):
-            raise ValueError('For AV1, the preset must be a number (0-12).')
+            raise ValueError('Для AV1 пресет должен быть числом (0-12).')
         if encoder == Encoder.x265 and not isinstance(v, X265Preset):
-            raise ValueError("For x265, the preset must be a string (e.g., 'slow').")
+            raise ValueError("Для x265 пресет должен быть строкой (например, 'slow').")
         if isinstance(v, int) and (v < 0 or v > 12):
-            raise ValueError('The preset for AV1 must be in the range of 0 to 12.')
+            raise ValueError('Пресет для AV1 должен быть в диапазоне от 0 до 12.')
         return v
 
 class CrfSearchRequest(AutoEncodeRequest):
     pass
 
 class EncodeRequest(BaseTaskRequest):
-    preset: Union[int, X265Preset] = Field(3, description="Preset for the encoder. For AV1: 0-12 (int). For x265: 'slow', 'medium', etc. (str).")
-    crf: float = Field(20, description="CRF value (Constant Rate Factor). Fractional values are allowed.")
+    preset: Union[int, X265Preset] = Field(3, description="Пресет для кодировщика. Для AV1: 0-12 (int). Для x265: 'slow', 'medium' и т.д. (str).")
+    crf: float = Field(20, description="Значение CRF (Constant Rate Factor). Допускаются дробные значения.")
 
     @validator('preset')
     def preset_must_match_encoder(cls, v, values):
         encoder = values.get('encoder')
         if encoder == Encoder.av1 and not isinstance(v, int):
-            raise ValueError('For AV1, the preset must be a number (0-12).')
+            raise ValueError('Для AV1 пресет должен быть числом (0-12).')
         if encoder == Encoder.x265 and not isinstance(v, X265Preset):
-            raise ValueError("For x265, the preset must be a string (e.g., 'slow').")
+            raise ValueError("Для x265 пресет должен быть строкой (например, 'slow').")
         if isinstance(v, int) and (v < 0 or v > 12):
-            raise ValueError('The preset for AV1 must be in the range of 0 to 12.')
+            raise ValueError('Пресет для AV1 должен быть в диапазоне от 0 до 12.')
         return v
 
 class TaskStatusResponse(BaseModel):
     task_id: str
     task_type: str
     status: str
+    input_hash: str
     command: str
     created_at: datetime
-    started_at: Optional[datetime]
-    finished_at: Optional[datetime]
-    duration_seconds: Optional[float] = None
+    started_at: datetime | None
+    finished_at: datetime | None
+    output_path: str | None
     log_path: str
-    last_log_line: Optional[str]
-    associated_files: List[FileInfo] = []
-
-    encoder: Optional[Encoder] = None
-    preset: Union[int, str, None] = None
-    extra_options: Optional[str] = None
-    # Task-specific params
-    crf: Optional[float] = None
-    min_vmaf: Optional[int] = None
-    # Found values
-    found_crf: Optional[float] = None
-    found_vmaf: Optional[float] = None
+    last_log_line: str | None
+
+    encoder: Encoder | None = None
+    preset: Union[int, str] | None = None
+    crf: float | None = None
+    min_vmaf: int | None = None
+    extra_options: str | None = None
+
 
 class TaskCreateResponse(BaseModel):
     message: str
     task_id: str
     status_url: str
     log_url: str
-    download_url: str
     manage_url: str
 
-# --- Cleanup Logic (Janitor) ---
+# --- Логика очистки (Janitor) ---
 async def cleanup_files():
-    """Periodically deletes old files and controls storage size."""
-    print(f"[{datetime.utcnow()}] Running cleanup task...")
+    """Периодическая задача для удаления старых файлов и контроля размера хранилища."""
+    print(f"[{datetime.utcnow()}] Запуск задачи очистки...")
     
     now = datetime.utcnow()
     max_age_limit = now - timedelta(hours=MAX_AGE_HOURS)
@@ -188,8 +172,10 @@ async def cleanup_files():
     active_files = set()
     for task_id, task in TASKS_DB.items():
         if task['status'] in ['pending', 'running']:
-            for file_info in task.get('associated_files', []):
-                active_files.add(Path(file_info['file_path']))
+            if task['input_hash'] in FILES_DB:
+                active_files.add(Path(FILES_DB[task['input_hash']]['path']))
+            if task.get('output_path'):
+                active_files.add(Path(task['output_path']))
             if task.get('log_path'):
                 active_files.add(Path(task['log_path']))
     
@@ -225,82 +211,60 @@ async def cleanup_files():
     deleted_count = 0
     for file_path in files_to_delete:
         try:
-            file_hash_to_del = file_path.stem.split('_')[0]
             file_path.unlink()
             deleted_count += 1
-            FILES_DB.pop(file_hash_to_del, None)
-            
-            # Also remove from task association if needed
-            for task in TASKS_DB.values():
-                task['associated_files'] = [f for f in task.get('associated_files', []) if f['file_path'] != str(file_path)]
-
+            if str(file_path).startswith(str(UPLOADS_DIR)):
+                file_hash_to_del = file_path.stem
+                FILES_DB.pop(file_hash_to_del, None)
+            elif str(file_path).startswith(str(OUTPUTS_DIR)) or str(file_path).startswith(str(LOGS_DIR)):
+                task_id_to_del = file_path.stem
+                TASKS_DB.pop(task_id_to_del, None)
         except Exception as e:
-            print(f"Error deleting file {file_path}: {e}")
+            print(f"Ошибка при удалении файла {file_path}: {e}")
             
     if deleted_count > 0:
-        print(f"Cleanup finished. Deleted {deleted_count} files.")
+        print(f"Очистка завершена. Удалено {deleted_count} файлов.")
 
-# --- FastAPI App Initialization ---
+# --- Инициализация FastAPI приложения ---
 app = FastAPI(
     title="ab-av1 API Server",
-    description="REST API for asynchronous video encoding. **Interactive documentation: `/docs`**.",
-    version="3.0.0",
+    description="REST API для асинхронного кодирования видео. **Интерактивная документация: `/docs`**.",
+    version="2.8.0", # Версия обновлена
 )
 
 @app.on_event("startup")
 async def on_startup():
-    """Creates directories, checks API_KEY, and starts the scheduler."""
+    """Создаем директории, проверяем API_KEY и запускаем планировщик."""
     if not API_KEY:
-        print("CRITICAL ERROR: API_KEY environment variable is not set. The server cannot authorize requests.")
+        print("КРИТИЧЕСКАЯ ОШИБКА: Переменная окружения API_KEY не установлена. Сервер не сможет авторизовать запросы.")
     else:
-        print("API key loaded successfully.")
+        print("Ключ API успешно загружен.")
 
     for dir_path in [UPLOADS_DIR, OUTPUTS_DIR, LOGS_DIR]:
         dir_path.mkdir(parents=True, exist_ok=True)
     
     scheduler.add_job(cleanup_files, 'interval', minutes=CLEANUP_INTERVAL_MINUTES)
     scheduler.start()
-    print("File cleanup scheduler started.")
+    print("Планировщик очистки файлов запущен.")
 
 @app.on_event("shutdown")
 async def on_shutdown():
-    """Stops the scheduler and active processes on shutdown."""
+    """Останавливаем планировщик и активные процессы при выключении."""
     scheduler.shutdown()
-    print("Scheduler stopped.")
+    print("Планировщик остановлен.")
     for task_id, task in TASKS_DB.items():
         if task.get('process') and task['status'] == 'running':
-            print(f"Stopping process for task {task_id}...")
+            print(f"Остановка процесса для задачи {task_id}...")
             task['process'].terminate()
             try:
                 task['process'].wait(timeout=5)
             except subprocess.TimeoutExpired:
                 task['process'].kill()
 
-# --- Helper Functions ---
-
-def _update_task_timing(task: Dict[str, Any]):
-    """Calculates and updates task duration."""
-    if task.get("started_at") and task.get("finished_at"):
-        duration = task["finished_at"] - task["started_at"]
-        task["duration_seconds"] = round(duration.total_seconds(), 2)
-
-def _add_file_to_db(file_path: Path, origin: FileOrigin, original_filename: str, task_id: Optional[str] = None) -> FileInfo:
-    """Adds a file to the global file DB and returns its info."""
-    file_hash = hashlib.sha256(file_path.read_bytes()).hexdigest()
-    file_info = FileInfo(
-        file_hash=file_hash,
-        file_path=str(file_path),
-        original_filename=original_filename,
-        origin=origin,
-        task_id=task_id,
-        size=file_path.stat().st_size,
-        created_at=datetime.utcnow()
-    )
-    FILES_DB[file_hash] = file_info.model_dump()
-    return file_info
+# --- Вспомогательные функции ---
 
 def run_simple_task(task_id: str, command: list[str], log_path: Path):
-    """Executes a simple one-step command in the background."""
+    """Выполняет простую одношаговую команду в фоне (для encode и crf-search)."""
     task = TASKS_DB[task_id]
     task["started_at"] = datetime.utcnow()
     task["status"] = "running"
@@ -321,30 +285,30 @@ def run_simple_task(task_id: str, command: list[str], log_path: Path):
         process.wait()
         
         if task.get('was_cancelled'):
-            task["status"] = "cancelled"
+             task["status"] = "cancelled"
         elif process.returncode == 0:
             task["status"] = "completed"
         else:
             task["status"] = "failed"
-            task["last_log_line"] = f"Process finished with code {process.returncode}"
+            task["last_log_line"] = f"Процесс завершился с кодом {process.returncode}"
             
     except Exception as e:
         task["status"] = "failed"
-        error_message = f"A Python exception occurred: {e}"
+        error_message = f"Произошло исключение Python: {e}"
         task["last_log_line"] = error_message
         with open(log_path, "a", encoding='utf-8') as log_file:
             log_file.write(f"\n--- PYTHON EXCEPTION ---\n{error_message}")
     finally:
         task["finished_at"] = datetime.utcnow()
-        _update_task_timing(task)
         task.pop('process', None)
 
 def run_auto_encode_workflow(task_id: str, request: AutoEncodeRequest):
-    """Executes the complex workflow for auto-encode with VFR check."""
+    """
+    Выполняет сложный воркфлоу для auto-encode с проверкой VFR.
+    """
     task = TASKS_DB[task_id]
     log_path = Path(task["log_path"])
-    input_file_info = FileInfo(**FILES_DB[request.input_hash])
-    original_input_path = Path(input_file_info.file_path)
+    original_input_path = Path(FILES_DB[request.input_hash]["path"])
     temp_cfr_path = None
 
     def _log_message(message: str, level: str = "INFO"):
@@ -355,8 +319,8 @@ def run_auto_encode_workflow(task_id: str, request: AutoEncodeRequest):
         task["last_log_line"] = message
 
     def _run_sub_task(command: list[str], sub_task_name: str) -> str:
-        _log_message(f"Starting sub-task: {sub_task_name}")
-        _log_message(f"Command: {' '.join(command)}")
+        _log_message(f"Запуск подзадачи: {sub_task_name}")
+        _log_message(f"Команда: {' '.join(command)}")
         
         process = subprocess.Popen(
             command, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
@@ -377,7 +341,7 @@ def run_auto_encode_workflow(task_id: str, request: AutoEncodeRequest):
         task.pop('process', None)
 
         if process.returncode != 0:
-            raise RuntimeError(f"Sub-task '{sub_task_name}' failed (code: {process.returncode}). See log for details.")
+            raise RuntimeError(f"Подзадача '{sub_task_name}' завершилась с ошибкой (код: {process.returncode}). Смотрите лог для деталей.")
         
         return "".join(full_output)
 
@@ -388,9 +352,9 @@ def run_auto_encode_workflow(task_id: str, request: AutoEncodeRequest):
             f.write(f"Starting auto-encode workflow for task {task_id}\n")
 
         if not shutil.which("mediainfo"):
-            raise RuntimeError("The 'mediainfo' utility was not found in the system PATH. Please install it.")
+            raise RuntimeError("Утилита 'mediainfo' не найдена в системном PATH. Пожалуйста, установите ее.")
         
-        _log_message("Step 1/4: Checking for Variable Frame Rate (VFR)")
+        _log_message("Шаг 1/4: Проверка на Variable Frame Rate (VFR)")
         vfr_check_cmd = ["mediainfo", "--Inform=Video;%FrameRate_Mode%", str(original_input_path)]
         vfr_check = subprocess.run(vfr_check_cmd, capture_output=True, text=True, check=True)
         frame_rate_mode = vfr_check.stdout.strip()
@@ -398,33 +362,30 @@ def run_auto_encode_workflow(task_id: str, request: AutoEncodeRequest):
         crf_search_input = original_input_path
         
         if "VFR" in frame_rate_mode.upper():
-            _log_message(f"VFR detected ({frame_rate_mode}). Starting conversion to CFR.")
+            _log_message(f"Обнаружен VFR ({frame_rate_mode}). Начало конвертации в CFR.")
             
             max_fps_res_cmd = ["mediainfo", "--Inform=Video;%FrameRate_Maximum%", str(original_input_path)]
             max_fps_res = subprocess.run(max_fps_res_cmd, capture_output=True, text=True, check=True)
             target_fps = math.ceil(float(max_fps_res.stdout.strip()))
-            _log_message(f"Target FPS for CFR: {target_fps}")
+            _log_message(f"Целевой FPS для CFR: {target_fps}")
 
             temp_cfr_path = OUTPUTS_DIR / f"{task_id}_temp_cfr.mp4"
             
+            # --- ИЗМЕНЕНИЕ: Используются переменные ��з конфигурации ---
             cfr_cmd = [
                 "ffmpeg", "-i", str(original_input_path), "-vf", f"fps={target_fps}",
-                "-c:v", "libsvtav1", "-crf", str(request.vfr_to_cfr_crf), 
-                "-preset", str(request.vfr_to_cfr_preset),
+                "-c:v", "libsvtav1", 
+                "-crf", str(VFR_TO_CFR_CRF), 
+                "-preset", str(VFR_TO_CFR_PRESET),
                 "-c:a", "copy", "-c:s", "copy", str(temp_cfr_path)
             ]
-            _run_sub_task(cfr_cmd, "VFR to CFR conversion")
-            
-            # Add intermediate file to DB and task
-            file_info = _add_file_to_db(temp_cfr_path, FileOrigin.VFR_TO_CFR, f"{original_input_path.stem}_cfr.mp4", task_id)
-            task['associated_files'].append(file_info.model_dump())
-
+            _run_sub_task(cfr_cmd, "VFR в CFR конвертация")
             crf_search_input = temp_cfr_path
-            _log_message("Conversion to CFR completed successfully.")
+            _log_message("Конвертация в CFR успешно завершена.")
         else:
-            _log_message(f"CFR detected ({frame_rate_mode}). Conversion not required.")
+            _log_message(f"Обнаружен CFR ({frame_rate_mode}). Конвертация не требуется.")
 
-        _log_message("Step 2/4: Searching for optimal CRF (crf-search)")
+        _log_message("Шаг 2/4: Поиск оптимального CRF (crf-search)")
         
         preset_value = request.preset.value if isinstance(request.preset, Enum) else str(request.preset)
         
@@ -436,59 +397,54 @@ def run_auto_encode_workflow(task_id: str, request: AutoEncodeRequest):
         if request.extra_options:
             search_cmd.extend(request.extra_options.split())
             
-        search_output = _run_sub_task(search_cmd, "CRF Search")
+        search_output = _run_sub_task(search_cmd, "Поиск CRF")
         
-        # Regex to find the recommended encode line
-        match = re.search(r"Recommended command:\n(ab-av1 encode .* --crf ([\d.]+) .* --vmaf-target ([\d.]+))", search_output, re.DOTALL)
-        if not match: # Fallback for older formats
-            match = re.search(r"encode .*--crf ([\d.]+) .*--vmaf ([\d.]+)", search_output)
-
+        found_crf = None
+        match = re.search(r"encode .*--crf ([\d.]+)", search_output)
         if match:
-            task["found_crf"] = float(match.group(2))
-            task["found_vmaf"] = float(match.group(3) if len(match.groups()) > 2 else re.search(r'VMAF score: ([\d.]+)', search_output).group(1))
-            _log_message(f"Found optimal CRF: {task['found_crf']} for VMAF {task['found_vmaf']}")
+            found_crf = match.group(1)
         else:
-            raise RuntimeError("Could not find recommended CRF in crf-search output.")
+            match = re.search(r"^crf ([\d.]+) VMAF", search_output, re.MULTILINE)
+            if match:
+                found_crf = match.group(1)
 
-        _log_message("Step 3/4: Final encoding")
+        if not found_crf:
+            raise RuntimeError("Не удалось найти рекомендованный CRF в выводе crf-search.")
+        _log_message(f"Найден оптимальный CRF: {found_crf}")
+
+        _log_message("Шаг 3/4: Финальное кодирование")
         final_output_path = Path(task["output_path"])
         encode_cmd = [
             "ab-av1", "encode", "-i", str(crf_search_input), "-o", str(final_output_path),
-            "--crf", str(task["found_crf"]), "-e", request.encoder.value, "--preset", preset_value
+            "--crf", found_crf, "-e", request.encoder.value, "--preset", preset_value
         ]
         if request.extra_options:
             encode_cmd.extend(request.extra_options.split())
             
-        _run_sub_task(encode_cmd, "Final Encoding")
-        
-        # Add final output file to DB and task
-        file_info = _add_file_to_db(final_output_path, FileOrigin.ENCODE_OUTPUT, f"{original_input_path.stem}_encoded.mp4", task_id)
-        task['associated_files'].append(file_info.model_dump())
+        _run_sub_task(encode_cmd, "Финальное кодирование")
         
         task["status"] = "completed"
-        _log_message("Step 4/4: Task completed successfully!")
+        _log_message("Шаг 4/4: Задача успешно завершена!")
 
     except Exception as e:
         task["status"] = "failed"
-        error_message = f"Workflow failed: {e}"
+        error_message = f"Воркфлоу завершился с ошибкой: {e}"
         _log_message(error_message, level="ERROR")
     finally:
         if temp_cfr_path and temp_cfr_path.exists():
-            _log_message("Cleaning up temporary files...")
+            _log_message("Очистка временных файлов...")
             temp_cfr_path.unlink()
         task["finished_at"] = datetime.utcnow()
-        _update_task_timing(task)
         task.pop('process', None)
 
 def create_task(task_type: str, request: BaseTaskRequest, background_tasks: BackgroundTasks):
-    """General function to create and run any type of task."""
+    """Общая функция для создания и запуска любого типа задачи."""
     if request.input_hash not in FILES_DB:
-        raise HTTPException(status_code=404, detail=f"File with hash {request.input_hash} not found.")
+        raise HTTPException(status_code=404, detail=f"Файл с хешем {request.input_hash} не найден.")
     
-    input_file_info = FileInfo(**FILES_DB[request.input_hash])
-    input_path = Path(input_file_info.file_path)
+    input_path = Path(FILES_DB[request.input_hash]["path"])
     if not input_path.exists():
-        raise HTTPException(status_code=404, detail=f"Source file for hash {request.input_hash} has been deleted.")
+        raise HTTPException(status_code=404, detail=f"Исходный файл для хеша {request.input_hash} был удален.")
         
     task_id = str(uuid.uuid4())
     output_path = OUTPUTS_DIR / f"{task_id}.mp4"
@@ -518,21 +474,20 @@ def create_task(task_type: str, request: BaseTaskRequest, background_tasks: Back
         "task_id": task_id, 
         "task_type": task_type, 
         "status": "pending", 
+        "input_hash": request.input_hash, 
         "command": command_str, 
         "created_at": datetime.utcnow(), 
         "started_at": None, 
         "finished_at": None, 
         "output_path": str(output_path) if task_type != "crf-search" else None, 
         "log_path": str(log_path), 
-        "last_log_line": "Task queued.",
-        "associated_files": [input_file_info.model_dump()], # Start with the input file
+        "last_log_line": "Задача поставлена в очередь.",
+
         "encoder": request.encoder,
         "preset": request.preset,
         "extra_options": request.extra_options,
         "crf": getattr(request, 'crf', None),
         "min_vmaf": getattr(request, 'min_vmaf', None),
-        "found_crf": None,
-        "found_vmaf": None,
     }
     
     if task_type == "auto-encode":
@@ -541,29 +496,28 @@ def create_task(task_type: str, request: BaseTaskRequest, background_tasks: Back
         background_tasks.add_task(run_simple_task, task_id, command, log_path)
     
     return TaskCreateResponse(
-        message=f"Task '{task_type}' created successfully.", 
-        task_id=task_id, 
-        status_url=f"/tasks/{task_id}/status", 
-        log_url=f"/tasks/{task_id}/log",
-        download_url=f"/download/{task_id}", # Main download endpoint
-        manage_url="/manage"
+        message=f"Задача '{task_type}' успешно создана.", 
+        task_id=task_id, status_url=f"/tasks/{task_id}/status", 
+        log_url=f"/tasks/{task_id}/log", manage_url="/manage"
     )
 
-# --- API Endpoints ---
+# --- Эндпоинты API ---
 
-@app.get("/", summary="API Status")
+@app.get("/", summary="Статус API")
 def read_root():
     return {"status": "ok"}
 
-@app.post("/upload", response_model=UploadResponse, summary="Upload a video file", dependencies=[Depends(verify_token)])
+@app.post("/upload", response_model=UploadResponse, summary="Загрузка видеофайла", dependencies=[Depends(verify_token)])
 async def upload_file(file: UploadFile = File(...)):
     contents = await file.read()
     file_hash = hashlib.sha256(contents).hexdigest()
     
-    if file_hash in FILES_DB and Path(FILES_DB[file_hash]["file_path"]).exists():
+    if file_hash in FILES_DB and Path(FILES_DB[file_hash]["path"]).exists():
         return UploadResponse(
-            message="A file with this hash already exists.", 
-            file_info=FileInfo(**FILES_DB[file_hash]),
+            message="Файл с таким хешем уже существует.", 
+            file_hash=file_hash, 
+            file_path=FILES_DB[file_hash]["path"], 
+            original_filename=FILES_DB[file_hash]["original_filename"], 
             is_new=False
         )
         
@@ -573,61 +527,74 @@ async def upload_file(file: UploadFile = File(...)):
     with open(saved_path, "wb") as f:
         f.write(contents)
         
-    file_info = _add_file_to_db(saved_path, FileOrigin.UPLOAD, file.filename)
+    FILES_DB[file_hash] = {
+        "path": str(saved_path), 
+        "original_filename": file.filename, 
+        "uploaded_at": datetime.utcnow(),
+        "size": len(contents)
+    }
     
     return UploadResponse(
-        message="File uploaded successfully.", 
-        file_info=file_info,
+        message="Файл успешно загружен.", 
+        file_hash=file_hash, 
+        file_path=str(saved_path), 
+        original_filename=file.filename, 
         is_new=True
     )
 
-@app.post("/tasks/auto-encode", response_model=TaskCreateResponse, status_code=202, summary="Run auto-encode task with VFR logic", dependencies=[Depends(verify_token)])
+@app.post("/tasks/auto-encode", response_model=TaskCreateResponse, status_code=202, summary="Запуск задачи auto-encode с логикой VFR", dependencies=[Depends(verify_token)])
 async def task_auto_encode(request: AutoEncodeRequest, background_tasks: BackgroundTasks):
     return create_task("auto-encode", request, background_tasks)
 
-@app.post("/tasks/crf-search", response_model=TaskCreateResponse, status_code=202, summary="Run crf-search task", dependencies=[Depends(verify_token)])
+@app.post("/tasks/crf-search", response_model=TaskCreateResponse, status_code=202, summary="Запуск задачи crf-search", dependencies=[Depends(verify_token)])
 async def task_crf_search(request: CrfSearchRequest, background_tasks: BackgroundTasks):
     return create_task("crf-search", request, background_tasks)
 
-@app.post("/tasks/encode", response_model=TaskCreateResponse, status_code=202, summary="Run encode task", dependencies=[Depends(verify_token)])
+@app.post("/tasks/encode", response_model=TaskCreateResponse, status_code=202, summary="Запуск задачи encode", dependencies=[Depends(verify_token)])
 async def task_encode(request: EncodeRequest, background_tasks: BackgroundTasks):
     return create_task("encode", request, background_tasks)
 
-@app.get("/tasks/{task_id}/status", response_model=TaskStatusResponse, summary="Get task status", dependencies=[Depends(verify_token)])
-def get_task_status(task_id: str = FastApiPath(..., description="Task ID")):
+@app.get("/tasks/{task_id}/status", response_model=TaskStatusResponse, summary="Получить статус задачи", dependencies=[Depends(verify_token)])
+def get_task_status(task_id: str = FastApiPath(..., description="ID задачи")):
     if task_id not in TASKS_DB:
-        raise HTTPException(status_code=404, detail="Task not found.")
+        raise HTTPException(status_code=404, detail="Задача не найдена.")
     task_info = TASKS_DB[task_id].copy()
     task_info.pop('process', None)
     return task_info
 
-@app.get("/tasks/{task_id}/log", summary="Get full task log", dependencies=[Depends(verify_token)])
-def get_task_log(task_id: str = FastApiPath(..., description="Task ID")):
+@app.get("/tasks/{task_id}/log", summary="Получить полный лог задачи", dependencies=[Depends(verify_token)])
+def get_task_log(task_id: str = FastApiPath(..., description="ID задачи")):
     if task_id not in TASKS_DB:
-        raise HTTPException(status_code=404, detail="Task not found.")
+        raise HTTPException(status_code=404, detail="Задача не найдена.")
     log_path = Path(TASKS_DB[task_id]["log_path"])
     if not log_path.exists():
-        return JSONResponse(status_code=404, content={"detail": "Log file not found."})
+        return JSONResponse(status_code=404, content={"detail": "Файл лога не найден."})
     return FileResponse(log_path, media_type="text/plain", filename=log_path.name)
 
-@app.get("/download/{file_hash}", summary="Download a result or any managed file by hash", dependencies=[Depends(verify_token)])
-def download_result(file_hash: str = FastApiPath(..., description="SHA256 hash of the file to download")):
-    if file_hash not in FILES_DB:
-        raise HTTPException(status_code=404, detail="File hash not found in the database.")
-        
-    file_info = FileInfo(**FILES_DB[file_hash])
-    file_path = Path(file_info.file_path)
-
-    if not file_path.exists():
-        raise HTTPException(status_code=404, detail="The file does not exist on the server.")
+@app.get("/download/{task_id}", summary="Скачать результат кодирования", dependencies=[Depends(verify_token)])
+def download_result(task_id: str = FastApiPath(..., description="ID задачи")):
+    if task_id not in TASKS_DB:
+        raise HTTPException(status_code=404, detail="Задача не найдена.")
+    task = TASKS_DB[task_id]
+    if task["status"] != "completed":
+        raise HTTPException(status_code=400, detail=f"Задача еще не завершена. Статус: {task['status']}.")
+    output_path = task.get("output_path")
+    if not output_path or not Path(output_path).exists():
+        raise HTTPException(status_code=404, detail="Выходной файл не найден.")
     
-    return FileResponse(file_path, filename=file_info.original_filename)
+    output_path = Path(output_path)
+    input_hash = task["input_hash"]
+    original_filename = Path(FILES_DB[input_hash]["original_filename"]).stem
+    
+    return FileResponse(output_path, filename=f"{original_filename}_{task['task_type']}_{task_id[:8]}{output_path.suffix}")
 
-# --- Management Endpoints ---
+# --- Эндпоинты для управления ---
 
-@app.get("/manage", summary="Get lists of tasks and files (JSON)", dependencies=[Depends(verify_token)])
+@app.get("/manage", summary="Получить списки задач и файлов (JSON)", dependencies=[Depends(verify_token)])
 async def get_management_page():
-    """Returns JSON with lists of all tasks and managed files."""
+    """
+    Возвращает JSON со списками всех задач и загруженных файлов.
+    """
     tasks_list = []
     for task_id, task_data in TASKS_DB.items():
         task_info = task_data.copy()
@@ -635,68 +602,56 @@ async def get_management_page():
         tasks_list.append(task_info)
     
     sorted_tasks = sorted(tasks_list, key=lambda x: x['created_at'], reverse=True)
-    sorted_files = sorted(list(FILES_DB.values()), key=lambda x: x['created_at'], reverse=True)
 
-    return {"tasks": sorted_tasks, "files": sorted_files}
+    return {"tasks": sorted_tasks, "files": FILES_DB}
 
 
-@app.post("/manage/task/{task_id}/cancel", summary="Cancel a running task", dependencies=[Depends(verify_token)])
-def cancel_task(task_id: str = FastApiPath(..., description="ID of the task to cancel")):
+@app.post("/manage/task/{task_id}/cancel", summary="Прервать выполняющуюся задачу", dependencies=[Depends(verify_token)])
+def cancel_task(task_id: str = FastApiPath(..., description="ID задачи для прерывания")):
     if task_id not in TASKS_DB:
-        raise HTTPException(status_code=404, detail="Task not found.")
+        raise HTTPException(status_code=404, detail="Задача не найдена.")
     task = TASKS_DB[task_id]
     if task['status'] != 'running' or 'process' not in task:
-        raise HTTPException(status_code=400, detail="Task cannot be canceled (it is not running).")
+        raise HTTPException(status_code=400, detail="Задачу нельзя прервать (она не выполняется).")
     
-    print(f"Canceling task {task_id} (PID: {task['process'].pid})...")
+    print(f"Прерывание задачи {task_id} (PID: {task['process'].pid})...")
     task['was_cancelled'] = True
     os.killpg(os.getpgid(task['process'].pid), signal.SIGTERM)
     
-    return {"message": f"Command to cancel task {task_id} sent."}
+    return {"message": f"Команда на прерывание задачи {task_id} отправлена."}
 
-@app.delete("/manage/task/{task_id}", summary="Delete a task and its files", dependencies=[Depends(verify_token)])
-def delete_task(task_id: str = FastApiPath(..., description="ID of the task to delete")):
+@app.delete("/manage/task/{task_id}", summary="Удалить задачу и ее файлы", dependencies=[Depends(verify_token)])
+def delete_task(task_id: str = FastApiPath(..., description="ID задачи для удаления")):
     if task_id not in TASKS_DB:
-        raise HTTPException(status_code=404, detail="Task not found.")
+        raise HTTPException(status_code=404, detail="Задача не найдена.")
     
     task = TASKS_DB[task_id]
     if task['status'] == 'running':
-        raise HTTPException(status_code=400, detail="Cancel the running task first.")
-
-    # Delete associated files (outputs and intermediates)
-    for file_info_dict in task.get('associated_files', []):
-        file_info = FileInfo(**file_info_dict)
-        if file_info.origin != FileOrigin.UPLOAD:
-            Path(file_info.file_path).unlink(missing_ok=True)
-            FILES_DB.pop(file_info.file_hash, None)
+        raise HTTPException(status_code=400, detail="Сначала прервите выполняющуюся задачу.")
 
-    # Delete the log file
+    if task.get('output_path') and Path(task['output_path']).exists():
+        Path(task['output_path']).unlink(missing_ok=True)
     if task.get('log_path') and Path(task['log_path']).exists():
         Path(task['log_path']).unlink(missing_ok=True)
         
     del TASKS_DB[task_id]
     
-    return {"message": f"Task {task_id} and its associated files have been deleted."}
+    return {"message": f"Задача {task_id} и ее файлы были удалены."}
 
-@app.delete("/manage/file/{file_hash}", summary="Delete a managed file", dependencies=[Depends(verify_token)])
-def delete_file(file_hash: str = FastApiPath(..., description="Hash of the file to delete")):
+@app.delete("/manage/file/{file_hash}", summary="Удалить загруженный файл", dependencies=[Depends(verify_token)])
+def delete_file(file_hash: str = FastApiPath(..., description="Хеш файла для удаления")):
     if file_hash not in FILES_DB:
-        raise HTTPException(status_code=404, detail="File not found.")
+        raise HTTPException(status_code=404, detail="Файл не найден.")
 
     for task in TASKS_DB.values():
-        for f in task.get('associated_files', []):
-            if f['file_hash'] == file_hash and task['status'] in ['running', 'pending']:
-                raise HTTPException(status_code=400, detail=f"Cannot delete file, it is being used by active task {task['task_id']}.")
+        if task['input_hash'] == file_hash and task['status'] in ['running', 'pending']:
+            raise HTTPException(status_code=400, detail=f"Нельзя удалить файл, так как он используется активной задачей {task['task_id']}.")
             
-    file_info = FILES_DB[file_hash]
-    file_path = Path(file_info['file_path'])
+    file_path = Path(FILES_DB[file_hash]['path'])
     if file_path.exists():
         file_path.unlink()
         
     del FILES_DB[file_hash]
     
-    # Remove from any task that might reference it
-    for task in TASKS_DB.values():
-        task['associated_files'] = [f for f in task.get('associated_files', []) if f['file_hash'] != file_hash]
+    return {"message": f"Файл {file_hash} был удален."}
 
-    return {"message": f"File {file_hash} has been deleted."}