Update main.py

main.py

@@ -1,54 +1,61 @@
 #!/usr/bin/env python3
+# -*- coding: utf-8 -*-
 """
-Flask single-file app for online audio processing.
-
-How to use (notes for deployment):
-- This file is self-contained Flask app. Save as `app.py`.
-- Requirements (install in your Docker image / environment):
-    pip install flask pydub python-multipart
-  Additionally you must have ffmpeg installed in the container (pydub uses ffmpeg).
-  Example Debian Dockerfile snippet:
-    RUN apt-get update && apt-get install -y ffmpeg
-    RUN pip install -U pip
-    RUN pip install flask pydub python-multipart
-
-Features:
-- Upload audio (mp3, wav, ogg, m4a, flac, etc.)
-- Options: normalize, change speed, lowpass/highpass filter, trim silence, export format
-- In-browser upload form + playback of processed file
-- Processes audio using pydub (ffmpeg required).
-- Single-file, stores temp files in ./tmp (created automatically). Cleans up old files on each request.
+main.py — single-file Flask app with a polished web UI and real-time processing updates (SSE).
+Save as main.py and run in Docker (see earlier Dockerfile with ffmpeg installed).
+Requirements (requirements.txt):
+flask
+pydub
+gunicorn
+python-multipart
+
+Запуск локально:
+    python main.py
+В контейнере (gunicorn):
+    gunicorn -b 0.0.0.0:7860 main:app
 """
 
 import os
 import io
 import uuid
 import time
-import shutil
+import queue
+import threading
 from pathlib import Path
-from flask import Flask, request, send_file, redirect, url_for, render_template_string, abort, jsonify
+from flask import (
+    Flask, request, jsonify, url_for, send_file,
+    render_template_string, abort, Response
+)
 from pydub import AudioSegment, effects, silence
 
+# ----------------------------
 # Configuration
+# ----------------------------
 TMP_DIR = Path("./tmp")
 TMP_DIR.mkdir(exist_ok=True)
-MAX_UPLOAD_MB = 200  # maximum upload size
-ALLOWED_MIMES = {
-    "audio/mpeg", "audio/wav", "audio/x-wav", "audio/ogg", "audio/mp4", "audio/x-m4a",
-    "audio/flac", "audio/x-flac", "application/octet-stream"
-}
-KEEP_FILES_SEC = 60 * 60  # keep processed files for 1 hour (auto-clean)
+KEEP_FILES_SEC = 60 * 60  # 1 hour
+MAX_UPLOAD_MB = 200
 
 app = Flask(__name__)
 app.config["MAX_CONTENT_LENGTH"] = MAX_UPLOAD_MB * 1024 * 1024
 
+# job_queues: job_id -> Queue of event dicts
+job_queues = {}
+# job_files: job_id -> output Path
+job_files = {}
+# simple lock for dicts
+jobs_lock = threading.Lock()
+
+
+# ----------------------------
+# Utility helpers & processors
+# ----------------------------
+def random_filename(ext: str) -> Path:
+    return TMP_DIR / (str(uuid.uuid4()) + "." + ext)
 
-# ---------------------------
-# Utility helpers
-# ---------------------------
 
 def secure_extension_for_format(fmt: str) -> str:
-    fmt = fmt.lower().strip()
+    fmt = (fmt or "").lower().strip()
     if fmt in ("mp3", "mpeg"):
         return "mp3"
     if fmt in ("wav", "wave"):
@@ -59,207 +66,424 @@ def secure_extension_for_format(fmt: str) -> str:
         return "ogg"
     if fmt in ("m4a", "mp4", "aac"):
         return "m4a"
-    # default
     return "wav"
 
 
-def random_filename(ext: str) -> Path:
-    return TMP_DIR / (str(uuid.uuid4()) + "." + ext)
-
-
 def cleanup_old_files():
-    """Remove files older than KEEP_FILES_SEC"""
     now = time.time()
     for p in list(TMP_DIR.iterdir()):
         try:
-            if p.is_file():
-                if now - p.stat().st_mtime > KEEP_FILES_SEC:
-                    p.unlink()
+            if p.is_file() and (now - p.stat().st_mtime) > KEEP_FILES_SEC:
+                p.unlink()
         except Exception:
             pass
 
 
