livepilot 1.0.0

package/remote_script/LivePilot/diagnostics.py

@@ -0,0 +1,198 @@
+"""
+LivePilot - Session diagnostics handler (1 command).
+
+Analyzes the current session and flags potential issues:
+armed tracks, mute/solo leftovers, empty clips, unnamed tracks,
+empty scenes, and device-less instrument tracks.
+"""
+
+from .router import register
+
+
+# Default track names that indicate the user hasn't renamed them.
+# Ableton auto-names tracks like "1-MIDI", "2-Audio", "3-MIDI", etc.
+_DEFAULT_NAME_PATTERNS = frozenset([
+    "MIDI", "Audio", "Inst", "Return",
+])
+
+
+def _looks_default_name(name):
+    """Check if a track name looks like an Ableton default."""
+    stripped = name.strip()
+    # Pattern: "N-Type" or just "Type" (e.g., "1-MIDI", "MIDI", "2-Audio")
+    for part in stripped.split("-"):
+        part = part.strip()
+        if part.isdigit():
+            continue
+        if part in _DEFAULT_NAME_PATTERNS:
+            return True
+    return False
+
+
+@register("get_session_diagnostics")
+def get_session_diagnostics(song, params):
+    """Analyze the session and return a diagnostic report."""
+    issues = []
+    stats = {
+        "track_count": 0,
+        "return_track_count": 0,
+        "scene_count": 0,
+        "total_clips": 0,
+        "empty_scenes": 0,
+    }
+
+    tracks = list(song.tracks)
+    scenes = list(song.scenes)
+    return_tracks = list(song.return_tracks)
+
+    stats["track_count"] = len(tracks)
+    stats["return_track_count"] = len(return_tracks)
+    stats["scene_count"] = len(scenes)
+
+    # ── Track-level checks ─────────────────────────────────────────────
+
+    armed_tracks = []
+    soloed_tracks = []
+    muted_tracks = []
+    unnamed_tracks = []
+    empty_tracks = []  # no clips at all
+    no_device_midi_tracks = []  # MIDI tracks with no instruments
+    track_slots = []  # cached clip_slots per track (avoid re-evaluating LOM tuple)
+
+    for i, track in enumerate(tracks):
+        # Armed check
+        if track.arm:
+            armed_tracks.append({"index": i, "name": track.name})
+
+        # Solo check
+        if track.solo:
+            soloed_tracks.append({"index": i, "name": track.name})
+
+        # Muted tracks (informational, only flag if many)
+        if track.mute:
+            muted_tracks.append({"index": i, "name": track.name})
+
+        # Unnamed / default name check
+        if _looks_default_name(track.name):
+            unnamed_tracks.append({"index": i, "name": track.name})
+
+        # Cache clip_slots once per track
+        slots = list(track.clip_slots)
+        track_slots.append(slots)
+
+        # Clip count
+        clip_count = 0
+        for slot in slots:
+            if slot.has_clip:
+                clip_count += 1
+        stats["total_clips"] += clip_count
+
+        if clip_count == 0:
+            empty_tracks.append({"index": i, "name": track.name})
+
+        # MIDI track with no devices (no instrument loaded)
+        if track.has_midi_input and len(list(track.devices)) == 0:
+            no_device_midi_tracks.append({"index": i, "name": track.name})
+
+    # Build issues from checks
+    if armed_tracks:
+        issues.append({
+            "type": "armed_tracks",
+            "severity": "warning",
+            "message": "%d track(s) left armed" % len(armed_tracks),
+            "details": armed_tracks,
+        })
+
+    if soloed_tracks:
+        issues.append({
+            "type": "soloed_tracks",
+            "severity": "warning",
+            "message": "%d track(s) soloed — other tracks are silenced" % len(soloed_tracks),
+            "details": soloed_tracks,
+        })
+
+    if len(muted_tracks) > len(tracks) * 0.5 and len(muted_tracks) > 2:
+        issues.append({
+            "type": "many_muted",
+            "severity": "info",
+            "message": "%d of %d tracks muted — consider cleaning up unused tracks" % (
+                len(muted_tracks), len(tracks)
+            ),
+            "details": muted_tracks,
+        })
+
+    if unnamed_tracks:
+        issues.append({
+            "type": "unnamed_tracks",
+            "severity": "info",
+            "message": "%d track(s) have default names" % len(unnamed_tracks),
+            "details": unnamed_tracks,
+        })
+
+    if empty_tracks:
+        issues.append({
+            "type": "empty_tracks",
+            "severity": "info",
+            "message": "%d track(s) have no clips" % len(empty_tracks),
+            "details": empty_tracks,
+        })
+
+    if no_device_midi_tracks:
+        issues.append({
+            "type": "no_instrument",
+            "severity": "warning",
+            "message": "%d MIDI track(s) have no instrument loaded" % len(no_device_midi_tracks),
+            "details": no_device_midi_tracks,
+        })
+
+    # ── Scene-level checks ──────────────────────────────────────────────
+
+    empty_scenes = []
+    for i, scene in enumerate(scenes):
+        has_any_clip = False
+        for slots in track_slots:
+            if i < len(slots) and slots[i].has_clip:
+                has_any_clip = True
+                break
+        if not has_any_clip:
+            empty_scenes.append({"index": i, "name": scene.name})
+
+    stats["empty_scenes"] = len(empty_scenes)
+
+    if empty_scenes and len(empty_scenes) > 1:
+        issues.append({
+            "type": "empty_scenes",
+            "severity": "info",
+            "message": "%d scene(s) have no clips across any track" % len(empty_scenes),
+            "details": empty_scenes[:10],  # Cap at 10 to avoid huge payloads
+        })
+
+    # ── Return track checks ─────────────────────────────────────────────
+
+    soloed_returns = []
+    for i, track in enumerate(return_tracks):
+        if track.solo:
+            soloed_returns.append({"index": i, "name": track.name})
+
+    if soloed_returns:
+        issues.append({
+            "type": "soloed_returns",
+            "severity": "warning",
+            "message": "%d return track(s) soloed" % len(soloed_returns),
+            "details": soloed_returns,
+        })
+
+    # ── Summary ─────────────────────────────────────────────────────────
+
+    severity_counts = {"warning": 0, "info": 0}
+    for issue in issues:
+        severity_counts[issue["severity"]] = severity_counts.get(issue["severity"], 0) + 1
+
+    return {
+        "healthy": len(issues) == 0,
+        "issue_count": len(issues),
+        "warnings": severity_counts.get("warning", 0),
+        "info": severity_counts.get("info", 0),
+        "issues": issues,
+        "stats": stats,
+    }

