livepilot 1.1.0

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 Exception:
+        result["input_routing_type"] = None
+    try:
+        result["input_routing_channel"] = track.input_routing_channel.display_name
+    except Exception:
+        result["input_routing_channel"] = None
+    try:
+        result["output_routing_type"] = track.output_routing_type.display_name
+    except Exception:
+        result["output_routing_type"] = None
+    try:
+        result["output_routing_channel"] = track.output_routing_channel.display_name
+    except Exception:
+        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

package/remote_script/LivePilot/notes.py

@@ -0,0 +1,339 @@
+"""
+LivePilot - Notes domain handlers (8 commands).
+
+Uses Live 12's modern note API: add_new_notes, get_notes_extended,
+remove_notes_extended, remove_notes_by_id, apply_note_modifications.
+"""
+
+from .router import register
+from .utils import get_clip, get_track
+
+
+@register("add_notes")
+def add_notes(song, params):
+    """Add MIDI notes to a clip using Live 12's modern API."""
+    track_index = int(params["track_index"])
+    clip_index = int(params["clip_index"])
+    notes = params["notes"]
+    if not notes:
+        raise ValueError("notes list cannot be empty")
+
+    clip = get_clip(song, track_index, clip_index)
+    import Live
+    song.begin_undo_step()
+    try:
+        note_specs = []
+        for note in notes:
+            kwargs = dict(
+                pitch=int(note["pitch"]),
+                start_time=float(note["start_time"]),
+                duration=float(note["duration"]),
+                velocity=float(note.get("velocity", 100)),
+                mute=bool(note.get("mute", False)),
+            )
+            if "probability" in note:
+                kwargs["probability"] = float(note["probability"])
+            if "velocity_deviation" in note:
+                kwargs["velocity_deviation"] = float(note["velocity_deviation"])
+            if "release_velocity" in note:
+                kwargs["release_velocity"] = float(note["release_velocity"])
+            spec = Live.Clip.MidiNoteSpecification(**kwargs)
+            note_specs.append(spec)
+        clip.add_new_notes(tuple(note_specs))
+    finally:
+        song.end_undo_step()
+
+    return {
+        "track_index": track_index,
+        "clip_index": clip_index,
+        "notes_added": len(notes),
+    }
+
+
+@register("get_notes")
+def get_notes(song, params):
+    """Get MIDI notes from a clip region."""
+    track_index = int(params["track_index"])
+    clip_index = int(params["clip_index"])
+    clip = get_clip(song, track_index, clip_index)
+
+    from_pitch = int(params.get("from_pitch", 0))
+    pitch_span = int(params.get("pitch_span", 128))
+    from_time = float(params.get("from_time", 0.0))
+    # Default to clip length, but use a large span if clip has no length yet
+    default_span = clip.length if clip.length > 0 else 32768.0
+    time_span = float(params.get("time_span", default_span))
+
+    raw_notes = clip.get_notes_extended(from_pitch, pitch_span, from_time, time_span)
+
+    result = []
+    for note in raw_notes:
+        result.append({
+            "note_id": note.note_id,
+            "pitch": note.pitch,
+            "start_time": note.start_time,
+            "duration": note.duration,
+            "velocity": note.velocity,
+            "mute": note.mute,
+            "probability": note.probability,
+            "velocity_deviation": note.velocity_deviation,
+            "release_velocity": note.release_velocity,
+        })
+
+    return {
+        "track_index": track_index,
+        "clip_index": clip_index,
+        "notes": result,
+    }
+
+
+@register("remove_notes")
+def remove_notes(song, params):
+    """Remove MIDI notes from a clip region."""
+    track_index = int(params["track_index"])
+    clip_index = int(params["clip_index"])
+    clip = get_clip(song, track_index, clip_index)
+
+    from_pitch = int(params.get("from_pitch", 0))
+    pitch_span = int(params.get("pitch_span", 128))
+    from_time = float(params.get("from_time", 0.0))
+    default_span = clip.length if clip.length > 0 else 32768.0
+    time_span = float(params.get("time_span", default_span))
+
+    song.begin_undo_step()
+    try:
+        clip.remove_notes_extended(from_pitch, pitch_span, from_time, time_span)
+    finally:
+        song.end_undo_step()
+
+    return {
+        "track_index": track_index,
+        "clip_index": clip_index,
+        "removed": True,
+    }
+
+
+@register("remove_notes_by_id")
+def remove_notes_by_id(song, params):
+    """Remove specific MIDI notes by their IDs."""
+    track_index = int(params["track_index"])
+    clip_index = int(params["clip_index"])
+    note_ids = params["note_ids"]
+    if not note_ids:
+        raise ValueError("note_ids list cannot be empty")
+
+    clip = get_clip(song, track_index, clip_index)
+    song.begin_undo_step()
+    try:
+        clip.remove_notes_by_id(tuple(int(nid) for nid in note_ids))
+    finally:
+        song.end_undo_step()
+
+    return {
+        "track_index": track_index,
+        "clip_index": clip_index,
+        "removed_count": len(note_ids),
+    }
+
+
+@register("modify_notes")
+def modify_notes(song, params):
+    """Modify existing MIDI notes by ID."""
+    track_index = int(params["track_index"])
+    clip_index = int(params["clip_index"])
+    modifications = params["modifications"]
+    if not modifications:
+        raise ValueError("modifications list cannot be empty")
+
+    clip = get_clip(song, track_index, clip_index)
+
+    # Get all notes — returns a C++ NoteVector that must be passed back intact
+    all_notes = clip.get_notes_extended(0, 128, 0.0, clip.length + 1.0)
+
+    # Build a lookup by note_id
+    note_map = {}
+    for note in all_notes:
+        note_map[note.note_id] = note
+
+    # Apply modifications in-place on the original NoteVector's objects
+    modified_count = 0
+    for mod in modifications:
+        note_id = int(mod["note_id"])
+        if note_id not in note_map:
+            raise ValueError("Note ID %d not found in clip" % note_id)
+        note = note_map[note_id]
+        if "pitch" in mod:
+            note.pitch = int(mod["pitch"])
+        if "start_time" in mod:
+            note.start_time = float(mod["start_time"])
+        if "duration" in mod:
+            note.duration = float(mod["duration"])
+        if "velocity" in mod:
+            note.velocity = float(mod["velocity"])
+        if "probability" in mod:
+            note.probability = float(mod["probability"])
+        modified_count += 1
+
+    # Pass the original NoteVector back — Boost.Python requires the C++ type
+    song.begin_undo_step()
+    try:
+        clip.apply_note_modifications(all_notes)
+    finally:
+        song.end_undo_step()
+
+    return {
+        "track_index": track_index,
+        "clip_index": clip_index,
+        "modified_count": modified_count,
+    }
+
+
+@register("duplicate_notes")
+def duplicate_notes(song, params):
+    """Duplicate specific notes by ID, with optional time offset."""
+    track_index = int(params["track_index"])
+    clip_index = int(params["clip_index"])
+    note_ids = params["note_ids"]
+    time_offset = float(params.get("time_offset", 0.0))
+    if not note_ids:
+        raise ValueError("note_ids list cannot be empty")
+
+    clip = get_clip(song, track_index, clip_index)
+    note_id_set = set(int(nid) for nid in note_ids)
+
+    # Get all notes and filter to the requested IDs
+    all_notes = clip.get_notes_extended(0, 128, 0.0, clip.length + 1.0)
+    source_notes = []
+    for note in all_notes:
+        if note.note_id in note_id_set:
+            source_notes.append({
+                "pitch": note.pitch,
+                "start_time": note.start_time + time_offset,
+                "duration": note.duration,
+                "velocity": note.velocity,
+                "mute": note.mute,
+                "probability": note.probability,
+                "velocity_deviation": note.velocity_deviation,
+                "release_velocity": note.release_velocity,
+            })
+
+    if not source_notes:
+        raise ValueError("No matching notes found for the given IDs")
+
+    # Add the duplicated notes with all attributes preserved
+    import Live
+    song.begin_undo_step()
+    try:
+        note_specs = []
+        for note in source_notes:
+            kwargs = dict(
+                pitch=int(note["pitch"]),
+                start_time=float(note["start_time"]),
+                duration=float(note["duration"]),
+                velocity=float(note["velocity"]),
+                mute=bool(note["mute"]),
+            )
+            if note.get("probability") is not None:
+                kwargs["probability"] = float(note["probability"])
+            if note.get("velocity_deviation") is not None:
+                kwargs["velocity_deviation"] = float(note["velocity_deviation"])
+            if note.get("release_velocity") is not None:
+                kwargs["release_velocity"] = float(note["release_velocity"])
+            spec = Live.Clip.MidiNoteSpecification(**kwargs)
+            note_specs.append(spec)
+        clip.add_new_notes(tuple(note_specs))
+    finally:
+        song.end_undo_step()
+
+    return {
+        "track_index": track_index,
+        "clip_index": clip_index,
+        "duplicated_count": len(source_notes),
+    }
+
+
+@register("transpose_notes")
+def transpose_notes(song, params):
+    """Transpose notes in a time range by a number of semitones."""
+    track_index = int(params["track_index"])
+    clip_index = int(params["clip_index"])
+    semitones = int(params["semitones"])
+    arrangement = bool(params.get("arrangement", False))
+
+    if arrangement:
+        track = get_track(song, track_index)
+        arr_clips = list(track.arrangement_clips)
+        if clip_index < 0 or clip_index >= len(arr_clips):
+            raise IndexError(
+                "Arrangement clip index %d out of range (0..%d)"
+                % (clip_index, len(arr_clips) - 1)
+            )
+        clip = arr_clips[clip_index]
+    else:
+        clip = get_clip(song, track_index, clip_index)
+
+    from_time = float(params.get("from_time", 0.0))
+    time_span = float(params.get("time_span", clip.length))
+
+    # Get notes — returns C++ NoteVector that must be passed back intact
+    all_notes = clip.get_notes_extended(0, 128, from_time, time_span)
+
+    # Modify pitch in-place, skip notes that would go out of MIDI range
+    transposed_count = 0
+    skipped_count = 0
+    total_in_range = 0
+    for note in all_notes:
+        total_in_range += 1
+        new_pitch = note.pitch + semitones
+        if new_pitch < 0 or new_pitch > 127:
+            skipped_count += 1
+            continue
+        note.pitch = new_pitch
+        transposed_count += 1
+
+    if transposed_count > 0:
+        # Pass the original NoteVector back — Boost.Python requires the C++ type
+        song.begin_undo_step()
+        try:
+            clip.apply_note_modifications(all_notes)
+        finally:
+            song.end_undo_step()
+
+    result = {
+        "track_index": track_index,
+        "clip_index": clip_index,
+        "transposed_count": transposed_count,
+        "semitones": semitones,
+    }
+    if skipped_count > 0:
+        result["skipped_out_of_range"] = skipped_count
+        result["warning"] = (
+            "%d note(s) skipped — transposing by %+d semitones would "
+            "exceed MIDI range (0-127)" % (skipped_count, semitones)
+        )
+    return result
+
+
+@register("quantize_clip")
+def quantize_clip(song, params):
+    """Quantize a clip to a grid.
+
+    grid is a RecordQuantization enum integer:
+        0=None, 1=1/4, 2=1/8, 3=1/8T, 4=1/8+T,
+        5=1/16, 6=1/16T, 7=1/16+T, 8=1/32
+    """
+    track_index = int(params["track_index"])
+    clip_index = int(params["clip_index"])
+    grid = int(params["grid"])
+    amount = float(params.get("amount", 1.0))
+
+    clip = get_clip(song, track_index, clip_index)
+    clip.quantize(grid, amount)
+
+    return {
+        "track_index": track_index,
+        "clip_index": clip_index,
+        "grid": grid,
+        "amount": amount,
+        "quantized": True,
+    }

