AbletonMCP

Instructions

Implementation Reference

• AbletonMCP_Remote_Script/__init__.py:941-1065 (handler)

  The implementation of the get_browser_items_at_path handler in the Ableton remote script, which traverses the Ableton Live browser hierarchy to return items at a given path.

  def get_browser_items_at_path(self, path):
      """
      Get browser items at a specific path.
      
      Args:
          path: Path in the format "category/folder/subfolder"
               where category is one of: instruments, sounds, drums, audio_effects, midi_effects
               or any other available browser category
               
      Returns:
          Dictionary with items at the specified path
      """
      try:
          # Access the application's browser instance instead of creating a new one
          app = self.application()
          if not app:
              raise RuntimeError("Could not access Live application")
              
          # Check if browser is available
          if not hasattr(app, 'browser') or app.browser is None:
              raise RuntimeError("Browser is not available in the Live application")
          
          # Log available browser attributes to help diagnose issues
          browser_attrs = [attr for attr in dir(app.browser) if not attr.startswith('_')]
          self.log_message("Available browser attributes: {0}".format(browser_attrs))
              
          # Parse the path
          path_parts = path.split("/")
          if not path_parts:
              raise ValueError("Invalid path")
          
          # Determine the root category
          root_category = path_parts[0].lower()
          current_item = None
          
          # Check standard categories first
          if root_category == "instruments" and hasattr(app.browser, 'instruments'):
              current_item = app.browser.instruments
          elif root_category == "sounds" and hasattr(app.browser, 'sounds'):
              current_item = app.browser.sounds
          elif root_category == "drums" and hasattr(app.browser, 'drums'):
              current_item = app.browser.drums
          elif root_category == "audio_effects" and hasattr(app.browser, 'audio_effects'):
              current_item = app.browser.audio_effects
          elif root_category == "midi_effects" and hasattr(app.browser, 'midi_effects'):
              current_item = app.browser.midi_effects
          else:
              # Try to find the category in other browser attributes
              found = False
              for attr in browser_attrs:
                  if attr.lower() == root_category:
                      try:
                          current_item = getattr(app.browser, attr)
                          found = True
                          break
                      except Exception as e:
                          self.log_message("Error accessing browser attribute {0}: {1}".format(attr, str(e)))
              
              if not found:
                  # If we still haven't found the category, return available categories
                  return {
                      "path": path,
                      "error": "Unknown or unavailable category: {0}".format(root_category),
                      "available_categories": browser_attrs,
                      "items": []
                  }
          
          # Navigate through the path
          for i in range(1, len(path_parts)):
              part = path_parts[i]
              if not part:  # Skip empty parts
                  continue
              
              if not hasattr(current_item, 'children'):
                  return {
                      "path": path,
                      "error": "Item at '{0}' has no children".format('/'.join(path_parts[:i])),
                      "items": []
                  }
              
              found = False
              for child in current_item.children:
                  if hasattr(child, 'name') and child.name.lower() == part.lower():
                      current_item = child
                      found = True
                      break
              
              if not found:
                  return {
                      "path": path,
                      "error": "Path part '{0}' not found".format(part),
                      "items": []
                  }
          
          # Get items at the current path
          items = []
          if hasattr(current_item, 'children'):
              for child in current_item.children:
                  item_info = {
                      "name": child.name if hasattr(child, 'name') else "Unknown",
                      "is_folder": hasattr(child, 'children') and bool(child.children),
                      "is_device": hasattr(child, 'is_device') and child.is_device,
                      "is_loadable": hasattr(child, 'is_loadable') and child.is_loadable,
                      "uri": child.uri if hasattr(child, 'uri') else None
                  }
                  items.append(item_info)
          
          result = {
              "path": path,
              "name": current_item.name if hasattr(current_item, 'name') else "Unknown",
              "uri": current_item.uri if hasattr(current_item, 'uri') else None,
              "is_folder": hasattr(current_item, 'children') and bool(current_item.children),
              "is_device": hasattr(current_item, 'is_device') and current_item.is_device,
              "is_loadable": hasattr(current_item, 'is_loadable') and current_item.is_loadable,
              "items": items
          }
          
          self.log_message("Retrieved {0} items at path: {1}".format(len(items), path))
          return result
          
      except Exception as e:
          self.log_message("Error getting browser items at path: {0}".format(str(e)))
          self.log_message(traceback.format_exc())
          raise