Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,91 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/1657591309536.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/1657591680538.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/1657591832727.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/1657616409629.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/1657616591950.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/1657616660848.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/1657616730783.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/1657616788731.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/1657616954951.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/1657923632784.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/288298605_1687187951639494_579221224540621563_n.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/289438954_5129286887125053_220682033208031067_n.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/289568281_1462345327513048_3022742540007505592_n.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/290154393_565236208447925_526246679178540543_n.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/290702607_425330016154178_254797435320646581_n.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/290990526_409256130973654_5788653198617875871_n.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/291032176_120067890734229_1814549935092808193_n.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/657591201007.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/657591253340.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/Snapinsta.app_video_2B4333A1E1AE5B90482FB1125369C59B_video_dashinit_scene_001.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/Snapinsta.app_video_2B4333A1E1AE5B90482FB1125369C59B_video_dashinit_scene_002.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/Snapinsta.app_video_2B4333A1E1AE5B90482FB1125369C59B_video_dashinit_scene_003.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/Snapinsta.app_video_2B4333A1E1AE5B90482FB1125369C59B_video_dashinit_scene_004.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/Snapinsta.app_video_2B4333A1E1AE5B90482FB1125369C59B_video_dashinit_scene_005.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/Snapinsta.app_video_2B4333A1E1AE5B90482FB1125369C59B_video_dashinit_scene_006.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/Snapinsta.app_video_2B4333A1E1AE5B90482FB1125369C59B_video_dashinit_scene_007.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/Snapinsta.app_video_2B4333A1E1AE5B90482FB1125369C59B_video_dashinit_scene_008.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/Snapinsta.app_video_2B4333A1E1AE5B90482FB1125369C59B_video_dashinit_scene_009.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/Snapinsta.app_video_2B4333A1E1AE5B90482FB1125369C59B_video_dashinit_scene_010.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/Snapinsta.app_video_2B4E29561A51827AF04D3C92BDED06B5_video_dashinit_scene_001.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/Snapinsta.app_video_2B4E29561A51827AF04D3C92BDED06B5_video_dashinit_scene_002.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/Snapinsta.app_video_2B4E29561A51827AF04D3C92BDED06B5_video_dashinit_scene_003.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/Snapinsta.app_video_2B4E29561A51827AF04D3C92BDED06B5_video_dashinit_scene_004.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/Snapinsta.app_video_2B4E29561A51827AF04D3C92BDED06B5_video_dashinit_scene_005.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/Snapinsta.app_video_2B4E29561A51827AF04D3C92BDED06B5_video_dashinit_scene_006.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/Snapinsta.app_video_2B4E29561A51827AF04D3C92BDED06B5_video_dashinit_scene_007.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/Snapinsta.app_video_3547B2AC7669AF7E434D64AFDC9A6C9F_video_dashinit_scene_001.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/Snapinsta.app_video_3547B2AC7669AF7E434D64AFDC9A6C9F_video_dashinit_scene_002.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/Snapinsta.app_video_3547B2AC7669AF7E434D64AFDC9A6C9F_video_dashinit_scene_003.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/Snapinsta.app_video_3547B2AC7669AF7E434D64AFDC9A6C9F_video_dashinit_scene_004.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/Snapinsta.app_video_3547B2AC7669AF7E434D64AFDC9A6C9F_video_dashinit_scene_005.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/Snapinsta.app_video_3547B2AC7669AF7E434D64AFDC9A6C9F_video_dashinit_scene_006.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/Snapinsta.app_video_6F4E14515715C2DB44E4959237066298_video_dashinit_scene_001.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/Snapinsta.app_video_6F4E14515715C2DB44E4959237066298_video_dashinit_scene_002.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/Snapinsta.app_video_7944DC0BB36028CA2D36023098F3029C_video_dashinit.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/Snapinsta.app_video_E544C6323B8E4CAB778F010CB59E0D88_video_dashinit_scene_001.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/Snapinsta.app_video_E544C6323B8E4CAB778F010CB59E0D88_video_dashinit_scene_002.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/Snapinsta.app_video_E544C6323B8E4CAB778F010CB59E0D88_video_dashinit_scene_003.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/Snapinsta.app_video_E544C6323B8E4CAB778F010CB59E0D88_video_dashinit_scene_004.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/Snapinsta.app_video_E544C6323B8E4CAB778F010CB59E0D88_video_dashinit_scene_005.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/Snapinsta.app_video_E544C6323B8E4CAB778F010CB59E0D88_video_dashinit_scene_006.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/Snapinsta.app_video_E544C6323B8E4CAB778F010CB59E0D88_video_dashinit_scene_007.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/Snapinsta.app_video_E544C6323B8E4CAB778F010CB59E0D88_video_dashinit_scene_008.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/Snapinsta.app_video_E544C6323B8E4CAB778F010CB59E0D88_video_dashinit_scene_009.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/Snapinsta.app_video_E544C6323B8E4CAB778F010CB59E0D88_video_dashinit_scene_010.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/Snapinsta.app_video_E544C6323B8E4CAB778F010CB59E0D88_video_dashinit_scene_011.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/Snapinsta.app_video_E544C6323B8E4CAB778F010CB59E0D88_video_dashinit_scene_012.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/Snapinsta.app_video_E544C6323B8E4CAB778F010CB59E0D88_video_dashinit_scene_013.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/Snapinsta.app_video_E544C6323B8E4CAB778F010CB59E0D88_video_dashinit_scene_014.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/Snapinsta.app_video_E544C6323B8E4CAB778F010CB59E0D88_video_dashinit_scene_015.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/Snapinsta.app_video_E544C6323B8E4CAB778F010CB59E0D88_video_dashinit_scene_016.mp4 filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/ai-generated-8079926_1280.png filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/ai-generated-8601539_1280.jpg filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/ai-generated-9151678_1280.jpg filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/antique-car-7577214_1280.jpg filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/automobile-1850862_1280.jpg filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/bmw-6236208_1280.jpg filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/car-171415_1280.jpg filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/car-219813_1280.jpg filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/car-5548243_1280.jpg filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/car-5548244_1280.jpg filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/car-6306695_1280.jpg filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/car-6483720_1280.jpg filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/car-6589240_1280.jpg filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/car-6658749_1280.jpg filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/car-7139944_1280.jpg filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/car-7203265_1280(1).jpg filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/car-7203265_1280.jpg filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/car-7725834_1280.jpg filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/car-7830737_1280.jpg filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/car-8141820_1280.jpg filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/fashion-1399346_1280.jpg filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/mercedes-benz-7383931_1280.jpg filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/speedy-car-8391554_1280.jpg filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/sport-4155825_1280.jpg filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/vintage-car-7300881_1280.jpg filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/clips/vintage-rolls-royce-7414656_1280.jpg filter=lfs diff=lfs merge=lfs -text
+tools/beatsyncer/tmp/input_audio.mp3 filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,12 +1,6 @@
 ---
-title: AI Tools Platform
-emoji: 💻
-colorFrom: blue
-colorTo: pink
+title: AI_Tools_Platform
+app_file: main_ui.py
 sdk: gradio
-sdk_version: 5.48.0
-app_file: app.py
-pinned: false
+sdk_version: 4.19.2
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

colab_launcher.py

@@ -0,0 +1,157 @@
+import os
+import sys
+import json
+import importlib.util
+from pathlib import Path
+
+# Define paths
+DRIVE_ROOT = "/content/drive/MyDrive/AI_Tools_Platform"
+TOOLS_DIR = os.path.join(DRIVE_ROOT, "tools")
+INSTALLED_TOOLS_JSON = os.path.join(DRIVE_ROOT, "installed_tools.json")
+
+# Import the Tool class from main_ui
+from main_ui import Tool, MainUI
+
+def setup_environment():
+    print("Setting up environment...")
+    
+    # Create tools directory in Google Drive if it doesn't exist
+    os.makedirs(TOOLS_DIR, exist_ok=True)
+    print(f"Tools directory in Drive: {TOOLS_DIR}")
+    
+    # Create installed_tools.json in Google Drive if it doesn't exist
+    if not os.path.exists(INSTALLED_TOOLS_JSON):
+        with open(INSTALLED_TOOLS_JSON, 'w') as f:
+            json.dump({"tools": []}, f, indent=4)
+        print(f"Created initial installed_tools.json in Drive")
+    else:
+        print(f"Using existing installed_tools.json from Drive")
+    
+    # Verify the content of installed_tools.json
+    try:
+        with open(INSTALLED_TOOLS_JSON, 'r') as f:
+            tools_data = json.load(f)
+            if not isinstance(tools_data, dict) or "tools" not in tools_data:
+                print("Warning: installed_tools.json has incorrect format. Fixing...")
+                with open(INSTALLED_TOOLS_JSON, 'w') as f:
+                    json.dump({"tools": []}, f, indent=4)
+    except (json.JSONDecodeError, UnicodeDecodeError):
+        print("Error: installed_tools.json is not valid JSON. Fixing...")
+        with open(INSTALLED_TOOLS_JSON, 'w') as f:
+            json.dump({"tools": []}, f, indent=4)
+    
+    # Add tools directory to Python path
+    if TOOLS_DIR not in sys.path:
+        sys.path.append(TOOLS_DIR)
+    if os.getcwd() not in sys.path:
+        sys.path.append(os.getcwd())
+    
+    print("\nEnvironment set up successfully!")
+
+# Override MainUI methods to use direct file paths
+class ColabMainUI(MainUI):
+    def __init__(self):
+        # Set up paths before calling parent's __init__
+        self.tools = {}  # Initialize tools dictionary
+        self.tools_dir = TOOLS_DIR
+        self.installed_tools_json = INSTALLED_TOOLS_JSON
+        self.marketplace_url = "https://marketplace.vidplus.app/api/marketplace"
+        self.version = "0.1"
+        
+        # Create tools directory if it doesn't exist
+        os.makedirs('tools', exist_ok=True)
+        
+        # Load tools manually instead of calling parent's __init__
+        self.load_installed_tools()
+    
+    def load_installed_tools(self):
+        """Load installed tools directly from Google Drive"""
+        print(f"Loading tools from {self.installed_tools_json}")
+        try:
+            if os.path.exists(self.installed_tools_json):
+                with open(self.installed_tools_json, 'r') as f:
+                    data = json.load(f)
+                    
+                for tool_data in data.get('tools', []):
+                    # If ui_module is specified, dynamically import it
+                    if tool_data.get('ui_module'):
+                        try:
+                            # Modify the module path to use the direct path
+                            module_name = tool_data['ui_module']
+                            if module_name.startswith('tools.'):
+                                # Extract the relative path and use the full path
+                                rel_path = module_name.replace('tools.', '')
+                                module_path = os.path.join(TOOLS_DIR, rel_path.replace('.', '/') + '.py')
+                                print(f"Loading module from: {module_path}")
+                                
+                                # Use importlib to import the module
+                                spec = importlib.util.spec_from_file_location(module_name, module_path)
+                                if spec:
+                                    module = importlib.util.module_from_spec(spec)
+                                    spec.loader.exec_module(module)
+                                    ui_class = getattr(module, tool_data['ui_class'])
+                                    
+                                    self.tools[tool_data['id']] = Tool(
+                                        name=tool_data['name'],
+                                        description=tool_data['description'],
+                                        ui_class=ui_class,
+                                        icon=tool_data['icon'],
+                                        version=tool_data['version'],
+                                        ui_module=tool_data['ui_module']
+                                    )
+                                else:
+                                    print(f"Could not find module: {module_path}")
+                            else:
+                                # Standard import for non-tools modules
+                                module = importlib.import_module(module_name)
+                                ui_class = getattr(module, tool_data['ui_class'])
+                                
+                                self.tools[tool_data['id']] = Tool(
+                                    name=tool_data['name'],
+                                    description=tool_data['description'],
+                                    ui_class=ui_class,
+                                    icon=tool_data['icon'],
+                                    version=tool_data['version'],
+                                    ui_module=tool_data['ui_module']
+                                )
+                        except (ImportError, AttributeError) as e:
+                            print(f"Error loading tool {tool_data['name']}: {e}")
+                            import traceback
+                            traceback.print_exc()
+        except Exception as e:
+            print(f"Error loading installed tools: {e}")
+            import traceback
+            traceback.print_exc()
+    
+    def save_installed_tools(self):
+        """Save installed tools directly to Google Drive"""
+        data = {
+            "tools": [
+                {
+                    "id": tool_id,
+                    "name": tool.name,
+                    "description": tool.description,
+                    "icon": tool.icon,
+                    "version": tool.version,
+                    "ui_class": tool.ui_class.__name__,
+                    "ui_module": tool.ui_module
+                }
+                for tool_id, tool in self.tools.items()
+            ]
+        }
+        
+        with open(self.installed_tools_json, 'w') as f:
+            json.dump(data, f, indent=4)
+        print(f"Saved tools configuration to {self.installed_tools_json}")
+
+if __name__ == "__main__":
+    setup_environment()
+    
+    # Import and run the modified UI
+    print("\nStarting AI Tools Platform...")
+    
+    ui = ColabMainUI()
+    demo = ui.create_ui()
+    demo.queue()
+    demo.title = "AI Tools Platform"
+    demo.launch(debug=True, share=True)  # share=True to get a public URL