package/remote_script/LivePilot/router.py

@@ -0,0 +1,74 @@
+"""
+LivePilot - Command dispatch registry.
+
+Handlers register themselves via the @register decorator.
+dispatch() is called on the main thread to route commands.
+"""
+
+from .utils import (
+    success_response,
+    error_response,
+    INDEX_ERROR,
+    INVALID_PARAM,
+    NOT_FOUND,
+    INTERNAL,
+)
+
+# ── Handler registry ─────────────────────────────────────────────────────────
+
+_handlers = {}
+
+
+def register(command_type):
+    """Decorator that registers a handler function for *command_type*."""
+    def decorator(fn):
+        _handlers[command_type] = fn
+        return fn
+    return decorator
+
+
+# ── Dispatcher ───────────────────────────────────────────────────────────────
+
+def dispatch(song, command):
+    """Route a parsed command dict to the appropriate handler.
+
+    Parameters
+    ----------
+    song : Live.Song.Song
+        The current song instance.
+    command : dict
+        Must contain ``id`` (str), ``type`` (str), and optionally ``params`` (dict).
+
+    Returns
+    -------
+    dict
+        A success or error response envelope.
+    """
+    request_id = command.get("id", "unknown")
+    cmd_type = command.get("type")
+    params = command.get("params", {})
+
+    if cmd_type is None:
+        return error_response(request_id, "Missing 'type' field", INVALID_PARAM)
+
+    # Built-in ping — no handler registration needed.
+    if cmd_type == "ping":
+        return success_response(request_id, {"pong": True})
+
+    handler = _handlers.get(cmd_type)
+    if handler is None:
+        return error_response(
+            request_id,
+            "Unknown command type: %s" % cmd_type,
+            NOT_FOUND,
+        )
+
+    try:
+        result = handler(song, params)
+        return success_response(request_id, result)
+    except IndexError as exc:
+        return error_response(request_id, str(exc), INDEX_ERROR)
+    except ValueError as exc:
+        return error_response(request_id, str(exc), INVALID_PARAM)
+    except Exception as exc:
+        return error_response(request_id, str(exc), INTERNAL)

