livepilot 1.4.1 → 1.4.4

package/remote_script/LivePilot/arrangement.py

@@ -606,7 +606,8 @@ def jump_to_time(song, params):
     if beat_time < 0:
         raise ValueError("beat_time must be >= 0")
     song.current_song_time = beat_time
-    return {"current_song_time": song.current_song_time}
+    # Echo requested value — getter may return stale state before update propagates
+    return {"current_song_time": beat_time}
 
 
 @register("capture_midi")

package/remote_script/LivePilot/browser.py

@@ -14,8 +14,13 @@ def _get_browser():
 
 
 def _get_categories(browser):
-    """Return a dict of browser category name -> browser item."""
-    return {
+    """Return a dict of browser category name -> browser item.
+
+    Includes all documented Browser properties from the Live Object Model:
+    instruments, audio_effects, midi_effects, sounds, drums, samples,
+    packs, user_library, plugins, max_for_live, clips, current_project.
+    """
+    categories = {
         "instruments": browser.instruments,
         "audio_effects": browser.audio_effects,
         "midi_effects": browser.midi_effects,
@@ -25,6 +30,15 @@ def _get_categories(browser):
         "packs": browser.packs,
         "user_library": browser.user_library,
     }
+    # Additional categories — may not exist on older Live versions
+    for attr in ("plugins", "max_for_live", "clips", "current_project"):
+        try:
+            val = getattr(browser, attr)
+            if val is not None:
+                categories[attr] = val
+        except AttributeError:
+            pass
+    return categories
 
 
 def _navigate_path(browser, path):
@@ -180,11 +194,32 @@ def load_browser_item(song, params):
     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",
-    )
+    # Parse category hint from URI (e.g., "query:Drums#..." -> prioritize drums)
+    _category_map = {
+        "drums": "drums", "samples": "samples", "instruments": "instruments",
+        "audiofx": "audio_effects", "audio_effects": "audio_effects",
+        "midifx": "midi_effects", "midi_effects": "midi_effects",
+        "sounds": "sounds", "packs": "packs",
+        "userlibrary": "user_library", "user_library": "user_library",
+        "plugins": "plugins", "max_for_live": "max_for_live",
+    }
+    priority_attr = None
+    if ":" in uri:
+        # Extract category from "query:Drums#..." or "query:UserLibrary#..."
+        after_colon = uri.split(":", 1)[1]
+        cat_hint = after_colon.split("#", 1)[0].lower().replace(" ", "_")
+        priority_attr = _category_map.get(cat_hint)
+
+    # Build category search order — prioritize the category from the URI
+    category_attrs = [
+        "user_library", "plugins", "max_for_live", "samples",
+        "instruments", "audio_effects", "midi_effects", "packs",
+        "sounds", "drums",
+    ]
+    if priority_attr and priority_attr in category_attrs:
+        category_attrs.remove(priority_attr)
+        category_attrs.insert(0, priority_attr)
+
     categories = []
     for attr in category_attrs:
         try:
@@ -193,7 +228,7 @@ def load_browser_item(song, params):
             pass
 
     _iterations = [0]
-    MAX_ITERATIONS = 10000
+    MAX_ITERATIONS = 50000
 
     # ── Strategy 1: match by URI directly ────────────────────────────
     def find_by_uri(parent, target_uri, depth=0):
@@ -234,6 +269,54 @@ def load_browser_item(song, params):
     device_name = uri
     if "#" in uri:
         device_name = uri.split("#", 1)[1]
