Upload 8 files

app.py

@@ -109,7 +109,7 @@ def _load_model() -> Any | None:
         )
         from safetensors.torch import load_file
     except Exception as exc:
-        MODEL_ERROR = f"Dépendances MuScriptor indisponibles : {type(exc).__name__}: {exc}"
+        MODEL_ERROR = f"MuScriptor dependencies are unavailable: {type(exc).__name__}: {exc}"
         return None
 
     NoteStartEvent = _NoteStartEvent
@@ -120,8 +120,8 @@ def _load_model() -> Any | None:
     token = os.environ.get("HF_TOKEN")
     if not token:
         MODEL_ERROR = (
-            "HF_TOKEN absent. Acceptez la licence du modèle MuScriptor medium, "
-            "puis ajoutez un secret HF_TOKEN en lecture dans les réglages du Space."
+            "HF_TOKEN is missing. Accept the MuScriptor large model license, then "
+            "add a read-only HF_TOKEN secret in the Space settings."
         )
         return None
 
@@ -144,18 +144,18 @@ def _load_model() -> Any | None:
         tokenizer = MT3Tokenizer(instrument_vocabulary="MT3_FULL_PLUS", max_shift_steps=1001)
         return TranscriptionModel(model=model, tokenizer=tokenizer, device=device)
     except Exception as exc:
-        MODEL_ERROR = f"Chargement du modèle impossible : {type(exc).__name__}: {exc}"
+        MODEL_ERROR = f"The model could not be loaded: {type(exc).__name__}: {exc}"
         return None
 
 
 if os.environ.get("MUSCRIPTOR_SKIP_MODEL_LOAD") != "1":
     started = time.perf_counter()
-    print(f"[MuScriptor Studio] Chargement du modèle {MODEL_VARIANT}…", flush=True)
+    print(f"[MuScriptor Studio] Loading the {MODEL_VARIANT} model…", flush=True)
     MODEL = _load_model()
     if MODEL is None:
-        print(f"[MuScriptor Studio] Mode interface uniquement : {MODEL_ERROR}", file=sys.stderr, flush=True)
+        print(f"[MuScriptor Studio] Interface-only mode: {MODEL_ERROR}", file=sys.stderr, flush=True)
     else:
-        print(f"[MuScriptor Studio] Modèle prêt en {time.perf_counter() - started:.2f}s.", flush=True)
+        print(f"[MuScriptor Studio] Model ready in {time.perf_counter() - started:.2f}s.", flush=True)
 
 
 def _audio_path(value: Any) -> str | None:
@@ -217,7 +217,7 @@ def _color_for(name: str) -> str:
 
 
 def _slug(name: str) -> str:
-    return re.sub(r"[^a-z0-9]+", "-", name.lower()).strip("-") or "piste"
+    return re.sub(r"[^a-z0-9]+", "-", name.lower()).strip("-") or "track"
 
 
 def _data_uri(data: bytes, mime: str = "audio/midi") -> str:
@@ -328,7 +328,7 @@ def _event_for_instrument(event: Any, instrument: str) -> bool:
 
 def _write_midi_outputs(events: list[Any], track_names: list[str]) -> tuple[Path, dict[str, Path], bytes, dict[str, bytes]]:
     if MODEL is None:
-        raise RuntimeError(MODEL_ERROR or "Modèle non chargé.")
+        raise RuntimeError(MODEL_ERROR or "Model not loaded.")
     output_dir = Path(tempfile.mkdtemp(prefix="muscriptor-midi-"))
     full_bytes = MODEL.events_to_midi_bytes(iter(events))
     full_path = output_dir / "transcription-complete.mid"
@@ -389,17 +389,17 @@ def transcribe_audio(
 ]:
     path = _audio_path(audio)
     if not path:
-        yield _error_result("Importez un fichier audio avant de lancer la transcription.")
+        yield _error_result("Upload an audio file before starting transcription.")
         return
 
     audio_name = Path(path).name
     duration = _audio_duration(path)
     if duration <= 0:
-        yield _error_result("La durée du fichier audio n’a pas pu être déterminée.", audio_name, original_audio=path)
+        yield _error_result("The audio duration could not be determined.", audio_name, original_audio=path)
         return
     if duration > MAX_AUDIO_SECONDS:
         yield _error_result(
-            f"Ce Space accepte des enregistrements de {MAX_AUDIO_SECONDS / 60:.1f} minutes maximum.",
+            f"This Space accepts recordings up to {MAX_AUDIO_SECONDS / 60:.1f} minutes.",
             audio_name,
             duration,
             path,
@@ -407,7 +407,7 @@ def transcribe_audio(
         return
     if MODEL is None:
         yield _error_result(
-            MODEL_ERROR or "Le modèle MuScriptor n’est pas disponible.",
+            MODEL_ERROR or "The MuScriptor model is unavailable.",
             audio_name,
             duration,
             path,
@@ -440,9 +440,9 @@ def transcribe_audio(
             tracks = _track_payloads(notes, requested)
             fraction = event.completed / max(1, event.total)
             status = (
-                "ZeroGPU prêt · préparation de la première fenêtre"
+                "ZeroGPU ready · preparing the first five-second window"
                 if event.completed == 0
-                else f"Fenêtre {event.completed}/{event.total} transcrite"
+                else f"Transcribed window {event.completed}/{event.total}"
             )
             viewer = _viewer_payload(
                 state="transcribing",
@@ -470,7 +470,7 @@ def transcribe_audio(
         tracks = _track_payloads(notes, midi_by_instrument=midi_by_instrument)
         viewer = _viewer_payload(
             state="complete",
-            status=f"Transcription terminée en {elapsed:.1f} s · partition disponible sur demande",
+            status=f"Transcription complete in {elapsed:.1f}s · score available on demand",
             progress=1,
             audio_name=audio_name,
             elapsed=elapsed,
@@ -499,7 +499,7 @@ def transcribe_audio(
         )
     except Exception as exc:
         elapsed = time.perf_counter() - started
-        message = f"Transcription interrompue : {type(exc).__name__}: {exc}"
+        message = f"Transcription stopped: {type(exc).__name__}: {exc}"
         print(f"[MuScriptor Studio] {message}", file=sys.stderr, flush=True)
         tracks = _track_payloads(_notes_from_events(events), requested)
         viewer = _viewer_payload(
@@ -521,8 +521,36 @@ def transcribe_audio(
         )
 
 
-def reset_score_outputs() -> tuple[None, None, None, dict[str, Any]]:
-    return None, None, None, gr.update(interactive=False)
+def reset_score_outputs(audio: Any) -> tuple[Any, ...]:
+    """Clear the previous session immediately, before ZeroGPU enters its queue."""
+
+    path = _audio_path(audio)
+    audio_name = Path(path).name if path else ""
+    duration = _audio_duration(path) if path else 0.0
+    viewer = _viewer_payload(
+        state="queued" if path else "idle",
+        status=(
+            "Request sent · waiting for a ZeroGPU worker"
+            if path
+            else "Upload a recording to begin."
+        ),
+        progress=0.01 if path else 0,
+        audio_name=audio_name,
+        elapsed=0,
+        duration=duration,
+        tracks=[],
+    )
+    return (
+        path,
+        None,
+        None,
+        None,
+        None,
+        None,
+        viewer,
+        {},
+        gr.update(interactive=False),
+    )
 
 
 def finalize_notation(
@@ -550,7 +578,7 @@ def finalize_notation(
         updated.update(
             {
                 "state": "ready",
-                "status": "Transcription et partition prêtes",
+                "status": "Transcription and score are ready",
                 "score_svg": result.preview_svg,
                 "score_pages": len(result.svg_pages),
                 "notation": {
@@ -572,98 +600,163 @@ def finalize_notation(
     except Exception as exc:
         updated = dict(viewer)
         updated["state"] = "notation_error"
-        updated["status"] = f"MIDI prêt, mais partition non générée : {type(exc).__name__}: {exc}"
+        updated["status"] = f"MIDI is ready, but the score could not be generated: {type(exc).__name__}: {exc}"
         return None, None, None, updated
 
 
 APP_CSS = (ROOT / "frontend" / "app.css").read_text(encoding="utf-8")
 
-INSTRUMENT_CHOICES = [(_display_name(name), name) for name in sorted(INSTRUMENT_NAMES)]
+INSTRUMENT_CHOICES = [(_display_name(name), name) for name in INSTRUMENT_NAMES]
 
 HEADER = """
-<header class="studio-masthead">
-  <div class="studio-brand"><span class="studio-logo">♫</span><div><strong>MuScriptor Studio</strong><small>Audio multipiste vers MIDI et partition</small></div></div>
-  <div class="studio-badges"><span class="model-badge">Large · 1.4B</span><span class="gpu-badge">ZeroGPU</span></div>
+<header class="masthead-inner">
+  <a class="brand" href="https://github.com/muscriptor/muscriptor" target="_blank" rel="noreferrer">
+    <span class="brand-mark" aria-hidden="true"><i></i><i></i><i></i><i></i></span>
+    <span>MuScriptor Studio</span>
+  </a>
+  <div class="header-meta">
+    <span id="model-badge"><b></b> Large · 1.4B</span>
+    <span class="zerogpu-badge">ZeroGPU</span>
+  </div>
 </header>
 """
 
+INTRO = """
+<div class="intro-copy">
+  <span class="eyebrow">Multitrack transcription</span>
+  <h1>Turn a recording into<br><em>editable music.</em></h1>
+  <p>Separate a performance into instrument-aware MIDI tracks, inspect every note, compare it with the original recording and create an editable score.</p>
+</div>
+"""
+
+UPLOAD_HEADING = f"""
+<div class="section-heading">
+  <span class="step-number">01</span>
+  <div><h2>Choose audio</h2><p>WAV, MP3, FLAC or OGG · up to {MAX_AUDIO_SECONDS / 60:.0f} minutes</p></div>
+</div>
+"""
+
+RESULT_HEADING = """
+<div class="section-heading result-heading">
+  <span class="step-number">02</span>
+  <div><h2>Transcription studio</h2><p>Original/MIDI comparison, isolated tracks and notation</p></div>
+</div>
+"""
+
+FOOTNOTE = """
+<div class="footnote">
+  <span>Audio is processed ephemerally and is not retained.</span>
+  <span>MuScriptor Large · ZeroGPU · CC BY-NC 4.0 weights</span>
+</div>
+"""
+
 with gr.Blocks(title="MuScriptor Studio") as demo:
-    gr.HTML(HEADER)
-    with gr.Row(elem_id="input-grid", equal_height=True):
-        with gr.Column(scale=7, min_width=360, elem_classes="input-card"):
-            gr.Markdown(
-                f"### 1. Importer un enregistrement\n"
-                f"Déposez un morceau de {MAX_AUDIO_SECONDS / 60:.0f} minutes maximum."
-            )
-            audio_input = gr.Audio(
-                label="Audio source",
-                sources=["upload"],
-                type="filepath",
-                format="wav",
-                elem_id="audio-input",
-            )
-            transcribe_button = gr.Button(
-                "Transcrire le morceau",
-                variant="primary",
-                size="lg",
-                elem_id="transcribe-button",
-            )
-        with gr.Column(scale=5, min_width=320, elem_classes="settings-card"):
-            gr.Markdown("### 2. Paramètres")
-            instrument_input = gr.CheckboxGroup(
-                choices=INSTRUMENT_CHOICES,
-                value=[],
-                label="Known instruments",
-                info="Optional — leave empty for automatic discovery.",
-            )
-            with gr.Accordion("Décodage avancé", open=False):
-                use_sampling_input = gr.Checkbox(label="Décodage créatif", value=False)
-                temperature_input = gr.Slider(0.2, 1.4, value=1.0, step=0.1, label="Température")
-                beam_size_input = gr.Slider(
-                    1,
-                    4,
-                    value=1,
-                    step=1,
-                    label="Largeur du beam",
-                    info="Conservez 1 pour les morceaux longs ; 2–4 multiplient le temps GPU.",
+    with gr.Column(elem_id="app-shell"):
+        gr.HTML(HEADER, elem_id="masthead")
+        gr.HTML(INTRO, elem_id="intro")
+
+        with gr.Row(elem_id="studio-grid", equal_height=False):
+            with gr.Column(scale=4, min_width=320, elem_id="upload-card"):
+                gr.HTML(UPLOAD_HEADING)
+                audio_input = gr.Audio(
+                    label="Drop audio here",
+                    sources=["upload"],
+                    type="filepath",
+                    elem_id="audio-input",
                 )
-            with gr.Accordion("Partition", open=True):
-                with gr.Row():
-                    tempo_input = gr.Number(value=120, minimum=20, maximum=300, label="Tempo (BPM)")
-                    time_signature_input = gr.Dropdown(
-                        ["4/4", "3/4", "6/8", "2/4", "12/8"], value="4/4", label="Mesure"
+                with gr.Accordion(
+                    "Guide the transcription",
+                    open=False,
+                    elem_id="advanced-settings",
+                ):
+                    instrument_input = gr.CheckboxGroup(
+                        choices=INSTRUMENT_CHOICES,
+                        value=[],
+                        label="Known instruments",
+                        info="Optional — leave empty for automatic discovery.",
                     )
-                quantization_input = gr.Radio(
-                    ["1/8", "1/16", "1/32"], value="1/16", label="Quantification"
+                    use_sampling_input = gr.Checkbox(
+                        label="Creative decoding",
+                        value=False,
+                        info="Use stochastic sampling instead of deterministic decoding.",
+                    )
+                    temperature_input = gr.Slider(
+                        0.2,
+                        1.4,
+                        value=1.0,
+                        step=0.1,
+                        label="Temperature",
+                    )
+                    beam_size_input = gr.Slider(
+                        1,
+                        4,
+                        value=1,
+                        step=1,
+                        label="Beam width",
+                        info="1 is fastest. Widths 2–4 multiply GPU time.",
+                    )
+                transcribe_button = gr.Button(
+                    "Transcribe audio",
+                    variant="primary",
+                    size="lg",
+                    elem_id="transcribe-button",
                 )
-                solfege_input = gr.Checkbox(label="Afficher Do Ré Mi", value=False)
-                generate_score_button = gr.Button(
-                    "Generate score from transcription",
-                    variant="secondary",
+                gr.HTML(
+                    '<p class="cold-note"><span></span> The first run can take a moment while ZeroGPU restores the model.</p>'
+                )
+
+            with gr.Column(scale=7, min_width=420, elem_id="result-panel"):
+                gr.HTML(RESULT_HEADING)
+                session_state = gr.State(value={})
+                viewer = StudioViewer(elem_id="studio-viewer")
+                original_audio_output = gr.Audio(
+                    label="Original audio playback",
                     interactive=False,
-                    elem_id="generate-score-button",
+                    visible="hidden",
+                    elem_id="original-audio-output",
                 )
 
-    session_state = gr.State(value={})
-    viewer = StudioViewer(elem_id="studio-viewer")
-    original_audio_output = gr.Audio(
-        label="Original audio playback",
-        interactive=False,
-        visible="hidden",
-        elem_id="original-audio-output",
-    )
+                with gr.Accordion("Create an editable score", open=False, elem_id="score-settings"):
+                    with gr.Row():
+                        tempo_input = gr.Number(value=120, minimum=20, maximum=300, label="Tempo (BPM)")
+                        time_signature_input = gr.Dropdown(
+                            ["4/4", "3/4", "6/8", "2/4", "12/8"], value="4/4", label="Time signature"
+                        )
+                    quantization_input = gr.Radio(
+                        ["1/8", "1/16", "1/32"], value="1/16", label="Quantization"
+                    )
+                    solfege_input = gr.Checkbox(label="Show solfège names (Do, Ré, Mi)", value=False)
+                    generate_score_button = gr.Button(
+                        "Generate score from transcription",
+                        variant="secondary",
+                        interactive=False,
+                        elem_id="generate-score-button",
+                    )
+
+                with gr.Accordion("All downloads", open=False, elem_id="downloads-panel"):
+                    with gr.Row(elem_id="downloads-row"):
+                        full_midi_output = gr.File(label="Full MIDI")
+                        track_midi_output = gr.File(label="MIDI by instrument", file_count="multiple")
+                        musicxml_output = gr.File(label="MusicXML")
+                        pdf_output = gr.File(label="Score PDF")
+                        bundle_output = gr.File(label="All exports (.zip)")
 
-    with gr.Accordion("Downloads", open=False, elem_id="downloads-panel"):
-        with gr.Row(elem_id="downloads-row"):
-            full_midi_output = gr.File(label="Full MIDI")
-            track_midi_output = gr.File(label="MIDI by instrument", file_count="multiple")
-            musicxml_output = gr.File(label="MusicXML")
-            pdf_output = gr.File(label="Score PDF")
-            bundle_output = gr.File(label="All exports (.zip)")
+        gr.HTML(FOOTNOTE)
 
     preflight = transcribe_button.click(
         reset_score_outputs,
-        outputs=[musicxml_output, pdf_output, bundle_output, generate_score_button],
+        inputs=[audio_input],
+        outputs=[
+            original_audio_output,
+            full_midi_output,
+            track_midi_output,
+            musicxml_output,
+            pdf_output,
+            bundle_output,
+            viewer,
+            session_state,
+            generate_score_button,
+        ],
         queue=False,
         show_progress="hidden",
     )
@@ -704,5 +797,11 @@ if __name__ == "__main__":
     demo.launch(
         css=APP_CSS,
         theme=gr.themes.Base(primary_hue="violet", neutral_hue="slate"),
-        footer_links=["gradio"],
+        js="""() => {
+          document.documentElement.classList.add('dark');
+          document.body.classList.add('dark');
+          document.body.style.background = '#090b0f';
+          try { localStorage.setItem('theme', 'dark'); } catch (_) {}
+        }""",
+        footer_links=[],
     )

studio_component.py

@@ -18,7 +18,7 @@ def _read_frontend(name: str) -> str:
 def initial_studio_value() -> dict[str, Any]:
     return {
         "state": "idle",
-        "status": "Importez un enregistrement pour commencer.",
+        "status": "Upload a recording to begin.",
         "progress": 0,
         "audio_name": "",
         "elapsed": 0,
@@ -45,7 +45,6 @@ class StudioViewer(gr.HTML):
             js_on_load=f"{synth_bundle}\n{viewer_script}",
             apply_default_css=False,
             container=False,
-            min_height=780,
             **kwargs,
         )
 

studio_component.pyi

@@ -46,7 +46,6 @@ class StudioViewer(gr.HTML):
             js_on_load=f"{synth_bundle}\n{viewer_script}",
             apply_default_css=False,
             container=False,
-            min_height=780,
             **kwargs,
         )