-def detect_format_from_bytes(b: bytes) -> str:
-    # pydub's AudioSegment.from_file requires a file-like object and format hint.
-    # We'll attempt with no hint; if fails, client-specified extension will be used.
-    return ""
-
-
-def load_audio_from_file_storage(file_storage):
-    """
-    Load an AudioSegment from Flask's FileStorage object.
-    Tries to use filename extension; falls back to letting ffmpeg autodetect.
-    """
-    data = file_storage.read()
+def load_audio_from_filestorage(filestorage):
+    data = filestorage.read()
     buf = io.BytesIO(data)
-    # Try to guess format from filename
-    filename = file_storage.filename or ""
+    filename = filestorage.filename or ""
     ext = ""
     if "." in filename:
         ext = filename.rsplit(".", 1)[1].lower()
-    try:
-        if ext:
+    # Try with extension first, else try common formats
+    if ext:
+        try:
+            buf.seek(0)
             return AudioSegment.from_file(buf, format=ext)
-        else:
-            # Let ffmpeg autodetect
+        except Exception:
+            pass
+    for fmt in ("mp3", "wav", "ogg", "flac", "m4a", "aac"):
+        try:
             buf.seek(0)
-            return AudioSegment.from_file(buf)
-    except Exception:
-        # Last attempt: try common formats
-        for fmt in ("mp3", "wav", "ogg", "flac", "m4a", "aac"):
-            try:
-                buf.seek(0)
-                return AudioSegment.from_file(buf, format=fmt)
-            except Exception:
-                continue
-        raise
+            return AudioSegment.from_file(buf, format=fmt)
+        except Exception:
+            continue
+    # final attempt letting ffmpeg autodetect
+    buf.seek(0)
+    return AudioSegment.from_file(buf)
+
+
+# Processing steps (return AudioSegment)
+def apply_trim_silence(seg: AudioSegment, silence_thresh_db=-50, chunk_len_ms=10):
+    non_silence = silence.detect_nonsilent(seg, min_silence_len=chunk_len_ms, silence_thresh=silence_thresh_db)
+    if not non_silence:
+        return seg[:0]
+    start = non_silence[0][0]
+    end = non_silence[-1][1]
+    return seg[start:end]
 
 
-# ---------------------------
-# Audio processing actions
-# ---------------------------
+def apply_lowpass(seg: AudioSegment, cutoff_hz: float):
+    if cutoff_hz and cutoff_hz > 0:
+        return seg.low_pass_filter(int(cutoff_hz))
+    return seg
 
-def apply_normalize(seg: AudioSegment) -> AudioSegment:
-    return effects.normalize(seg)
 
+def apply_highpass(seg: AudioSegment, cutoff_hz: float):
+    if cutoff_hz and cutoff_hz > 0:
+        return seg.high_pass_filter(int(cutoff_hz))
+    return seg
 
-def apply_speed_change(seg: AudioSegment, speed: float) -> AudioSegment:
-    """
-    Change playback speed while preserving pitch approximately using pydub's speedup (it slices frames).
-    For large changes, artifacts may appear. Speed must be >0.
-    """
+
+def apply_speed_change(seg: AudioSegment, speed: float):
     if speed <= 0 or abs(speed - 1.0) < 1e-6:
         return seg
-    # pydub.effects.speedup accepts playback_speed parameter
     try:
+        # small speed changes: use pydub.effects.speedup
         return effects.speedup(seg, playback_speed=speed)
     except Exception:
-        # Fallback: change frame_rate (this changes pitch)
         new_frame_rate = int(seg.frame_rate * speed)
         return seg._spawn(seg.raw_data, overrides={"frame_rate": new_frame_rate}).set_frame_rate(seg.frame_rate)
 
 