installed_tools.json

@@ -0,0 +1,40 @@
+{
+    "tools": [
+        {
+            "id": "image_background_remover",
+            "name": "Image Background Remover",
+            "description": "A tool that removes backgrounds from images",
+            "icon": "\ud83d\uddbc\ufe0f",
+            "version": "1.0.0",
+            "ui_class": "ImageBackgroundRemoverUI",
+            "ui_module": "tools.image_background_remover.image_background_remover_ui"
+        },
+        {
+            "id": "beatsyncer",
+            "name": "Beatsyncer",
+            "description": "Create amazing videos synchronized with music beats",
+            "icon": "\ud83c\udfb5",
+            "version": "1.0.0",
+            "ui_class": "BeatsyncerUI",
+            "ui_module": "tools.beatsyncer.beatsyncer_ui"
+        },
+        {
+            "id": "image_background_remover",
+            "name": "Image Background Remover",
+            "description": "A tool that removes backgrounds from images",
+            "icon": "\ud83d\uddbc\ufe0f",
+            "version": "1.0.0",
+            "ui_class": "ImageBackgroundRemoverUI",
+            "ui_module": "tools.image_background_remover.image_background_remover_ui"
+        },
+        {
+            "id": "image_background_remover",
+            "name": "Image Background Remover",
+            "description": "A tool that removes backgrounds from images",
+            "icon": "\ud83d\uddbc\ufe0f",
+            "version": "1.0.0",
+            "ui_class": "ImageBackgroundRemoverUI",
+            "ui_module": "tools.image_background_remover.image_background_remover_ui"
+        }
+    ]
+}

main_ui.py

