Update app.py

app.py

@@ -1,16 +1,14 @@
 # audio_split_zip_gradio.py
-# UI: Gradio. Splits big audio into N-second chunks, exports with chosen bitrate,
-# and returns a ZIP archive with all parts.
-#
-# Notes:
-# - Works best with ffmpeg installed (system dependency).
-# - Supports most common formats (mp3, wav, m4a, flac, ogg, etc.).
-# - Keeps original bitrate if "Auto (same as source)" is selected and bitrate is detectable.
+# Gradio app: upload huge audio -> split into N-second parts -> download ZIP (mp3 parts)
+# - Auto bitrate = same as source if detectable; fallback to 192 kbps
+# - Custom bitrate slider appears only in Custom mode
+# - Mobile-friendly UI (bigger text, simpler layout)
+# - Uses ffmpeg/ffprobe (system dependency)
 
 import os
 import math
 import re
-import shutil
+import time
 import tempfile
 import zipfile
 import subprocess
@@ -20,14 +18,10 @@ import gradio as gr
 
 
 # -------------------------
-# Helpers
+# Subprocess helpers
 # -------------------------
 
-AUDIO_EXTS = {".mp3", ".wav", ".m4a", ".aac", ".flac", ".ogg", ".opus", ".wma", ".aiff", ".alac", ".mp4", ".webm"}
-
-
 def _run(cmd):
-    """Run subprocess command, raise with readable stderr on error."""
     p = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
     if p.returncode != 0:
         raise RuntimeError(f"Command failed:\n{' '.join(cmd)}\n\n{p.stderr.strip()}")
@@ -36,23 +30,19 @@ def _run(cmd):
 
 def ffprobe_info(path: str) -> dict:
     """
-    Extract duration and bitrate info via ffprobe.
-    Returns dict with:
-      duration_sec (float or None),
-      bitrate_bps (int or None),
-      codec_name (str or None),
-      format_name (str or None)
+    Returns:
+      duration_sec: float|None
+      bitrate_bps: int|None   (tries stream bitrate, then format bitrate)
     """
-    # Get duration + format bitrate (if present)
-    cmd = [
+    info = {"duration_sec": None, "bitrate_bps": None}
+
+    # duration + format bitrate
+    out, _ = _run([
         "ffprobe", "-v", "error",
-        "-show_entries", "format=duration,bit_rate,format_name",
+        "-show_entries", "format=duration,bit_rate",
         "-of", "default=noprint_wrappers=1:nokey=0",
         path
-    ]
-    out, _ = _run(cmd)
-    info = {"duration_sec": None, "bitrate_bps": None, "codec_name": None, "format_name": None}
-
+    ])
     for line in out.splitlines():
         if "=" not in line:
             continue
@@ -68,45 +58,36 @@ def ffprobe_info(path: str) -> dict:
                 info["bitrate_bps"] = int(v)
             except Exception:
                 pass
-        elif k == "format_name":
-            info["format_name"] = v
 
-    # Get audio stream codec (optional)
-    cmd2 = [
+    # prefer audio stream bitrate if available
+    out2, _ = _run([
         "ffprobe", "-v", "error",
         "-select_streams", "a:0",
-        "-show_entries", "stream=codec_name,bit_rate",
+        "-show_entries", "stream=bit_rate",
         "-of", "default=noprint_wrappers=1:nokey=0",
         path
-    ]
-    out2, _ = _run(cmd2)
-    # Try to parse codec and stream bitrate (stream bitrate may be more accurate)
-    codec = None
-    stream_br = None
+    ])
     for line in out2.splitlines():
         if "=" not in line:
             continue
         k, v = line.split("=", 1)
-        k, v = k.strip(), v.strip()
-        if k == "codec_name":
-            codec = v
-        elif k == "bit_rate":
+        if k.strip() == "bit_rate":
             try:
-                stream_br = int(v)
+                info["bitrate_bps"] = int(v.strip())
             except Exception:
                 pass
 