-def apply_lowpass(seg: AudioSegment, cutoff_hz: float) -> AudioSegment:
-    if cutoff_hz and cutoff_hz > 0:
-        return seg.low_pass_filter(int(cutoff_hz))
-    return seg
-
-
-def apply_highpass(seg: AudioSegment, cutoff_hz: float) -> AudioSegment:
-    if cutoff_hz and cutoff_hz > 0:
-        return seg.high_pass_filter(int(cutoff_hz))
-    return seg
+def apply_normalize(seg: AudioSegment):
+    return effects.normalize(seg)
 
 
-def apply_trim_silence(seg: AudioSegment, silence_thresh_db=-50, chunk_len_ms=10) -> AudioSegment:
+# ----------------------------
+# Background processing worker
+# ----------------------------
+def processing_worker(job_id, fs_file, options):
     """
-    Trim silence from the start and end.
-    silence_thresh_db: threshold in dB relative to max to consider silence (e.g., -50)
-    chunk_len_ms: granularity for silence detection
+    Runs in a separate thread. Posts progress events into the job queue.
+    Each event is a dict: {"type": "progress"/"error"/"done", "msg": "...", "percent": 0-100, "file": filename_if_done}
     """
-    non_silence_ranges = silence.detect_nonsilent(seg, min_silence_len=chunk_len_ms, silence_thresh=silence_thresh_db)
-    if not non_silence_ranges:
-        # Entire segment is silence => return empty short segment
-        return seg[:0]
-    start = non_silence_ranges[0][0]
-    end = non_silence_ranges[-1][1]
-    return seg[start:end]
+    q = job_queues.get(job_id)
+    if q is None:
+        return
+
+    def post(event_type, msg=None, percent=None, filename=None):
+        payload = {"type": event_type}
+        if msg is not None:
+            payload["msg"] = msg
+        if percent is not None:
+            payload["percent"] = percent
+        if filename is not None:
+            payload["file"] = filename
+        try:
+            q.put(payload, timeout=1)
+        except Exception:
+            pass
 
+    try:
+        post("progress", "Получаю файл...", 2)
+        # load audio
+        fs_file.stream.seek(0)
+        try:
+            seg = load_audio_from_filestorage(fs_file)
+        except Exception as e:
+            post("error", f"Не удалось загрузить аудио: {e}")
+            return
 
-# ---------------------------
-# Flask routes
-# ---------------------------
+        post("progress", "Анализ аудио...", 10)
+        time.sleep(0.2)
+
+        # trim
+        if options.get("trim_silence"):
+            post("progress", "Обрезаю тишину...", 20)
+            try:
+                seg = apply_trim_silence(seg, silence_thresh_db=int(options.get("sil_thresh", -50)))
+            except Exception as exc:
+                post("error", f"Ошибка при обрезке тишины: {exc}")
+                return
+            time.sleep(0.1)
+
+        # filters
+        lp = float(options.get("lowpass", 0) or 0)
+        hp = float(options.get("highpass", 0) or 0)
+        if lp > 0:
+            post("progress", f"Применяю low-pass {int(lp)} Hz...", 40)
+            try:
+                seg = apply_lowpass(seg, lp)
+            except Exception as exc:
+                post("error", f"Ошибка low-pass: {exc}")
+                return
+            time.sleep(0.1)
+        if hp > 0:
+            post("progress", f"Применяю high-pass {int(hp)} Hz...", 50)
+            try:
+                seg = apply_highpass(seg, hp)
+            except Exception as exc:
+                post("error", f"Ошибка high-pass: {exc}")
+                return
+            time.sleep(0.1)
+
+        # speed
+        speed = float(options.get("speed", 1.0) or 1.0)
+        if abs(speed - 1.0) > 1e-6:
+            post("progress", f"Изменяю скорость x{speed}...", 60)
+            try:
+                seg = apply_speed_change(seg, speed)
+            except Exception as exc:
+                post("error", f"Ошибка изменения скорости: {exc}")
+                return
+            time.sleep(0.1)
+
+        # normalize
+        if options.get("normalize"):
+            post("progress", "Нормализация громкости...", 75)
+            try:
+                seg = apply_normalize(seg)
+            except Exception as exc:
+                post("error", f"Ошибка при нормализации: {exc}")
+                return
+            time.sleep(0.1)
+
+        # export
+        out_fmt = secure_extension_for_format(options.get("out_format", "wav"))
+        out_path = random_filename(out_fmt)
+        post("progress", "Экспортирую файл...", 90)
+        try:
+            export_kwargs = {}
+            if out_fmt == "mp3":
+                export_kwargs["bitrate"] = "192k"
+            seg.export(out_path.as_posix(), format=out_fmt, **export_kwargs)
+        except Exception as exc:
+            post("error", f"Ошибка при экспорте: {exc}")
+            return
+
+        # register file
+        with jobs_lock:
+            job_files[job_id] = out_path
+
+        file_url = url_for("download_file", filename=out_path.name, _external=True)
+        post("done", "Готово", 100, filename=out_path.name)
+        post("file_url", file_url)
+    except Exception as e:
+        post("error", f"Внутренняя ошибка: {e}")
 