@@ -0,0 +1,1556 @@
+import os
+import json
+import importlib
+import requests
+import gradio as gr
+import subprocess
+
+class Tool:
+    def __init__(self, name, description, ui_class, icon="🔧", version="0.1", ui_module=None):
+        self.name = name
+        self.description = description
+        self.ui_class = ui_class
+        self.icon = icon
+        self.version = version
+        self.ui_module = ui_module
+
+class MainUI:
+    def __init__(self):
+        # Load installed tools from JSON
+        self.tools = {}
+        self.load_installed_tools()
+        
+        # Marketplace server URL
+        self.marketplace_url = "https://marketplace.vidplus.app/api/marketplace"
+        self.version = "0.1"
+        
+        # Create tools directory if it doesn't exist
+        os.makedirs('tools', exist_ok=True)
+
+    def load_installed_tools(self):
+        """Load installed tools from JSON file"""
+        try:
+            if os.path.exists('installed_tools.json'):
+                with open('installed_tools.json', 'r') as f:
+                    data = json.load(f)
+                    
+                for tool_data in data.get('tools', []):
+                    # If ui_module is specified, dynamically import it
+                    if tool_data.get('ui_module'):
+                        try:
+                            module = importlib.import_module(tool_data['ui_module'])
+                            ui_class = getattr(module, tool_data['ui_class'])
+                            
+                            self.tools[tool_data['id']] = Tool(
+                                name=tool_data['name'],
+                                description=tool_data['description'],
+                                ui_class=ui_class,
+                                icon=tool_data['icon'],
+                                version=tool_data['version'],
+                                ui_module=tool_data['ui_module']
+                            )
+                        except (ImportError, AttributeError) as e:
+                            print(f"Error loading tool {tool_data['name']}: {e}")
+        except Exception as e:
+            print(f"Error loading installed tools: {e}")
+            # Fallback to default BeatSyncer tool
+            # self.tools = {
+            #     "beatsyncer": Tool(
+            #         name="BeatSyncer",
+            #         description="Create amazing videos synchronized with music beats",
+            #         ui_class=BeatSyncerUI,
+            #         icon="🎵"
+            #     )
+            # }
+
+    def save_installed_tools(self):
+        """Save installed tools to JSON file"""
+        data = {
+            "tools": [
+                {
+                    "id": tool_id,
+                    "name": tool.name,
+                    "description": tool.description,
+                    "icon": tool.icon,
+                    "version": tool.version,
+                    "ui_class": tool.ui_class.__name__,
+                    "ui_module": tool.ui_module
+                }
+                for tool_id, tool in self.tools.items()
+            ]
+        }
+        
+        with open('installed_tools.json', 'w') as f:
+            json.dump(data, f, indent=4)
+
+    def fetch_marketplace_tools(self):
+        """Fetch available tools from marketplace server"""
+        try:
+            response = requests.get(f"{self.marketplace_url}/tools")
+            if response.status_code == 200:
+                # Get the list of tools from the marketplace
+                marketplace_tools = response.json()
+                
+                # Ensure we're working with the latest state of installed tools
+                # This is important after a tool has been removed
+                if os.path.exists('installed_tools.json'):
+                    with open('installed_tools.json', 'r') as f:
+                        data = json.load(f)
+                        installed_tool_ids = [tool['id'] for tool in data.get('tools', [])]
+                else:
+                    installed_tool_ids = []
+                
+                # Update the is_installed flag for each tool
+                for tool in marketplace_tools:
+                    tool['is_installed'] = tool['id'] in installed_tool_ids
+                
+                return marketplace_tools
+            else:
+                return []
+        except Exception as e:
+            print(f"Error fetching marketplace tools: {e}")
+            return []
+
+    def fetch_tool_details(self, tool_id):
+        """Fetch details for a specific tool from marketplace server"""
+        try:
+            response = requests.get(f"{self.marketplace_url}/tools/{tool_id}")
+            if response.status_code == 200:
+                return response.json()
+            else:
+                return None
+        except Exception as e:
+            print(f"Error fetching tool details: {e}")
+            return None
+
+    def install_tool(self, tool_id):
+        """Install a tool from the marketplace"""
+        try:
+            # Import required modules
+            import importlib
+            import importlib.util
+            import sys
+            import subprocess
+            import gradio as gr
+            
+            # Fetch tool data
+            response = requests.get(f"{self.marketplace_url}/tools/{tool_id}/download")
+            if response.status_code != 200:
+                return f"Error: Failed to download tool (Status code: {response.status_code})"
+            
+            tool_data = response.json()
+            tool_info = tool_data['tool']
+            tool_files = tool_data['files']
+            
+            # Check and install dependencies if they exist
+            dependencies = tool_info.get('dependencies', [])
+            if dependencies:
+                try:
+                    # Read current requirements.txt
+                    current_requirements = []
+                    if os.path.exists('requirements.txt'):
+                        with open('requirements.txt', 'r') as f:
+                            current_requirements = [line.strip() for line in f.readlines() if line.strip()]
+                    
+                    # Check which dependencies need to be installed
+                    to_install = []
+                    to_add_to_requirements = []
+                    
+                    for dep in dependencies:
+                        # Extract just the package name (ignore version requirements)
+                        pkg_name = dep.split('>=')[0].split('==')[0].split('>')[0].split('<')[0].strip()
+                        
+                        # Check if dependency is already in requirements.txt
+                        is_in_requirements = False
+                        for req in current_requirements:
+                            req_name = req.split('>=')[0].split('==')[0].split('>')[0].split('<')[0].strip()
+                            if req_name == pkg_name:
+                                is_in_requirements = True
+                                break
+                        
+                        if not is_in_requirements:
+                            to_add_to_requirements.append(dep)
+                        
+                        try:
+                            # Try to import the package to check if it's installed
+                            importlib.import_module(pkg_name)
+                        except ImportError:
+                            # Package not installed, add to installation list
+                            to_install.append(dep)
+                    
+                    # Install missing dependencies
+                    if to_install:
+                        for dep in to_install:
+                            # Use subprocess to run pip install
+                            subprocess.check_call([sys.executable, "-m", "pip", "install", dep])
+                    
+                    # Append new dependencies to requirements.txt
+                    if to_add_to_requirements:
+                        with open('requirements.txt', 'a') as f:
+                            for dep in to_add_to_requirements:
+                                f.write(f"\n{dep}")
+                        print(f"Added {len(to_add_to_requirements)} dependencies to requirements.txt")
+                        
+                except Exception as e:
+                    return f"Error installing dependencies: {e}"
+            
+            # Create tool directory
+            tool_dir = os.path.join('tools', tool_id)
+            os.makedirs(tool_dir, exist_ok=True)
+            
+            # Write tool files
+            for file_name, file_content in tool_files.items():
+                # Rename files to match our convention
+                target_file_name = file_name
+                if file_name.endswith('_tool_logic.py'):
+                    target_file_name = f"{tool_id}_tool.py"
+                elif file_name.endswith('_tool_ui.py'):
+                    target_file_name = f"{tool_id}_ui.py"
+                
+                with open(os.path.join(tool_dir, target_file_name), 'w') as f:
+                    f.write(file_content)
+            
+            # Create __init__.py to make the directory a package
+            with open(os.path.join(tool_dir, '__init__.py'), 'w') as f:
+                f.write(f"# {tool_info['name']} package\n")
+            
+            # Add tool to installed tools
+            ui_module = f"tools.{tool_id}.{tool_id}_ui"
+            ui_class = f"{tool_id.title().replace('_', '')}UI"
+            
+            # Update installed_tools.json
+            with open('installed_tools.json', 'r') as f:
+                data = json.load(f)
+            
+            data['tools'].append({
+                "id": tool_id,
+                "name": tool_info['name'],
+                "description": tool_info['description'],
+                "icon": tool_info['icon'],
+                "version": tool_info['version'],
+                "ui_class": ui_class,
+                "ui_module": ui_module
+            })
+            
+            with open('installed_tools.json', 'w') as f:
+                json.dump(data, f, indent=4)
+            
+            # Dynamically load the newly installed tool
+            try:
+                # Reload the module if it was already imported
+                if ui_module in sys.modules:
+                    importlib.reload(sys.modules[ui_module])
+                
+                # Import the module
+                module = importlib.import_module(ui_module)
+                ui_class_obj = getattr(module, ui_class)
+                
+                # Add the tool to self.tools
+                self.tools[tool_id] = Tool(
+                    name=tool_info['name'],
+                    description=tool_info['description'],
+                    ui_class=ui_class_obj,
+                    icon=tool_info['icon'],
+                    version=tool_info['version'],
+                    ui_module=ui_module
+                )
+                
+                # Flag to indicate this is a newly installed tool that needs special handling
+                self.tools[tool_id].newly_installed = True
+                
+                # Return success message
+                return f"Successfully installed {tool_info['name']}. The tool is now available in the Tools page."
+            except Exception as e:
+                print(f"Error dynamically loading tool: {e}")
+                import traceback
+                traceback.print_exc()
+                # Still return success but with a restart message
+                return f"Successfully installed {tool_info['name']}. Please restart the application to use the new tool."
+        except Exception as e:
+            return f"Error installing tool: {e}"
+
+    def remove_tool(self, tool_id):
+        """Remove an installed tool"""
+        try:
+            if tool_id not in self.tools:
+                return "Error: Tool is not installed"
+            
+            # Get tool info before removal
+            tool_name = self.tools[tool_id].name
+            
+            # Remove tool directory
+            tool_dir = os.path.join('tools', tool_id)
+            if os.path.exists(tool_dir):
+                import shutil
+                shutil.rmtree(tool_dir)
+                print(f"Removed tool directory: {tool_dir}")
+            
+            # Remove tool from installed_tools.json
+            if os.path.exists('installed_tools.json'):
+                with open('installed_tools.json', 'r') as f:
+                    data = json.load(f)
+                
+                # Filter out the tool to be removed
+                data['tools'] = [tool for tool in data['tools'] if tool['id'] != tool_id]
+                
+                # Save updated tools list
+                with open('installed_tools.json', 'w') as f:
+                    json.dump(data, f, indent=4)
+                
+                print(f"Removed tool from installed_tools.json: {tool_id}")
+            
+            # Remove tool from self.tools
+            del self.tools[tool_id]
+            
+            return f"✅ Successfully removed {tool_name}"
+        except Exception as e:
+            print(f"Error removing tool: {e}")
+            import traceback
+            traceback.print_exc()
+            return f"Error removing tool: {str(e)}"
+
+    def create_tool_card(self, name):
+        return f"""
+            <div style="
+                background: #E6E6E6;
+                border-radius: 16px;
+                width: 200px;
+                height: 200px;
+                display: flex;
+                justify-content: center;
+                align-items: center;
+                cursor: pointer;
+                transition: transform 0.2s;
+                box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+                &:hover {{
+                    transform: scale(1.02);
+                }}">
+                <span style="color: #1a1a1a; font-size: 16px; font-weight: 500;">{name}</span>
+            </div>
+        """
+
+    def create_ui(self):
+        css = """
+        :root {
+            --sidebar-width: 200px;
+        }
+        
+        body {
+            margin: 0;
+            padding: 0;
+            overflow: hidden;
+        }
+        
+        #sidebar {
+            background-color: #0A192F;
+            color: white;
+            padding: 32px 24px;
+            height: 100vh;
+            width: var(--sidebar-width);
+            position: fixed;
+            left: 0;
+            top: 0;
+            display: flex;
+            flex-direction: column;
+            box-sizing: border-box;
+            z-index: 1000;
+        }
+        
+        #main-content {
+            background-color: #0F172A;
+            min-height: 100vh;
+            margin-left: var(--sidebar-width);
+            padding: 50px;
+            box-sizing: border-box;
+            overflow-y: auto;
+            position: relative;
+            max-height: 100vh; /* Ensure content is scrollable */
+        }
+        
+        .nav-button {
+            background: none !important;
+            border: none !important;
+            box-shadow: none !important;
+            color: #94A3B8 !important;
+            padding: 8px 0 !important;
+            margin: 4px 0 !important;
+            min-width: unset !important;
+            width: 100% !important;
+            text-align: left !important;
+            font-size: 16px !important;
+            font-weight: 500 !important;
+            height: auto !important;
+            line-height: 1.2 !important;
+        }
+        
+        .nav-button:hover {
+            color: white !important;
+        }
+        
+        .nav-button[variant="primary"] {
+            color: white !important;
+        }
+        
+        .tool-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fill, minmax(250px, 1fr));
+            gap: 20px;
+            padding: 24px 0;
+            width: 100%;
+        }
+        
+        .version-text {
+            margin-top: auto;
+            color: #64748B;
+            font-size: 12px;
+            padding-top: 16px;
+        }
+        
+        .title {
+            font-size: 32px;
+            font-weight: 800;
+            margin-bottom: 32px;
+            color: white;
+            letter-spacing: -0.5px;
+        }
+        
+        .page-title {
+            font-size: 28px;
+            font-weight: 700;
+            color: white;
+            margin: 0;
+            padding: 0;
+            letter-spacing: -0.5px;
+        }
+        
+        #content-wrapper {
+            width: 100%;
+            max-width: 100%;
+            padding: 24px;
+        }
+        
+        .tool-card {
+            background: #1E293B !important;
+            border: none !important;
+            border-radius: 16px !important;
+            overflow: hidden !important;
+            transition: transform 0.2s !important;
+            box-shadow: 0 4px 6px rgba(0,0,0,0.1) !important;
+            height: 100% !important;
+            display: flex !important;
+            flex-direction: column !important;
+            width: auto !important;
+            min-height: 200px !important;
+            justify-content: flex-start !important;
+            align-items: stretch !important;
+            padding: 0 !important;
+            color: white !important;
+            text-align: left !important;
+            cursor: pointer !important;
+        }
+        
+        .tool-card:hover {
+            transform: scale(1.02) !important;
+        }
+        
+        .tool-card-img {
+            width: 100%;
+            height: 150px;
+            background: #2D3748;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            font-size: 48px;
+            color: #38BDF8;
+        }
+        
+        .tool-card-content {
+            padding: 16px !important;
+            flex-grow: 1 !important;
+            display: flex !important;
+            flex-direction: column !important;
+        }
+        
+        .tool-card-title {
+            font-size: 18px !important;
+            font-weight: 600 !important;
+            color: white !important;
+            margin: 0 0 8px 0 !important;
+        }
+        
+        .tool-card-description {
+            font-size: 14px !important;
+            color: #94A3B8 !important;
+            margin: 0 !important;
+            flex-grow: 1 !important;
+        }
+        
+        .installed-indicator {
+            background-color: #10B981 !important;
+            color: white !important;
+            font-size: 12px !important;
+            font-weight: 600 !important;
+            padding: 4px 8px !important;
+            border-radius: 4px !important;
+            margin-top: 8px !important;
+            display: inline-block !important;
+        }
+        
+        .tool-card.installed {
+            border: 2px solid #10B981 !important;
+        }
+        
+        .add-tool-card {
+            background: rgba(255, 255, 255, 0.05) !important;
+            border: 2px dashed rgba(255, 255, 255, 0.2) !important;
+            color: rgba(255, 255, 255, 0.8) !important;
+            display: flex !important;
+            flex-direction: column !important;
+            justify-content: center !important;
+            align-items: center !important;
+            text-align: center !important;
+            padding: 16px !important;
+        }
+        
+        .add-tool-icon {
+            font-size: 32px;
+            margin-bottom: 16px;
+            color: rgba(255, 255, 255, 0.5);
+        }
+        
+        .tool-card-button {
+            background: transparent !important;
+            border: none !important;
+            padding: 0 !important;
+            margin: 0 !important;
+            width: 100% !important;
+            height: auto !important;
+            min-height: 0 !important;
+            box-shadow: none !important;
+        }
+        
+        .tool-details {
+            width: 100%;
+            max-width: 100%;
+            padding: 0;
+        }
+        
+        .tool-details-container {
+            background: #0F172A;
+            border-radius: 0;
+            padding: 32px;
+            margin-bottom: 0;
+            max-height: 100vh;
+            overflow-y: auto;
+            width: 100%;
+        }
+        
+        .tool-details-header {
+            display: flex;
+            align-items: center;
+            margin-bottom: 24px;
+            justify-content: space-between;
+        }
+        
+        .tool-details-title-section {
+            display: flex;
+            align-items: center;
+        }
+        
+        .tool-details-icon {
+            font-size: 28px;
+            margin-right: 16px;
+        }
+        
+        .tool-details-title {
+            font-size: 28px;
+            font-weight: 700;
+            color: white;
+            margin: 0;
+        }
+        
+        .tool-details-version {
+            font-size: 14px;
+            color: #94A3B8;
+            margin-left: 8px;
+        }
+        
+        .tool-details-description {
+            font-size: 16px;
+            color: #E2E8F0;
+            margin-bottom: 32px;
+            max-width: 800px;
+        }
+        
+        .tool-details-section-title {
+            font-size: 18px;
+            font-weight: 600;
+            color: white;
+            margin: 32px 0 16px 0;
+        }
+        
+        .tool-details-features {
+            display: flex;
+            flex-direction: column;
+            gap: 12px;
+            margin-bottom: 32px;
+        }
+        
+        .tool-details-feature {
+            display: flex;
+            align-items: center;
+            margin-bottom: 0;
+        }
+        
+        .tool-details-feature-icon {
+            color: #38BDF8;
+            margin-right: 12px;
+            font-size: 16px;
+        }
+        
+        .tool-details-feature-text {
+            color: #E2E8F0;
+            font-size: 16px;
+        }
+        
+        .tool-details-screenshots {
+            display: grid;
+            grid-template-columns: repeat(auto-fill, minmax(300px, 1fr));
+            gap: 16px;
+            margin-top: 16px;
+        }
+        
+        .tool-details-screenshot {
+            width: 100%;
+            border-radius: 8px;
+            overflow: hidden;
+        }
+        
+        .tool-details-video {
+            width: 100%;
+            aspect-ratio: 16/9;
+            border-radius: 8px;
+            overflow: hidden;
+            margin-top: 16px;
+            background: #1E293B;
+            border: none;
+            max-width: 800px;
+            height: 450px;
+        }
+        
+        .back-button {
+            background: transparent !important;
+            border: none !important;
+            color: #94A3B8 !important;
+            font-size: 14px !important;
+            padding: 8px 16px !important;
+            border-radius: 8px !important;
+            cursor: pointer !important;
+            transition: background-color 0.2s !important;
+            text-align: left !important;
+            width: auto !important;
+            margin-bottom: 24px !important;
+        }
+        
+        .back-button:hover {
+            background: rgba(255, 255, 255, 0.1) !important;
+        }
+        
+        .install-button {
+            background: #38BDF8 !important;
+            color: #0F172A !important;
+            font-weight: 600 !important;
+            padding: 12px 24px !important;
+            border-radius: 8px !important;
+            margin-top: 24px !important;
+            width: 100% !important;
+        }
+        
+        .install-button:hover {
+            background: #0EA5E9 !important;
+        }
+        
+        .remove-button {
+            background: #EF4444 !important;
+            color: white !important;
+            font-weight: 600 !important;
+            padding: 12px 24px !important;
+            border-radius: 8px !important;
+            margin-top: 24px !important;
+            width: 100% !important;
+            border: none !important;
+            cursor: pointer !important;
+            transition: background-color 0.2s !important;
+        }
+        
+        .remove-button:hover {
+            background: #DC2626 !important;
+        }
+        
+        .tool-details-action .remove-button {
+            margin-top: 0 !important;
+            padding: 8px 16px !important;
+            font-size: 14px !important;
+            width: auto !important;
+        }
+        
+        /* Confirmation dialog styling */
+        .confirmation-dialog {
+            background-color: #1E293B;
+            border-radius: 8px;
+            padding: 24px;
+            margin-bottom: 24px;
+            box-shadow: 0 4px 12px rgba(0, 0, 0, 0.2);
+            border: 1px solid #2D3748;
+        }
+        
+        .confirmation-title {
+            font-size: 18px;
+            font-weight: 600;
+            color: white;
+            margin-bottom: 16px;
+        }
+        
+        .confirmation-message {
+            font-size: 14px;
+            color: #E2E8F0;
+            margin-bottom: 24px;
+        }
+        
+        .confirmation-buttons {
+            display: flex;
+            justify-content: flex-end;
+            gap: 12px;
+        }
+        
+        .cancel-button {
+            background: #4B5563 !important;
+            color: white !important;
+            font-weight: 600 !important;
+            padding: 8px 16px !important;
+            border-radius: 8px !important;
+            border: none !important;
+            cursor: pointer !important;
+            transition: background-color 0.2s !important;
+        }
+        
+        .cancel-button:hover {
+            background: #374151 !important;
+        }
+        
+        .confirm-button {
+            background: #EF4444 !important;
+            color: white !important;
+            font-weight: 600 !important;
+            padding: 8px 16px !important;
+            border-radius: 8px !important;
+            border: none !important;
+            cursor: pointer !important;
+            transition: background-color 0.2s !important;
+        }
+        
+        .confirm-button:hover {
+            background: #DC2626 !important;
+        }
+        
+        /* Modal styling */
+        #installation-modal {
+            max-width: 500px;
+            border-radius: 8px;
+            box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
+        }
+        
+        #installation-status {
+            font-size: 18px;
+            font-weight: 600;
+            margin-bottom: 12px;
+            padding-bottom: 8px;
+            border-bottom: 1px solid #e5e7eb;
+        }
+        
+        #installation-result {
+            font-size: 14px;
+            margin-bottom: 20px;
+            white-space: pre-wrap;
+            max-height: 300px;
+            overflow-y: auto;
+        }
+        
+        #close-modal-btn {
+            background-color: #6B7280;
+            color: white;
+            border: none;
+            padding: 8px 16px;
+            border-radius: 4px;
+            cursor: pointer;
+            font-weight: 500;
+            transition: background-color 0.2s;
+            margin-top: 12px;
+        }
+        
+        #close-modal-btn:hover {
+            background-color: #4B5563;
+        }
+        
+        /* Installation result styling */
+        #installation-result-container {
+            margin-bottom: 20px;
+            border: 1px solid #2D3748;
+            border-radius: 8px;
+            padding: 16px;
+            background-color: #1E293B;
+            max-width: 100%;
+            position: relative;
+            z-index: 100;
+            box-shadow: 0 4px 12px rgba(0, 0, 0, 0.2);
+            margin-top: 0;
+        }
+        
+        #installation-status {
+            font-size: 18px;
+            font-weight: 600;
+            margin-bottom: 12px;
+            padding-bottom: 8px;
+            border-bottom: 1px solid #2D3748;
+        }
+        
+        #installation-result {
+            font-size: 14px;
+            margin-bottom: 20px;
+            white-space: pre-wrap;
+            max-height: 300px;
+            overflow-y: auto;
+        }
+        
+        #close-result-btn {
+            background-color: #6B7280;
+            color: white;
+            border: none;
+            padding: 8px 16px;
+            border-radius: 4px;
+            cursor: pointer;
+            font-weight: 500;
+            transition: background-color 0.2s;
+            margin-top: 12px;
+        }
+        
+        #close-result-btn:hover {
+            background-color: #4B5563;
+        }
+        
+        .tool-details-action {
+            display: flex;
+            align-items: center;
+        }
+        
+        .tool-details-action .install-button {
+            margin-top: 0 !important;
+            padding: 8px 16px !important;
+            font-size: 14px !important;
+            width: auto !important;
+        }
+        """
+
+        with gr.Blocks(theme=gr.themes.Default(), css=css) as app:
+            # Define state variables
+            marketplace_tools_state = gr.State([])
+            current_tool_details_state = gr.State(None)
+
+            # Define event handlers first, before any references to them
+            def show_tools():
+                # Create updates to hide all tool containers
+                tool_container_updates = [gr.update(visible=False) for _ in tool_containers]
+                
+                # Generate fresh HTML for tools grid based on current tools
+                tools_html = ''
+                for tool_id, tool in self.tools.items():
+                    # Create HTML for each tool card
+                    tools_html += f'''
+                    <div class="tool-card" id="tool-card-{tool_id}" onclick="document.getElementById('tool-btn-{tool_id}').click()">
+                        <div class="tool-card-img">
+                            {tool.icon}
+                        </div>
+                        <div class="tool-card-content">
+                            <h3 class="tool-card-title">{tool.name}</h3>
+                            <p class="tool-card-description">{tool.description if hasattr(tool, 'description') else ""}</p>
+                        </div>
+                    </div>
+                    '''
+                
+                # Add "Add New Tool" button
+                tools_html += '''
+                <div class="tool-card add-tool-card" onclick="document.getElementById('add-tool-btn').click()">
+                    <div class="add-tool-icon">+</div>
+                    <div>Add New Tool from Marketplace</div>
+                </div>
+                '''
+                
+                # Create HTML update for tools grid
+                tools_html_component = gr.HTML(f'<div class="tool-grid">{tools_html}</div>')
+                
+                return [
+                    gr.update(visible=True),   # tools_content
+                    gr.update(visible=False),  # marketplace_content
+                    gr.update(visible=False),  # settings_content
+                    gr.update(visible=False),  # tool_interfaces
+                    gr.update(visible=False),  # tool_details_content
+                    gr.update(variant="primary"),    # tools_btn
+                    gr.update(variant="secondary"),  # marketplace_btn
+                    gr.update(variant="secondary"),  # settings_btn,
+                    tools_html_component,  # tools_html_component
+                    gr.update(value="")  # tool_interfaces_html
+                ] + tool_container_updates
+            
+            def show_marketplace():
+                # Fetch marketplace tools
+                tools = self.fetch_marketplace_tools()
+                
+                # Create HTML for marketplace grid
+                html = '<div class="tool-grid">'
+                
+                for i, tool in enumerate(tools):
+                    # Use a unique ID for each card based on the tool ID
+                    # Add a class to indicate if the tool is installed
+                    installed_class = "installed" if tool.get('is_installed', False) else ""
+                    
+                    # Add an indicator for installed tools
+                    installed_indicator = '<div class="installed-indicator">✓ Installed</div>' if tool.get('is_installed', False) else ''
+                    
+                    html += f'''
+                    <div class="tool-card {installed_class}" id="card-{tool['id']}" onclick="document.getElementById('marketplace-tool-btn-{i}').click()">
+                        <div class="tool-card-img">
+                            {tool['icon']}
+                        </div>
+                        <div class="tool-card-content">
+                            <h3 class="tool-card-title">{tool['name']}</h3>
+                            <p class="tool-card-description">{tool['description']}</p>
+                            {installed_indicator}
+                        </div>
+                    </div>
+                    '''
+                
+                html += '</div>'
+                
+                # Hide installation result container and confirmation dialog
+                installation_result_container_update = gr.update(visible=False)
+                confirmation_dialog_update = gr.update(visible=False)
+                
+                # Create updates for all tool containers
+                tool_container_updates = [gr.update(visible=False) for _ in tool_containers]
+                
+                # Update marketplace_tools_state with the latest tools
+                # This ensures the marketplace shows the current state of available tools
+                
+                return [
+                    gr.update(visible=False),  # tools_content
+                    gr.update(visible=True),   # marketplace_content
+                    gr.update(visible=False),  # settings_content
+                    gr.update(visible=False),  # tool_interfaces
+                    gr.update(visible=False),  # tool_details_content
+                    gr.update(variant="secondary"),  # tools_btn
+                    gr.update(variant="primary"),    # marketplace_btn
+                    gr.update(variant="secondary"),  # settings_btn
+                    tools,  # marketplace_tools_state - updated with latest tools
+                    html,   # marketplace_html
+                    installation_result_container_update,  # installation_result_container
+                    confirmation_dialog_update,  # confirmation_dialog
+                    gr.update(value="")  # tool_interfaces_html
+                ] + tool_container_updates
+            
+            def show_settings():
+                # Create updates to hide all tool containers
+                tool_container_updates = [gr.update(visible=False) for _ in tool_containers]
+                
+                return [
+                    gr.update(visible=False),  # tools_content
+                    gr.update(visible=False),  # marketplace_content
+                    gr.update(visible=True),   # settings_content
+                    gr.update(visible=False),  # tool_interfaces
+                    gr.update(visible=False),  # tool_details_content
+                    gr.update(variant="secondary"),  # tools_btn
+                    gr.update(variant="secondary"),  # marketplace_btn
+                    gr.update(variant="primary"),    # settings_btn
+                    gr.update(value="")  # tool_interfaces_html
+                ] + tool_container_updates
+            
+            def show_tool(tool_id=None):
+                # Import gradio at the beginning of the function
+                import gradio as gr
+                
+                # Check if the tool exists
+                if tool_id not in self.tools:
+                    print(f"Tool {tool_id} not found")
+                    return show_tools()
+                
+                # Get the tool
+                tool = self.tools[tool_id]
+                
+                # Check if this is a newly installed tool that needs special handling
+                if hasattr(tool, 'newly_installed') and tool.newly_installed:
+                    print(f"Dynamically creating UI for newly installed tool: {tool_id}")
+                    
+                    try:
+                        # Create a message to inform the user that we're loading the tool
+                        loading_message = f"""
+                        <div style="text-align: center; padding: 20px;">
+                            <h2>Loading {tool.name}...</h2>
+                            <p>Please wait while we set up the tool interface.</p>
+                        </div>
+                        """
+                        
+                        # First, return a loading message
+                        loading_updates = [
+                            gr.update(visible=False),  # tools_content
+                            gr.update(visible=False),  # marketplace_content
+                            gr.update(visible=False),  # settings_content
+                            gr.update(visible=True),   # tool_interfaces
+                            gr.update(visible=False),  # tool_details_content
+                            gr.update(variant="secondary"),  # tools_btn
+                            gr.update(variant="secondary"),  # marketplace_btn
+                            gr.update(variant="secondary"),  # settings_btn
+                            gr.update(value=loading_message)  # tool_interfaces_html
+                        ] + [gr.update(visible=False) for _ in tool_containers]
+                        
+                        # Instead of trying to create the UI dynamically, which can cause issues with Gradio components,
+                        # we'll create a simple HTML interface that provides basic functionality and instructions
+                        
+                        # Get the tool class name and module for display
+                        tool_class_name = tool.ui_class.__name__
+                        tool_module_name = tool.ui_module
+                        
+                        # Create a friendly HTML interface
+                        tool_html = f"""
+                        <div style="text-align: center; padding: 20px;">
+                            <h2>{tool.name} is Ready!</h2>
+                            <p>This tool has been successfully installed.</p>
+                            <p>For the best experience with this tool, please restart the application.</p>
+                            <p>After restarting, you'll be able to use all the features of this tool.</p>
+                            <!--<div style="margin-top: 20px;">
+                                <button onclick="window.location.reload()" style="background-color: #4CAF50; color: white; padding: 10px 20px; border: none; border-radius: 4px; cursor: pointer; font-size: 16px;">Refresh Page</button>
+                            </div>-->
+                        </div>
+                        """
+                        
+                        # Remove the newly_installed flag so we don't try to create the UI again
+                        delattr(tool, 'newly_installed')
+                        
+                        # Return the HTML interface
+                        return [
+                            gr.update(visible=False),  # tools_content
+                            gr.update(visible=False),  # marketplace_content
+                            gr.update(visible=False),  # settings_content
+                            gr.update(visible=True),   # tool_interfaces
+                            gr.update(visible=False),  # tool_details_content
+                            gr.update(variant="secondary"),  # tools_btn
+                            gr.update(variant="secondary"),  # marketplace_btn
+                            gr.update(variant="secondary"),  # settings_btn
+                            gr.update(value=tool_html)  # tool_interfaces_html
+                        ] + [gr.update(visible=False) for _ in tool_containers]
+                    except Exception as e:
+                        print(f"Error creating UI for newly installed tool: {e}")
+                        import traceback
+                        traceback.print_exc()
+                        
+                        # If there's an error, show a message asking the user to restart
+                        restart_message = f"""
+                        <div style="text-align: center; padding: 20px;">
+                            <h2>Error Loading {tool.name}</h2>
+                            <p>There was an error setting up the tool interface:</p>
+                            <pre style="text-align: left; background: #f0f0f0; padding: 10px; border-radius: 5px; overflow: auto;">{str(e)}</pre>
+                            <p>Please restart the application to use this tool.</p>
+                            <div style="margin-top: 20px;">
+                                <button onclick="window.location.reload()" style="background-color: #4CAF50; color: white; padding: 10px 20px; border: none; border-radius: 4px; cursor: pointer; font-size: 16px;">Refresh Page</button>
+                            </div>
+                        </div>
+                        """
+                        
+                        return [
+                            gr.update(visible=False),  # tools_content
+                            gr.update(visible=False),  # marketplace_content
+                            gr.update(visible=False),  # settings_content
+                            gr.update(visible=True),   # tool_interfaces
+                            gr.update(visible=False),  # tool_details_content
+                            gr.update(variant="secondary"),  # tools_btn
+                            gr.update(variant="secondary"),  # marketplace_btn
+                            gr.update(variant="secondary"),  # settings_btn
+                            gr.update(value=restart_message)  # tool_interfaces_html
+                        ] + [gr.update(visible=False) for _ in tool_containers]
+                
+                # For existing tools with proper UI containers
+                # Create a list of visibility updates for all tool containers
+                updates = []
+                
+                for i, container in enumerate(tool_containers):
+                    # Get the tool_id for this container
+                    container_tool_id = None
+                    for tid, t in self.tools.items():
+                        if hasattr(t, 'ui_container') and t.ui_container == container:
+                            container_tool_id = tid
+                            break
+                    
+                    # Set visibility based on whether this is the selected tool
+                    if container_tool_id == tool_id:
+                        updates.append(gr.update(visible=True))
+                    else:
+                        updates.append(gr.update(visible=False))
+                
+                return [
+                    gr.update(visible=False),  # tools_content
+                    gr.update(visible=False),  # marketplace_content
+                    gr.update(visible=False),  # settings_content
+                    gr.update(visible=True),   # tool_interfaces
+                    gr.update(visible=False),  # tool_details_content
+                    gr.update(variant="secondary"),  # tools_btn
+                    gr.update(variant="secondary"),  # marketplace_btn
+                    gr.update(variant="secondary"),  # settings_btn
+                    gr.update(value="")  # tool_interfaces_html
+                ] + updates
+            
+            def show_tool_details(tool_id):
+                # Fetch tool details
+                tool = self.fetch_tool_details(tool_id)
+                
+                # Create updates to hide all tool containers
+                tool_container_updates = [gr.update(visible=False) for _ in tool_containers]
+                
+                if not tool:
+                    return [
+                        gr.update(visible=False),  # tools_content
+                        gr.update(visible=True),   # marketplace_content
+                        gr.update(visible=False),  # settings_content
+                        gr.update(visible=False),  # tool_interfaces
+                        gr.update(visible=False),  # tool_details_content
+                        gr.update(variant="secondary"),  # tools_btn
+                        gr.update(variant="primary"),    # marketplace_btn
+                        gr.update(variant="secondary"),  # settings_btn
+                        None,  # current_tool_details_state
+                        "",    # tool_details_html
+                        gr.update(visible=False),  # installation_result_container
+                        gr.update(visible=False),   # confirmation_dialog
+                        gr.update(value="")  # tool_interfaces_html
+                    ] + tool_container_updates
+                
+                # Create features HTML
+                features_html = "".join([
+                    f'<div class="tool-details-feature"><span class="tool-details-feature-icon">✓</span><span class="tool-details-feature-text">{feature}</span></div>'
+                    for feature in tool.get('features', [])
+                ])
+                
+                # Create demo video HTML
+                demo_video_html = f'<iframe class="tool-details-video" src="{tool.get("demo_video", "https://www.youtube.com/embed/dQw4w9WgXcQ")}" frameborder="0" allowfullscreen></iframe>' if True else ''
+                
+                # Check if the tool is already installed
+                # Use the is_installed flag if available, otherwise check self.tools
+                is_installed = tool.get('is_installed', False) or tool_id in self.tools
+                
+                # Determine which button to show based on installation status
+                if is_installed:
+                    action_button = f'<button id="remove-tool-btn-inline" class="remove-button" onclick="document.getElementById(\'remove-btn\').click()">Remove Tool</button>'
+                else:
+                    action_button = f'<button id="add-tool-btn-inline" class="install-button" onclick="document.getElementById(\'install-btn\').click()">Add Tool</button>'
+                
+                # Create HTML for tool details
+                html = f'''
+                <div class="tool-details-container">
+                    <div class="tool-details">
+                        <div class="tool-details-header">
+                            <div class="tool-details-title-section">
+                                <div class="tool-details-icon">{tool['icon']}</div>
+                                <h2 class="tool-details-title">{tool['name']} <span class="tool-details-version">v{tool['version']}</span></h2>
+                            </div>
+                            <div class="tool-details-action">
+                                {action_button}
+                            </div>
+                        </div>
+                        <p class="tool-details-description">{tool['description']}</p>
+                        
+                        <h3 class="tool-details-section-title">Features</h3>
+                        <div class="tool-details-features">
+                            {features_html}
+                        </div>
+                        
+                        <h3 class="tool-details-section-title">Video</h3>
+                        {demo_video_html}
+                    </div>
+                </div>
+                '''
+                
+                print(f"Setting current_tool_details_state to: {tool}")
+                return [
+                    gr.update(visible=False),  # tools_content
+                    gr.update(visible=False),  # marketplace_content
+                    gr.update(visible=False),  # settings_content
+                    gr.update(visible=False),  # tool_interfaces
+                    gr.update(visible=True),   # tool_details_content
+                    gr.update(variant="secondary"),  # tools_btn
+                    gr.update(variant="secondary"),  # marketplace_btn
+                    gr.update(variant="secondary"),  # settings_btn
+                    tool,  # current_tool_details_state
+                    html,  # tool_details_html
+                    gr.update(visible=False),  # installation_result_container
+                    gr.update(visible=False),   # confirmation_dialog
+                    gr.update(value="")  # tool_interfaces_html
+                ] + tool_container_updates
+            
+            def install_selected_tool(tool_details):
+                print(f"Installing tool: {tool_details}")
+                
+                if not tool_details:
+                    print("No tool details provided")
+                    return [
+                        gr.update(visible=True),  # installation_result_container
+                        "⚠️ Installation Failed",     # installation_status
+                        "No tool selected to install."  # installation_result
+                    ]
+                
+                try:
+                    # Install the tool
+                    result = self.install_tool(tool_details['id'])
+                    
+                    if "Error" in result:
+                        return [
+                            gr.update(visible=True),  # installation_result_container
+                            "⚠️ Installation Failed",     # installation_status
+                            result                       # installation_result
+                        ]
+                    else:
+                        # If installation was successful, we'll show a success message
+                        # The user can click "Close" to see the installation result
+                        # and then navigate to the tools page to see the new tool
+                        return [
+                            gr.update(visible=True),  # installation_result_container
+                            "✅ Installation Successful",  # installation_status
+                            result                        # installation_result
+                        ]
+                except Exception as e:
+                    print(f"Error installing tool: {e}")
+                    return [
+                        gr.update(visible=True),  # installation_result_container
+                        "⚠️ Installation Failed",     # installation_status
+                        f"Error installing tool: {e}"  # installation_result
+                    ]
+
+            # Create components after defining the functions
+            with gr.Row():
+                # Sidebar
+                with gr.Column(elem_id="sidebar", scale=1):
+                    gr.Markdown("AI TOOLS", elem_classes="title")
+                    tools_btn = gr.Button("Tools", elem_classes="nav-button", variant="primary")
+                    marketplace_btn = gr.Button("Marketplace", elem_classes="nav-button", variant="secondary")
+                    settings_btn = gr.Button("Settings", elem_classes="nav-button", variant="secondary")
+                    gr.Markdown(f"version: {self.version}", elem_classes="version-text")
+                
+                # Main content
+                with gr.Column(elem_id="main-content", scale=4):
+                    # Define all content containers
+                    tools_content = gr.Column(visible=True)
+                    marketplace_content = gr.Column(visible=False)
+                    settings_content = gr.Column(visible=False)
+                    tool_interfaces = gr.Column(visible=False)
+                    tool_details_content = gr.Column(visible=False)
+                    
+                    # Fill tools content
+                    with tools_content:
+                        gr.Markdown("Tools", elem_classes="page-title")
+                        
+                        tool_buttons = []
+                        tool_ids = []  # Store tool_ids in the same order as tool_buttons
+                        
+                        # Create HTML for all tools
+                        tools_html = ''
+                        
+                        for tool_id, tool in self.tools.items():
+                            # Create HTML for each tool card
+                            tools_html += f'''
+                            <div class="tool-card" id="tool-card-{tool_id}" onclick="document.getElementById('tool-btn-{tool_id}').click()">
+                                <div class="tool-card-img">
+                                    {tool.icon}
+                                </div>
+                                <div class="tool-card-content">
+                                    <h3 class="tool-card-title">{tool.name}</h3>
+                                    <p class="tool-card-description">{tool.description if hasattr(tool, 'description') else ""}</p>
+                                </div>
+                            </div>
+                            '''
+                            
+                            # Create hidden buttons for tool selection
+                            btn = gr.Button(f"Select {tool.name}", visible=False, elem_id=f"tool-btn-{tool_id}")
+                            tool_buttons.append(btn)
+                            tool_ids.append(tool_id)
+                        
+                        # Add "Add New Tool" button
+                        tools_html += '''
+                        <div class="tool-card add-tool-card" onclick="document.getElementById('add-tool-btn').click()">
+                            <div class="add-tool-icon">+</div>
+                            <div>Add New Tool from Marketplace</div>
+                        </div>
+                        '''
+                        
+                        # Render the HTML inside a div with the tool-grid class
+                        tools_html_component = gr.HTML(f'<div class="tool-grid">{tools_html}</div>')
+                        
+                        # Create hidden add tool button
+                        add_tool_btn = gr.Button("Add New Tool", visible=False, elem_id="add-tool-btn")
+                    
+                    # Fill marketplace content
+                    with marketplace_content:
+                        gr.Markdown("Marketplace", elem_classes="page-title")
+                        marketplace_html = gr.HTML("Loading marketplace tools...")
+                        
+                        # Create hidden buttons for marketplace tool details with unique IDs
+                        tool_buttons_container = gr.Column(visible=False)
+                        
+                        # Create hidden buttons for marketplace tools
+                        marketplace_tool_buttons = []
+                        for i, tool in enumerate(self.fetch_marketplace_tools()):
+                            tool_btn = gr.Button(f"View {tool['name']}", visible=False, elem_id=f"marketplace-tool-btn-{i}")
+                            marketplace_tool_buttons.append((tool['id'], tool_btn))
+                        
+                        # The click handlers for marketplace tool buttons will be set up after all components are defined
+                    
+                    # Fill tool details content
+                    with tool_details_content:
+                        # Installation result section at the top
+                        with gr.Column(elem_id="installation-result-container", elem_classes="installation-result-container", visible=False) as installation_result_container:
+                            installation_status = gr.Markdown("Ready to install", elem_id="installation-status")
+                            installation_result = gr.Markdown("Click the Install Tool button to install the selected tool.", elem_id="installation-result")
+                            close_result_btn = gr.Button("Close", elem_id="close-result-btn")
+                        
+                        # Confirmation dialog for tool removal
+                        with gr.Column(elem_id="confirmation-dialog", elem_classes="confirmation-dialog", visible=False) as confirmation_dialog:
+                            gr.Markdown("⚠️ Warning: Remove Tool", elem_id="confirmation-title", elem_classes="confirmation-title")
+                            gr.Markdown(
+                                "Are you sure you want to remove this tool? This action cannot be undone. "
+                                "All data created by this tool will be permanently deleted.", 
+                                elem_id="confirmation-message", 
+                                elem_classes="confirmation-message"
+                            )
+                            with gr.Row(elem_classes="confirmation-buttons"):
+                                cancel_btn = gr.Button("Cancel", elem_classes="cancel-button")
+                                confirm_btn = gr.Button("Yes, Remove Tool", elem_classes="confirm-button")
+                            
+                        with gr.Row():
+                            with gr.Column(scale=1):
+                                back_btn = gr.Button("← Back to Marketplace", elem_classes="back-button")
+                            with gr.Column(scale=3):
+                                gr.Markdown("", elem_classes="page-title")
+                        
+                        # Tool details content
+                        tool_details_html = gr.HTML("")
+                        
+                        # Hidden install button (will be triggered by the inline button)
+                        install_btn = gr.Button("Add Tool", elem_classes="install-button", elem_id="install-btn", variant="primary", visible=False)
+                        
+                        # Hidden remove button (will be triggered by the inline button)
+                        remove_btn = gr.Button("Remove Tool", elem_classes="remove-button", elem_id="remove-btn", variant="primary", visible=False)
+                        
+                        # Add a direct event handler to the install button
+                        def debug_install_click():
+                            print("Install button clicked directly!")
+                            return [gr.update(visible=True), gr.update(value="Install button clicked!")]
+                        
+                        # Add a direct event handler to the remove button to show confirmation dialog
+                        def show_confirmation_dialog():
+                            print("Remove button clicked - showing confirmation dialog")
+                            return gr.update(visible=True)
+                        
+                        # Function to handle tool removal confirmation
+                        def remove_selected_tool(tool_details):
+                            print(f"Removing tool: {tool_details}")
+                            
+                            if not tool_details:
+                                print("No tool details provided")
+                                return [
+                                    gr.update(visible=False),  # confirmation_dialog
+                                    gr.update(visible=True),   # installation_result_container
+                                    "⚠️ Removal Failed",       # installation_status
+                                    "No tool selected to remove."  # installation_result
+                                ]
+                            
+                            try:
+                                # Remove the tool
+                                result = self.remove_tool(tool_details['id'])
+                                
+                                if "Error" in result:
+                                    return [
+                                        gr.update(visible=False),  # confirmation_dialog
+                                        gr.update(visible=True),   # installation_result_container
+                                        "⚠️ Removal Failed",       # installation_status
+                                        result                     # installation_result
+                                    ]
+                                else:
+                                    # After successful removal, show success message
+                                    # The user will need to click "Back to Marketplace" manually
+                                    # This avoids issues with dynamic UI updates
+                                    return [
+                                        gr.update(visible=False),  # confirmation_dialog
+                                        gr.update(visible=True),   # installation_result_container
+                                        "✅ Removal Successful",   # installation_status
+                                        f"{result} - Click 'Back to Marketplace' to return. You may need to restart the application to see all changes."  # installation_result
+                                    ]
+                            except Exception as e:
+                                print(f"Error removing tool: {e}")
+                                return [
+                                    gr.update(visible=False),  # confirmation_dialog
+                                    gr.update(visible=True),   # installation_result_container
+                                    "⚠️ Removal Failed",       # installation_status
+                                    f"Error removing tool: {e}"  # installation_result
+                                ]
+                        
+                        # Function to cancel removal
+                        def cancel_removal():
+                            return gr.update(visible=False)
+                        
+                        debug_output = gr.Textbox(label="Debug Output", visible=False)
+                        
+                        # Set up event handlers for buttons
+                        install_btn.click(
+                            fn=install_selected_tool,
+                            inputs=[current_tool_details_state],
+                            outputs=[installation_result_container, installation_status, installation_result]
+                        )
+                        remove_btn.click(fn=show_confirmation_dialog, outputs=confirmation_dialog)
+                        
+                        # Set up confirmation dialog buttons
+                        cancel_btn.click(fn=cancel_removal, outputs=confirmation_dialog)
+                        confirm_btn.click(
+                            fn=remove_selected_tool,
+                            inputs=[current_tool_details_state],
+                            outputs=[confirmation_dialog, installation_result_container, installation_status, installation_result]
+                        )
+                    
+                    # Fill settings content
+                    with settings_content:
+                        gr.Markdown("Settings", elem_classes="page-title")
+                        gr.Markdown("Settings options will appear here...")
+                    
+                    # Fill tool interfaces
+                    with tool_interfaces:
+                        # Add an HTML component to display messages for newly installed tools
+                        tool_interfaces_html = gr.HTML("", elem_id="tool-interfaces-html")
+                        
+                        for tool_id, tool in self.tools.items():
+                            with gr.Column(visible=False) as tool_container:
+                                tool_ui = tool.ui_class()
+                                tool_ui.create_ui()
+                            # Store the UI container in the tool object for later reference
+                            tool.ui_container = tool_container
+            
+            # Set up event handlers after all components are defined
+            # Set up tool button events
+            
+            # Collect all tool containers for outputs
+            tool_containers = []
+            for tool_id, tool in self.tools.items():
+                if hasattr(tool, 'ui_container'):
+                    tool_containers.append(tool.ui_container)
+            
+            # Set up click handlers for marketplace tool buttons
+            for i, (tool_id, tool_btn) in enumerate(marketplace_tool_buttons):
+                # We need to create a separate function for each button to avoid lambda closure issues
+                def make_handler(tid):
+                    return lambda: show_tool_details(tid)
+                
+                handler = make_handler(tool_id)
+                tool_btn.click(
+                    fn=handler,
+                    outputs=[
+                        tools_content, marketplace_content, settings_content, tool_interfaces, 
+                        tool_details_content, tools_btn, marketplace_btn, settings_btn,
+                        current_tool_details_state, tool_details_html, installation_result_container,
+                        confirmation_dialog, tool_interfaces_html
+                    ] + tool_containers
+                )
+            
+            for i, btn in enumerate(tool_buttons):
+                if isinstance(btn, gr.Button):  # Check if it's a button from the tools grid
+                    tool_id = tool_ids[i]  # Get the corresponding tool_id
+                    
+                    # We need to create a separate function for each button to avoid lambda closure issues
+                    def make_handler(tid):
+                        return lambda: show_tool(tid)
+                    
+                    handler = make_handler(tool_id)
+                    btn.click(
+                        fn=handler,
+                        outputs=[tools_content, marketplace_content, settings_content, tool_interfaces, 
+                                tool_details_content, tools_btn, marketplace_btn, settings_btn,
+                                tool_interfaces_html] + tool_containers
+                    )
+            
+            # Set up navigation events
+            tools_btn.click(
+                fn=show_tools,
+                outputs=[tools_content, marketplace_content, settings_content, tool_interfaces, 
+                        tool_details_content, tools_btn, marketplace_btn, settings_btn,
+                        tools_html_component, tool_interfaces_html] + tool_containers
+            )
+            
+            marketplace_btn.click(
+                fn=show_marketplace,
+                outputs=[tools_content, marketplace_content, settings_content, tool_interfaces, 
+                        tool_details_content, tools_btn, marketplace_btn, settings_btn,
+                        marketplace_tools_state, marketplace_html, installation_result_container,
+                        confirmation_dialog, tool_interfaces_html] + tool_containers
+            )
+            
+            settings_btn.click(
+                fn=show_settings,
+                outputs=[tools_content, marketplace_content, settings_content, tool_interfaces, 
+                        tool_details_content, tools_btn, marketplace_btn, settings_btn,
+                        tool_interfaces_html] + tool_containers
+            )
+            
+            # Set up add tool button to navigate to marketplace
+            add_tool_btn.click(
+                fn=show_marketplace,
+                outputs=[tools_content, marketplace_content, settings_content, tool_interfaces, 
+                        tool_details_content, tools_btn, marketplace_btn, settings_btn,
+                        marketplace_tools_state, marketplace_html, installation_result_container,
+                        confirmation_dialog, tool_interfaces_html] + tool_containers
+            )
+            
+            # Set up event handlers for tool details
+            back_btn.click(
+                fn=show_marketplace,
+                outputs=[
+                    tools_content, marketplace_content, settings_content, tool_interfaces, 
+                    tool_details_content, tools_btn, marketplace_btn, settings_btn,
+                    marketplace_tools_state, marketplace_html, installation_result_container,
+                    confirmation_dialog
+                ] + tool_containers
+            )
+            
+            # Define a function to handle closing the installation result and navigating to tools
+            def close_result_and_show_tools():
+                # First hide the installation result container
+                installation_result_update = gr.update(visible=False)
+                
+                # Then get the updates from show_tools
+                tools_updates = show_tools()
+                
+                # Combine the updates
+                return [installation_result_update] + tools_updates
+            
+            # Set up close button for installation result
+            close_result_btn.click(
+                fn=close_result_and_show_tools,
+                outputs=[installation_result_container, 
+                         tools_content, marketplace_content, settings_content, tool_interfaces, 
+                         tool_details_content, tools_btn, marketplace_btn, settings_btn,
+                         tools_html_component, tool_interfaces_html] + tool_containers
+            )
+
+        return app
+
+if __name__ == "__main__":
+    ui = MainUI()
+    demo = ui.create_ui()
+    demo.queue()  # Add queue for better handling of multiple requests
+    demo.title = "AI Tools Platform"  # Add a title
+    demo.launch(
+        debug=True,
+        share=True,
+        server_name="0.0.0.0",
+        server_port=7860
+    ) 