+    # For Sounds URIs like "Pad:FileId_6343", strip the FileId part
+    # and use the subcategory or the full fragment for matching
+    if "FileId_" in device_name:
+        # URI contains an internal file ID — name-based search won't work.
+        # Try one more URI pass with a much higher iteration limit.
+        _iterations[0] = 0
+        DEEP_MAX = 200000
+        def find_by_uri_deep(parent, target_uri, depth=0):
+            if depth > 12 or _iterations[0] > DEEP_MAX:
+                return None
+            try:
+                children = list(parent.children)
+            except AttributeError:
+                return None
+            for child in children:
+                _iterations[0] += 1
+                if _iterations[0] > DEEP_MAX:
+                    return None
+                try:
+                    if child.uri == target_uri and child.is_loadable:
+                        return child
+                except AttributeError:
+                    pass
+                result = find_by_uri_deep(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_deep(category, uri)
+            if found is not None:
+                song.view.selected_track = track
+                browser.load_item(found)
+                device_count = len(list(track.devices))
+                return {
+                    "track_index": track_index,
+                    "loaded": True,
+                    "name": found.name,
+                    "device_count": device_count,
+                }
+
+        raise ValueError(
+            "Item '%s' not found in browser (FileId URI — try "
+            "search_browser to find the item, then use find_and_load_device "
+            "with the exact name instead)" % uri
+        )
+
     for sep in (":", "/"):
         if sep in device_name:
             device_name = device_name.rsplit(sep, 1)[1]

package/remote_script/LivePilot/devices.py

@@ -71,14 +71,24 @@ def set_device_parameter(song, params):
 
     if parameter_name is not None:
         param = None
+        # Try exact match first
         for p in device.parameters:
             if p.name == parameter_name:
                 param = p
                 break
+        # Fallback: case-insensitive match
         if param is None:
+            target_lower = parameter_name.lower()
+            for p in device.parameters:
+                if p.name.lower() == target_lower:
+                    param = p
+                    break
+        if param is None:
+            available = [p.name for p in list(device.parameters)[:20]]
             raise ValueError(
-                "Parameter '%s' not found on device '%s'"
-                % (parameter_name, device.name)
+                "Parameter '%s' not found on device '%s'. "
+                "Available (first 20): %s"
+                % (parameter_name, device.name, ", ".join(available))
             )
     elif parameter_index is not None:
         parameter_index = int(parameter_index)
@@ -123,14 +133,26 @@ def batch_set_parameters(song, params):
             param = dev_params[idx]
         else:
             param = None
+            target = str(name_or_index)
+            # Try exact match first
             for p in dev_params:
-                if p.name == name_or_index:
+                if p.name == target:
                     param = p
                     break
+            # Fallback: case-insensitive match
+            if param is None:
+                target_lower = target.lower()
+                for p in dev_params:
+                    if p.name.lower() == target_lower:
+                        param = p
+                        break
             if param is None:
+                # List similar parameter names for debugging
+                available = [p.name for p in dev_params[:20]]
                 raise ValueError(
-                    "Parameter '%s' not found on device '%s'"
-                    % (name_or_index, device.name)
+                    "Parameter '%s' not found on device '%s'. "
+                    "Available (first 20): %s"
+                    % (name_or_index, device.name, ", ".join(available))
                 )
 
         param.value = value
@@ -187,11 +209,31 @@ def load_device_by_uri(song, params):
     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",
-    )
+    # Parse category hint from URI (e.g., "query:Drums#..." -> prioritize drums)
+    _category_map = {
+        "drums": "drums", "samples": "samples", "instruments": "instruments",
+        "audiofx": "audio_effects", "audio_effects": "audio_effects",
+        "midifx": "midi_effects", "midi_effects": "midi_effects",
+        "sounds": "sounds", "packs": "packs",
+        "userlibrary": "user_library", "user_library": "user_library",
+    }
+    priority_attr = None
+    if ":" in uri:
+        # Extract category from "query:Drums#..." or "query:UserLibrary#..."
+        after_colon = uri.split(":", 1)[1]
+        cat_hint = after_colon.split("#", 1)[0].lower().replace(" ", "_")
+        priority_attr = _category_map.get(cat_hint)
+
+    # Build category search order — prioritize the category from the URI
+    category_attrs = [
+        "user_library", "plugins", "max_for_live", "samples",
+        "instruments", "audio_effects", "midi_effects", "packs",
+        "sounds", "drums",
+    ]
+    if priority_attr and priority_attr in category_attrs:
+        category_attrs.remove(priority_attr)
+        category_attrs.insert(0, priority_attr)
+
     categories = []
     for attr in category_attrs:
         try:
@@ -200,7 +242,7 @@ def load_device_by_uri(song, params):
             pass
 
     _iterations = [0]
