Enhance README and app.py: Improve score visualization and add MuseScore AppImage handling

README.md

@@ -18,7 +18,7 @@ A Gradio web interface for [AnalysisGNN](https://github.com/manoskary/analysisGN
 ## Features
 
 - 🎼 **MusicXML Upload**: Upload and analyze musical scores in MusicXML format
-- 🎨 **Score Visualization**: Automatic rendering of uploaded scores to images
+- 🎨 **Score Visualization**: Automatic rendering of uploaded scores to images (now with built-in MuseScore AppImage fallback)
 - 📊 **Multi-task Analysis**: Perform various music analysis tasks:
   - Cadence Detection
   - Key Analysis (Local & Tonalized)
@@ -69,6 +69,10 @@ This app is designed to run on Hugging Face Spaces. Simply deploy it as a Gradio
    - Analysis results table (note-level predictions)
 5. **Download results** as CSV if needed
 
+### Score Rendering Backend
+
+The interface first tries to render MusicXML scores with Partitura. If that backend is missing MuseScore/LilyPond, the app now mirrors the [manoskary/weavemuse](https://github.com/manoskary/weavemuse) approach: it automatically downloads and extracts the MuseScore AppImage (stored under `./artifacts/musescore/`) and calls it headlessly (`QT_QPA_PLATFORM=offscreen`). You can override the binary by setting `MUSESCORE_BIN=/path/to/mscore` before launching the app.
+
 ## Model
 
 The app uses a pre-trained AnalysisGNN model automatically downloaded from Weights & Biases. The model is cached in the `./artifacts/` folder to avoid re-downloading.

app.py

@@ -9,9 +9,16 @@ Users can upload MusicXML scores, run the model, and view results.
 import gradio as gr
 import pandas as pd
 import numpy as np
+import logging
 import os
+import shutil
+import subprocess
 import tempfile
+import time
 import torch
+import urllib.request
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from contextlib import contextmanager
 from pathlib import Path
 from typing import Tuple, Optional, Dict
 import traceback
@@ -29,13 +36,63 @@ from analysisgnn.utils.chord_representations import available_representations, N
 if "note_degree" not in available_representations and NoteDegree49 is not None:
     available_representations["note_degree"] = NoteDegree49
 
+LOG_LEVEL = os.environ.get("ANALYSISGNN_LOG_LEVEL", "INFO").upper()
+logging.basicConfig(
+    level=getattr(logging, LOG_LEVEL, logging.INFO),
+    format="[%(asctime)s] %(levelname)s %(name)s: %(message)s",
+)
+logger = logging.getLogger("analysisgnn_app")
+
+PARALLEL_CONFIG = os.environ.get("ANALYSISGNN_PARALLEL", "auto").strip().lower()
+CPU_COUNT = os.cpu_count() or 1
+
+MUSESCORE_APPIMAGE_URL = "https://www.modelscope.cn/studio/Genius-Society/piano_trans/resolve/master/MuseScore.AppImage"
+MUSESCORE_STORAGE_DIR = Path("artifacts") / "musescore"
+MUSESCORE_ENV_VAR = "MUSESCORE_BIN"
+MUSESCORE_RENDER_TIMEOUT = int(os.environ.get("MUSESCORE_RENDER_TIMEOUT", "120"))
+MUSESCORE_EXTRACT_TIMEOUT = int(os.environ.get("MUSESCORE_EXTRACT_TIMEOUT", "240"))
+_MUSESCORE_BINARY: Optional[str] = None
+_MUSESCORE_READY: bool = False
+
 # Global model variable
 MODEL = None
 DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
 
-print(f"Using device: {DEVICE}")
+logger.info("Using device: %s", DEVICE)
 if torch.cuda.is_available():
-    print(f"CUDA device: {torch.cuda.get_device_name(0)}")
+    logger.info("CUDA device: %s", torch.cuda.get_device_name(0))
+
+
+@contextmanager
+def log_timing(label: str):
+    """Log start/stop (with duration) for expensive operations."""
+    start = time.perf_counter()
+    logger.info("▶ %s", label)
+    try:
+        yield
+    except Exception:
+        elapsed = time.perf_counter() - start
+        logger.exception("✗ %s failed after %.2fs", label, elapsed)
+        raise
+    else:
+        elapsed = time.perf_counter() - start
+        logger.info("✓ %s in %.2fs", label, elapsed)
+
+
+def should_parallelize() -> bool:
+    """
+    Decide whether to run analysis/visualization in parallel.
+    
+    Controlled via ANALYSISGNN_PARALLEL env:
+    - "0"/"false": force sequential
+    - "1"/"true": force parallel
+    - "auto" (default): enable if more than one CPU core is available
+    """
+    if PARALLEL_CONFIG in {"0", "false", "no", "off"}:
+        return False
+    if PARALLEL_CONFIG in {"1", "true", "yes", "on"}:
+        return True
+    return CPU_COUNT > 1
 
 
 def download_wandb_checkpoint(artifact_path: str = "melkisedeath/AnalysisGNN/model-uvj2ddun:v1") -> str:
@@ -47,7 +104,7 @@ def download_wandb_checkpoint(artifact_path: str = "melkisedeath/AnalysisGNN/mod
     # Check if checkpoint already exists directly in artifacts/models
     checkpoint_path = os.path.join(artifacts_dir, "model.ckpt")
     if os.path.exists(checkpoint_path):
-        print(f"Using cached checkpoint: {checkpoint_path}")
+        logger.info("Using cached checkpoint: %s", checkpoint_path)
         return checkpoint_path
     
     # Check for any .ckpt file in the artifacts/models directory
@@ -55,25 +112,26 @@ def download_wandb_checkpoint(artifact_path: str = "melkisedeath/AnalysisGNN/mod
         for fname in os.listdir(artifacts_dir):
             if fname.endswith('.ckpt'):
                 checkpoint_path = os.path.join(artifacts_dir, fname)
-                print(f"Using cached checkpoint: {checkpoint_path}")
+                logger.info("Using cached checkpoint: %s", checkpoint_path)
                 return checkpoint_path
     
     # Check artifact-specific subdirectory
     artifact_dir = os.path.join(artifacts_dir, os.path.basename(artifact_path))
     checkpoint_path = os.path.join(artifact_dir, "model.ckpt")
     if os.path.exists(checkpoint_path):
-        print(f"Using cached checkpoint: {checkpoint_path}")
+        logger.info("Using cached checkpoint: %s", checkpoint_path)
         return checkpoint_path
     
     # Only import and use wandb if checkpoint is not cached
     import wandb
-    print(f"Downloading checkpoint from W&B: {artifact_path}")
+    logger.info("Downloading checkpoint from W&B: %s", artifact_path)
     
     # Initialize wandb in offline mode to avoid creating online runs
     run = wandb.init(mode="offline")
     try:
         artifact = run.use_artifact(artifact_path, type='model')
-        artifact_dir = artifact.download(root=artifacts_dir)
+        with log_timing("Downloading W&B checkpoint"):
+            artifact_dir = artifact.download(root=artifacts_dir)
     finally:
         wandb.finish()
     
@@ -94,17 +152,248 @@ def load_model() -> ContinualAnalysisGNN:
     
     if MODEL is None:
         checkpoint_path = download_wandb_checkpoint()
-        print(f"Loading model from: {checkpoint_path}")
+        logger.info("Loading model from: %s", checkpoint_path)
         MODEL = ContinualAnalysisGNN.load_from_checkpoint(
             checkpoint_path,
             map_location=DEVICE
         )
         MODEL.eval()
         MODEL.to(DEVICE)
-        print("Model loaded successfully!")
+        logger.info("Model loaded successfully!")
     return MODEL
 
 
+def _format_bytes(num_bytes: float) -> str:
+    """Return human readable size string."""
+    units = ["B", "KB", "MB", "GB", "TB"]
+    size = float(num_bytes)
+    for unit in units:
+        if size < 1024:
+            return f"{size:.1f}{unit}"
+        size /= 1024
+    return f"{size:.1f}PB"
+
+
+def _download_file(url: str, destination: Path) -> bool:
+    """Download a file from url to destination."""
+    try:
+        destination.parent.mkdir(parents=True, exist_ok=True)
+        logger.info("Starting download: %s -> %s", url, destination)
+        with urllib.request.urlopen(url) as response, open(destination, "wb") as out_file:
+            total_size = int(response.headers.get("Content-Length", 0))
+            downloaded = 0
+            chunk_size = 1024 * 256
+            last_log = time.perf_counter()
+            while True:
+                chunk = response.read(chunk_size)
+                if not chunk:
+                    break
+                out_file.write(chunk)
+                downloaded += len(chunk)
+                now = time.perf_counter()
+                if now - last_log > 5:
+                    pct = (downloaded / total_size * 100) if total_size else 0
+                    logger.info(
+                        "Downloading... %s / %s (%.1f%%)",
+                        _format_bytes(downloaded),
+                        _format_bytes(total_size) if total_size else "unknown",
+                        pct,
+                    )
+                    last_log = now
+        logger.info(
+            "Finished download: %s (%s)",
+            destination,
+            _format_bytes(destination.stat().st_size),
+        )
+        return True
+    except Exception as exc:
+        logger.exception("Error downloading %s: %s", url, exc)
+        return False
+
+
+def _cleanup_musescore_artifacts(remove_appimage: bool = False) -> None:
+    """Remove partially extracted MuseScore artifacts to allow a clean retry."""
+    extract_dir = MUSESCORE_STORAGE_DIR / "squashfs-root"
+    if extract_dir.exists():
+        logger.warning("Removing stale MuseScore extract at %s", extract_dir)
+        shutil.rmtree(extract_dir, ignore_errors=True)
+    if remove_appimage:
+        appimage = MUSESCORE_STORAGE_DIR / "MuseScore.AppImage"
+        if appimage.exists():
+            try:
+                appimage.unlink()
+                logger.warning("Removed corrupt MuseScore AppImage at %s", appimage)
+            except Exception:
+                logger.warning("Could not remove MuseScore AppImage at %s", appimage)
+
+
+def ensure_musescore_binary() -> Optional[str]:
+    """Ensure a MuseScore binary is available for rendering."""
+    global _MUSESCORE_BINARY
+    if _MUSESCORE_BINARY and os.path.exists(_MUSESCORE_BINARY):
+        return _MUSESCORE_BINARY
+    env_path = os.environ.get(MUSESCORE_ENV_VAR)
+    if env_path and os.path.exists(env_path):
+        logger.info("Using MuseScore binary from %s", MUSESCORE_ENV_VAR)
+        _MUSESCORE_BINARY = env_path
+        return _MUSESCORE_BINARY
+    for candidate in ("mscore", "mscore3", "musescore3", "musescore", "MuseScore3"):
+        found = shutil.which(candidate)
+        if found:
+            logger.info("Found MuseScore executable on PATH: %s", found)
+            _MUSESCORE_BINARY = found
+            return _MUSESCORE_BINARY
+    MUSESCORE_STORAGE_DIR.mkdir(parents=True, exist_ok=True)
+    appimage_path = (MUSESCORE_STORAGE_DIR / "MuseScore.AppImage").resolve(strict=False)
+    apprun_path = (MUSESCORE_STORAGE_DIR / "squashfs-root" / "AppRun").resolve(strict=False)
+    if apprun_path.exists():
+        logger.info("Using cached MuseScore AppRun at %s", apprun_path)
+        os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+        _MUSESCORE_BINARY = str(apprun_path)
+        return _MUSESCORE_BINARY
+
+    for attempt in (1, 2):
+        if not appimage_path.exists() or appimage_path.stat().st_size == 0:
+            logger.info("MuseScore AppImage missing. Downloading (attempt %s)...", attempt)
+            if not _download_file(MUSESCORE_APPIMAGE_URL, appimage_path):
+                return None
+        try:
+            os.chmod(appimage_path, 0o755)
+        except Exception as exc:
+            logger.warning("Could not chmod MuseScore AppImage: %s", exc)
+        try:
+            with log_timing("Extracting MuseScore AppImage"):
+                subprocess.run(
+                    [str(appimage_path), "--appimage-extract"],
+                    cwd=MUSESCORE_STORAGE_DIR,
+                    check=True,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    timeout=MUSESCORE_EXTRACT_TIMEOUT,
+                )
+        except subprocess.CalledProcessError as exc:
+            stderr = exc.stderr.decode(errors='ignore') if exc.stderr else str(exc)
+            logger.error("MuseScore extraction failed: %s", stderr)
+            _cleanup_musescore_artifacts(remove_appimage=(attempt == 1))
+            continue
+        except subprocess.TimeoutExpired:
+            logger.error("MuseScore extraction timed out after %ss", MUSESCORE_EXTRACT_TIMEOUT)
+            _cleanup_musescore_artifacts(remove_appimage=(attempt == 1))
+            continue
+        if apprun_path.exists():
+            os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+            _MUSESCORE_BINARY = str(apprun_path)
+            try:
+                os.chmod(apprun_path, 0o755)
+            except Exception:
+                logger.debug("Could not chmod MuseScore AppRun; continuing anyway.")
+            logger.info("MuseScore AppRun ready at %s", _MUSESCORE_BINARY)
+            return _MUSESCORE_BINARY
+        logger.error("MuseScore extraction completed but AppRun was not found.")
+        _cleanup_musescore_artifacts(remove_appimage=(attempt == 1))
+    logger.error("MuseScore binary unavailable after retries.")
+    return None
+
+
+def initialize_musescore_backend() -> bool:
+    """Initialize MuseScore AppRun at startup to avoid on-demand downloads."""
+    global _MUSESCORE_READY
+    if _MUSESCORE_READY:
+        return True
+    binary = ensure_musescore_binary()
+    if binary:
+        logger.info("MuseScore AppRun ready at startup: %s", binary)
+        _MUSESCORE_READY = True
+        return True
+    logger.warning("MuseScore AppRun could not be initialized; score visualization will fail.")
+    return False
+
+
+def _coalesce_musescore_output(output_path: str) -> Optional[str]:
+    """
+    Normalize MuseScore CLI output when it renders multiple PNG pages.
+    
+    MuseScore writes `basename-1.png`, `basename-2.png`, ... even if we request
+    a single filename. We promote the first page to the requested output path
+    so downstream code can always load one predictable image.
+    """
+    target = Path(output_path)
+    if target.exists():
+        return str(target)
+    
+    suffix = target.suffix
+    pattern = f"{target.stem}-*{suffix}" if suffix else f"{target.name}-*"
+    matches = sorted(target.parent.glob(pattern))
+    if not matches:
+        return None
+    
+    first_page = matches[0]
+    normalized_path: Optional[Path] = None
+    try:
+        shutil.move(str(first_page), str(target))
+        normalized_path = target
+    except Exception:
+        try:
+            shutil.copy(str(first_page), str(target))
+            normalized_path = target
+        except Exception:
+            normalized_path = first_page
+    if normalized_path == target:
+        logger.debug("Normalized MuseScore output %s -> %s", first_page, target)
+    else:
+        logger.debug("Using MuseScore page %s as output", first_page)
+    
+    # Remove leftover pages to avoid clutter, keep best-effort
+    for extra in matches:
+        if extra == first_page:
+            continue
+        try:
+            extra.unlink()
+        except Exception:
+            pass
+    
+    return str(normalized_path)
+
+
+def render_with_musescore(musicxml_path: Optional[str], output_path: str) -> Optional[str]:
+    """Render using MuseScore command-line interface."""
+    if not musicxml_path or not os.path.exists(musicxml_path):
+        return None
+    musescore_bin = ensure_musescore_binary()
+    if musescore_bin is None:
+        logger.warning("MuseScore binary unavailable; skipping MuseScore rendering.")
+        return None
+    env = os.environ.copy()
+    env["QT_QPA_PLATFORM"] = "offscreen"
+    env.setdefault("QTWEBENGINE_DISABLE_SANDBOX", "1")
+    env.setdefault("MUSESCORE_NO_AUDIO", "1")
+    cmd = [musescore_bin, "-o", output_path, musicxml_path]
+    logger.debug("Executing MuseScore command: %s", " ".join(cmd))
+    try:
+        with log_timing("MuseScore rendering"):
+            subprocess.run(
+                cmd,
+                check=True,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                env=env,
+                timeout=MUSESCORE_RENDER_TIMEOUT,
+            )
+    except subprocess.CalledProcessError as exc:
+        stderr = exc.stderr.decode(errors='ignore') if exc.stderr else str(exc)
+        logger.error("MuseScore rendering failed: %s", stderr)
+        return None
+    except subprocess.TimeoutExpired:
+        logger.error("MuseScore rendering timed out after %ss", MUSESCORE_RENDER_TIMEOUT)
+        return None
+    normalized_path = _coalesce_musescore_output(output_path)
+    if normalized_path and os.path.exists(normalized_path):
+        logger.info("MuseScore rendered %s -> %s", musicxml_path, normalized_path)
+        return normalized_path
+    logger.error("MuseScore rendered score but the expected output file was not found.")
+    return None
+
+
 def resolve_musicxml_path(musicxml_file) -> Optional[str]:
     """Return a filesystem path for the uploaded MusicXML file."""
     if musicxml_file is None:
@@ -133,57 +422,30 @@ def save_parsed_musicxml(score: pt.score.Score, original_path: Optional[str]) ->
                 suffix = original_suffix
         fd, tmp_path = tempfile.mkstemp(suffix=suffix)
         os.close(fd)
-        pt.save_musicxml(score, tmp_path)
+        with log_timing("Saving parsed MusicXML"):
+            pt.save_musicxml(score, tmp_path)
         return tmp_path
     except Exception as exc:
-        print(f"Warning: Could not save parsed MusicXML: {exc}")
+        logger.warning("Could not save parsed MusicXML: %s", exc)
         return None
 
 
-def render_score_to_image(score: pt.score.Score, output_path: str) -> Optional[str]:
+def render_score_to_image(
+    score: pt.score.Score,
+    output_path: str,
+    source_musicxml_path: Optional[str] = None
+) -> Optional[str]:
     """
-    Render score to image using partitura.
+    Render score directly with the MuseScore AppRun (no other fallbacks).
     
-    Parameters
-    ----------
-    score : pt.score.Score
-        The score to render
-    output_path : str
-        Path to save the rendered image
-        
-    Returns
-    -------
-    str or None
-        Path to the rendered image, or None if rendering failed
+    The `score` argument is unused but kept for backward compatibility with the
+    earlier pipeline that rendered from a score object.
     """
-    try:
-        # Try to render to PNG using partitura
-        pt.render(score, fmt="png", out=output_path)
-        if os.path.exists(output_path):
-            return output_path
-    except Exception as e:
-        print(f"Error rendering score to PNG: {e}")
-    
-    # If PNG rendering failed, try PDF
-    try:
-        pdf_path = output_path.replace('.png', '.pdf')
-        pt.render(score, fmt="pdf", out=pdf_path)
-        if os.path.exists(pdf_path):
-            # Convert PDF to PNG if possible
-            try:
-                from pdf2image import convert_from_path
-                images = convert_from_path(pdf_path)
-                if images:
-                    images[0].save(output_path, 'PNG')
-                    return output_path
-            except (ImportError, Exception) as e:
-                # If conversion fails, return the PDF path
-                print(f"PDF to PNG conversion failed: {e}")
-                print("Score rendered as PDF but could not be converted to PNG for visualization.")
-    except Exception as e:
-        print(f"Error rendering score to PDF: {e}")
-    
-    return None
+    del score  # Render is driven solely by the MusicXML path
+    if not source_musicxml_path or not os.path.exists(source_musicxml_path):
+        logger.error("Cannot render score: MusicXML path '%s' not found.", source_musicxml_path)
+        return None
+    return render_with_musescore(source_musicxml_path, output_path)
 
 
 def predict_analysis(
@@ -209,8 +471,8 @@ def predict_analysis(
         Dictionary mapping task names to predictions and confidence scores
     """
     with torch.no_grad():
-        # Get predictions from model
-        predictions = model.predict(score)
+        with log_timing("Model prediction"):
+            predictions = model.predict(score)
     
     # Decode predictions
     decoded_predictions = {}
@@ -241,7 +503,7 @@ def predict_analysis(
                     else:
                         decoded_predictions[task] = decoded.flatten()
                 except (IndexError, ValueError) as e:
-                    print(f"Warning: Error decoding {task} predictions: {e}")
+                    logger.warning("Error decoding %s predictions: %s", task, e)
                     # Fallback to raw indices
                     decoded_predictions[task] = pred_onehot.cpu().numpy()
             else:
@@ -254,7 +516,7 @@ def predict_analysis(
         else:
             decoded_predictions["onset_beat"] = score.note_array()["onset_beat"]
     except (AttributeError, KeyError, IndexError) as e:
-        print(f"Warning: Could not add onset timing: {e}")
+        logger.warning("Could not add onset timing: %s", e)
     
     try:
         if "s_measure" in predictions:
@@ -262,7 +524,7 @@ def predict_analysis(
         else:
             decoded_predictions["measure"] = score[0].measure_number_map(score.note_array()["onset_div"])
     except (AttributeError, KeyError, IndexError) as e:
-        print(f"Warning: Could not add measure information: {e}")
+        logger.warning("Could not add measure information: %s", e)
     
     return decoded_predictions
 
@@ -299,30 +561,77 @@ def process_musicxml(
         
         # Load the model
         status_msg = "Loading model..."
-        print(status_msg)
+        logger.info(status_msg)
         model = load_model()
         
         # Load the score
         status_msg = "Loading score..."
-        print(status_msg)
+        logger.info(status_msg)
         score = pt.load_musicxml(score_path)
         
         parsed_score_path = save_parsed_musicxml(score, score_path)
         
         # Render score to image
-        status_msg = "Rendering score..."
-        print(status_msg)
         with tempfile.NamedTemporaryFile(suffix='.png', delete=False) as tmp_img:
             img_path = tmp_img.name
         
-        rendered_path = render_score_to_image(score, img_path)
+        rendered_path: Optional[str] = None
+        predictions: Dict[str, np.ndarray] = {}
+        source_path = parsed_score_path or score_path
+        parallel_enabled = should_parallelize()
+        logger.info("Rendering score (parallel analysis enabled=%s)...", parallel_enabled)
+        if parallel_enabled:
+            logger.info("Running analysis and visualization in parallel (threads=%s).", 2)
+            render_success = False
+            analysis_success = False
+            with ThreadPoolExecutor(max_workers=2) as executor:
+                future_map = {
+                    executor.submit(
+                        render_score_to_image,
+                        score,
+                        img_path,
+                        source_musicxml_path=source_path,
+                    ): "render",
+                    executor.submit(
+                        predict_analysis,
+                        model,
+                        score,
+                        selected_tasks,
+                    ): "analysis",
+                }
+                for future in as_completed(future_map):
+                    task_name = future_map[future]
+                    try:
+                        result = future.result()
+                    except Exception:
+                        logger.exception("%s task failed.", task_name.capitalize())
+                        continue
+                    if task_name == "render":
+                        rendered_path = result
+                        render_success = True
+                    else:
+                        predictions = result or {}
+                        analysis_success = True
+            if not render_success:
+                logger.info("Retrying score rendering sequentially after parallel failure.")
+                rendered_path = render_score_to_image(
+                    score,
+                    img_path,
+                    source_musicxml_path=source_path,
+                )
+            if not analysis_success:
+                logger.info("Retrying analysis sequentially after parallel failure.")
+                predictions = predict_analysis(model, score, selected_tasks)
+        else:
+            logger.info("Running analysis and visualization sequentially (parallel disabled).")
+            rendered_path = render_score_to_image(
+                score,
+                img_path,
+                source_musicxml_path=source_path,
+            )
+            predictions = predict_analysis(model, score, selected_tasks)
         if rendered_path is None:
-            print("Note: Score rendering failed. This requires MuseScore or LilyPond to be installed.")
-        
-        # Perform analysis
-        status_msg = "Running analysis..."
-        print(status_msg)
-        predictions = predict_analysis(model, score, selected_tasks)
+            logger.warning("MuseScore AppRun could not render the score. Visualization will be unavailable.")
         
         # Create DataFrame
         if predictions:
@@ -379,7 +688,7 @@ def process_musicxml(
         
     except Exception as e:
         error_msg = f"Error processing file: {str(e)}\n\n{traceback.format_exc()}"
-        print(error_msg)
+        logger.error(error_msg)
         return None, None, None, error_msg
 
 
@@ -408,6 +717,9 @@ DISPLAY_NAME_OVERRIDES = {
     "note_degree": "Note Degree",
 }
 
+# Ensure MuseScore AppRun is available before the UI is constructed
+initialize_musescore_backend()
+
 # Create Gradio interface
 with gr.Blocks(title="AnalysisGNN Music Analysis", theme=gr.themes.Soft()) as demo:
     gr.Markdown("""
@@ -457,18 +769,18 @@ with gr.Blocks(title="AnalysisGNN Music Analysis", theme=gr.themes.Soft()) as de
                 interactive=False
             )
     
-with gr.Row():
-    with gr.Column():
-        # Score visualization
-        gr.Markdown("### 🎼 Score Visualization")
-        image_output = gr.Image(
-            label="Rendered Score",
-            type="filepath"
-        )
-        parsed_score_output = gr.File(
-            label="Parsed MusicXML (Download)",
-            interactive=False
-        )
+    with gr.Row():
+        with gr.Column():
+            # Score visualization
+            gr.Markdown("### 🎼 Score Visualization")
+            image_output = gr.Image(
+                label="Rendered Score",
+                type="filepath"
+            )
+            parsed_score_output = gr.File(
+                label="Parsed MusicXML (Download)",
+                interactive=False
+            )
     
     with gr.Row():
         with gr.Column():
@@ -523,9 +835,9 @@ with gr.Row():
         
         if not os.path.exists(example_path):
             try:
-                print(f"Downloading example score from: {url}")
+                logger.info("Downloading example score from: %s", url)
                 urllib.request.urlretrieve(url, example_path)
-                print(f"Example score saved to: {example_path}")
+                logger.info("Example score saved to: %s", example_path)
             except Exception as e:
                 return None, f"Error downloading example: {e}"
         
@@ -558,14 +870,11 @@ with gr.Row():
 # Launch the app
 if __name__ == "__main__":
     # Pre-load the model at startup for efficiency
-    print("=" * 50)
-    print("Initializing AnalysisGNN app...")
-    print("=" * 50)
-    print("Pre-loading model at startup...")
+    logger.info("=" * 50)
+    logger.info("Initializing AnalysisGNN app...")
+    logger.info("=" * 50)
+    logger.info("Pre-loading model at startup...")
     load_model()
-    print("✓ Model loaded successfully!")
-    
-    print("=" * 50)
-    print("Starting Gradio interface...")
-    print("=" * 50)
+    logger.info("Model ready. Launching Gradio interface...")
+    logger.info("=" * 50)
     demo.launch()