requirements.txt

@@ -0,0 +1,12 @@
+librosa==0.10.1
+numpy==1.26.3
+moviepy==2.1.2
+opencv-python>=4.8.0
+scikit-learn>=1.3.0
+scenedetect~=0.6.5.2
+gradio==4.19.2
+flask==2.3.3
+requests==2.31.0
+rembg
+Pillow
+onnxruntime

tools/beatsyncer/__init__.py

@@ -0,0 +1 @@
+# Beatsyncer package

tools/beatsyncer/beatsyncer_tool.py

@@ -0,0 +1,470 @@
+import os
+import random
+import librosa
+import numpy as np
+from moviepy import *
+
+class BeatSyncer:
+    AUDIO_EXTENSIONS = {'.mp3', '.wav', '.m4a', '.aac', '.ogg', '.flac'}
+    VIDEO_EXTENSIONS = {'.mp4', '.avi', '.mov', '.mkv', '.wmv', '.flv'}
+
+    def __init__(self, audio_filename):
+        # Construct the full path to the audio file relative to the script's directory
+        script_dir = os.path.dirname(os.path.abspath(__file__))
+        input_path = os.path.join(script_dir, audio_filename)
+        
+        # Convert to audio if needed
+        if self._is_video_file(input_path):
+            print(f"Converting video file '{input_path}' to audio...")
+            audio_path = self._convert_to_audio(input_path)
+            self.audio_path = audio_path
+        elif self._is_audio_file(input_path):
+            self.audio_path = input_path
+        else:
+            raise ValueError(f"Unsupported file format. File must be one of: {self.AUDIO_EXTENSIONS.union(self.VIDEO_EXTENSIONS)}")
+        
+        self.y = None  # Audio samples
+        self.sr = None  # Sample rate
+        self.beat_times = None
+        self.beat_drop_times = None
+
+    def _is_audio_file(self, filepath):
+        """Check if the file is an audio file based on its extension."""
+        return os.path.splitext(filepath)[1].lower() in self.AUDIO_EXTENSIONS
+
+    def _is_video_file(self, filepath):
+        """Check if the file is a video file based on its extension."""
+        return os.path.splitext(filepath)[1].lower() in self.VIDEO_EXTENSIONS
+
+    def _convert_to_audio(self, video_path):
+        """Convert a video file to audio and return the path to the audio file."""
+        try:
+            # Create tmp directory in project root if it doesn't exist
+            script_dir = os.path.dirname(os.path.abspath(__file__))
+            tmp_dir = os.path.join(script_dir, 'tmp')
+            os.makedirs(tmp_dir, exist_ok=True)
+            
+            # Create audio filename in tmp directory
+            base_name = os.path.basename(video_path)
+            audio_name = os.path.splitext(base_name)[0] + '.mp3'
+            audio_path = os.path.join(tmp_dir, audio_name)
+            
+            # Convert video to audio
+            video = VideoFileClip(video_path)
+            video.audio.write_audiofile(audio_path)
+            video.close()
+            
+            return audio_path
+        except Exception as e:
+            raise ValueError(f"Error converting video to audio: {str(e)}")
+
+    def load_audio(self, duration_minutes=None):
+        """
+        Load the audio file using librosa, limiting to duration_minutes if provided.
+        """
+        try:
+            self.sr = 44100  # Set a standard sample rate
+            if duration_minutes is not None:
+                duration_seconds = duration_minutes * 60
+            else:
+                duration_seconds = None  # Load full audio
+            self.y, _ = librosa.load(self.audio_path, sr=self.sr, duration=duration_seconds)
+            if self.y is None or len(self.y) == 0:
+                raise ValueError("Audio data is empty.")
+            duration = len(self.y) / self.sr
+            print(f"Loaded audio file '{self.audio_path}' with duration {duration:.2f} seconds.")
+        except Exception as e:
+            print(f"An error occurred while loading the audio file: {e}")
+            raise
+
+    def detect_beat_drops(self, sensitivity='medium'):
+        """
+        Improved beat detection using onset_strength_multi and adjusted parameters.
+        
+        Args:
+            sensitivity (str): Detection sensitivity level ('low', 'medium', or 'high').
+                             - low: Less sensitive, detects only major beat drops
+                             - medium: Balanced sensitivity (default)
+                             - high: More sensitive, detects subtle beat changes
+        """
+        print("Detecting beat drops...")
+        if self.y is None or len(self.y) == 0:
+            raise ValueError("Audio data is empty. Cannot perform beat detection.")
+
+        # Map sensitivity levels to parameters
+        sensitivity_params = {
+            'low': {
+                'hop_length': 512,  # Larger hop length for less granular detection
+                'std_multiplier': 1.0,  # Higher threshold for beat detection
+                'min_interval': 0.05  # Longer minimum interval between beats
+            },
+            'medium': {
+                'hop_length': 256,  # Default hop length
+                'std_multiplier': 0.5,  # Default threshold
+                'min_interval': 0.02  # Default minimum interval
+            },
+            'high': {
+                'hop_length': 128,  # Smaller hop length for more granular detection
+                'std_multiplier': 0.25,  # Lower threshold for beat detection
+                'min_interval': 0.01  # Shorter minimum interval between beats
+            }
+        }
+
+        # Validate and get sensitivity parameters
+        sensitivity = sensitivity.lower()
+        if sensitivity not in sensitivity_params:
+            raise ValueError(f"Invalid sensitivity level. Must be one of: {list(sensitivity_params.keys())}")
+        
+        params = sensitivity_params[sensitivity]
+        
+        # Parameters for onset detection
+        hop_length = params['hop_length']
+        
+        params.update({
+            "detrend": True,
+            "tightness": 100
+        })
+
+        # Compute the onset envelope using onset_strength_multi with adjusted parameters
+        onset_env_multi = librosa.onset.onset_strength_multi(
+            y=self.y,
+            sr=self.sr,
+            hop_length=params["hop_length"],
+            aggregate=np.median,
+            lag=1,
+            max_size=1,
+            detrend=params["detrend"],
+            center=True,
+        )
+
+        # Sum across channels if multi-channel audio
+        onset_env = onset_env_multi.mean(axis=0)
+
+        # Beat tracking with adjusted parameters
+        tempo, beats = librosa.beat.beat_track(
+            onset_envelope=onset_env,
+            sr=self.sr,
+            hop_length=params["hop_length"],
+            tightness=params["tightness"],
+            units='time'
+        )
+
+        # Convert tempo to scalar if it's an array
+        tempo = float(np.mean(tempo)) if isinstance(tempo, np.ndarray) else float(tempo)
+
+        # Adjust tempo if it's unusually high (e.g., over 180 BPM)
+        if tempo >= 180:
+            tempo /= 2
+            print(f"Adjusted tempo: {tempo:.2f} BPM")
+        else:
+            print(f"Detected tempo: {tempo:.2f} BPM")
+
+        self.beat_times = beats
+
+        if len(self.beat_times) == 0:
+            raise ValueError("No beats detected in the audio.")
+
+        # Compute the difference in onset envelope with sensitivity-based threshold
+        onset_diff = np.diff(onset_env)
+        threshold = np.mean(onset_diff) + params['std_multiplier'] * np.std(onset_diff)
+        beat_drop_indices = np.where(onset_diff > threshold)[0] + 1
+
+        # Convert beat frames to times
+        onset_times = librosa.frames_to_time(
+            np.arange(len(onset_env)), sr=self.sr, hop_length=hop_length
+        )
+
+        # Map beat drop indices to times
+        beat_drop_times = onset_times[beat_drop_indices]
+
+        # Remove duplicate beat times
+        self.beat_drop_times = np.unique(beat_drop_times)
+
+        # Remove beat drops that are too close together based on sensitivity
+        min_interval = params['min_interval']
+        filtered_beat_drop_times = [self.beat_drop_times[0]]
+        for bd_time in self.beat_drop_times[1:]:
+            if bd_time - filtered_beat_drop_times[-1] >= min_interval:
+                filtered_beat_drop_times.append(bd_time)
+        self.beat_drop_times = np.array(filtered_beat_drop_times)
+
+        print(f"Detected {len(self.beat_drop_times)} beat drops with {sensitivity} sensitivity.")
+
+    def _get_media_files(self, media_dir):
+        """
+        Get list of media files from the directory.
+        Returns a shuffled list of absolute paths to media files.
+        """
+        supported_extensions = ('.mp4', '.avi', '.mov', '.png', '.jpg', '.jpeg', '.gif', '.mkv')
+        media_files = []
+        
+        # Walk through directory
+        for root, _, files in os.walk(media_dir):
+            for file in files:
+                if file.lower().endswith(supported_extensions):
+                    full_path = os.path.join(root, file)
+                    media_files.append(full_path)
+        
+        if not media_files:
+            raise ValueError(f"No supported media files found in directory: {media_dir}")
+        
+        # Shuffle the media files list
+        random.shuffle(media_files)
+        print(f"Found and shuffled {len(media_files)} media files")
+            
+        return media_files
+
+    def _calculate_text_duration(self, text):
+        """
+        Calculate the duration a text should be displayed based on its word count.
+        
+        Args:
+            text (str): The text to be displayed
+            
+        Returns:
+            float: Duration in seconds
+        """
+        # Count words (split by whitespace)
+        word_count = len(text.split())
+        
+        # Base duration calculation:
+        # - Minimum duration: 2 seconds
+        # - Add 0.5 seconds per word
+        # - Maximum duration: 8 seconds
+        duration = min(max(2, word_count * 0.5), 8)
+        
+        return duration
+
+    def _wrap_text(self, text, max_chars_per_line=30):
+        """
+        Wrap text to ensure it fits nicely on screen.
+        
+        Args:
+            text (str): Text to wrap
+            max_chars_per_line (int): Maximum characters per line
+            
+        Returns:
+            str: Wrapped text with newlines and increased line spacing
+        """
+        words = text.split()
+        lines = []
+        current_line = []
+        current_length = 0
+        
+        for word in words:
+            word_length = len(word)
+            if current_length + word_length + len(current_line) <= max_chars_per_line:
+                current_line.append(word)
+                current_length += word_length
+            else:
+                lines.append(' '.join(current_line))
+                current_line = [word]
+                current_length = word_length
+        
+        if current_line:
+            lines.append(' '.join(current_line))
+            
+        # Add extra line spacing by using double newlines
+        return '\n'.join(lines)
+
+    def sync_with_media_directory(self, media_dir, output_path, duration_minutes=None, video_size=None, dark_overlay=0.3, 
+                                text_overlays=None):
+        """
+        Create a video by syncing media files with beat drops.
+        Args:
+            media_dir: Directory containing images and videos
+            output_path: Path where the output video will be saved
+            duration_minutes: Desired total duration in minutes
+            video_size: Tuple of (width, height) for output video
+            dark_overlay: Opacity of dark overlay (0.0 to 1.0, where 1.0 is completely black)
+            text_overlays: List of text strings or tuples (text, duration_seconds). 
+                         If only text is provided, duration will be calculated based on word count.
+        """
+        print("Creating video from media files...")
+        media_files = self._get_media_files(media_dir)
+        
+        if not media_files:
+            raise ValueError(f"No media files found in directory: {media_dir}")
+
+        # Prepare clips with dark theme
+        clips = []
+        
+        # Set desired_total_duration
+        if duration_minutes is not None:
+            desired_total_duration = duration_minutes * 60  # Convert minutes to seconds
+        else:
+            desired_total_duration = len(self.y) / self.sr  # Use the length of the audio
+
+        # Limit the beat_drop_times to the desired duration
+        beat_drop_times = self.beat_drop_times[self.beat_drop_times <= desired_total_duration]
+
+        if len(beat_drop_times) == 0:
+            raise ValueError("No beat drops detected within the desired duration.")
+
+        # Include the start (0) and end times to cover the entire duration
+        beat_times_full = np.concatenate(([0], beat_drop_times, [desired_total_duration]))
+
+        num_media = len(media_files)
+        media_index = 0
+
+        synced_clips = []
+
+        # Define the desired clip length for initial blank space
+        initial_clip_duration = 2  # 2 seconds for each clip in the initial blank space
+        base_scale = 1.2  # resized factor to make clips larger than the video size
+        zoom_factor = 0.009  # Zoom factor for zoom effects
+
+        # Loop over intervals between beat times to cover entire duration
+        for i in range(len(beat_times_full) - 1):
+            start_time = beat_times_full[i]
+            end_time = beat_times_full[i + 1]
+            interval_duration = end_time - start_time
+
+            if i == 0 and interval_duration > initial_clip_duration:
+                # Handle the initial blank space with multiple clips
+                num_initial_clips = int(np.ceil(interval_duration / initial_clip_duration))
+                for j in range(num_initial_clips):
+                    clip_start_time = start_time + j * initial_clip_duration
+                    clip_end_time = min(clip_start_time + initial_clip_duration, end_time)
+                    clip_duration = clip_end_time - clip_start_time
+
+                    media_file = media_files[media_index % num_media]
+                    media_index += 1
+
+                    if media_file.lower().endswith(('.mp4', '.avi', '.mov')):
+                        # It's a video file
+                        clip = VideoFileClip(media_file).subclipped(0, clip_duration).resized(base_scale)
+                        
+                    else:
+                        # It's an image file
+                        clip = ImageClip(media_file).with_duration(clip_duration).resized(base_scale)
+
+
+                    # cropped the clip to the desired video size
+                    clip = clip.cropped(width=video_size[0], height=video_size[1], x_center=clip.w / 2,
+                                     y_center=clip.h / 2)
+
+                    # Set the start time of the clip
+                    clip = clip.with_start(clip_start_time)
+
+                    # Apply random zoom in or zoom out effect with slower zoom
+                    zoom_type = random.choice(['zoom_in', 'zoom_out', None])
+                    # if zoom_type == 'zoom_in':
+                    #     # Slow down zoom in effect
+                    #     clip = clip.with_effects([vfx.Resize(lambda t: 1 + zoom_factor * (t / clip.duration))])
+                    # elif zoom_type == 'zoom_out':
+                    #     # Slow down zoom out effect
+                    #     clip = clip.with_effects([vfx.Resize(lambda t: 1 + zoom_factor * (1 - t / clip.duration))])
+
+                    # Add random transition to the clip
+                    if synced_clips:
+                        transition_type = random.choice(['crossfadein', 'fadein', None])
+                        if transition_type == 'crossfadein':
+                            # clip = clip.crossfadein(0.1)
+                            print()
+                        elif transition_type == 'fadein':
+                            # clip = clip.fadein(0.1)
+                            print()
+
+                    synced_clips.append(clip)
+            else:
+                # Handle regular intervals between beat drops
+                media_file = media_files[media_index % num_media]
+                media_index += 1
+
+                if media_file.lower().endswith(('.mp4', '.avi', '.mov')):
+                    # It's a video file
+                    clip = VideoFileClip(media_file).subclipped(0, interval_duration).resized(base_scale)
+                    
+                    
+                else:
+                    # It's an image file
+                    clip = ImageClip(media_file).with_duration(interval_duration).resized(base_scale)
+                   
+
+                # cropped the clip to the desired video size
+                clip = clip.cropped(width=video_size[0], height=video_size[1], x_center=clip.w / 2, y_center=clip.h / 2)
+
+                # Set the start time of the clip
+                clip = clip.with_start(start_time)
+
+                # Apply random zoom in or zoom out effect with slower zoom
+                zoom_type = random.choice(['zoom_in', 'zoom_out', None])
+                # if zoom_type == 'zoom_in':
+                #     # Slow down zoom in effect
+                #     clip = clip.with_effects([vfx.Resize(lambda t: 1 + zoom_factor * (t / clip.duration))])
+                # elif zoom_type == 'zoom_out':
+                #     # Slow down zoom out effect
+                #     clip = clip.with_effects([vfx.Resize(lambda t: 1 + zoom_factor * (1 - t / clip.duration))])
+                    
+
+                # If this is the last clip, apply fadeout
+                if i == len(beat_times_full) - 2:
+                    fade_duration = min(2, clip.duration / 2)
+                    
+                    clip = clip.with_effects([vfx.FadeOut(fade_duration)])
+
+                synced_clips.append(clip)
+
+        # Create the final video
+        final_clip = CompositeVideoClip(synced_clips, size=video_size)
+
+        # Create a list of all clips for final composition
+        all_clips = [final_clip]
+
+        # Add dark overlay if enabled
+        if dark_overlay > 0:
+            # Create a black ColorClip with the same size as the video
+            black_clip = ColorClip(size=video_size, color=(0, 0, 0))
+            black_clip = black_clip.with_duration(final_clip.duration)
+            black_clip = black_clip.with_opacity(dark_overlay)
+            all_clips.append(black_clip)
+
+        # Add text overlays if provided
+        if text_overlays:
+            current_time = 0
+            for text_item in text_overlays:
+                # Handle both string and tuple inputs
+                if isinstance(text_item, tuple):
+                    text, duration = text_item
+                else:
+                    text = text_item
+                    duration = self._calculate_text_duration(text)
+                
+                # Wrap text if needed
+                wrapped_text = self._wrap_text(text)
+                print(f"Adding text: '{wrapped_text}' with duration: {duration:.1f}s")
+                
+                # Create text clip with white color and nice font
+                txt_clip = TextClip(text=wrapped_text, font_size=40, color='white', 
+                                  font='Arial Black',method='label', interline=-1)  # 'label' method handles multiline text better
+                
+                # Center the text
+                txt_clip = txt_clip.with_position(('center', 'center'))
+                
+                # Set the duration and start time
+                txt_clip = txt_clip.with_duration(duration)
+                txt_clip = txt_clip.with_start(current_time)
+                
+                # Add fade in/out effects
+                txt_clip = txt_clip.with_effects([vfx.FadeIn(0.5), vfx.FadeOut(0.5)])
+                
+                all_clips.append(txt_clip)
+                current_time += duration
+
+        # Create final composition with all layers
+        final_clip = CompositeVideoClip(all_clips, size=video_size)
+
+        # Set the audio of the final clip
+        audio_clip = AudioFileClip(self.audio_path).subclipped(0, desired_total_duration)
+        # Apply audio fadeout at the end
+        fade_duration = min(2, audio_clip.duration / 2)
+        audio_clip = audio_clip.with_effects([afx.AudioFadeOut(fade_duration)])
+        final_clip = final_clip.with_audio(audio_clip)
+        final_clip = final_clip.with_duration(desired_total_duration)
+
+        # Write the output video file
+        final_clip.write_videofile(
+            output_path, fps=30, threads=32, audio_codec="aac", preset='ultrafast'
+        )
+        print(f"Output video saved to '{output_path}'")