+
+# ----------------------------
+# Flask routes
+# ----------------------------
 INDEX_HTML = """
 <!doctype html>
 <html lang="ru">
 <head>
   <meta charset="utf-8" />
-  <title>Online Audio Processing</title>
+  <title>Music Processor — Онлайн</title>
   <meta name="viewport" content="width=device-width,initial-scale=1" />
+  <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.3/dist/css/bootstrap.min.css" rel="stylesheet">
   <style>
-    body { font-family: Arial, Helvetica, sans-serif; margin: 32px; }
-    label { display:block; margin-top:10px; }
-    .controls { margin-top: 10px; }
-    .result { margin-top: 20px; }
-    input[type="number"] { width: 8rem; }
+    body { background: linear-gradient(180deg,#0f172a, #071233); color: #e6eef8; min-height:100vh; }
+    .card { border-radius: 12px; background: rgba(255,255,255,0.04); box-shadow: 0 8px 30px rgba(2,6,23,0.6); }
+    .accent { color: #7dd3fc; }
+    .small-muted { color: #9fb3c8; font-size: 0.9rem; }
+    .progress { height: 18px; }
+    .controls label { font-weight: 600; color: #cdeefb; }
+    footer { margin-top: 24px; color: #8aa7bd; }
   </style>
 </head>
 <body>
-  <h2>Онлайн обработка музыки</h2>
-  <form id="uploadForm" method="post" action="/process" enctype="multipart/form-data">
-    <label>Файл (mp3, wav, ogg, m4a, flac):
-      <input required type="file" name="audio_file" accept="audio/*" />
-    </label>
-
-    <div class="controls">
-      <label><input type="checkbox" name="normalize" /> Нормализовать (gain)</label>
-      <label>
-        Скорость (0.5 = вдвое медленнее, 1.0 = без изменений, 1.5 = быстрее):
-        <input type="number" step="0.1" name="speed" value="1.0" />
-      </label>
-      <label>
-        Low-pass cutoff (Hz, 0 отключить):
-        <input type="number" name="lowpass" value="0" />
-      </label>
-      <label>
-        High-pass cutoff (Hz, 0 отключить):
-        <input type="number" name="highpass" value="0" />
-      </label>
-      <label><input type="checkbox" name="trim_silence" /> Обрезать тишину в начале/конце</label>
-      <label>
-        Silence threshold (dB, для обрезки, например -50):
-        <input type="number" name="sil_thresh" value="-50" />
-      </label>
-
-      <label>
-        Экспорт формат:
-        <select name="out_format">
-          <option value="mp3">MP3</option>
-          <option value="wav" selected>WAV</option>
-          <option value="flac">FLAC</option>
-          <option value="ogg">OGG</option>
-          <option value="m4a">M4A</option>
-        </select>
-      </label>
-    </div>
-
-    <div style="margin-top:12px;">
-      <button type="submit">Обработать и скачать / прослушать</button>
+<div class="container py-5">
+  <div class="row justify-content-center">
+    <div class="col-lg-8">
+      <div class="card p-4">
+        <h2 class="mb-1 accent">Онлайн обработка музыки</h2>
+        <p class="small-muted mb-3">Загрузите трек, примените эффекты в реальном времени — прогресс будет отображаться прямо в интерфейсе.</p>
+
+        <form id="uploadForm" enctype="multipart/form-data" class="mb-3">
+          <div class="mb-3">
+            <label class="form-label">Аудиофайл</label>
+            <input class="form-control" type="file" id="audio_file" name="audio_file" accept="audio/*" required>
+          </div>
+
+          <div class="row g-2">
+            <div class="col-md-4">
+              <div class="form-check">
+                <input class="form-check-input" type="checkbox" id="normalize" name="normalize">
+                <label class="form-check-label" for="normalize">Нормализовать</label>
+              </div>
+            </div>
+            <div class="col-md-4">
+              <label class="form-label">Скорость</label>
+              <input class="form-control" type="number" step="0.1" name="speed" id="speed" value="1.0">
+            </div>
+            <div class="col-md-4">
+              <label class="form-label">Формат вывода</label>
+              <select class="form-select" id="out_format" name="out_format">
+                <option value="wav" selected>WAV</option>
+                <option value="mp3">MP3</option>
+                <option value="flac">FLAC</option>
+                <option value="ogg">OGG</option>
+                <option value="m4a">M4A</option>
+              </select>
+            </div>
+          </div>
+
+          <div class="row g-2 mt-3">
+            <div class="col-md-6">
+              <label class="form-label">Low-pass (Hz, 0 = off)</label>
+              <input class="form-control" type="number" id="lowpass" name="lowpass" value="0">
+            </div>
+            <div class="col-md-6">
+              <label class="form-label">High-pass (Hz, 0 = off)</label>
+              <input class="form-control" type="number" id="highpass" name="highpass" value="0">
+            </div>
+          </div>
+
+          <div class="form-check form-switch mt-3">
+            <input class="form-check-input" type="checkbox" id="trim_silence" name="trim_silence">
+            <label class="form-check-label" for="trim_silence">Обрезать тишину в начале/конце</label>
+          </div>
+
+          <div class="mt-3 d-flex gap-2">
+            <button type="submit" id="submitBtn" class="btn btn-primary">Обработать</button>
+            <button type="button" id="resetBtn" class="btn btn-outline-light">Сброс</button>
+          </div>
+        </form>
+
+        <div id="statusArea" style="display:none;">
+          <div class="mb-2 small-muted">Статус обработки:</div>
+          <div class="mb-2">
+            <div class="progress">
+              <div id="progressBar" class="progress-bar bg-info" role="progressbar" style="width: 0%">0%</div>
+            </div>
+          </div>
+          <div id="log" class="small-muted" style="min-height:48px;"></div>
+
+          <div id="resultArea" class="mt-3" style="display:none;">
+            <h5 class="accent">Готово — прослушать / скачать</h5>
+            <audio id="player" controls style="width:100%"></audio>
+            <div class="mt-2">
+              <a id="downloadLink" class="btn btn-outline-light" href="#" download>Скачать</a>
+            </div>
+          </div>
+        </div>
+
+        <hr class="text-muted mt-4">
+        <div class="small-muted">Подсказка: обработка выполняется в контейнере с ffmpeg. Если загрузка не проходит — убедитесь, что файл меньше {{max_mb}} МБ.</div>
+      </div>
+
+      <footer class="text-center">
+        <small>Made with ♥ — быстрый аудио-пайплайн (pydub + ffmpeg). Временные файлы хранятся ~1 час.</small>
+      </footer>
     </div>
-  </form>
-
-  <div class="result" id="resultArea" style="display:none;">
-    <h3>Результат</h3>
-    <audio id="player" controls></audio>
-    <p><a id="downloadLink" href="#" download>Скачать обработанный файл</a></p>
   </div>
+</div>
 
 <script>
-document.getElementById('uploadForm').addEventListener('submit', async function(ev){
-  ev.preventDefault();
-  const form = ev.target;
-  const data = new FormData(form);
-  const resp = await fetch('/process', { method: 'POST', body: data });
-  if (!resp.ok) {
-    const text = await resp.text();
-    alert('Ошибка: ' + resp.status + '\\n' + text);
+const maxMB = {{max_mb}};
+const uploadForm = document.getElementById('uploadForm');
+const statusArea = document.getElementById('statusArea');
+const logEl = document.getElementById('log');
+const progressBar = document.getElementById('progressBar');
+const resultArea = document.getElementById('resultArea');
+const player = document.getElementById('player');
+const downloadLink = document.getElementById('downloadLink');
+const submitBtn = document.getElementById('submitBtn');
+const resetBtn = document.getElementById('resetBtn');
+
+function log(msg) {
+  const time = new Date().toLocaleTimeString();
+  logEl.innerHTML = `<div>[${time}] ${msg}</div>` + logEl.innerHTML;
+}
+
+uploadForm.addEventListener('submit', async function(e) {
+  e.preventDefault();
+  logEl.innerHTML = '';
+  resultArea.style.display = 'none';
+  statusArea.style.display = 'block';
+  progressBar.style.width = '0%';
+  progressBar.textContent = '0%';
+
+  const fileInput = document.getElementById('audio_file');
+  if (!fileInput.files || fileInput.files.length === 0) {
+    alert('Выберите аудио-файл');
+    return;
+  }
+  const file = fileInput.files[0];
+  if (file.size > maxMB * 1024 * 1024) {
+    alert('Файл слишком большой (макс ' + maxMB + ' MB)');
     return;
   }
-  // server returns JSON with 'file_url' field
-  const resjson = await resp.json();
-  const url = resjson.file_url;
-  const filename = resjson.filename || 'processed_audio';
-  const area = document.getElementById('resultArea');
-  area.style.display = 'block';
-  const player = document.getElementById('player');
-  player.src = url;
-  const dl = document.getElementById('downloadLink');
-  dl.href = url;
-  dl.download = filename;
+
+  submitBtn.disabled = true;
+
+  // Prepare form
+  const form = new FormData();
+  form.append('audio_file', file);
+  form.append('normalize', document.getElementById('normalize').checked ? '1' : '');
+  form.append('speed', document.getElementById('speed').value);
+  form.append('lowpass', document.getElementById('lowpass').value);
+  form.append('highpass', document.getElementById('highpass').value);
+  form.append('trim_silence', document.getElementById('trim_silence').checked ? '1' : '');
+  form.append('sil_thresh', -50);
+  form.append('out_format', document.getElementById('out_format').value);
+
+  try {
+    const resp = await fetch('/start', { method: 'POST', body: form });
+    if (!resp.ok) {
+      const txt = await resp.text();
+      alert('Ошибка: ' + resp.status + '\\n' + txt);
+      submitBtn.disabled = false;
+      return;
+    }
+    const js = await resp.json();
+    const job_id = js.job_id;
+    log('Задача создана: ' + job_id);
+
+    // Connect to SSE for live updates
+    const evtSource = new EventSource('/events/' + job_id);
+    evtSource.onmessage = function(e) {
+      try {
+        const data = JSON.parse(e.data);
+        if (data.type === 'progress') {
+          const pct = data.percent || 0;
+          progressBar.style.width = pct + '%';
+          progressBar.textContent = pct + '%';
+          if (data.msg) log(data.msg);
+        } else if (data.type === 'done') {
+          progressBar.style.width = '100%';
+          progressBar.textContent = '100%';
+          log(data.msg || 'Готово');
+        } else if (data.type === 'file_url') {
+          const fileurl = data;
+          // in case server sends a full object with file_url
+          let url = data;
+          if (data.file) url = '/download/' + data.file;
+          if (typeof data === 'object' && data.file_url) url = data.file_url;
+          // Set player and download link
+          const finalUrl = url;
+          player.src = finalUrl;
+          downloadLink.href = finalUrl;
+          downloadLink.download = 'processed_' + file.name;
+          resultArea.style.display = 'block';
+          log('Файл доступен: ' + finalUrl);
+          evtSource.close();
+          submitBtn.disabled = false;
+        } else if (data.type === 'error') {
+          log('Ошибка: ' + (data.msg || 'unknown'));
+          alert('Ошибка обработки: ' + (data.msg || 'неизвестно'));
+          evtSource.close();
+          submitBtn.disabled = false;
+        }
+      } catch (err) {
+        console.error('SSE parse error', err, e.data);
+      }
+    };
+    evtSource.onerror = function(ev) {
+      console.warn('SSE connection error', ev);
+      log('Соединение SSE прервано');
+      evtSource.close();
+      submitBtn.disabled = false;
+    };
+  } catch (err) {
+    alert('Ошибка при отправке: ' + err);
+    submitBtn.disabled = false;
+  }
 });
-</script>
 
+resetBtn.addEventListener('click', function() {
+  uploadForm.reset();
+  statusArea.style.display = 'none';
+  resultArea.style.display = 'none';
+  logEl.innerHTML = '';
+  progressBar.style.width = '0%';
+  progressBar.textContent = '0%';
+});
+</script>
 </body>
 </html>
 """