-    MAX_ITERATIONS = 10000
+    MAX_ITERATIONS = 50000
 
     # ── Strategy 1: match by URI directly ────────────────────────────
     def find_by_uri(parent, target_uri, depth=0):
@@ -235,6 +277,45 @@ def load_device_by_uri(song, params):
     device_name = uri
     if "#" in uri:
         device_name = uri.split("#", 1)[1]
+    # For Sounds URIs like "Pad:FileId_6343", the FileId is an internal
+    # identifier useless for name search — retry URI match with deep limit.
+    if "FileId_" in device_name:
+        _iterations[0] = 0
+        DEEP_MAX = 200000
+        def find_by_uri_deep(parent, target_uri, depth=0):
+            if depth > 12 or _iterations[0] > DEEP_MAX:
+                return None
+            try:
+                children = list(parent.children)
+            except AttributeError:
+                return None
+            for child in children:
+                _iterations[0] += 1
+                if _iterations[0] > DEEP_MAX:
+                    return None
+                try:
+                    if child.uri == target_uri and child.is_loadable:
+                        return child
+                except AttributeError:
+                    pass
+                result = find_by_uri_deep(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_deep(category, uri)
+            if found is not None:
+                song.view.selected_track = track
+                browser.load_item(found)
+                return {"loaded": found.name, "track_index": track_index}
+
+        raise ValueError(
+            "Item '%s' not found in browser (FileId URI — try "
+            "find_and_load_device with the exact name instead)" % uri
+        )
+
     for sep in (":", "/"):
         if sep in device_name:
             device_name = device_name.rsplit(sep, 1)[1]
@@ -296,36 +377,56 @@ def find_and_load_device(song, params):
     track = get_track(song, track_index)
     browser = _get_browser()
 
-    MAX_ITERATIONS = 10000
+    MAX_ITERATIONS = 50000
     iterations = 0
 
-    def search_children(item, depth=0):
-        """Recursively search browser children up to depth 8."""
+    def _name_matches(child_name, target, exact_only):
+        """Check if a browser item name matches the search target."""
+        child_lower = child_name.lower()
+        # Strip extension for comparison
+        child_base = child_lower
+        for ext in (".amxd", ".adv", ".adg", ".aupreset", ".als"):
+            if child_base.endswith(ext):
+                child_base = child_base[:-len(ext)]
+                break
+        if exact_only:
+            return child_base == target
+        else:
+            return child_base == target or target in child_lower
+
+    def search_breadth_first(category, exact_only=False):
+        """Breadth-first search: check all top-level items first, then recurse.
+        This ensures raw 'Operator' is found before 'Hello Operator.adg' buried
+        in a user_library subfolder."""
         nonlocal iterations
-        if depth > 8:
-            return None
-        try:
-            children = list(item.children)
-        except AttributeError:
-            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
+        # Queue of (item, depth) tuples
+        queue = [(category, 0)]
+        while queue:
+            item, depth = queue.pop(0)
+            if depth > 8:
+                continue
+            try:
+                children = list(item.children)
+            except AttributeError:
+                continue
+            for child in children:
+                iterations += 1
+                if iterations > MAX_ITERATIONS:
+                    return None
+                if _name_matches(child.name, device_name, exact_only) and child.is_loadable:
+                    return child
+                # Queue children for later (breadth-first)
+                if child.is_folder:
+                    queue.append((child, depth + 1))
         return None
 
     # Search device categories only — never samples (avoids "Castanet Reverb.aif"
-    # matching before the actual Reverb device). user_library first for M4L.
+    # matching before the actual Reverb device).
+    # plugins + max_for_live included for AU/VST/AUv3 and M4L devices.
     category_attrs = (
         "audio_effects", "instruments", "midi_effects",
-        "user_library", "drums", "sounds", "packs",
+        "plugins", "max_for_live", "user_library",
+        "drums", "sounds", "packs",
     )
     categories = []
     for attr in category_attrs:
@@ -334,9 +435,38 @@ def find_and_load_device(song, params):
         except AttributeError:
             pass
 
+    # Pass 0: FAST — check only top-level children of each category (no recursion).
+    # Raw devices like "Operator", "Analog", "Compressor" are always top-level.
+    # This is O(N) where N = number of top-level items (~50), not O(thousands).
+    for category in categories:
+        try:
+            for child in category.children:
+                if _name_matches(child.name, device_name, True) and child.is_loadable:
+                    song.view.selected_track = track
+                    browser.load_item(child)
+                    return {
+                        "loaded": child.name,
+                        "track_index": track_index,
+                    }
+        except AttributeError:
+            pass
+
+    # Pass 1: exact name match with recursion (for items nested in folders)
+    for category in categories:
+        iterations = 0
+        found = search_breadth_first(category, exact_only=True)
+        if found is not None:
+            song.view.selected_track = track
+            browser.load_item(found)
+            return {
+                "loaded": found.name,
+                "track_index": track_index,
+            }
+
+    # Pass 2: partial name match (for M4L devices like "trnr.Kickster")
     for category in categories:
         iterations = 0
-        found = search_children(category)
+        found = search_breadth_first(category, exact_only=False)
         if found is not None:
             song.view.selected_track = track
             browser.load_item(found)

package/remote_script/LivePilot/server.py

@@ -24,9 +24,11 @@ WRITE_COMMANDS = frozenset([
     "create_midi_track", "create_audio_track", "create_return_track",
     "delete_track", "duplicate_track", "set_track_name", "set_track_color",
     "set_track_mute", "set_track_solo", "set_track_arm", "stop_track_clips",
+    "set_group_fold", "set_track_input_monitoring",
     # clips
     "create_clip", "delete_clip", "duplicate_clip", "fire_clip", "stop_clip",
     "set_clip_name", "set_clip_color", "set_clip_loop", "set_clip_launch",
+    "set_clip_warp_mode",
     # notes
     "add_notes", "remove_notes", "remove_notes_by_id", "modify_notes",
     "duplicate_notes", "transpose_notes", "quantize_clip",
@@ -36,7 +38,7 @@ WRITE_COMMANDS = frozenset([
     "set_chain_volume", "set_simpler_playback_mode",
     # scenes
     "create_scene", "delete_scene", "duplicate_scene", "fire_scene",
-    "set_scene_name",
+    "set_scene_name", "set_scene_color", "set_scene_tempo",
     # mixing
     "set_track_volume", "set_track_pan", "set_track_send",
     "set_master_volume", "set_track_routing",
@@ -44,7 +46,12 @@ WRITE_COMMANDS = frozenset([
     "load_browser_item",
     # arrangement
     "jump_to_time", "jump_to_cue", "capture_midi", "start_recording",
-    "stop_recording", "toggle_cue_point",
+    "stop_recording", "toggle_cue_point", "back_to_arranger",
+    "create_arrangement_clip", "add_arrangement_notes",
+    "remove_arrangement_notes", "remove_arrangement_notes_by_id",
+    "modify_arrangement_notes", "duplicate_arrangement_notes",
+    "transpose_arrangement_notes", "set_arrangement_automation",
+    "set_arrangement_clip_name",
 ])
 
 

package/remote_script/LivePilot/transport.py

@@ -127,9 +127,11 @@ def set_session_loop(song, params):
     if "loop_length" in params:
         song.loop_length = float(params["loop_length"])
     # Set enabled LAST so it sticks
-    song.loop = bool(params["enabled"])
+    enabled = bool(params["enabled"])
+    song.loop = enabled
+    # Echo requested value — song.loop getter may return stale state
     return {
-        "loop": song.loop,
+        "loop": enabled,
         "loop_start": song.loop_start,
         "loop_length": song.loop_length,
     }

package/remote_script/LivePilot/utils.py

@@ -92,10 +92,15 @@ def get_clip(song, track_index, clip_index):
 def get_device(track, device_index):
     """Return a device from a track by index."""
     devices = list(track.devices)
+    if not devices:
+        raise IndexError(
+            "Track '%s' has no devices — load an instrument or effect first"
+            % track.name
+        )
     if device_index < 0 or device_index >= len(devices):
         raise IndexError(
-            "Device index %d out of range (0..%d)"
-            % (device_index, len(devices) - 1)
+            "Device index %d out of range (0..%d) on track '%s'"
+            % (device_index, len(devices) - 1, track.name)
         )
     return devices[device_index]