livepilot 1.1.0

package/remote_script/LivePilot/devices.py

@@ -0,0 +1,466 @@
+"""
+LivePilot - Device domain handlers (11 commands).
+"""
+
+import Live
+
+from .router import register
+from .utils import get_track, get_device
+
+
+def _get_browser():
+    """Get the browser from the Application object (not Song)."""
+    return Live.Application.get_application().browser
+
+
+@register("get_device_info")
+def get_device_info(song, params):
+    """Return detailed info for a single device."""
+    track_index = int(params["track_index"])
+    device_index = int(params["device_index"])
+    track = get_track(song, track_index)
+    device = get_device(track, device_index)
+
+    result = {
+        "name": device.name,
+        "class_name": device.class_name,
+        "is_active": device.is_active,
+        "can_have_chains": device.can_have_chains,
+        "parameter_count": len(list(device.parameters)),
+    }
+    try:
+        result["type"] = device.type
+    except Exception:
+        result["type"] = None
+    return result
+
+
+@register("get_device_parameters")
+def get_device_parameters(song, params):
+    """Return all parameters for a device."""
+    track_index = int(params["track_index"])
+    device_index = int(params["device_index"])
+    track = get_track(song, track_index)
+    device = get_device(track, device_index)
+
+    parameters = []
+    for i, param in enumerate(device.parameters):
+        parameters.append({
+            "index": i,
+            "name": param.name,
+            "value": param.value,
+            "min": param.min,
+            "max": param.max,
+            "is_quantized": param.is_quantized,
+            "value_string": param.str_for_value(param.value),
+        })
+    return {"parameters": parameters}
+
+
+@register("set_device_parameter")
+def set_device_parameter(song, params):
+    """Set a single device parameter by name or index."""
+    track_index = int(params["track_index"])
+    device_index = int(params["device_index"])
+    value = float(params["value"])
+    track = get_track(song, track_index)
+    device = get_device(track, device_index)
+
+    parameter_name = params.get("parameter_name", None)
+    parameter_index = params.get("parameter_index", None)
+
+    if parameter_name is not None:
+        param = None
+        for p in device.parameters:
+            if p.name == parameter_name:
+                param = p
+                break
+        if param is None:
+            raise ValueError(
+                "Parameter '%s' not found on device '%s'"
+                % (parameter_name, device.name)
+            )
+    elif parameter_index is not None:
+        parameter_index = int(parameter_index)
+        dev_params = list(device.parameters)
+        if parameter_index < 0 or parameter_index >= len(dev_params):
+            raise IndexError(
+                "Parameter index %d out of range (0..%d)"
+                % (parameter_index, len(dev_params) - 1)
+            )
+        param = dev_params[parameter_index]
+    else:
+        raise ValueError("Must provide parameter_name or parameter_index")
+
+    param.value = value
+    return {"name": param.name, "value": param.value}
+
+
+@register("batch_set_parameters")
+def batch_set_parameters(song, params):
+    """Set multiple device parameters in one call."""
+    track_index = int(params["track_index"])
+    device_index = int(params["device_index"])
+    parameters = params["parameters"]
+    track = get_track(song, track_index)
+    device = get_device(track, device_index)
+
+    dev_params = list(device.parameters)
+    results = []
+    for entry in parameters:
+        value = float(entry["value"])
+        name_or_index = entry.get("name_or_index")
+
+        if isinstance(name_or_index, int) or (
+            isinstance(name_or_index, str) and name_or_index.isdigit()
+        ):
+            idx = int(name_or_index)
+            if idx < 0 or idx >= len(dev_params):
+                raise IndexError(
+                    "Parameter index %d out of range (0..%d)"
+                    % (idx, len(dev_params) - 1)
+                )
+            param = dev_params[idx]
+        else:
+            param = None
+            for p in dev_params:
+                if p.name == name_or_index:
+                    param = p
+                    break
+            if param is None:
+                raise ValueError(
+                    "Parameter '%s' not found on device '%s'"
+                    % (name_or_index, device.name)
+                )
+
+        param.value = value
+        results.append({"name": param.name, "value": param.value})
+
+    return {"parameters": results}
+
+
+@register("toggle_device")
+def toggle_device(song, params):
+    """Enable or disable a device."""
+    track_index = int(params["track_index"])
+    device_index = int(params["device_index"])
+    active = bool(params["active"])
+    track = get_track(song, track_index)
+    device = get_device(track, device_index)
+
+    # Find the "Device On" parameter by name (safer than assuming index 0)
+    on_param = None
+    for p in device.parameters:
+        if p.name == "Device On":
+            on_param = p
+            break
+    if on_param is None:
+        # Fallback to parameter 0 for devices that don't use "Device On"
+        on_param = device.parameters[0]
+
+    on_param.value = 1.0 if active else 0.0
+    return {"name": device.name, "is_active": on_param.value > 0.5}
+
+
+@register("delete_device")
+def delete_device(song, params):
+    """Delete a device from a track."""
+    track_index = int(params["track_index"])
+    device_index = int(params["device_index"])
+    track = get_track(song, track_index)
+    # Validate device exists
+    get_device(track, device_index)
+    track.delete_device(device_index)
+    return {"deleted": device_index}
+
+
+@register("load_device_by_uri")
+def load_device_by_uri(song, params):
+    """Load a device onto a track using a browser URI.
+
+    First tries URI-based matching (exact child.uri comparison).
+    Falls back to name extraction from the URI's last path segment.
+    Searches all browser categories including user_library and samples.
+    """
+    track_index = int(params["track_index"])
+    uri = str(params["uri"])
+    track = get_track(song, track_index)
+    browser = _get_browser()
+
+    # All categories to search
+    category_attrs = (
+        "user_library", "samples", "instruments", "audio_effects",
+        "midi_effects", "packs", "sounds", "drums",
+    )
+    categories = []
+    for attr in category_attrs:
+        try:
+            categories.append(getattr(browser, attr))
+        except Exception:
+            pass
+
+    _iterations = [0]
+    MAX_ITERATIONS = 10000
+
+    # ── Strategy 1: match by URI directly ────────────────────────────
+    def find_by_uri(parent, target_uri, depth=0):
+        if depth > 8 or _iterations[0] > MAX_ITERATIONS:
+            return None
+        try:
+            children = list(parent.children)
+        except Exception:
+            return None
+        for child in children:
+            _iterations[0] += 1
+            if _iterations[0] > MAX_ITERATIONS:
+                return None
+            try:
+                if child.uri == target_uri and child.is_loadable:
+                    return child
+            except Exception:
+                pass
+            result = find_by_uri(child, target_uri, depth + 1)
+            if result is not None:
+                return result
+        return None
+
+    for category in categories:
+        _iterations[0] = 0
+        found = find_by_uri(category, uri)
+        if found is not None:
+            song.view.selected_track = track
+            browser.load_item(found)
+            return {"loaded": found.name, "track_index": track_index}
+
+    # ── Strategy 2: extract name from URI, search by name ────────────
+    device_name = uri
+    if "#" in uri:
+        device_name = uri.split("#", 1)[1]
+    for sep in (":", "/"):
+        if sep in device_name:
+            device_name = device_name.rsplit(sep, 1)[1]
+    # URL-decode
+    try:
+        from urllib.parse import unquote
+        device_name = unquote(device_name)
+    except ImportError:
+        device_name = device_name.replace("%20", " ")
+    # Strip file extensions
+    for ext in (".amxd", ".adv", ".adg", ".aupreset", ".als", ".wav", ".aif", ".aiff", ".mp3"):
+        if device_name.lower().endswith(ext):
+            device_name = device_name[:-len(ext)]
+            break
+
+    target = device_name.lower()
+
+    def find_by_name(parent, depth=0):
+        if depth > 8 or _iterations[0] > MAX_ITERATIONS:
+            return None
+        try:
+            children = list(parent.children)
+        except Exception:
+            return None
+        for child in children:
+            _iterations[0] += 1
+            if _iterations[0] > MAX_ITERATIONS:
+                return None
+            child_lower = child.name.lower()
+            if (child_lower == target or target in child_lower) and child.is_loadable:
+                return child
+            result = find_by_name(child, depth + 1)
+            if result is not None:
+                return result
+        return None
+
+    for category in categories:
+        _iterations[0] = 0
+        found = find_by_name(category)
+        if found is not None:
+            song.view.selected_track = track
+            browser.load_item(found)
+            return {"loaded": found.name, "track_index": track_index}
+
+    raise ValueError(
+        "Device '%s' not found in browser" % device_name
+    )
+
+
+@register("find_and_load_device")
+def find_and_load_device(song, params):
+    """Find a device by name in the browser and load it onto a track.
+
+    Searches all browser categories including user_library for M4L devices.
+    Supports partial matching: 'Kickster' matches 'trnr.Kickster'.
+    """
+    track_index = int(params["track_index"])
+    device_name = str(params["device_name"]).lower()
+    track = get_track(song, track_index)
+    browser = _get_browser()
+
+    MAX_ITERATIONS = 10000
+    iterations = 0
+
+    def search_children(item, depth=0):
+        """Recursively search browser children up to depth 8."""
+        nonlocal iterations
+        if depth > 8:
+            return None
+        try:
+            children = list(item.children)
+        except Exception:
+            return None
+        for child in children:
+            iterations += 1
+            if iterations > MAX_ITERATIONS:
+                return None
+            child_lower = child.name.lower()
+            # Exact match or partial match (e.g. "kickster" in "trnr.kickster")
+            if (child_lower == device_name or device_name in child_lower) and child.is_loadable:
+                return child
+            result = search_children(child, depth + 1)
+            if result is not None:
+                return result
+        return None
+
+    # Search ALL categories — user_library first (M4L devices live there)
+    category_attrs = (
+        "user_library", "samples", "instruments", "audio_effects",
+        "midi_effects", "packs", "sounds", "drums",
+    )
+    categories = []
+    for attr in category_attrs:
+        try:
+            categories.append(getattr(browser, attr))
+        except Exception:
+            pass
+
+    for category in categories:
+        iterations = 0  # Reset per category so each gets a fair search budget
+        found = search_children(category)
+        if found is not None:
+            song.view.selected_track = track
+            browser.load_item(found)
+            return {
+                "loaded": found.name,
+                "track_index": track_index,
+            }
+
+    raise ValueError(
+        "Device '%s' not found in browser. Check spelling or use "
+        "search_browser to find the exact name." % params["device_name"]
+    )
+
+
+@register("set_simpler_playback_mode")
+def set_simpler_playback_mode(song, params):
+    """Set Simpler's playback mode (Classic/One-Shot/Slice).
+
+    playback_mode: 0=Classic, 1=One-Shot, 2=Slice
+    slice_by (optional, only for Slice mode): 0=Transient, 1=Beat, 2=Region, 3=Manual
+    sensitivity (optional, 0.0-1.0, only for Transient slicing)
+    """
+    track_index = int(params["track_index"])
+    device_index = int(params["device_index"])
+    playback_mode = int(params["playback_mode"])
+    track = get_track(song, track_index)
+    device = get_device(track, device_index)
+
+    if device.class_name != "OriginalSimpler":
+        raise ValueError(
+            "Device '%s' is %s, not Simpler"
+            % (device.name, device.class_name)
+        )
+    if playback_mode not in (0, 1, 2):
+        raise ValueError("playback_mode must be 0 (Classic), 1 (One-Shot), or 2 (Slice)")
+
+    device.playback_mode = playback_mode
+
+    result = {
+        "track_index": track_index,
+        "device_index": device_index,
+        "playback_mode": playback_mode,
+        "mode_name": ["Classic", "One-Shot", "Slice"][playback_mode],
+    }
+
+    # Set slicing style if in Slice mode
+    if playback_mode == 2:
+        slice_by = params.get("slice_by", None)
+        if slice_by is not None:
+            slice_by = int(slice_by)
+            if slice_by not in (0, 1, 2, 3):
+                raise ValueError(
+                    "slice_by must be 0 (Transient), 1 (Beat), 2 (Region), or 3 (Manual)"
+                )
+            device.slicing_style = slice_by
+            result["slice_by"] = slice_by
+            result["slice_by_name"] = ["Transient", "Beat", "Region", "Manual"][slice_by]
+
+        sensitivity = params.get("sensitivity", None)
+        if sensitivity is not None:
+            sensitivity = float(sensitivity)
+            device.slicing_sensitivity = max(0.0, min(1.0, sensitivity))
+            result["sensitivity"] = device.slicing_sensitivity
+
+    return result
+
+
+@register("get_rack_chains")
+def get_rack_chains(song, params):
+    """Return chain info for a rack device."""
+    track_index = int(params["track_index"])
+    device_index = int(params["device_index"])
+    track = get_track(song, track_index)
+    device = get_device(track, device_index)
+
+    if not device.can_have_chains:
+        raise ValueError(
+            "Device '%s' is not a rack and cannot have chains" % device.name
+        )
+
+    chains = []
+    for i, chain in enumerate(device.chains):
+        chain_info = {
+            "index": i,
+            "name": chain.name,
+            "volume": chain.mixer_device.volume.value,
+            "pan": chain.mixer_device.panning.value,
+            "mute": chain.mute,
+            "solo": chain.solo,
+        }
+        chains.append(chain_info)
+    return {"chains": chains}
+
+
+@register("set_chain_volume")
+def set_chain_volume(song, params):
+    """Set volume and/or pan for a rack chain."""
+    track_index = int(params["track_index"])
+    device_index = int(params["device_index"])
+    chain_index = int(params["chain_index"])
+    track = get_track(song, track_index)
+    device = get_device(track, device_index)
+
+    if not device.can_have_chains:
+        raise ValueError(
+            "Device '%s' is not a rack and cannot have chains" % device.name
+        )
+
+    chains = list(device.chains)
+    if chain_index < 0 or chain_index >= len(chains):
+        raise IndexError(
+            "Chain index %d out of range (0..%d)"
+            % (chain_index, len(chains) - 1)
+        )
+    chain = chains[chain_index]
+
+    if "volume" in params:
+        chain.mixer_device.volume.value = float(params["volume"])
+    if "pan" in params:
+        chain.mixer_device.panning.value = float(params["pan"])
+
+    return {
+        "index": chain_index,
+        "name": chain.name,
+        "volume": chain.mixer_device.volume.value,
+        "pan": chain.mixer_device.panning.value,
+    }

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,
+    }