package/remote_script/LivePilot/mixing.py

@@ -0,0 +1,194 @@
+"""
+LivePilot - Mixing domain handlers (8 commands).
+"""
+
+from .router import register
+from .utils import get_track
+
+
+@register("set_track_volume")
+def set_track_volume(song, params):
+    """Set the volume of a track."""
+    track_index = int(params["track_index"])
+    track = get_track(song, track_index)
+    volume = float(params["volume"])
+    track.mixer_device.volume.value = volume
+    return {"index": track_index, "volume": track.mixer_device.volume.value}
+
+
+@register("set_track_pan")
+def set_track_pan(song, params):
+    """Set the panning of a track."""
+    track_index = int(params["track_index"])
+    track = get_track(song, track_index)
+    pan = float(params["pan"])
+    track.mixer_device.panning.value = pan
+    return {"index": track_index, "pan": track.mixer_device.panning.value}
+
+
+@register("set_track_send")
+def set_track_send(song, params):
+    """Set a send value on a track."""
+    track_index = int(params["track_index"])
+    track = get_track(song, track_index)
+    send_index = int(params["send_index"])
+    sends = list(track.mixer_device.sends)
+    if send_index < 0 or send_index >= len(sends):
+        raise IndexError(
+            "Send index %d out of range (0..%d)"
+            % (send_index, len(sends) - 1)
+        )
+    sends[send_index].value = float(params["value"])
+    return {
+        "index": track_index,
+        "send_index": send_index,
+        "value": sends[send_index].value,
+    }
+
+
+@register("get_return_tracks")
+def get_return_tracks(song, params):
+    """Return info about all return tracks."""
+    result = []
+    for i, track in enumerate(song.return_tracks):
+        result.append({
+            "index": i,
+            "name": track.name,
+            "color_index": track.color_index,
+            "volume": track.mixer_device.volume.value,
+            "panning": track.mixer_device.panning.value,
+        })
+    return {"return_tracks": result}
+
+
+@register("get_master_track")
+def get_master_track(song, params):
+    """Return info about the master track."""
+    master = song.master_track
+    devices = []
+    for i, device in enumerate(master.devices):
+        devices.append({
+            "index": i,
+            "name": device.name,
+            "class_name": device.class_name,
+            "is_active": device.is_active,
+        })
+    return {
+        "name": master.name,
+        "volume": master.mixer_device.volume.value,
+        "panning": master.mixer_device.panning.value,
+        "devices": devices,
+    }
+
+
+@register("set_master_volume")
+def set_master_volume(song, params):
+    """Set the master track volume."""
+    volume = float(params["volume"])
+    song.master_track.mixer_device.volume.value = volume
+    return {"volume": song.master_track.mixer_device.volume.value}
+
+
+@register("get_track_routing")
+def get_track_routing(song, params):
+    """Get the input/output routing for a track."""
+    track_index = int(params["track_index"])
+    track = get_track(song, track_index)
+    result = {"index": track_index}
+    try:
+        result["input_routing_type"] = track.input_routing_type.display_name
+    except AttributeError:
+        result["input_routing_type"] = None
+    try:
+        result["input_routing_channel"] = track.input_routing_channel.display_name
+    except AttributeError:
+        result["input_routing_channel"] = None
+    try:
+        result["output_routing_type"] = track.output_routing_type.display_name
+    except AttributeError:
+        result["output_routing_type"] = None
+    try:
+        result["output_routing_channel"] = track.output_routing_channel.display_name
+    except AttributeError:
+        result["output_routing_channel"] = None
+    return result
+
+
+@register("set_track_routing")
+def set_track_routing(song, params):
+    """Set input/output routing for a track by display name."""
+    track_index = int(params["track_index"])
+    track = get_track(song, track_index)
+    if not any(k in params for k in ("input_type", "input_channel", "output_type", "output_channel")):
+        raise ValueError("At least one routing parameter must be provided")
+    result = {"index": track_index}
+
+    if "input_type" in params:
+        name = str(params["input_type"])
+        available = list(track.available_input_routing_types)
+        matched = None
+        for rt in available:
+            if rt.display_name == name:
+                matched = rt
+                break
+        if matched is None:
+            options = [rt.display_name for rt in available]
+            raise ValueError(
+                "Input routing type '%s' not found. Available: %s"
+                % (name, ", ".join(options))
+            )
+        track.input_routing_type = matched
+        result["input_routing_type"] = track.input_routing_type.display_name
+
+    if "input_channel" in params:
+        name = str(params["input_channel"])
+        available = list(track.available_input_routing_channels)
+        matched = None
+        for ch in available:
+            if ch.display_name == name:
+                matched = ch
+                break
+        if matched is None:
+            options = [ch.display_name for ch in available]
+            raise ValueError(
+                "Input routing channel '%s' not found. Available: %s"
+                % (name, ", ".join(options))
+            )
+        track.input_routing_channel = matched
+        result["input_routing_channel"] = track.input_routing_channel.display_name
+
+    if "output_type" in params:
+        name = str(params["output_type"])
+        available = list(track.available_output_routing_types)
+        matched = None
+        for rt in available:
+            if rt.display_name == name:
+                matched = rt
+                break
+        if matched is None:
+            options = [rt.display_name for rt in available]
+            raise ValueError(
+                "Output routing type '%s' not found. Available: %s"
+                % (name, ", ".join(options))
+            )
+        track.output_routing_type = matched
+        result["output_routing_type"] = track.output_routing_type.display_name
+
+    if "output_channel" in params:
+        name = str(params["output_channel"])
+        available = list(track.available_output_routing_channels)
+        matched = None
+        for ch in available:
+            if ch.display_name == name:
+                matched = ch
+                break
+        if matched is None:
+            options = [ch.display_name for ch in available]
+            raise ValueError(
+                "Output routing channel '%s' not found. Available: %s"
+                % (name, ", ".join(options))
+            )
+        track.output_routing_channel = matched
+        result["output_routing_channel"] = track.output_routing_channel.display_name
+
+    return result