@@ -268,77 +492,118 @@ document.getElementById('uploadForm').addEventListener('submit', async function(
 @app.route("/", methods=["GET"])
 def index():
     cleanup_old_files()
-    return render_template_string(INDEX_HTML)
+    rendered = render_template_string(INDEX_HTML, max_mb=MAX_UPLOAD_MB)
+    return rendered
 
 
-@app.route("/process", methods=["POST"])
-def process_audio():
+@app.route("/start", methods=["POST"])
+def start_job():
     cleanup_old_files()
     if "audio_file" not in request.files:
         return "No file part 'audio_file'", 400
-    file = request.files["audio_file"]
-    if file.filename == "":
+    fs = request.files["audio_file"]
+    if fs.filename == "":
         return "No selected file", 400
 
-    # Basic content-length check is already handled by MAX_CONTENT_LENGTH
-    # Load audio
-    try:
-        seg = load_audio_from_file_storage(file)
-    except Exception as e:
-        return f"Не удалось загрузить аудио: {str(e)}", 400
-
-    # Parse options
-    try:
-        normalize_flag = request.form.get("normalize") == "on" or request.form.get("normalize") == "true" or bool(request.form.get("normalize"))
-        speed = float(request.form.get("speed", "1.0") or 1.0)
-        lowpass = float(request.form.get("lowpass", "0") or 0)
-        highpass = float(request.form.get("highpass", "0") or 0)
-        trim_silence_flag = request.form.get("trim_silence") == "on" or request.form.get("trim_silence") == "true" or bool(request.form.get("trim_silence"))
-        sil_thresh = int(request.form.get("sil_thresh", "-50") or -50)
-        out_format = secure_extension_for_format(request.form.get("out_format", "wav"))
-    except Exception as e:
-        return f"Ошибка в параметрах: {e}", 400
-
-    # Apply chain of processing (order: trim -> filters -> speed -> normalize)
-    try:
-        if trim_silence_flag:
-            seg = apply_trim_silence(seg, silence_thresh_db=sil_thresh)
-
-        if lowpass and lowpass > 0:
-            seg = apply_lowpass(seg, lowpass)
-
-        if highpass and highpass > 0:
-            seg = apply_highpass(seg, highpass)
-
-        if abs(speed - 1.0) > 1e-6:
-            seg = apply_speed_change(seg, speed)
+    job_id = str(uuid.uuid4())
+    q = queue.Queue()
+    with jobs_lock:
+        job_queues[job_id] = q
+
+    # gather options
+    options = {
+        "normalize": bool(request.form.get("normalize")),
+        "speed": request.form.get("speed", "1.0"),
+        "lowpass": request.form.get("lowpass", "0"),
+        "highpass": request.form.get("highpass", "0"),
+        "trim_silence": bool(request.form.get("trim_silence")),
+        "sil_thresh": request.form.get("sil_thresh", "-50"),
+        "out_format": request.form.get("out_format", "wav"),
+    }
+
+    # We must keep a copy of the uploaded file stream for the background worker.
+    # Easiest: read bytes into BytesIO-like object stored on disk or memory.
+    # We'll save the uploaded file into memory-backed object but keep a small temp file on disk to avoid memory blow.
+    # Save a temp copy to pass into thread as a FileStorage-like object:
+    temp_in = TMP_DIR / (job_id + "_in")
+    fs.stream.seek(0)
+    fs.save(temp_in)
+    # reopen as a file object with necessary attributes for loader
+    class _FSWrapper:
+        def __init__(self, path, filename):
+            self.path = path
+            self.filename = filename
+            self.stream = open(path, "rb")
+        def read(self):
+            self.stream.seek(0)
+            return self.stream.read()
+    fs_wrapper = _FSWrapper(temp_in, fs.filename)
+
+    # start thread
+    t = threading.Thread(target=processing_worker, args=(job_id, fs_wrapper, options), daemon=True)
+    t.start()
+
+    return jsonify({"job_id": job_id})
+
+
+@app.route("/events/<job_id>")
+def events(job_id):
+    # Stream Server-Sent Events from the job queue
+    def gen():
+        q = None
+        with jobs_lock:
+            q = job_queues.get(job_id)
+        if q is None:
+            yield f"data: {json_safe({'type': 'error', 'msg': 'Job not found'})}\n\n"
+            return
+        # keep streaming until we see done or error and queue empties
+        finished = False
+        while True:
+            try:
+                item = q.get(timeout=0.5)
+            except queue.Empty:
+                # if job completed and queue empty, break
+                with jobs_lock:
+                    if job_files.get(job_id) is not None and q.empty():
+                        break
+                continue
+            # send JSON string
+            yield f"data: {json_safe(item)}\n\n"
+            if item.get("type") in ("done", "error"):
+                # continue loop to potentially send file_url event after done
+                if item.get("type") == "error":
+                    break
+        # after done, if file exists, send file_url
+        with jobs_lock:
+            outp = job_files.get(job_id)
+        if outp:
+            file_url = url_for("download_file", filename=outp.name, _external=True)
+            yield f"data: {json_safe({'type': 'file_url', 'file_url': file_url})}\n\n"
+        # cleanup queue and small temp input file
+        with jobs_lock:
+            job_queues.pop(job_id, None)
+        # remove temp input file if present
+        try:
+            temp_in = TMP_DIR / (job_id + "_in")
+            if temp_in.exists():
+                temp_in.unlink()
+        except Exception:
+            pass
 
-        if normalize_flag:
-            seg = apply_normalize(seg)
-    except Exception as e:
-        return f"Ошибка при обработке аудио: {e}", 500
+    return Response(gen(), mimetype="text/event-stream")
 
-    # Export to temporary file
-    out_path = random_filename(out_format)
-    try:
-        # Export parameters: for mp3, use bitrate; for wav default; flac default
-        export_kwargs = {}
-        if out_format == "mp3":
-            export_kwargs["bitrate"] = "192k"
-        # pydub will call ffmpeg
-        seg.export(out_path.as_posix(), format=out_format, **export_kwargs)
-    except Exception as e:
-        return f"Не удалось экспортировать аудио: {e}", 500
 
-    # Build file URL for client to download/stream
-    file_url = url_for("download_file", filename=out_path.name, _external=True)
-    response_payload = {"file_url": file_url, "filename": out_path.name}
-    return jsonify(response_payload)
+def json_safe(obj):
+    """
+    Very small JSON serialization without importing json in the template string path.
+    Use python's json.dumps normally, but keep this helper for convenience.
+    """
+    import json
+    return json.dumps(obj, ensure_ascii=False)
 
 
-@app.route("/download/<filename>", methods=["GET"])
+@app.route("/download/<filename>")
 def download_file(filename):
-    # security: only allow files in TMP_DIR
     cleanup_old_files()
     safe_path = (TMP_DIR / filename).resolve()
     try:
@@ -351,18 +616,15 @@ def download_file(filename):
         return f"Error serving file: {e}", 500
 
 
-# Small healthcheck
-@app.route("/healthz", methods=["GET"])
+@app.route("/healthz")
 def health():
     return "ok", 200
 
 
-# ---------------------------
-# Run
-# ---------------------------
-
+# ----------------------------
+# Run (for dev)
+# ----------------------------
 if __name__ == "__main__":
-    # On Hugging Face Spaces with Docker, they often expect the app to listen on 0.0.0.0 and port from env
     port = int(os.environ.get("PORT", 7860))
     host = os.environ.get("HOST", "0.0.0.0")
     app.run(host=host, port=port, debug=False)