package/remote_script/LivePilot/scenes.py

@@ -0,0 +1,75 @@
+"""
+LivePilot - Scene domain handlers (6 commands).
+"""
+
+from .router import register
+from .utils import get_scene
+
+
+@register("get_scenes_info")
+def get_scenes_info(song, params):
+    """Return info for all scenes."""
+    scenes = []
+    for i, scene in enumerate(song.scenes):
+        scenes.append({
+            "index": i,
+            "name": scene.name,
+            "tempo": scene.tempo if scene.tempo > 0 else None,
+            "color_index": scene.color_index,
+        })
+    return {"scenes": scenes}
+
+
+@register("create_scene")
+def create_scene(song, params):
+    """Create a new scene at the given index."""
+    index = int(params.get("index", -1))
+    song.create_scene(index)
+    if index == -1:
+        new_index = len(list(song.scenes)) - 1
+    else:
+        new_index = index
+    scene = list(song.scenes)[new_index]
+    return {
+        "index": new_index,
+        "name": scene.name,
+        "color_index": scene.color_index,
+    }
+
+
+@register("delete_scene")
+def delete_scene(song, params):
+    """Delete a scene by index."""
+    scene_index = int(params["scene_index"])
+    get_scene(song, scene_index)
+    song.delete_scene(scene_index)
+    return {"deleted": scene_index}
+
+
+@register("duplicate_scene")
+def duplicate_scene(song, params):
+    """Duplicate a scene by index."""
+    scene_index = int(params["scene_index"])
+    get_scene(song, scene_index)
+    song.duplicate_scene(scene_index)
+    new_index = scene_index + 1
+    scene = list(song.scenes)[new_index]
+    return {"index": new_index, "name": scene.name}
+
+
+@register("fire_scene")
+def fire_scene(song, params):
+    """Fire (launch) a scene."""
+    scene_index = int(params["scene_index"])
+    scene = get_scene(song, scene_index)
+    scene.fire()
+    return {"index": scene_index, "fired": True}
+
+
+@register("set_scene_name")
+def set_scene_name(song, params):
+    """Rename a scene."""
+    scene_index = int(params["scene_index"])
+    scene = get_scene(song, scene_index)
+    scene.name = str(params["name"])
+    return {"index": scene_index, "name": scene.name}