Upload 6 files

app.py

@@ -0,0 +1,617 @@
+from __future__ import annotations
+
+import os
+
+# ZeroGPU and third-party caches must be configured before importing libraries.
+os.environ.setdefault("HF_HOME", "/tmp/.cache/huggingface")
+os.environ.setdefault("HF_MODULES_CACHE", "/tmp/hf_modules")
+os.environ.setdefault("MPLCONFIGDIR", "/tmp/matplotlib")
+os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
+
+try:  # ZeroGPU requires spaces to be imported before torch.
+    import spaces
+except ImportError:  # Local UI and tests work without the ZeroGPU package.
+    class _SpacesFallback:
+        @staticmethod
+        def GPU(duration=None):
+            def decorate(function):
+                return function
+
+            return decorate
+
+    spaces = _SpacesFallback()  # type: ignore[assignment]
+
+import base64
+import hashlib
+import math
+import re
+import sys
+import tempfile
+import time
+from collections import defaultdict
+from pathlib import Path
+from typing import Any, Iterator
+
+import gradio as gr
+
+from notation import file_data_uri, generate_notation
+from studio_component import StudioViewer, initial_studio_value, normalize_viewer_value
+
+
+ROOT = Path(__file__).resolve().parent
+MODEL_ID = "MuScriptor/muscriptor-medium"
+MODEL_VARIANT = "medium"
+MAX_AUDIO_SECONDS = 60.0
+GPU_BASE_SECONDS = 24
+GPU_SECONDS_PER_CHUNK = 7
+GPU_DURATION_CAP = 120
+
+COLORS = (
+    "#35c8ff",
+    "#f6a623",
+    "#fb7185",
+    "#9b87f5",
+    "#67e8a5",
+    "#60a5fa",
+    "#f472b6",
+    "#a3e635",
+    "#2dd4bf",
+    "#f6c667",
+)
+
+FALLBACK_INSTRUMENTS = (
+    "acoustic_piano",
+    "electric_piano",
+    "clean_electric_guitar",
+    "distorted_electric_guitar",
+    "acoustic_guitar",
+    "electric_bass",
+    "acoustic_bass",
+    "violin",
+    "viola",
+    "cello",
+    "strings",
+    "trumpet",
+    "trombone",
+    "flutes",
+    "clarinet",
+    "soprano_and_alto_sax",
+    "tenor_sax",
+    "voice",
+    "drums",
+)
+
+
+MODEL: Any | None = None
+MODEL_ERROR = ""
+NoteStartEvent: Any = None
+NoteEndEvent: Any = None
+ProgressEvent: Any = None
+INSTRUMENT_NAMES = list(FALLBACK_INSTRUMENTS)
+
+
+def _load_model() -> Any | None:
+    global MODEL_ERROR, NoteStartEvent, NoteEndEvent, ProgressEvent, INSTRUMENT_NAMES
+    try:
+        import torch
+        from huggingface_hub import hf_hub_download
+        from muscriptor.events import NoteEndEvent as _NoteEndEvent
+        from muscriptor.events import NoteStartEvent as _NoteStartEvent
+        from muscriptor.events import ProgressEvent as _ProgressEvent
+        from muscriptor.tokenizer.mt3 import MT3Tokenizer, MT3_FULL_PLUS_GROUP_NAMES
+        from muscriptor.transcription_model import (
+            TranscriptionModel,
+            _build_model,
+            _remap_single_codebook_keys,
+            _resolve_config,
+            _resolve_source,
+        )
+        from safetensors.torch import load_file
+    except Exception as exc:
+        MODEL_ERROR = f"Dépendances MuScriptor indisponibles : {type(exc).__name__}: {exc}"
+        return None
+
+    NoteStartEvent = _NoteStartEvent
+    NoteEndEvent = _NoteEndEvent
+    ProgressEvent = _ProgressEvent
+    INSTRUMENT_NAMES = list(MT3_FULL_PLUS_GROUP_NAMES)
+
+    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."
+        )
+        return None
+
+    try:
+        source = _resolve_source(MODEL_VARIANT)
+        weights_path = Path(
+            hf_hub_download(
+                repo_id=MODEL_ID,
+                filename="model.safetensors",
+                token=token,
+            )
+        )
+        config = _resolve_config(source, weights_path)
+        device = torch.device("cuda")
+        model = _build_model(device, config)
+        model.eval()
+        state_dict = _remap_single_codebook_keys(load_file(str(weights_path), device="cpu"))
+        model.load_state_dict(state_dict)
+        model.to("cuda")
+        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}"
+        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)
+    MODEL = _load_model()
+    if MODEL is None:
+        print(f"[MuScriptor Studio] Mode interface uniquement : {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)
+
+
+def _audio_path(value: Any) -> str | None:
+    if value is None:
+        return None
+    if isinstance(value, (str, Path)):
+        return str(value)
+    if isinstance(value, dict):
+        path = value.get("path") or value.get("name")
+        return str(path) if path else None
+    path = getattr(value, "path", None) or getattr(value, "name", None)
+    return str(path) if path else None
+
+
+def _audio_duration(path: str | None) -> float:
+    if not path:
+        return 0.0
+    try:
+        import soundfile as sf
+
+        return float(sf.info(path).duration)
+    except Exception:
+        return 0.0
+
+
+def _estimate_gpu_duration(
+    audio: Any,
+    instruments: list[str] | None = None,
+    use_sampling: bool = False,
+    temperature: float = 1.0,
+    beam_size: int = 1,
+    *args: Any,
+    **kwargs: Any,
+) -> int:
+    duration = _audio_duration(_audio_path(audio)) or 15.0
+    chunks = max(1, math.ceil(duration / 5.0))
+    beam = max(1, min(4, int(beam_size or 1)))
+    return min(GPU_DURATION_CAP, GPU_BASE_SECONDS + chunks * GPU_SECONDS_PER_CHUNK * beam)
+
+
+def _display_name(name: str) -> str:
+    special = {
+        "drums": "Batterie",
+        "voice": "Voix",
+        "flutes": "Flûtes",
+        "electric_bass": "Basse électrique",
+        "acoustic_bass": "Contrebasse",
+        "acoustic_piano": "Piano acoustique",
+        "electric_piano": "Piano électrique",
+        "soprano_and_alto_sax": "Saxophone soprano / alto",
+        "tenor_sax": "Saxophone ténor",
+    }
+    return special.get(name, name.replace("_", " ").capitalize())
+
+
+def _color_for(name: str) -> str:
+    digest = hashlib.sha1(name.encode("utf-8")).digest()
+    return COLORS[int.from_bytes(digest[:2], "big") % len(COLORS)]
+
+
+def _slug(name: str) -> str:
+    return re.sub(r"[^a-z0-9]+", "-", name.lower()).strip("-") or "piste"
+
+
+def _data_uri(data: bytes, mime: str = "audio/midi") -> str:
+    return f"data:{mime};base64,{base64.b64encode(data).decode('ascii')}"
+
+
+def _program_for(name: str) -> int:
+    if name == "drums" or MODEL is None:
+        return 0
+    try:
+        return int(MODEL._program_for_instrument(name))
+    except Exception:
+        return 0
+
+
+def _notes_from_events(events: list[Any]) -> dict[str, list[dict[str, float | int]]]:
+    notes: dict[str, list[dict[str, float | int]]] = defaultdict(list)
+    if NoteEndEvent is None:
+        return {}
+    for event in events:
+        if not isinstance(event, NoteEndEvent):
+            continue
+        start = event.start_event
+        notes[start.instrument].append(
+            {
+                "pitch": int(start.pitch),
+                "start": round(float(start.start_time), 4),
+                "end": round(max(float(event.end_time), float(start.start_time) + 0.03), 4),
+                "velocity": 100,
+            }
+        )
+    for values in notes.values():
+        values.sort(key=lambda item: (item["start"], item["pitch"]))
+    return dict(notes)
+
+
+def _track_payloads(
+    notes: dict[str, list[dict[str, float | int]]],
+    requested: list[str] | None = None,
+    midi_by_instrument: dict[str, bytes] | None = None,
+) -> list[dict[str, Any]]:
+    names = set(notes)
+    names.update(requested or [])
+    ordered = sorted(
+        names,
+        key=lambda name: (
+            notes.get(name, [{}])[0].get("start", float("inf")) if notes.get(name) else float("inf"),
+            name,
+        ),
+    )
+    tracks: list[dict[str, Any]] = []
+    for index, name in enumerate(ordered):
+        track_notes = notes.get(name, [])
+        midi = (midi_by_instrument or {}).get(name)
+        tracks.append(
+            {
+                "id": index,
+                "key": name,
+                "name": _display_name(name),
+                "color": _color_for(name),
+                "note_count": len(track_notes),
+                "program": _program_for(name),
+                "is_drum": name == "drums",
+                "midi": _data_uri(midi) if midi else "",
+                "notes": track_notes,
+            }
+        )
+    return tracks
+
+
+def _viewer_payload(
+    *,
+    state: str,
+    status: str,
+    progress: float,
+    audio_name: str,
+    elapsed: float,
+    duration: float,
+    tracks: list[dict[str, Any]],
+    full_midi: bytes | None = None,
+) -> dict[str, Any]:
+    value = initial_studio_value()
+    value.update(
+        {
+            "state": state,
+            "status": status,
+            "progress": round(max(0.0, min(1.0, progress)), 4),
+            "audio_name": audio_name,
+            "elapsed": round(elapsed, 2),
+            "duration": round(duration, 3),
+            "note_count": sum(track["note_count"] for track in tracks),
+            "tracks": tracks,
+            "full_midi": _data_uri(full_midi) if full_midi else "",
+        }
+    )
+    return value
+
+
+def _event_for_instrument(event: Any, instrument: str) -> bool:
+    if NoteStartEvent is not None and isinstance(event, NoteStartEvent):
+        return event.instrument == instrument
+    if NoteEndEvent is not None and isinstance(event, NoteEndEvent):
+        return event.start_event.instrument == instrument
+    return False
+
+
+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é.")
+    output_dir = Path(tempfile.mkdtemp(prefix="muscriptor-midi-"))
+    full_bytes = MODEL.events_to_midi_bytes(iter(events))
+    full_path = output_dir / "transcription-complete.mid"
+    full_path.write_bytes(full_bytes)
+    paths: dict[str, Path] = {}
+    payloads: dict[str, bytes] = {}
+    for name in track_names:
+        track_events = [event for event in events if _event_for_instrument(event, name)]
+        data = MODEL.events_to_midi_bytes(iter(track_events))
+        path = output_dir / f"{_slug(name)}.mid"
+        path.write_bytes(data)
+        paths[name] = path
+        payloads[name] = data
+    return full_path, paths, full_bytes, payloads
+
+
+def _error_result(message: str, audio_name: str = "", duration: float = 0.0):
+    viewer = _viewer_payload(
+        state="error",
+        status=message,
+        progress=0,
+        audio_name=audio_name,
+        elapsed=0,
+        duration=duration,
+        tracks=[],
+    )
+    return None, None, viewer, {"state": "error", "message": message, "viewer": viewer}
+
+
+@spaces.GPU(duration=_estimate_gpu_duration)
+def transcribe_audio(
+    audio: Any,
+    instruments: list[str] | None,
+    use_sampling: bool,
+    temperature: float,
+    beam_size: int,
+) -> Iterator[tuple[str | None, list[str] | None, dict[str, Any], dict[str, Any]]]:
+    path = _audio_path(audio)
+    if not path:
+        yield _error_result("Importez un fichier audio avant de lancer la 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)
+        return
+    if duration > MAX_AUDIO_SECONDS:
+        yield _error_result(
+            f"Cette première version accepte des enregistrements de {MAX_AUDIO_SECONDS:.0f} secondes maximum.",
+            audio_name,
+            duration,
+        )
+        return
+    if MODEL is None:
+        yield _error_result(MODEL_ERROR or "Le modèle MuScriptor n’est pas disponible.", audio_name, duration)
+        return
+
+    requested = list(dict.fromkeys(instruments or []))
+    beam = max(1, min(4, int(beam_size or 1)))
+    events: list[Any] = []
+    started = time.perf_counter()
+    last_completed = -1
+
+    try:
+        stream = MODEL.transcribe(
+            path,
+            instruments=requested or None,
+            use_sampling=bool(use_sampling),
+            temperature=float(temperature),
+            beam_size=beam,
+            batch_size=1,
+        )
+        for event in stream:
+            events.append(event)
+            if ProgressEvent is None or not isinstance(event, ProgressEvent):
+                continue
+            if event.completed == last_completed:
+                continue
+            last_completed = event.completed
+            notes = _notes_from_events(events)
+            tracks = _track_payloads(notes, requested)
+            fraction = event.completed / max(1, event.total)
+            status = (
+                "ZeroGPU prêt · préparation de la première fenêtre"
+                if event.completed == 0
+                else f"Fenêtre {event.completed}/{event.total} transcrite"
+            )
+            viewer = _viewer_payload(
+                state="transcribing",
+                status=status,
+                progress=fraction,
+                audio_name=audio_name,
+                elapsed=time.perf_counter() - started,
+                duration=duration,
+                tracks=tracks,
+            )
+            yield None, None, viewer, {"state": "running", "viewer": viewer}
+
+        elapsed = time.perf_counter() - started
+        notes = _notes_from_events(events)
+        preliminary = _track_payloads(notes)
+        track_names = [track["key"] for track in preliminary if track["note_count"]]
+        full_path, track_paths, full_bytes, midi_by_instrument = _write_midi_outputs(events, track_names)
+        tracks = _track_payloads(notes, midi_by_instrument=midi_by_instrument)
+        viewer = _viewer_payload(
+            state="complete",
+            status=f"Transcription terminée en {elapsed:.1f} s · génération de la partition…",
+            progress=1,
+            audio_name=audio_name,
+            elapsed=elapsed,
+            duration=duration,
+            tracks=tracks,
+            full_midi=full_bytes,
+        )
+        track_file_values = [str(track_paths[name]) for name in track_names]
+        session = {
+            "state": "complete",
+            "title": Path(audio_name).stem,
+            "audio_name": audio_name,
+            "duration": duration,
+            "elapsed": elapsed,
+            "tracks": tracks,
+            "viewer": viewer,
+            "midi_files": [str(full_path), *track_file_values],
+        }
+        yield str(full_path), track_file_values, viewer, session
+    except Exception as exc:
+        elapsed = time.perf_counter() - started
+        message = f"Transcription interrompue : {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(
+            state="error",
+            status=message,
+            progress=0,
+            audio_name=audio_name,
+            elapsed=elapsed,
+            duration=duration,
+            tracks=tracks,
+        )
+        yield None, None, viewer, {"state": "error", "message": message, "viewer": viewer}
+
+
+def finalize_notation(
+    session: dict[str, Any] | None,
+    tempo_bpm: float,
+    time_signature: str,
+    quantization: str,
+    show_solfege: bool,
+) -> tuple[str | None, str | None, str | None, dict[str, Any]]:
+    session = session or {}
+    viewer = normalize_viewer_value(session.get("viewer"))
+    if session.get("state") != "complete":
+        return None, None, None, viewer
+    try:
+        result = generate_notation(
+            session["tracks"],
+            title=session.get("title") or "Transcription MuScriptor",
+            tempo_bpm=tempo_bpm,
+            time_signature=time_signature,
+            quantization=quantization,
+            show_solfege=show_solfege,
+            midi_files=session.get("midi_files"),
+        )
+        updated = dict(viewer)
+        updated.update(
+            {
+                "state": "ready",
+                "status": "Transcription et partition prêtes",
+                "score_svg": result.preview_svg,
+                "score_pages": len(result.svg_pages),
+                "notation": {
+                    "tempo": round(float(tempo_bpm), 1),
+                    "time_signature": time_signature,
+                    "quantization": quantization,
+                    "show_solfege": bool(show_solfege),
+                    "musicxml": file_data_uri(result.musicxml, "application/vnd.recordare.musicxml+xml"),
+                    "svg": file_data_uri(result.svg_pages[0], "image/svg+xml") if result.svg_pages else "",
+                },
+            }
+        )
+        return (
+            str(result.musicxml),
+            str(result.pdf) if result.pdf else None,
+            str(result.bundle),
+            updated,
+        )
+    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}"
+        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)]
+
+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">Medium · 307M</span><span class="gpu-badge">ZeroGPU</span></div>
+</header>
+"""
+
+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("### 1. Importer un enregistrement\nDéposez un morceau de 60 secondes 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="Instruments connus",
+                info="Facultatif — laissez vide pour la détection automatique.",
+            )
+            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")
+            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"
+                    )
+                quantization_input = gr.Radio(
+                    ["1/8", "1/16", "1/32"], value="1/16", label="Quantification"
+                )
+                solfege_input = gr.Checkbox(label="Afficher Do Ré Mi", value=False)
+
+    session_state = gr.State(value={})
+    viewer = StudioViewer()
+
+    with gr.Row(elem_id="downloads-row"):
+        full_midi_output = gr.File(label="MIDI complet")
+        track_midi_output = gr.File(label="MIDI par instrument", file_count="multiple")
+        musicxml_output = gr.File(label="MusicXML")
+        pdf_output = gr.File(label="Partition PDF")
+        bundle_output = gr.File(label="Tous les exports (.zip)")
+
+    transcription = transcribe_button.click(
+        transcribe_audio,
+        inputs=[
+            audio_input,
+            instrument_input,
+            use_sampling_input,
+            temperature_input,
+            beam_size_input,
+        ],
+        outputs=[full_midi_output, track_midi_output, viewer, session_state],
+        api_name="transcribe",
+        concurrency_limit=1,
+        concurrency_id="muscriptor-medium",
+        show_progress="full",
+    )
+    transcription.then(
+        finalize_notation,
+        inputs=[session_state, tempo_input, time_signature_input, quantization_input, solfege_input],
+        outputs=[musicxml_output, pdf_output, bundle_output, viewer],
+        api_name="generate_score",
+        show_progress="minimal",
+    )
+
+demo.queue(default_concurrency_limit=1, max_size=8)
+
+
+if __name__ == "__main__":
+    demo.launch(
+        css=APP_CSS,
+        theme=gr.themes.Base(primary_hue="violet", neutral_hue="slate"),
+        footer_links=["gradio"],
+    )

midi_component.py

@@ -0,0 +1,290 @@
+from __future__ import annotations
+
+from bisect import bisect_right
+from collections import defaultdict, deque
+from pathlib import Path
+from typing import Any
+
+import gradio as gr
+import mido
+
+
+ROOT = Path(__file__).resolve().parent
+FRONTEND = ROOT / "frontend"
+MAX_FILE_BYTES = 5 * 1024 * 1024
+MAX_NOTES = 50_000
+TRACK_COLORS = [
+    "#8b5cf6",
+    "#22d3ee",
+    "#fb7185",
+    "#fbbf24",
+    "#34d399",
+    "#60a5fa",
+    "#f472b6",
+    "#a3e635",
+    "#fb923c",
+    "#c084fc",
+]
+PROGRAM_FAMILIES = [
+    "Piano",
+    "Percussions chromatiques",
+    "Orgue",
+    "Guitare",
+    "Basse",
+    "Cordes",
+    "Ensemble",
+    "Cuivres",
+    "Anches",
+    "Bois",
+    "Synthé lead",
+    "Synthé pad",
+    "Effets synthétiques",
+    "Instruments ethniques",
+    "Percussions",
+    "Effets sonores",
+]
+
+
+def _read_frontend(name: str) -> str:
+    return (FRONTEND / name).read_text(encoding="utf-8")
+
+
+class MidiPlayer(gr.HTML):
+    """A browser-synthesized MIDI player built with Gradio's custom HTML API."""
+
+    def __init__(self, value: Any | None = None, **kwargs: Any) -> None:
+        initial_value = value or {
+            "status": "empty",
+            "message": "Déposez un fichier MIDI pour commencer.",
+        }
+        super().__init__(
+            value=initial_value,
+            html_template=_read_frontend("player.html"),
+            css_template=_read_frontend("player.css"),
+            js_on_load=_read_frontend("player.js"),
+            apply_default_css=False,
+            min_height=680,
+            **kwargs,
+        )
+
+    def api_info(self) -> dict[str, Any]:
+        return {"type": "object"}
+
+
+class TempoMap:
+    def __init__(self, events: list[tuple[int, int]], ticks_per_beat: int) -> None:
+        if ticks_per_beat <= 0:
+            raise ValueError("Les fichiers MIDI avec division temporelle SMPTE ne sont pas pris en charge.")
+
+        collapsed: dict[int, int] = {0: 500_000}
+        for tick, tempo in sorted(events):
+            collapsed[tick] = tempo
+
+        self.ticks_per_beat = ticks_per_beat
+        self.segments: list[tuple[int, float, int]] = []
+        elapsed = 0.0
+        previous_tick = 0
+        previous_tempo = collapsed[0]
+
+        for tick, tempo in sorted(collapsed.items()):
+            if tick > 0:
+                elapsed += mido.tick2second(
+                    tick - previous_tick,
+                    ticks_per_beat,
+                    previous_tempo,
+                )
+            self.segments.append((tick, elapsed, tempo))
+            previous_tick = tick
+            previous_tempo = tempo
+
+        self._ticks = [segment[0] for segment in self.segments]
+
+    def seconds(self, tick: int) -> float:
+        index = max(0, bisect_right(self._ticks, tick) - 1)
+        start_tick, start_seconds, tempo = self.segments[index]
+        return start_seconds + mido.tick2second(
+            tick - start_tick,
+            self.ticks_per_beat,
+            tempo,
+        )
+
+
+def _display_name(track: mido.MidiTrack, index: int) -> str:
+    for message in track:
+        if message.type == "track_name" and message.name.strip():
+            return message.name.strip()[:80]
+    return f"Piste {index + 1}"
+
+
+def _instrument_name(programs: set[int], channels: set[int]) -> str:
+    if 9 in channels:
+        return "Percussions"
+    if not programs:
+        return "Instrument MIDI"
+    names = list(dict.fromkeys(PROGRAM_FAMILIES[program // 8] for program in sorted(programs)))
+    return ", ".join(names[:2]) + ("…" if len(names) > 2 else "")
+
+
+def parse_midi(path: str | Path, original_name: str | None = None) -> dict[str, Any]:
+    file_path = Path(path)
+    midi = mido.MidiFile(file_path, clip=True)
+    if midi.type == 2:
+        raise ValueError("Les fichiers MIDI type 2 (séquences asynchrones) ne sont pas pris en charge.")
+
+    tempo_events: list[tuple[int, int]] = []
+    time_signatures: list[dict[str, int]] = []
+    global_end_tick = 0
+    title = ""
+
+    for track in midi.tracks:
+        tick = 0
+        for message in track:
+            tick += message.time
+            if message.type == "set_tempo":
+                tempo_events.append((tick, message.tempo))
+            elif message.type == "time_signature":
+                time_signatures.append(
+                    {
+                        "tick": tick,
+                        "numerator": message.numerator,
+                        "denominator": message.denominator,
+                    }
+                )
+            elif message.type == "track_name" and not title and message.name.strip():
+                title = message.name.strip()[:120]
+        global_end_tick = max(global_end_tick, tick)
+
+    tempo_map = TempoMap(tempo_events, midi.ticks_per_beat)
+    tracks: list[dict[str, Any]] = []
+    total_notes = 0
+    min_pitch = 127
+    max_pitch = 0
+
+    for source_index, track in enumerate(midi.tracks):
+        tick = 0
+        programs_by_channel: defaultdict[int, int] = defaultdict(int)
+        active: defaultdict[tuple[int, int], deque[tuple[int, int, int]]] = defaultdict(deque)
+        raw_notes: list[tuple[int, int, int, int, int, int]] = []
+        channels: set[int] = set()
+        programs: set[int] = set()
+
+        for message in track:
+            tick += message.time
+            if message.type == "program_change":
+                programs_by_channel[message.channel] = message.program
+                programs.add(message.program)
+            elif message.type == "note_on" and message.velocity > 0:
+                channel = message.channel
+                program = programs_by_channel[channel]
+                active[(channel, message.note)].append((tick, message.velocity, program))
+                channels.add(channel)
+                programs.add(program)
+            elif message.type in {"note_off", "note_on"}:
+                key = (message.channel, message.note)
+                if active[key]:
+                    start_tick, velocity, program = active[key].popleft()
+                    raw_notes.append(
+                        (start_tick, max(tick, start_tick + 1), message.note, velocity, message.channel, program)
+                    )
+
+        for (channel, pitch), pending in active.items():
+            while pending:
+                start_tick, velocity, program = pending.popleft()
+                raw_notes.append(
+                    (start_tick, max(global_end_tick, start_tick + 1), pitch, velocity, channel, program)
+                )
+
+        if not raw_notes:
+            continue
+
+        raw_notes.sort(key=lambda note: (note[0], note[2]))
+        track_index = len(tracks)
+        notes = []
+        for start_tick, end_tick, pitch, velocity, channel, program in raw_notes:
+            start = tempo_map.seconds(start_tick)
+            end = tempo_map.seconds(end_tick)
+            notes.append(
+                {
+                    "s": round(start, 6),
+                    "e": round(max(end, start + 0.01), 6),
+                    "p": pitch,
+                    "v": velocity,
+                    "c": channel,
+                    "g": program,
+                    "t": track_index,
+                }
+            )
+            min_pitch = min(min_pitch, pitch)
+            max_pitch = max(max_pitch, pitch)
+
+        total_notes += len(notes)
+        if total_notes > MAX_NOTES:
+            raise ValueError(f"Le fichier dépasse la limite de {MAX_NOTES:,} notes.")
+
+        tracks.append(
+            {
+                "index": track_index,
+                "source_index": source_index,
+                "name": _display_name(track, source_index),
+                "color": TRACK_COLORS[track_index % len(TRACK_COLORS)],
+                "instrument": _instrument_name(programs, channels),
+                "channels": sorted(channel + 1 for channel in channels),
+                "notes": notes,
+            }
+        )
+
+    if not tracks:
+        raise ValueError("Ce fichier MIDI ne contient aucune note lisible.")
+
+    duration = max(
+        tempo_map.seconds(global_end_tick),
+        max(note["e"] for track in tracks for note in track["notes"]),
+    )
+    initial_tempo = tempo_map.segments[0][2]
+    safe_name = Path(original_name or file_path.name).name[:160]
+
+    return {
+        "status": "ready",
+        "file_name": safe_name,
+        "title": title or Path(safe_name).stem,
+        "format": midi.type,
+        "ticks_per_beat": midi.ticks_per_beat,
+        "duration": round(duration, 6),
+        "bpm": round(mido.tempo2bpm(initial_tempo), 1),
+        "tempo_changes": len(tempo_map.segments),
+        "time_signature": (
+            f"{time_signatures[0]['numerator']}/{time_signatures[0]['denominator']}"
+            if time_signatures
+            else "—"
+        ),
+        "track_count": len(tracks),
+        "note_count": total_notes,
+        "pitch_min": min_pitch,
+        "pitch_max": max_pitch,
+        "tracks": tracks,
+    }
+
+
+def load_midi(value: Any) -> dict[str, Any]:
+    try:
+        if not isinstance(value, dict) or value.get("status") != "uploaded":
+            raise ValueError("Aucun fichier MIDI valide n’a été transmis.")
+
+        path = Path(str(value.get("path", "")))
+        original_name = Path(str(value.get("name", path.name))).name
+        if path.suffix.lower() not in {".mid", ".midi"} and Path(original_name).suffix.lower() not in {
+            ".mid",
+            ".midi",
+        }:
+            raise ValueError("Formats acceptés : .mid et .midi.")
+        if not path.is_file():
+            raise ValueError("Le fichier uploadé est introuvable.")
+        if path.stat().st_size > MAX_FILE_BYTES:
+            raise ValueError("Le fichier dépasse la limite de 5 Mo.")
+
+        return parse_midi(path, original_name)
+    except (EOFError, OSError, ValueError, mido.KeySignatureError) as exc:
+        return {
+            "status": "error",
+            "message": str(exc) or "Impossible de lire ce fichier MIDI.",
+        }

notation.py

@@ -0,0 +1,255 @@
+from __future__ import annotations
+
+import base64
+import copy
+import io
+import json
+import re
+import shutil
+import tempfile
+import zipfile
+from dataclasses import dataclass
+from pathlib import Path
+from statistics import median
+from typing import Any
+
+
+QUANTIZATION_DIVISORS = {
+    "1/8": 2,
+    "1/16": 4,
+    "1/32": 8,
+}
+
+SOLFEGE_NAMES = ("Do", "Do♯", "Ré", "Mi♭", "Mi", "Fa", "Fa♯", "Sol", "La♭", "La", "Si♭", "Si")
+
+
+@dataclass(frozen=True)
+class NotationResult:
+    musicxml: Path
+    pdf: Path | None
+    bundle: Path
+    svg_pages: tuple[Path, ...]
+    preview_svg: str
+
+
+def _safe_slug(value: str) -> str:
+    return re.sub(r"[^a-z0-9]+", "-", value.lower()).strip("-") or "piste"
+
+
+def _parse_time_signature(value: str) -> tuple[int, int]:
+    try:
+        numerator, denominator = value.split("/", 1)
+        parsed = int(numerator), int(denominator)
+    except (AttributeError, TypeError, ValueError):
+        return 4, 4
+    if parsed[0] <= 0 or parsed[1] not in {1, 2, 4, 8, 16, 32}:
+        return 4, 4
+    return parsed
+
+
+def _music21_score(
+    tracks: list[dict[str, Any]],
+    *,
+    title: str,
+    tempo_bpm: float,
+    time_signature: str,
+    quantization: str,
+    show_solfege: bool,
+):
+    try:
+        from music21 import chord, clef, instrument, metadata, meter, note, stream, tempo
+    except ImportError as exc:  # pragma: no cover - deployment configuration
+        raise RuntimeError("La dépendance music21 est nécessaire pour générer la partition.") from exc
+
+    bpm = max(20.0, min(300.0, float(tempo_bpm)))
+    numerator, denominator = _parse_time_signature(time_signature)
+    divisor = QUANTIZATION_DIVISORS.get(quantization, 4)
+
+    score = stream.Score(id="muscriptor-score")
+    score.metadata = metadata.Metadata()
+    score.metadata.title = title or "Transcription MuScriptor"
+    score.metadata.composer = "Transcription automatique MuScriptor"
+
+    for track_index, track in enumerate(tracks):
+        notes = list(track.get("notes") or [])
+        if not notes:
+            continue
+
+        part = stream.Part(id=f"part-{track_index + 1}")
+        part.partName = str(track.get("name") or f"Piste {track_index + 1}")
+        midi_instrument = instrument.Instrument()
+        midi_instrument.partName = part.partName
+        midi_instrument.instrumentName = part.partName
+        if track.get("is_drum"):
+            midi_instrument.midiChannel = 9
+        else:
+            midi_instrument.midiProgram = max(0, min(127, int(track.get("program") or 0)))
+        part.insert(0, midi_instrument)
+        part.insert(0, tempo.MetronomeMark(number=bpm))
+        part.insert(0, meter.TimeSignature(f"{numerator}/{denominator}"))
+
+        pitches = [int(item.get("pitch", 60)) for item in notes]
+        if track.get("is_drum"):
+            part.insert(0, clef.PercussionClef())
+        elif median(pitches) < 55:
+            part.insert(0, clef.BassClef())
+        else:
+            part.insert(0, clef.TrebleClef())
+
+        grouped: dict[tuple[float, float], list[int]] = {}
+        velocities: dict[tuple[float, float], list[int]] = {}
+        for item in notes:
+            start_seconds = max(0.0, float(item.get("start", 0.0)))
+            end_seconds = max(start_seconds + 0.03, float(item.get("end", start_seconds + 0.1)))
+            offset = start_seconds * bpm / 60.0
+            duration = max(1 / divisor, (end_seconds - start_seconds) * bpm / 60.0)
+            key = (round(offset, 5), round(duration, 5))
+            grouped.setdefault(key, []).append(max(0, min(127, int(item.get("pitch", 60)))))
+            velocities.setdefault(key, []).append(max(1, min(127, int(item.get("velocity", 100)))))
+
+        for (offset, duration), group_pitches in sorted(grouped.items()):
+            if len(group_pitches) == 1:
+                musical_item = note.Note(group_pitches[0], quarterLength=duration)
+                if show_solfege:
+                    musical_item.addLyric(SOLFEGE_NAMES[group_pitches[0] % 12])
+            else:
+                musical_item = chord.Chord(group_pitches, quarterLength=duration)
+                if show_solfege:
+                    musical_item.addLyric(" ".join(SOLFEGE_NAMES[pitch % 12] for pitch in group_pitches))
+            musical_item.volume.velocity = round(sum(velocities[(offset, duration)]) / len(velocities[(offset, duration)]))
+            part.insert(offset, musical_item)
+
+        part.quantize(
+            quarterLengthDivisors=(divisor,),
+            processOffsets=True,
+            processDurations=True,
+            inPlace=True,
+        )
+        measured = part.makeMeasures(inPlace=False)
+        measured.makeNotation(inPlace=True)
+        score.insert(0, measured)
+
+    if not score.parts:
+        raise ValueError("Aucune note n’est disponible pour générer une partition.")
+    return score
+
+
+def _render_svg_pages(musicxml: Path, output_dir: Path) -> tuple[tuple[Path, ...], str]:
+    try:
+        import verovio
+    except ImportError as exc:  # pragma: no cover - deployment configuration
+        raise RuntimeError("La dépendance verovio est nécessaire pour afficher la partition.") from exc
+
+    toolkit = verovio.toolkit()
+    toolkit.setOptions(
+        {
+            "adjustPageHeight": True,
+            "breaks": "auto",
+            "footer": "none",
+            "header": "none",
+            "pageHeight": 2100,
+            "pageWidth": 2970,
+            "scale": 38,
+            "spacingStaff": 8,
+            "spacingSystem": 12,
+        }
+    )
+    if not toolkit.loadFile(str(musicxml)):
+        raise RuntimeError("Verovio n’a pas pu lire le MusicXML généré.")
+
+    pages: list[Path] = []
+    preview = ""
+    for page_number in range(1, toolkit.getPageCount() + 1):
+        svg = toolkit.renderToSVG(page_number)
+        if page_number == 1:
+            preview = svg
+        path = output_dir / f"partition-page-{page_number}.svg"
+        path.write_text(svg, encoding="utf-8")
+        pages.append(path)
+    return tuple(pages), preview
+
+
+def _render_pdf(svg_pages: tuple[Path, ...], output_path: Path) -> Path | None:
+    try:
+        import cairosvg
+        from pypdf import PdfReader, PdfWriter
+    except ImportError:
+        return None
+
+    writer = PdfWriter()
+    for svg in svg_pages:
+        pdf_bytes = cairosvg.svg2pdf(bytestring=svg.read_bytes())
+        reader = PdfReader(io.BytesIO(pdf_bytes))
+        for page in reader.pages:
+            writer.add_page(page)
+    with output_path.open("wb") as handle:
+        writer.write(handle)
+    return output_path
+
+
+def generate_notation(
+    tracks: list[dict[str, Any]],
+    *,
+    title: str,
+    tempo_bpm: float = 120,
+    time_signature: str = "4/4",
+    quantization: str = "1/16",
+    show_solfege: bool = False,
+    midi_files: list[str] | None = None,
+) -> NotationResult:
+    output_dir = Path(tempfile.mkdtemp(prefix="muscriptor-notation-"))
+    score = _music21_score(
+        tracks,
+        title=title,
+        tempo_bpm=tempo_bpm,
+        time_signature=time_signature,
+        quantization=quantization,
+        show_solfege=show_solfege,
+    )
+
+    musicxml = output_dir / "partition-complete.musicxml"
+    score.write("musicxml", fp=str(musicxml))
+
+    parts_dir = output_dir / "parties"
+    parts_dir.mkdir()
+    from music21 import stream as music21_stream
+
+    for part in score.parts:
+        part_score = music21_stream.Score(id=f"score-{part.id}")
+        part_score.metadata = copy.deepcopy(score.metadata)
+        part_score.insert(0, copy.deepcopy(part))
+        part_score.write("musicxml", fp=str(parts_dir / f"{_safe_slug(part.partName)}.musicxml"))
+
+    svg_pages, preview_svg = _render_svg_pages(musicxml, output_dir)
+    pdf = _render_pdf(svg_pages, output_dir / "partition-complete.pdf")
+
+    bundle = output_dir / "muscriptor-exports.zip"
+    with zipfile.ZipFile(bundle, "w", compression=zipfile.ZIP_DEFLATED) as archive:
+        archive.write(musicxml, musicxml.name)
+        for path in parts_dir.glob("*.musicxml"):
+            archive.write(path, f"parties/{path.name}")
+        for path in svg_pages:
+            archive.write(path, f"svg/{path.name}")
+        if pdf:
+            archive.write(pdf, pdf.name)
+        for value in midi_files or []:
+            midi_path = Path(value)
+            if midi_path.is_file():
+                archive.write(midi_path, f"midi/{midi_path.name}")
+
+    return NotationResult(
+        musicxml=musicxml,
+        pdf=pdf,
+        bundle=bundle,
+        svg_pages=svg_pages,
+        preview_svg=preview_svg,
+    )
+
+
+def file_data_uri(path: Path, mime_type: str) -> str:
+    encoded = base64.b64encode(path.read_bytes()).decode("ascii")
+    return f"data:{mime_type};base64,{encoded}"
+
+
+def session_json(value: dict[str, Any]) -> str:
+    return json.dumps(value, ensure_ascii=False, separators=(",", ":"))

pyproject.toml

@@ -0,0 +1,3 @@
+[tool.pytest.ini_options]
+pythonpath = ["."]
+testpaths = ["tests"]

requirements.txt

@@ -0,0 +1,13 @@
+gradio==6.20.0
+spaces==0.51.0
+muscriptor==0.2.1
+numpy==1.26.4
+einops==0.8.2
+mido==1.3.3
+soundfile==0.14.0
+safetensors==0.8.0
+huggingface_hub==1.21.0
+music21==9.9.1
+verovio==5.7.0
+CairoSVG==2.8.2
+pypdf==6.6.0

studio_component.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+import gradio as gr
+
+
+ROOT = Path(__file__).resolve().parent
+FRONTEND = ROOT / "frontend"
+
+
+def _read_frontend(name: str) -> str:
+    return (FRONTEND / name).read_text(encoding="utf-8")
+
+
+def initial_studio_value() -> dict[str, Any]:
+    return {
+        "state": "idle",
+        "status": "Importez un enregistrement pour commencer.",
+        "progress": 0,
+        "audio_name": "",
+        "elapsed": 0,
+        "duration": 0,
+        "note_count": 0,
+        "tracks": [],
+        "full_midi": "",
+        "score_svg": "",
+        "score_pages": 0,
+        "notation": {},
+    }
+
+
+class StudioViewer(gr.HTML):
+    """MuScriptor result viewer implemented with Gradio's custom HTML API."""
+
+    def __init__(self, value: Any | None = None, **kwargs: Any) -> None:
+        super().__init__(
+            value=value or initial_studio_value(),
+            html_template=_read_frontend("studio.html"),
+            css_template=_read_frontend("studio.css"),
+            js_on_load=_read_frontend("studio.js"),
+            apply_default_css=False,
+            min_height=760,
+            **kwargs,
+        )
+
+    def api_info(self) -> dict[str, Any]:
+        return {"type": "object"}
+
+
+def normalize_viewer_value(value: Any) -> dict[str, Any]:
+    if isinstance(value, dict):
+        return value
+    if isinstance(value, str):
+        try:
+            parsed = json.loads(value)
+            if isinstance(parsed, dict):
+                return parsed
+        except json.JSONDecodeError:
+            pass
+    return initial_studio_value()