tools/beatsyncer/beatsyncer_ui.py

@@ -0,0 +1,151 @@
+import os
+import gradio as gr
+
+import tempfile
+import shutil
+
+from tools.beatsyncer.beatsyncer_tool import BeatSyncer
+
+class BeatsyncerUI:
+    def __init__(self):
+        self.temp_dir = tempfile.mkdtemp()
+        # Use the existing clips directory from the project
+        script_dir = os.path.dirname(os.path.abspath(__file__))
+        self.clips_dir = os.path.join(script_dir, 'clips')
+        
+    def process_video(
+        self,
+        audio_file,
+        duration_minutes,
+        sensitivity,
+        video_height,
+        dark_overlay,
+        text_input,
+        progress=gr.Progress()
+    ):
+        try:
+            # Save audio file
+            audio_path = os.path.join(self.temp_dir, "input_audio" + os.path.splitext(audio_file.name)[1])
+            shutil.copy(audio_file.name, audio_path)
+            
+            # Process text overlays
+            text_overlays = [text.strip() for text in text_input.split('\n') if text.strip()]
+            
+            # Calculate video dimensions
+            video_width = int((video_height * 9) / 16)  # 16:9 aspect ratio
+            
+            # Set output path
+            output_path = os.path.join(self.temp_dir, "output_video.mp4")
+            
+            # Convert duration to float if provided
+            if duration_minutes and duration_minutes.strip():
+                duration_minutes = float(duration_minutes)
+            else:
+                duration_minutes = None
+            
+            progress(0.1, desc="Initializing BeatSyncer...")
+            
+            # Initialize BeatSyncer
+            beat_syncer = BeatSyncer(audio_path)
+            
+            progress(0.2, desc="Loading audio...")
+            beat_syncer.load_audio(duration_minutes=duration_minutes)
+            
+            progress(0.3, desc="Detecting beat drops...")
+            beat_syncer.detect_beat_drops(sensitivity=sensitivity)
+            
+            progress(0.4, desc="Creating video...")
+            beat_syncer.sync_with_media_directory(
+                self.clips_dir,  # Using the existing clips directory
+                output_path,
+                duration_minutes=duration_minutes,
+                video_size=(video_width, video_height),
+                dark_overlay=float(dark_overlay),
+                text_overlays=text_overlays
+            )
+            
+            progress(1.0, desc="Done!")
+            return output_path
+            
+        except Exception as e:
+            raise gr.Error(f"Error: {str(e)}")
+        
+    def create_ui(self):
+        with gr.Blocks(theme=gr.themes.Soft()) as app:
+            gr.Markdown("""
+            # 🎵 BeatSyncer - Video Creation Tool
+            Create amazing videos synchronized with music beats!
+            
+            Using media files from: {}
+            """.format(self.clips_dir))
+            
+            with gr.Row():
+                with gr.Column(scale=2):
+                    audio_input = gr.File(
+                        label="Upload Audio/Video File",
+                        file_types=[".mp3", ".wav", ".m4a", ".aac", ".ogg", ".flac", ".mp4", ".avi", ".mov", ".mkv", ".wmv", ".flv"]
+                    )
+                    
+                    
+                    duration = gr.Textbox(
+                        label="Duration (minutes, optional)",
+                        placeholder="Leave empty for full audio duration"
+                    )
+                    
+                    sensitivity = gr.Radio(
+                        choices=["low", "medium", "high"],
+                        value="medium",
+                        label="Beat Detection Sensitivity"
+                    )
+                    
+                    video_height = gr.Slider(
+                        minimum=480,
+                        maximum=1920,
+                        value=720,
+                        step=120,
+                        label="Video Height (16:9 ratio)"
+                    )
+                    
+                    dark_overlay = gr.Slider(
+                        minimum=0.0,
+                        maximum=1.0,
+                        value=0.3,
+                        step=0.1,
+                        label="Dark Overlay Intensity"
+                    )
+                    
+                    text_input = gr.Textbox(
+                        label="Text Overlays (one per line)",
+                        placeholder="Enter text overlays...",
+                        lines=5
+                    )
+                    
+                    create_btn = gr.Button("Create Video", variant="primary")
+                
+                with gr.Column(scale=1):
+                    output_video = gr.Video(
+                    label="Output Video",
+                        height=640,  # Fixed height for preview
+                        width=360   # Fixed width for preview
+                    )
+            
+            create_btn.click(
+                fn=self.process_video,
+                inputs=[
+                    audio_input,
+                    duration,
+                    sensitivity,
+                    video_height,
+                    dark_overlay,
+                    text_input
+                ],
+                outputs=output_video
+            )
+            
+        return app
+
+# Create and launch the UI
+if __name__ == "__main__":
+    ui = BeatSyncerUI()
+    demo = ui.create_ui()
+    demo.launch(debug=True, share=False, inbrowser=True)

