Update main.py

main.py

@@ -1,35 +1,32 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 """
-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).
+main.py — single-file Flask app с AJAX-поллингом для реального статуса обработки аудио.
+Save as main.py and run in Docker.
+
 Requirements (requirements.txt):
 flask
 pydub
 gunicorn
 python-multipart
 
-Запуск локально:
-    python main.py
-В контейнере (gunicorn):
-    gunicorn -b 0.0.0.0:7860 main:app
+Убедитесь, что в контейнере установлен ffmpeg.
 """
-
 import os
 import io
 import uuid
 import time
-import queue
 import threading
 from pathlib import Path
+from typing import List, Dict, Any
 from flask import (
     Flask, request, jsonify, url_for, send_file,
-    render_template_string, abort, Response
+    render_template_string, abort
 )
 from pydub import AudioSegment, effects, silence
 
 # ----------------------------
-# Configuration
+# Config
 # ----------------------------
 TMP_DIR = Path("./tmp")
 TMP_DIR.mkdir(exist_ok=True)
@@ -39,16 +36,17 @@ 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
+# job state storage
+# job_logs[job_id] = [event_dict, ...]
+job_logs: Dict[str, List[Dict[str, Any]]] = {}
+# job_files[job_id] = Path to output file
+job_files: Dict[str, Path] = {}
+# lock for thread-safety
 jobs_lock = threading.Lock()
 
 
 # ----------------------------
-# Utility helpers & processors
+# Helpers
 # ----------------------------
 def random_filename(ext: str) -> Path:
     return TMP_DIR / (str(uuid.uuid4()) + "." + ext)
@@ -86,25 +84,26 @@ def load_audio_from_filestorage(filestorage):
     ext = ""
     if "." in filename:
         ext = filename.rsplit(".", 1)[1].lower()
-    # Try with extension first, else try common formats
+    # Try with extension first
     if ext:
         try:
             buf.seek(0)
             return AudioSegment.from_file(buf, format=ext)
         except Exception:
             pass
+    # 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
-    # final attempt letting ffmpeg autodetect
+    # Final attempt: rely on ffmpeg autodetect
     buf.seek(0)
     return AudioSegment.from_file(buf)
 
 
-# Processing steps (return AudioSegment)
+# Processing functions
 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:
@@ -130,7 +129,6 @@ def apply_speed_change(seg: AudioSegment, speed: float):
     if speed <= 0 or abs(speed - 1.0) < 1e-6:
         return seg
     try:
-        # small speed changes: use pydub.effects.speedup
         return effects.speedup(seg, playback_speed=speed)
     except Exception:
         new_frame_rate = int(seg.frame_rate * speed)
@@ -142,127 +140,116 @@ def apply_normalize(seg: AudioSegment):
 
 
 # ----------------------------
-# Background processing worker
+# Worker thread
 # ----------------------------
-def processing_worker(job_id, fs_file, options):
+def post_log(job_id: str, item: dict):
+    with jobs_lock:
+        if job_id in job_logs:
+            job_logs[job_id].append(item)
+
+
+def processing_worker(job_id: str, input_path: Path, original_filename: str, options: dict):
     """
-    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}
+    Background worker: reads input_path, performs processing, writes output file,
+    and appends events into job_logs[job_id].
     """
-    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)
+        post_log(job_id, {"type": "progress", "msg": "Получаю файл...", "percent": 2})
         # load audio
-        fs_file.stream.seek(0)
         try:
-            seg = load_audio_from_filestorage(fs_file)
+            with open(input_path, "rb") as f:
+                class _FS:
+                    def __init__(self, data, filename):
+                        self._data = data
+                        self.filename = filename
+                    def read(self):
+                        return self._data
+                fs_wrapper = _FS(f.read(), original_filename)
+            seg = load_audio_from_filestorage(fs_wrapper)
         except Exception as e:
-            post("error", f"Не удалось загрузить аудио: {e}")
+            post_log(job_id, {"type": "error", "msg": f"Не удалось загрузить аудио: {e}"})
             return
 