-    if codec:
-        info["codec_name"] = codec
-    if stream_br:
-        info["bitrate_bps"] = stream_br
-
     return info
 
 
+def to_kbps(bps: int | None) -> int | None:
+    if not bps:
+        return None
+    return max(1, int(round(bps / 1000)))
+
+
 def sanitize_filename(name: str) -> str:
-    name = re.sub(r"[^\w\-.() ]+", "_", name, flags=re.UNICODE)
-    name = name.strip().strip(".")
+    name = re.sub(r"[^\w\-.() ]+", "_", name, flags=re.UNICODE).strip().strip(".")
     return name or "audio"
 
 
@@ -115,249 +96,197 @@ def format_seconds(s: float) -> str:
     hh = int(s // 3600)
     mm = int((s % 3600) // 60)
     ss = int(s % 60)
-    if hh > 0:
-        return f"{hh:02d}:{mm:02d}:{ss:02d}"
-    return f"{mm:02d}:{ss:02d}"
+    return f"{hh:02d}:{mm:02d}:{ss:02d}" if hh > 0 else f"{mm:02d}:{ss:02d}"
 
 
-def to_kbps(bps: int | None) -> int | None:
-    if not bps:
-        return None
-    return max(1, int(round(bps / 1000)))
-
+# -------------------------
+# Temp cleanup
+# -------------------------
 
-def choose_output_ext(input_path: str, preferred: str) -> str:
+def cleanup_tmpdirs(prefix="audiosplit_", older_than_seconds=6 * 3600):
     """
-    preferred:
-      - "Same as input" -> keep extension
-      - "mp3", "m4a (aac)", "wav", "flac", "ogg (vorbis)", "opus"
+    Best-effort cleanup of temp dirs created by this app.
+    Removes dirs in system temp older than N seconds.
     """
-    in_ext = Path(input_path).suffix.lower()
-    if preferred == "Same as input":
-        return in_ext if in_ext in AUDIO_EXTS else ".mp3"
-    mapping = {
-        "mp3": ".mp3",
-        "m4a (aac)": ".m4a",
-        "wav": ".wav",
-        "flac": ".flac",
-        "ogg (vorbis)": ".ogg",
-        "opus": ".opus",
-    }
-    return mapping.get(preferred, ".mp3")
-
-
-def ffmpeg_codec_args_for_ext(ext: str):
-    """
-    Return (codec_args, container_ext).
-    codec_args used for encoding audio.
-    """
-    ext = ext.lower()
-    if ext == ".mp3":
-        return ["-c:a", "libmp3lame"], ext
-    if ext == ".m4a":
-        return ["-c:a", "aac"], ext
-    if ext == ".wav":
-        # PCM; bitrate selection not applicable
-        return ["-c:a", "pcm_s16le"], ext
-    if ext == ".flac":
-        return ["-c:a", "flac"], ext
-    if ext == ".ogg":
-        return ["-c:a", "libvorbis"], ext
-    if ext == ".opus":
-        return ["-c:a", "libopus"], ext
-    # fallback
-    return ["-c:a", "libmp3lame"], ".mp3"
-
-
-def build_bitrate_arg(ext: str, bitrate_kbps: int | None):
-    """
-    For lossy codecs we can apply -b:a.
-    For wav/flac it doesn't make much sense; we'll ignore.
-    """
-    ext = ext.lower()
-    if bitrate_kbps is None:
-        return []
-    if ext in {".wav", ".flac"}:
-        return []
-    # common, flexible range 8..320 (or more for some codecs, but per your request)
-    bitrate_kbps = int(max(8, min(320, bitrate_kbps)))
-    return ["-b:a", f"{bitrate_kbps}k"]
+    tmp_root = Path(tempfile.gettempdir())
+    now = time.time()
+    for p in tmp_root.glob(prefix + "*"):
+        try:
+            if not p.is_dir():
+                continue
+            age = now - p.stat().st_mtime
+            if age > older_than_seconds:
+                # avoid importing shutil globally; but it's fine:
+                import shutil
+                shutil.rmtree(p, ignore_errors=True)
+        except Exception:
+            pass
 
 
 # -------------------------
-# Main processing
+# Main logic
 # -------------------------
 
-def split_and_zip(
-    file_obj,
-    chunk_seconds: int,
-    quality_mode: str,
-    custom_bitrate_kbps: int,
-    output_format: str
-):
-    if file_obj is None:
+def split_and_zip(file_path: str, chunk_seconds: int, quality_mode: str, custom_kbps: int):
+    if not file_path or not os.path.exists(file_path):
         raise gr.Error("Загрузите аудиофайл.")
 
-    in_path = file_obj if isinstance(file_obj, str) else getattr(file_obj, "name", None)
-    if not in_path or not os.path.exists(in_path):
-        raise gr.Error("Не удалось прочитать загруженный файл.")
-
     try:
         chunk_seconds = int(chunk_seconds)
     except Exception:
         raise gr.Error("Длина фрагмента должна быть целым числом (секунды).")
-
     if chunk_seconds <= 0:
-        raise gr.Error("Длина фрагмента должна быть > 0 секунд.")
+        raise gr.Error("Длина фрагмента должна быть больше 0.")
+
+    cleanup_tmpdirs()  # occasional cleanup
 
-    info = ffprobe_info(in_path)
+    info = ffprobe_info(file_path)
     duration = info.get("duration_sec")
     src_kbps = to_kbps(info.get("bitrate_bps"))
 
     if duration is None:
-        raise gr.Error("Не удалось определить длительность файла (проверьте ffmpeg/ffprobe и формат файла).")
-
-    out_ext = choose_output_ext(in_path, output_format)
-    codec_args, out_ext = ffmpeg_codec_args_for_ext(out_ext)
+        raise gr.Error("Не удалось определить длительность файла. Проверьте ffmpeg/ffprobe и формат.")
 
-    # Determine bitrate for output
-    bitrate_kbps = None
+    # bitrate selection
     if quality_mode == "Auto (same as source)":
-        bitrate_kbps = src_kbps  # may be None
+        out_kbps = src_kbps if src_kbps else 192
+        out_quality_text = f"Auto → {out_kbps} kbps" + ("" if src_kbps else " (fallback)")
     else:
-        bitrate_kbps = int(custom_bitrate_kbps)
-
-    # If auto but unknown -> choose a reasonable default for lossy formats
-    if quality_mode == "Auto (same as source)" and bitrate_kbps is None:
-        # Conservative default
-        bitrate_kbps = 192 if out_ext not in {".wav", ".flac"} else None
-
-    bitrate_args = build_bitrate_arg(out_ext, bitrate_kbps)
+        out_kbps = int(max(8, min(320, int(custom_kbps))))
+        out_quality_text = f"Custom → {out_kbps} kbps"
 
-    base = sanitize_filename(Path(in_path).stem)
+    base = sanitize_filename(Path(file_path).stem)
 
     tmpdir = tempfile.mkdtemp(prefix="audiosplit_")
-    outdir = os.path.join(tmpdir, "parts")
-    os.makedirs(outdir, exist_ok=True)
+    parts_dir = os.path.join(tmpdir, "parts")
+    os.makedirs(parts_dir, exist_ok=True)
 
     total_parts = int(math.ceil(duration / chunk_seconds))
     digits = max(3, len(str(total_parts)))
 
-    # We'll re-encode chunks (most compatible and consistent length).
-    # For some formats you could do stream copy, but then exact cut points are not guaranteed.
-    created_files = []
+    created = []
+    for i in range(total_parts):
+        start = i * chunk_seconds
+        remaining = max(0.0, duration - start)
+        this_len = min(float(chunk_seconds), remaining)
 
-    try:
-        for i in range(total_parts):
-            start = i * chunk_seconds
-            remaining = max(0.0, duration - start)
-            this_len = min(float(chunk_seconds), remaining)
-
-            out_name = f"{base}_part_{str(i+1).zfill(digits)}_{format_seconds(start)}-{format_seconds(start+this_len)}{out_ext}"
-            out_path = os.path.join(outdir, out_name)
-
-            cmd = [
-                "ffmpeg", "-y",
-                "-ss", str(start),
-                "-t", str(this_len),
-                "-i", in_path,
-                *codec_args,
-                *bitrate_args,
-                "-vn",  # no video
-                out_path
-            ]
-            _run(cmd)
-            created_files.append(out_path)
-
-        # Create zip
-        zip_path = os.path.join(tmpdir, f"{base}_split_{chunk_seconds}s.zip")
-        with zipfile.ZipFile(zip_path, "w", compression=zipfile.ZIP_DEFLATED) as zf:
-            for p in created_files:
-                zf.write(p, arcname=os.path.basename(p))
-
-        # Build status text
-        src_br_txt = f"{src_kbps} kbps" if src_kbps else "не удалось определить"
-        out_br_txt = "как в источнике" if quality_mode == "Auto (same as source)" else f"{custom_bitrate_kbps} kbps"
-        if out_ext in {".wav", ".flac"}:
-            out_br_txt += " (для WAV/FLAC параметр kbps не применяется)"
-
-        status = (
-            f"Файл: {Path(in_path).name}\n"
-            f"Длительность: {duration:.2f} сек\n"
-            f"Чанки: {chunk_seconds} сек\n"
-            f"Количество частей: {total_parts}\n"
-            f"Качество источника (битрейт): {src_br_txt}\n"
-            f"Выходной формат: {out_ext}\n"
-            f"Выходное качество: {out_br_txt}\n"
+        out_name = (
+            f"{base}_part_{str(i+1).zfill(digits)}_"
+            f"{format_seconds(start)}-{format_seconds(start+this_len)}.mp3"
         )
+        out_path = os.path.join(parts_dir, out_name)
+
+        # Re-encode to mp3 for consistent output and compatibility
+        cmd = [
+            "ffmpeg", "-y",
+            "-ss", str(start),
+            "-t", str(this_len),
+            "-i", file_path,
+            "-vn",
+            "-c:a", "libmp3lame",
+            "-b:a", f"{out_kbps}k",
+            out_path
+        ]
+        _run(cmd)
+        created.append(out_path)
+
+    zip_path = os.path.join(tmpdir, f"{base}_split_{chunk_seconds}s_mp3.zip")
+    with zipfile.ZipFile(zip_path, "w", compression=zipfile.ZIP_DEFLATED) as zf:
+        for p in created:
+            zf.write(p, arcname=os.path.basename(p))
+
+    src_txt = f"{src_kbps} kbps" if src_kbps else "не удалось определить"
+    status = (
+        f"Файл: {Path(file_path).name}\n"
+        f"Длительность: {duration:.2f} сек\n"
+        f"Фрагмент: {chunk_seconds} сек\n"
+        f"Частей: {total_parts}\n"
+        f"Битрейт источника: {src_txt}\n"
+        f"Выход: mp3\n"
+        f"Качество: {out_quality_text}\n"
+        f"ZIP готов."
+    )
 
-        return zip_path, status
-
-    finally:
-        # Important: Gradio needs the returned file to still exist.
-        # So we cannot delete tmpdir immediately here.
-        # Gradio will copy the file for download; to avoid leaks, we can schedule cleanup
-        # when process exits. As a simple approach: do nothing here.
-        # If you want aggressive cleanup, implement background cleanup with a delay.
-        pass
+    return zip_path, status
 
 
 # -------------------------
-# UI
+# UI (mobile-friendly)
 # -------------------------
 
-css = """
+CSS = """
+:root { --text-lg: 18px; --text-md: 16px; }
 #app { max-width: 980px; margin: 0 auto; }
-.small { font-size: 12px; opacity: 0.85; }
+#title h2 { font-size: 22px; margin-bottom: 6px; }
+.gradio-container { font-size: var(--text-md); }
+label, .wrap, .prose { font-size: var(--text-md) !important; }
+textarea, input, button { font-size: var(--text-md) !important; }
+button { padding: 12px 16px !important; }
+.smallnote { font-size: 13px; opacity: 0.85; }
+
+@media (max-width: 640px) {
+  #app { padding: 10px; }
+  #title h2 { font-size: 20px; }
+  .gradio-container { font-size: var(--text-lg); }
+  label, textarea, input, button { font-size: var(--text-lg) !important; }
+}
 """
 
-with gr.Blocks(css=css) as demo:
-    gr.Markdown("## Audio Splitter → ZIP\nЗагрузите большой аудиофайл, задайте длину фрагмента и качество, получите ZIP-архив с частями.")
+with gr.Blocks() as demo:
+    with gr.Column(elem_id="app"):
+        gr.Markdown("## Audio Splitter → ZIP (mp3)", elem_id="title")
+        gr.Markdown(
+            "<div class='smallnote'>"
+            "Загрузите аудиофайл, задайте длину фрагмента в секундах. "
+            "На выходе будет ZIP с mp3-частями."
+            "</div>"
+        )
 
-    with gr.Row():
         inp = gr.File(label="Аудиофайл", file_count="single", type="filepath")
-    with gr.Row():
+
         chunk_seconds = gr.Number(label="Длина одного фрагмента (сек)", value=10, precision=0)
-        output_format = gr.Dropdown(
-            label="Выходной формат",
-            value="Same as input",
-            choices=["Same as input", "mp3", "m4a (aac)", "wav", "flac", "ogg (vorbis)", "opus"]
-        )
 
-    with gr.Row():
         quality_mode = gr.Radio(
             label="Качество (битрейт)",
             choices=["Auto (same as source)", "Custom (8..320 kbps)"],
             value="Auto (same as source)"
         )
-        custom_bitrate_kbps = gr.Slider(
+
+        custom_bitrate = gr.Slider(
             label="Custom bitrate (kbps)",
-            minimum=8, maximum=320, value=192, step=1
+            minimum=8, maximum=320, value=192, step=1,
+            visible=False, interactive=True
         )
 
-    gr.Markdown(
-        "<div class='small'>"
-        "Подсказка: режим Auto пытается взять битрейт из источника через ffprobe. "
-        "Если битрейт не определяется, будет выбран дефолт 192 kbps (для lossy форматов)."
-        "</div>"
-    )
+        gr.Markdown(
+            "<div class='smallnote'>"
+            "Auto: пытаемся взять битрейт из исходника через ffprobe. Если не получилось — 192 kbps."
+            "</div>"
+        )
 
-    btn = gr.Button("Split & Download ZIP", variant="primary")
+        btn = gr.Button("Split & Download ZIP", variant="primary")
 
-    out_zip = gr.File(label="ZIP архив (скачать)")
-    status = gr.Textbox(label="Статус", lines=8)
+        out_zip = gr.File(label="ZIP архив (скачать)")
+        status = gr.Textbox(label="Статус", lines=8)
 
-    def _toggle_slider(mode):
-        return gr.update(interactive=(mode != "Auto (same as source)"))
+    def toggle_custom(mode):
+        return gr.update(visible=(mode.startswith("Custom")))
 
-    quality_mode.change(_toggle_slider, inputs=quality_mode, outputs=custom_bitrate_kbps)
+    quality_mode.change(toggle_custom, inputs=quality_mode, outputs=custom_bitrate)
 
     btn.click(
         split_and_zip,
-        inputs=[inp, chunk_seconds, quality_mode, custom_bitrate_kbps, output_format],
+        inputs=[inp, chunk_seconds, quality_mode, custom_bitrate],
         outputs=[out_zip, status]
     )
 
 if __name__ == "__main__":
-    # You can set share=True if you want a public link.
-    demo.launch(server_name="0.0.0.0", server_port=7860)
+    # Key changes:
+    # - css moved to launch() to avoid warning
+    # - ssr_mode disabled to remove SSR experimental mode
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        ssr_mode=False,
+        css=CSS
+    )