tools/beatsyncer/clips/1657591309536.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:69aa9858fca54bda6ac78abe43cf4bd3081ef0d6a69e433603cfe3995219c97c
+size 7222278

tools/beatsyncer/clips/1657591680538.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c531723d9ba697e7453cbc61d772e76957fca7ae83f2ecacaae4b18dd770d7d4
+size 40783923

tools/beatsyncer/clips/1657591832727.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:37be14aab321518e220315f3673dc63113b9a601ae96d246d614b36ea9993a63
+size 19891527

tools/beatsyncer/clips/1657616409629.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:30401ebf2010942c79f16f39dab912ba195c606959bab9500c52dcfa60039aca
+size 10948753

tools/beatsyncer/clips/1657616591950.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:863652f4a1abe5d0d6ee5d0cca92cac3aab6deb7b7d900fa1dfb06289698a274
+size 4494706

tools/beatsyncer/clips/1657616660848.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:09002494bd0c33f02fffecc9ec484da2630dac91399b2ee1adfa22433757b05d
+size 8450597

tools/beatsyncer/clips/1657616730783.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1aad238b7f6623ad10af2413ece4b65113ebae42bb87e41cc39d8276864a7c67
+size 6972420

tools/beatsyncer/clips/1657616788731.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ca25db432389307b40cd11a945d0b19ad0f72e9e7b9d34b2d8e37565e39beb3d
+size 7192248