-        post("progress", "Анализ аудио...", 10)
-        time.sleep(0.2)
+        post_log(job_id, {"type": "progress", "msg": "Анализ аудио...", "percent": 10})
+        time.sleep(0.15)
 
-        # trim
         if options.get("trim_silence"):
-            post("progress", "Обрезаю тишину...", 20)
+            post_log(job_id, {"type": "progress", "msg": "Обрезаю тишину...", "percent": 20})
             try:
                 seg = apply_trim_silence(seg, silence_thresh_db=int(options.get("sil_thresh", -50)))
             except Exception as exc:
-                post("error", f"Ошибка при обрезке тишины: {exc}")
+                post_log(job_id, {"type": "error", "msg": 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)
+            post_log(job_id, {"type": "progress", "msg": f"Применяю low-pass {int(lp)} Hz...", "percent": 40})
             try:
                 seg = apply_lowpass(seg, lp)
             except Exception as exc:
-                post("error", f"Ошибка low-pass: {exc}")
+                post_log(job_id, {"type": "error", "msg": f"Ошибка low-pass: {exc}"})
                 return
             time.sleep(0.1)
         if hp > 0:
-            post("progress", f"Применяю high-pass {int(hp)} Hz...", 50)
+            post_log(job_id, {"type": "progress", "msg": f"Применяю high-pass {int(hp)} Hz...", "percent": 50})
             try:
                 seg = apply_highpass(seg, hp)
             except Exception as exc:
-                post("error", f"Ошибка high-pass: {exc}")
+                post_log(job_id, {"type": "error", "msg": 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)
+            post_log(job_id, {"type": "progress", "msg": f"Изменяю скорость x{speed}...", "percent": 60})
             try:
                 seg = apply_speed_change(seg, speed)
             except Exception as exc:
-                post("error", f"Ошибка изменения скорости: {exc}")
+                post_log(job_id, {"type": "error", "msg": f"Ошибка изменения скорости: {exc}"})
                 return
             time.sleep(0.1)
 
-        # normalize
         if options.get("normalize"):
-            post("progress", "Нормализация громкости...", 75)
+            post_log(job_id, {"type": "progress", "msg": "Нормализация громкости...", "percent": 75})
             try:
                 seg = apply_normalize(seg)
             except Exception as exc:
-                post("error", f"Ошибка при нормализации: {exc}")
+                post_log(job_id, {"type": "error", "msg": 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)
+        post_log(job_id, {"type": "progress", "msg": "Экспортирую файл...", "percent": 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}")
+            post_log(job_id, {"type": "error", "msg": 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)
+        post_log(job_id, {"type": "done", "msg": "Готово", "percent": 100, "file": out_path.name})
     except Exception as e:
-        post("error", f"Внутренняя ошибка: {e}")
+        post_log(job_id, {"type": "error", "msg": f"Внутренняя ошибка: {e}"})
 
 
 # ----------------------------
-# Flask routes
+# Routes
 # ----------------------------
 INDEX_HTML = """
 <!doctype html>
 <html lang="ru">
 <head>
   <meta charset="utf-8" />
-  <title>Music Processor — Онлайн</title>
+  <title>Music Processor — AJAX</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>
@@ -273,6 +260,7 @@ INDEX_HTML = """
     .progress { height: 18px; }
     .controls label { font-weight: 600; color: #cdeefb; }
     footer { margin-top: 24px; color: #8aa7bd; }
+    #log { max-height: 220px; overflow:auto; }
   </style>
 </head>
 <body>
@@ -280,8 +268,8 @@ INDEX_HTML = """
   <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>
+        <h2 class="mb-1 accent">Онлайн обработка музыки (AJAX)</h2>
+        <p class="small-muted mb-3">Загрузите трек, прогресс обновляется через AJAX-поллинг.</p>
 
         <form id="uploadForm" enctype="multipart/form-data" class="mb-3">
           <div class="mb-3">
@@ -341,7 +329,7 @@ INDEX_HTML = """
               <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="log" class="small-muted mb-2" style="min-height:64px;"></div>
 
           <div id="resultArea" class="mt-3" style="display:none;">
             <h5 class="accent">Готово — прослушать / скачать</h5>
@@ -353,11 +341,11 @@ INDEX_HTML = """
         </div>
 
         <hr class="text-muted mt-4">
-        <div class="small-muted">Подсказка: обработка выполняется в контейнере с ffmpeg. Если загрузка не проходит — убедитесь, что файл меньше {{max_mb}} МБ.</div>
+        <div class="small-muted">Максимальный размер файла: {{max_mb}} МБ. Временные файлы хранятся ~1 час.</div>
       </div>
 
       <footer class="text-center">
-        <small>Made with ♥ — быстрый аудио-пайплайн (pydub + ffmpeg). Временные файлы хранятся ~1 час.</small>
+        <small>Made with ♥ — pydub + ffmpeg. Используется AJAX-поллинг для статуса.</small>
       </footer>
     </div>
   </div>
@@ -380,6 +368,9 @@ function log(msg) {
   logEl.innerHTML = `<div>[${time}] ${msg}</div>` + logEl.innerHTML;
 }
 
+let pollInterval = null;
+let last_idx = 0;
+
 uploadForm.addEventListener('submit', async function(e) {
   e.preventDefault();
   logEl.innerHTML = '';
@@ -387,6 +378,7 @@ uploadForm.addEventListener('submit', async function(e) {
   statusArea.style.display = 'block';
   progressBar.style.width = '0%';
   progressBar.textContent = '0%';
+  last_idx = 0;
 
   const fileInput = document.getElementById('audio_file');
   if (!fileInput.files || fileInput.files.length === 0) {
@@ -401,7 +393,6 @@ uploadForm.addEventListener('submit', async function(e) {
 
   submitBtn.disabled = true;
 
-  // Prepare form
   const form = new FormData();
   form.append('audio_file', file);
   form.append('normalize', document.getElementById('normalize').checked ? '1' : '');
@@ -424,51 +415,72 @@ uploadForm.addEventListener('submit', async function(e) {
     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) {
+    // start polling
+    if (pollInterval) clearInterval(pollInterval);
+    pollInterval = setInterval(async () => {
       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();
+        const sresp = await fetch('/status/' + job_id + '?last_idx=' + last_idx);
+        if (!sresp.ok) {
+          const t = await sresp.text();
+          log('Ошибка статуса: ' + sresp.status + ' ' + t);
+          clearInterval(pollInterval);
           submitBtn.disabled = false;
+          return;
+        }
+        const data = await sresp.json();
+        const events = data.events || [];
+        last_idx = data.next_index || last_idx;
+        for (const ev of events) {
+          if (ev.type === 'progress') {
+            const pct = ev.percent || 0;
+            progressBar.style.width = pct + '%';
+            progressBar.textContent = pct + '%';
+            if (ev.msg) log(ev.msg);
+          } else if (ev.type === 'done') {
+            progressBar.style.width = '100%';
+            progressBar.textContent = '100%';
+            if (ev.msg) log(ev.msg);
+            // waiting for file_url event below (server will include file in done event)
+          } else if (ev.type === 'error') {
+            log('Ошибка: ' + (ev.msg || 'unknown'));
+            alert('Ошибка обработки: ' + (ev.msg || 'неизвестно'));
+            clearInterval(pollInterval);
+            submitBtn.disabled = false;
+            return;
+          }
+          // If server included file name (or file_url) in event, open it
+          if (ev.file) {
+            // construct download url
+            const url = window.location.origin + '/download/' + ev.file;
+            player.src = url;
+            downloadLink.href = url;
+            downloadLink.download = 'processed_' + (file.name || 'file.' + (ev.file.split('.').pop() || 'wav'));
+            resultArea.style.display = 'block';
+            log('Файл доступен: ' + url);
+            clearInterval(pollInterval);
+            submitBtn.disabled = false;
+            break;
+          }
+          if (ev.file_url) {
+            const url = ev.file_url;
+            player.src = url;
+            downloadLink.href = url;
+            downloadLink.download = 'processed_' + (file.name || 'file');
+            resultArea.style.display = 'block';
+            log('Файл доступен: ' + url);
+            clearInterval(pollInterval);
+            submitBtn.disabled = false;
+            break;
+          }
         }
       } catch (err) {
-        console.error('SSE parse error', err, e.data);
+        console.error('poll err', err);
+        log('Ошибка запроса статуса: ' + err);
+        clearInterval(pollInterval);
+        submitBtn.disabled = false;
       }
-    };
-    evtSource.onerror = function(ev) {
-      console.warn('SSE connection error', ev);
-      log('Соединение SSE прервано');
-      evtSource.close();
-      submitBtn.disabled = false;
-    };
+    }, 800); // poll every 800ms
+
   } catch (err) {
     alert('Ошибка при отправке: ' + err);
     submitBtn.disabled = false;
@@ -482,6 +494,8 @@ resetBtn.addEventListener('click', function() {
   logEl.innerHTML = '';
   progressBar.style.width = '0%';
   progressBar.textContent = '0%';
+  if (pollInterval) clearInterval(pollInterval);
+  submitBtn.disabled = false;
 });
 </script>
 </body>
@@ -492,8 +506,7 @@ resetBtn.addEventListener('click', function() {
 @app.route("/", methods=["GET"])
 def index():
     cleanup_old_files()
-    rendered = render_template_string(INDEX_HTML, max_mb=MAX_UPLOAD_MB)
-    return rendered
+    return render_template_string(INDEX_HTML, max_mb=MAX_UPLOAD_MB)
 
 
 @app.route("/start", methods=["POST"])
@@ -506,11 +519,9 @@ def start_job():
         return "No selected file", 400
 
     job_id = str(uuid.uuid4())
-    q = queue.Queue()
     with jobs_lock:
-        job_queues[job_id] = q
+        job_logs[job_id] = []
 
-    # gather options
     options = {
         "normalize": bool(request.form.get("normalize")),
         "speed": request.form.get("speed", "1.0"),
@@ -521,88 +532,42 @@ def start_job():
         "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:
+    # Save uploaded file to tmp
     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)
+
+    # Start background worker
+    t = threading.Thread(target=processing_worker, args=(job_id, temp_in, fs.filename, 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
-
-    return Response(gen(), mimetype="text/event-stream")
-
-
-def json_safe(obj):
+@app.route("/status/<job_id>", methods=["GET"])
+def status(job_id):
     """
-    Very small JSON serialization without importing json in the template string path.
-    Use python's json.dumps normally, but keep this helper for convenience.
+    AJAX polling endpoint.
+    Query param: last_idx (int) — index of last event client already received.
+    Response: {"events": [...], "next_index": N}
     """
-    import json
-    return json.dumps(obj, ensure_ascii=False)
-
-
-@app.route("/download/<filename>")
+    last_idx = int(request.args.get("last_idx", "0") or 0)
+    with jobs_lock:
+        logs = job_logs.get(job_id, [])
+        # copy slice
+        events = logs[last_idx:]
+        next_index = last_idx + len(events)
+        # If any event has 'file' (filename), convert it to full URL as file_url
+        for ev in events:
+            if ev.get("file") and not ev.get("file_url"):
+                # build full URL
+                download_path = url_for("download_file", filename=ev["file"], _external=False)
+                host = request.host_url.rstrip('/')
+                ev["file_url"] = host + download_path
+    return jsonify({"events": events, "next_index": next_index})
+
+
+@app.route("/download/<filename>", methods=["GET"])
 def download_file(filename):
     cleanup_old_files()
     safe_path = (TMP_DIR / filename).resolve()
@@ -616,14 +581,11 @@ def download_file(filename):
         return f"Error serving file: {e}", 500
 
 
-@app.route("/healthz")
+@app.route("/healthz", methods=["GET"])
 def health():
     return "ok", 200
 
 
-# ----------------------------
-# Run (for dev)
-# ----------------------------
 if __name__ == "__main__":
     port = int(os.environ.get("PORT", 7860))
     host = os.environ.get("HOST", "0.0.0.0")