tools/beatsyncer/clips/1657616954951.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5021eb2d204cdc23fb8e938d0de0d6baa99ac1639726e2b0e3fe2e1e6566a7c3
+size 9827398

tools/beatsyncer/clips/1657923632784.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5837c302c5fe15878b068e22a0ebb1a2fedb747d226ea81a9ba0631fca898540
+size 8853773

tools/beatsyncer/clips/288298605_1687187951639494_579221224540621563_n.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5277a9bc08a20012285e5c438d043047802f525f82583e5c2d4106ec30da8cc3
+size 2767934

tools/beatsyncer/clips/289438954_5129286887125053_220682033208031067_n.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ba5f5469980c5df7e4910122e0cf818bd90fe98e3743650ecf189c706230009c
+size 6625183

tools/beatsyncer/clips/289568281_1462345327513048_3022742540007505592_n.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4801482e63465e85a02fd9a7eacbbe0268954bf9674f55a10aa8c80c9e2753f0
+size 1618834

tools/beatsyncer/clips/290154393_565236208447925_526246679178540543_n.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:671438acc46a10e657388d4c13d34dbecf5af5c6f9ae915b24caec154bf3390a
+size 3465572

tools/beatsyncer/clips/290702607_425330016154178_254797435320646581_n.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:99d8e8e4ee7391d0dc4d3223e5d5d203cea89089fc507862718fdd203c5234f8
+size 3268380

tools/beatsyncer/clips/290990526_409256130973654_5788653198617875871_n.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:191b27a28f64889c201c22daf0bc48ade99d9902b442c3a2d4e8e1ccaebb5060
+size 2297732

tools/beatsyncer/clips/291032176_120067890734229_1814549935092808193_n.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c69c8c738b98305e0b40fbd63ddb6133b886eaf279e8894e232252dad075fc43
+size 3250400

tools/beatsyncer/clips/657591201007.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ef0f3447388144458427572b64c768ec09cc88b87635fbece3192cc2eb973975
+size 11149649

tools/beatsyncer/clips/657591253340.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b1d3c5bd6614ea8e72703a4f94e7590c29a792b9eb0f22504b0f5bb663efbdbb
+size 6907398

tools/beatsyncer/clips/Snapinsta.app_video_2B4333A1E1AE5B90482FB1125369C59B_video_dashinit_scene_001.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9340f70c21ebebfa4230c3891198b278b849a8a3f788bf7f7edd36285f89e830
+size 2103745

tools/beatsyncer/clips/Snapinsta.app_video_2B4333A1E1AE5B90482FB1125369C59B_video_dashinit_scene_002.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b2fff2e4e65479a29a450cdcb340c78564f5794167ee03352dcdc2d8fe856930
+size 155997

tools/beatsyncer/clips/Snapinsta.app_video_2B4333A1E1AE5B90482FB1125369C59B_video_dashinit_scene_003.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:762d0ffc6a657e3c5b1c190190a9b6a3d3ea7a9979239db6de2532658a1dd0b9
+size 350743

tools/beatsyncer/clips/Snapinsta.app_video_2B4333A1E1AE5B90482FB1125369C59B_video_dashinit_scene_004.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0365717355f8e0c8cb39dedbbba0553c1e6132fd2e793972336c2581933eb4d0
+size 563440

tools/beatsyncer/clips/Snapinsta.app_video_2B4333A1E1AE5B90482FB1125369C59B_video_dashinit_scene_005.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bf5ba4edc9c23e961ef5d3379790b0e32b573b314fee099de74b3b14b841a3d1
+size 145942

tools/beatsyncer/clips/Snapinsta.app_video_2B4333A1E1AE5B90482FB1125369C59B_video_dashinit_scene_006.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:174b2c1e98000a026427acde3bdde0914f60ecabfbab8ac93be5dd81a4cf3bc8
+size 282620

tools/beatsyncer/clips/Snapinsta.app_video_2B4333A1E1AE5B90482FB1125369C59B_video_dashinit_scene_007.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f56a247020f35d3ce480f106605fdd704cfddb7513f0b52d7f63646c6e5be4d9
+size 353519

tools/beatsyncer/clips/Snapinsta.app_video_2B4333A1E1AE5B90482FB1125369C59B_video_dashinit_scene_008.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:711df5b60e0ced8b818a49f32e6ca516193346a3b4ce63bb2188d3802f62aace
+size 343334

tools/beatsyncer/clips/Snapinsta.app_video_2B4333A1E1AE5B90482FB1125369C59B_video_dashinit_scene_009.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ab88f7973f2fee383ba852f55d46912aaee7ad849a21a46cdaedb8e957046c6f
+size 204924

tools/beatsyncer/clips/Snapinsta.app_video_2B4333A1E1AE5B90482FB1125369C59B_video_dashinit_scene_010.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5ed2910d6e2e6b4159ba3290053526fa12573082a18dddd38f3d2eebc50ce15f
+size 144843

tools/beatsyncer/clips/Snapinsta.app_video_2B4E29561A51827AF04D3C92BDED06B5_video_dashinit_scene_001.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3b73792168a06223614b33179844a458bd8389f426980414f47ea0389f57cba2
+size 1138637

tools/beatsyncer/clips/Snapinsta.app_video_2B4E29561A51827AF04D3C92BDED06B5_video_dashinit_scene_002.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:85bcdde3e764e65ca3260b20c17918581dfce3acec4eb04e4813a2ac53e16587
+size 566912

tools/beatsyncer/clips/Snapinsta.app_video_2B4E29561A51827AF04D3C92BDED06B5_video_dashinit_scene_003.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:baa62fca4618f79cb7be3b2158509fc97f2f9e7f82991300b6e19b42df217a4d
+size 544288

tools/beatsyncer/clips/Snapinsta.app_video_2B4E29561A51827AF04D3C92BDED06B5_video_dashinit_scene_004.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:102282c000ac3021d2c6749d0164663e936a6e07655d56c1850015fdb148a292
+size 915749