|
|
import os
|
|
|
import sys
|
|
|
import importlib
|
|
|
import importlib.util
|
|
|
import inspect
|
|
|
from typing import Dict, Any, Optional, List, Union
|
|
|
from dataclasses import dataclass
|
|
|
import gradio as gr
|
|
|
import traceback
|
|
|
import subprocess
|
|
|
import git
|
|
|
import shutil
|
|
|
import stat
|
|
|
import json
|
|
|
|
|
|
def auto_install_and_enable_default_plugins(manager: 'PluginManager', wgp_globals: dict):
|
|
|
server_config = wgp_globals.get("server_config")
|
|
|
server_config_filename = wgp_globals.get("server_config_filename")
|
|
|
|
|
|
if not server_config or not server_config_filename:
|
|
|
print("[Plugins] WARNING: Cannot auto-install/enable default plugins. Server config not found.")
|
|
|
return
|
|
|
|
|
|
default_plugins = {
|
|
|
"wan2gp-gallery": "https://github.com/Tophness/wan2gp-gallery.git",
|
|
|
"wan2gp-lora-multipliers-ui": "https://github.com/Tophness/wan2gp-lora-multipliers-ui.git"
|
|
|
}
|
|
|
|
|
|
config_modified = False
|
|
|
enabled_plugins = server_config.get("enabled_plugins", [])
|
|
|
|
|
|
for repo_name, url in default_plugins.items():
|
|
|
target_dir = os.path.join(manager.plugins_dir, repo_name)
|
|
|
if not os.path.isdir(target_dir):
|
|
|
print(f"[Plugins] Auto-installing default plugin: {repo_name}...")
|
|
|
result = manager.install_plugin_from_url(url)
|
|
|
print(f"[Plugins] Install result for {repo_name}: {result}")
|
|
|
|
|
|
if "[Success]" in result:
|
|
|
if repo_name not in enabled_plugins:
|
|
|
enabled_plugins.append(repo_name)
|
|
|
config_modified = True
|
|
|
|
|
|
if config_modified:
|
|
|
print("[Plugins] Disabling newly installed default plugins...")
|
|
|
server_config["enabled_plugins"] = []
|
|
|
try:
|
|
|
with open(server_config_filename, 'w', encoding='utf-8') as f:
|
|
|
json.dump(server_config, f, indent=4)
|
|
|
except Exception as e:
|
|
|
print(f"[Plugins] ERROR: Failed to update config file '{server_config_filename}': {e}")
|
|
|
|
|
|
|
|
|
SYSTEM_PLUGINS = [
|
|
|
"wan2gp-about",
|
|
|
"wan2gp-configuration",
|
|
|
"wan2gp-downloads",
|
|
|
"wan2gp-guides",
|
|
|
"wan2gp-plugin-manager",
|
|
|
"wan2gp-video-mask-creator",
|
|
|
]
|
|
|
|
|
|
USER_PLUGIN_INSERT_POSITION = 4
|
|
|
|
|
|
@dataclass
|
|
|
class InsertAfterRequest:
|
|
|
target_component_id: str
|
|
|
new_component_constructor: callable
|
|
|
|
|
|
@dataclass
|
|
|
class PluginTab:
|
|
|
id: str
|
|
|
label: str
|
|
|
component_constructor: callable
|
|
|
position: int = -1
|
|
|
|
|
|
class WAN2GPPlugin:
|
|
|
def __init__(self):
|
|
|
self.tabs: Dict[str, PluginTab] = {}
|
|
|
self.name = self.__class__.__name__
|
|
|
self.version = "1.0.0"
|
|
|
self.description = "No description provided."
|
|
|
self._component_requests: List[str] = []
|
|
|
self._global_requests: List[str] = []
|
|
|
self._insert_after_requests: List[InsertAfterRequest] = []
|
|
|
self._setup_complete = False
|
|
|
self._data_hooks: Dict[str, List[callable]] = {}
|
|
|
self.tab_ids: List[str] = []
|
|
|
self._set_wgp_global_func = None
|
|
|
|
|
|
def setup_ui(self) -> None:
|
|
|
pass
|
|
|
|
|
|
def add_tab(self, tab_id: str, label: str, component_constructor: callable, position: int = -1):
|
|
|
self.tabs[tab_id] = PluginTab(id=tab_id, label=label, component_constructor=component_constructor, position=position)
|
|
|
|
|
|
def post_ui_setup(self, components: Dict[str, gr.components.Component]) -> Dict[gr.components.Component, Union[gr.update, Any]]:
|
|
|
return {}
|
|
|
|
|
|
def on_tab_select(self, state: Dict[str, Any]) -> None:
|
|
|
pass
|
|
|
|
|
|
def on_tab_deselect(self, state: Dict[str, Any]) -> None:
|
|
|
pass
|
|
|
|
|
|
def request_component(self, component_id: str) -> None:
|
|
|
if component_id not in self._component_requests:
|
|
|
self._component_requests.append(component_id)
|
|
|
|
|
|
def request_global(self, global_name: str) -> None:
|
|
|
if global_name not in self._global_requests:
|
|
|
self._global_requests.append(global_name)
|
|
|
|
|
|
def set_global(self, variable_name: str, new_value: Any):
|
|
|
if self._set_wgp_global_func:
|
|
|
return self._set_wgp_global_func(variable_name, new_value)
|
|
|
|
|
|
@property
|
|
|
def component_requests(self) -> List[str]:
|
|
|
return self._component_requests.copy()
|
|
|
|
|
|
@property
|
|
|
def global_requests(self) -> List[str]:
|
|
|
return self._global_requests.copy()
|
|
|
|
|
|
def register_data_hook(self, hook_name: str, callback: callable):
|
|
|
if hook_name not in self._data_hooks:
|
|
|
self._data_hooks[hook_name] = []
|
|
|
self._data_hooks[hook_name].append(callback)
|
|
|
|
|
|
def insert_after(self, target_component_id: str, new_component_constructor: callable) -> None:
|
|
|
if not hasattr(self, '_insert_after_requests'):
|
|
|
self._insert_after_requests = []
|
|
|
self._insert_after_requests.append(
|
|
|
InsertAfterRequest(
|
|
|
target_component_id=target_component_id,
|
|
|
new_component_constructor=new_component_constructor
|
|
|
)
|
|
|
)
|
|
|
|
|
|
class PluginManager:
|
|
|
def __init__(self, plugins_dir="plugins"):
|
|
|
self.plugins: Dict[str, WAN2GPPlugin] = {}
|
|
|
self.plugins_dir = plugins_dir
|
|
|
os.makedirs(self.plugins_dir, exist_ok=True)
|
|
|
if self.plugins_dir not in sys.path:
|
|
|
sys.path.insert(0, self.plugins_dir)
|
|
|
self.data_hooks: Dict[str, List[callable]] = {}
|
|
|
|
|
|
def get_plugins_info(self) -> List[Dict[str, str]]:
|
|
|
plugins_info = []
|
|
|
for dir_name in self.discover_plugins():
|
|
|
plugin_path = os.path.join(self.plugins_dir, dir_name)
|
|
|
is_system = dir_name in SYSTEM_PLUGINS
|
|
|
info = {'id': dir_name, 'name': dir_name, 'version': 'N/A', 'description': 'No description provided.', 'path': plugin_path, 'system': is_system}
|
|
|
try:
|
|
|
module = importlib.import_module(f"{dir_name}.plugin")
|
|
|
for name, obj in inspect.getmembers(module, inspect.isclass):
|
|
|
if issubclass(obj, WAN2GPPlugin) and obj != WAN2GPPlugin:
|
|
|
instance = obj()
|
|
|
info['name'] = instance.name
|
|
|
info['version'] = instance.version
|
|
|
info['description'] = instance.description
|
|
|
break
|
|
|
except Exception as e:
|
|
|
print(f"Could not load metadata for plugin {dir_name}: {e}")
|
|
|
plugins_info.append(info)
|
|
|
|
|
|
plugins_info.sort(key=lambda p: (not p['system'], p['name']))
|
|
|
return plugins_info
|
|
|
|
|
|
def _remove_readonly(self, func, path, exc_info):
|
|
|
if not os.access(path, os.W_OK):
|
|
|
os.chmod(path, stat.S_IWRITE)
|
|
|
func(path)
|
|
|
else:
|
|
|
raise
|
|
|
|
|
|
def uninstall_plugin(self, plugin_id: str):
|
|
|
if not plugin_id:
|
|
|
return "[Error] No plugin selected for uninstallation."
|
|
|
|
|
|
if plugin_id in SYSTEM_PLUGINS:
|
|
|
return f"[Error] Cannot uninstall system plugin '{plugin_id}'."
|
|
|
|
|
|
target_dir = os.path.join(self.plugins_dir, plugin_id)
|
|
|
if not os.path.isdir(target_dir):
|
|
|
return f"[Error] Plugin '{plugin_id}' directory not found."
|
|
|
|
|
|
try:
|
|
|
shutil.rmtree(target_dir, onerror=self._remove_readonly)
|
|
|
return f"[Success] Plugin '{plugin_id}' uninstalled. Please restart WanGP."
|
|
|
except Exception as e:
|
|
|
return f"[Error] Failed to remove plugin '{plugin_id}': {e}"
|
|
|
|
|
|
def update_plugin(self, plugin_id: str, progress=None):
|
|
|
if not plugin_id:
|
|
|
return "[Error] No plugin selected for update."
|
|
|
|
|
|
target_dir = os.path.join(self.plugins_dir, plugin_id)
|
|
|
if not os.path.isdir(os.path.join(target_dir, '.git')):
|
|
|
return f"[Error] '{plugin_id}' is not a git repository and cannot be updated automatically."
|
|
|
|
|
|
try:
|
|
|
if progress is not None: progress(0, desc=f"Updating '{plugin_id}'...")
|
|
|
repo = git.Repo(target_dir)
|
|
|
origin = repo.remotes.origin
|
|
|
|
|
|
if progress is not None: progress(0.2, desc=f"Fetching updates for '{plugin_id}'...")
|
|
|
origin.fetch()
|
|
|
|
|
|
local_commit = repo.head.commit
|
|
|
remote_commit = origin.refs[repo.active_branch.name].commit
|
|
|
|
|
|
if local_commit == remote_commit:
|
|
|
return f"[Info] Plugin '{plugin_id}' is already up to date."
|
|
|
|
|
|
if progress is not None: progress(0.6, desc=f"Pulling updates for '{plugin_id}'...")
|
|
|
origin.pull()
|
|
|
|
|
|
requirements_path = os.path.join(target_dir, 'requirements.txt')
|
|
|
if os.path.exists(requirements_path):
|
|
|
if progress is not None: progress(0.8, desc=f"Re-installing dependencies for '{plugin_id}'...")
|
|
|
subprocess.check_call([sys.executable, '-m', 'pip', 'install', '-r', requirements_path])
|
|
|
|
|
|
if progress is not None: progress(1.0, desc="Update complete.")
|
|
|
return f"[Success] Plugin '{plugin_id}' updated. Please restart WanGP for changes to take effect."
|
|
|
except git.exc.GitCommandError as e:
|
|
|
traceback.print_exc()
|
|
|
return f"[Error] Git update failed for '{plugin_id}': {e.stderr}"
|
|
|
except Exception as e:
|
|
|
traceback.print_exc()
|
|
|
return f"[Error] An unexpected error occurred during update of '{plugin_id}': {str(e)}"
|
|
|
|
|
|
def reinstall_plugin(self, plugin_id: str, progress=None):
|
|
|
if not plugin_id:
|
|
|
return "[Error] No plugin selected for reinstallation."
|
|
|
|
|
|
target_dir = os.path.join(self.plugins_dir, plugin_id)
|
|
|
if not os.path.isdir(target_dir):
|
|
|
return f"[Error] Plugin '{plugin_id}' not found."
|
|
|
|
|
|
git_url = None
|
|
|
if os.path.isdir(os.path.join(target_dir, '.git')):
|
|
|
try:
|
|
|
repo = git.Repo(target_dir)
|
|
|
git_url = repo.remotes.origin.url
|
|
|
except Exception as e:
|
|
|
traceback.print_exc()
|
|
|
return f"[Error] Could not get remote URL for '{plugin_id}': {e}"
|
|
|
|
|
|
if not git_url:
|
|
|
return f"[Error] Could not determine remote URL for '{plugin_id}'. Cannot reinstall."
|
|
|
|
|
|
if progress is not None: progress(0, desc=f"Reinstalling '{plugin_id}'...")
|
|
|
|
|
|
backup_dir = f"{target_dir}.bak"
|
|
|
if os.path.exists(backup_dir):
|
|
|
try:
|
|
|
shutil.rmtree(backup_dir, onerror=self._remove_readonly)
|
|
|
except Exception as e:
|
|
|
return f"[Error] Could not remove old backup directory '{backup_dir}'. Please remove it manually and try again. Error: {e}"
|
|
|
|
|
|
try:
|
|
|
if progress is not None: progress(0.2, desc=f"Moving old version of '{plugin_id}' aside...")
|
|
|
os.rename(target_dir, backup_dir)
|
|
|
except OSError as e:
|
|
|
traceback.print_exc()
|
|
|
return f"[Error] Could not move the existing plugin directory for '{plugin_id}'. It may be in use by another process. Please close any file explorers or editors in that folder and try again. Error: {e}"
|
|
|
|
|
|
install_msg = self.install_plugin_from_url(git_url, progress=progress)
|
|
|
|
|
|
if "[Success]" in install_msg:
|
|
|
try:
|
|
|
shutil.rmtree(backup_dir, onerror=self._remove_readonly)
|
|
|
except Exception:
|
|
|
pass
|
|
|
return f"[Success] Plugin '{plugin_id}' reinstalled. Please restart WanGP."
|
|
|
else:
|
|
|
try:
|
|
|
os.rename(backup_dir, target_dir)
|
|
|
return f"[Error] Reinstallation failed during install step: {install_msg}. The original plugin has been restored."
|
|
|
except Exception as restore_e:
|
|
|
return f"[CRITICAL ERROR] Reinstallation failed AND could not restore backup. Plugin '{plugin_id}' is now in a broken state. Please manually rename '{backup_dir}' back to '{target_dir}'. Original error: {install_msg}. Restore error: {restore_e}"
|
|
|
|
|
|
def install_plugin_from_url(self, git_url: str, progress=None):
|
|
|
if not git_url or not git_url.startswith("https://github.com/"):
|
|
|
return "[Error] Invalid GitHub URL."
|
|
|
|
|
|
try:
|
|
|
repo_name = git_url.split('/')[-1].replace('.git', '')
|
|
|
target_dir = os.path.join(self.plugins_dir, repo_name)
|
|
|
|
|
|
if os.path.exists(target_dir):
|
|
|
return f"[Warning] Plugin '{repo_name}' already exists. Please remove it manually to reinstall."
|
|
|
|
|
|
if progress is not None: progress(0.1, desc=f"Cloning '{repo_name}'...")
|
|
|
git.Repo.clone_from(git_url, target_dir)
|
|
|
|
|
|
requirements_path = os.path.join(target_dir, 'requirements.txt')
|
|
|
if os.path.exists(requirements_path):
|
|
|
if progress is not None: progress(0.5, desc=f"Installing dependencies for '{repo_name}'...")
|
|
|
try:
|
|
|
subprocess.check_call([sys.executable, '-m', 'pip', 'install', '-r', requirements_path])
|
|
|
except subprocess.CalledProcessError as e:
|
|
|
traceback.print_exc()
|
|
|
return f"[Error] Failed to install dependencies for {repo_name}. Check console for details. Error: {e}"
|
|
|
|
|
|
setup_path = os.path.join(target_dir, 'setup.py')
|
|
|
if os.path.exists(setup_path):
|
|
|
if progress is not None: progress(0.8, desc=f"Running setup for '{repo_name}'...")
|
|
|
try:
|
|
|
subprocess.check_call([sys.executable, '-m', 'pip', 'install', '-e', target_dir])
|
|
|
except subprocess.CalledProcessError as e:
|
|
|
traceback.print_exc()
|
|
|
return f"[Error] Failed to run setup.py for {repo_name}. Check console for details. Error: {e}"
|
|
|
|
|
|
init_path = os.path.join(target_dir, '__init__.py')
|
|
|
if not os.path.exists(init_path):
|
|
|
with open(init_path, 'w') as f:
|
|
|
pass
|
|
|
|
|
|
if progress is not None: progress(1.0, desc="Installation complete.")
|
|
|
return f"[Success] Plugin '{repo_name}' installed. Please enable it in the list and restart WanGP."
|
|
|
|
|
|
except git.exc.GitCommandError as e:
|
|
|
traceback.print_exc()
|
|
|
return f"[Error] Git clone failed: {e.stderr}"
|
|
|
except Exception as e:
|
|
|
traceback.print_exc()
|
|
|
return f"[Error] An unexpected error occurred: {str(e)}"
|
|
|
|
|
|
def discover_plugins(self) -> List[str]:
|
|
|
discovered = []
|
|
|
for item in os.listdir(self.plugins_dir):
|
|
|
path = os.path.join(self.plugins_dir, item)
|
|
|
if os.path.isdir(path) and os.path.exists(os.path.join(path, '__init__.py')):
|
|
|
discovered.append(item)
|
|
|
return sorted(discovered)
|
|
|
|
|
|
def load_plugins_from_directory(self, enabled_user_plugins: List[str]) -> None:
|
|
|
plugins_to_load = SYSTEM_PLUGINS + [p for p in enabled_user_plugins if p not in SYSTEM_PLUGINS]
|
|
|
|
|
|
for plugin_dir_name in self.discover_plugins():
|
|
|
if plugin_dir_name not in plugins_to_load:
|
|
|
continue
|
|
|
try:
|
|
|
module = importlib.import_module(f"{plugin_dir_name}.plugin")
|
|
|
|
|
|
for name, obj in inspect.getmembers(module, inspect.isclass):
|
|
|
if issubclass(obj, WAN2GPPlugin) and obj != WAN2GPPlugin:
|
|
|
plugin = obj()
|
|
|
plugin.setup_ui()
|
|
|
self.plugins[plugin_dir_name] = plugin
|
|
|
for hook_name, callbacks in plugin._data_hooks.items():
|
|
|
if hook_name not in self.data_hooks:
|
|
|
self.data_hooks[hook_name] = []
|
|
|
self.data_hooks[hook_name].extend(callbacks)
|
|
|
if plugin_dir_name not in SYSTEM_PLUGINS:
|
|
|
print(f"Loaded plugin: {plugin.name} (from {plugin_dir_name})")
|
|
|
break
|
|
|
except Exception as e:
|
|
|
print(f"Error loading plugin from directory {plugin_dir_name}: {e}")
|
|
|
traceback.print_exc()
|
|
|
|
|
|
def get_all_plugins(self) -> Dict[str, WAN2GPPlugin]:
|
|
|
return self.plugins.copy()
|
|
|
|
|
|
def inject_globals(self, global_references: Dict[str, Any]) -> None:
|
|
|
for plugin_id, plugin in self.plugins.items():
|
|
|
try:
|
|
|
if 'set_wgp_global' in global_references:
|
|
|
plugin._set_wgp_global_func = global_references['set_wgp_global']
|
|
|
for global_name in plugin.global_requests:
|
|
|
if global_name in global_references:
|
|
|
setattr(plugin, global_name, global_references[global_name])
|
|
|
except Exception as e:
|
|
|
print(f" [!] ERROR injecting globals for {plugin_id}: {str(e)}")
|
|
|
|
|
|
def setup_ui(self) -> Dict[str, Dict[str, Any]]:
|
|
|
tabs = {}
|
|
|
for plugin_id, plugin in self.plugins.items():
|
|
|
try:
|
|
|
for tab_id, tab in plugin.tabs.items():
|
|
|
tabs[tab_id] = {
|
|
|
'label': tab.label,
|
|
|
'component_constructor': tab.component_constructor,
|
|
|
'position': tab.position
|
|
|
}
|
|
|
except Exception as e:
|
|
|
print(f"Error in setup_ui for plugin {plugin_id}: {str(e)}")
|
|
|
return {'tabs': tabs}
|
|
|
|
|
|
def run_data_hooks(self, hook_name: str, *args, **kwargs):
|
|
|
if hook_name not in self.data_hooks:
|
|
|
return kwargs.get('configs')
|
|
|
|
|
|
callbacks = self.data_hooks[hook_name]
|
|
|
data = kwargs.get('configs')
|
|
|
|
|
|
if 'configs' in kwargs:
|
|
|
kwargs.pop('configs')
|
|
|
|
|
|
for callback in callbacks:
|
|
|
try:
|
|
|
data = callback(data, **kwargs)
|
|
|
except Exception as e:
|
|
|
print(f"[PluginManager] Error running hook '{hook_name}' from {callback.__module__}: {e}")
|
|
|
traceback.print_exc()
|
|
|
return data
|
|
|
|
|
|
def run_component_insertion_and_setup(self, all_components: Dict[str, Any]):
|
|
|
all_insert_requests: List[InsertAfterRequest] = []
|
|
|
|
|
|
for plugin_id, plugin in self.plugins.items():
|
|
|
try:
|
|
|
for comp_id in plugin.component_requests:
|
|
|
if comp_id in all_components and (not hasattr(plugin, comp_id) or getattr(plugin, comp_id) is None):
|
|
|
setattr(plugin, comp_id, all_components[comp_id])
|
|
|
|
|
|
requested_components = {
|
|
|
comp_id: all_components[comp_id]
|
|
|
for comp_id in plugin.component_requests
|
|
|
if comp_id in all_components
|
|
|
}
|
|
|
|
|
|
plugin.post_ui_setup(requested_components)
|
|
|
|
|
|
insert_requests = getattr(plugin, '_insert_after_requests', [])
|
|
|
if insert_requests:
|
|
|
all_insert_requests.extend(insert_requests)
|
|
|
plugin._insert_after_requests.clear()
|
|
|
|
|
|
except Exception as e:
|
|
|
print(f"[PluginManager] ERROR in post_ui_setup for {plugin_id}: {str(e)}")
|
|
|
traceback.print_exc()
|
|
|
|
|
|
if all_insert_requests:
|
|
|
for request in all_insert_requests:
|
|
|
try:
|
|
|
target = all_components.get(request.target_component_id)
|
|
|
parent = getattr(target, 'parent', None)
|
|
|
if not target or not parent or not hasattr(parent, 'children'):
|
|
|
print(f"[PluginManager] ERROR: Target '{request.target_component_id}' for insertion not found or invalid.")
|
|
|
continue
|
|
|
|
|
|
target_index = parent.children.index(target)
|
|
|
with parent:
|
|
|
new_component = request.new_component_constructor()
|
|
|
|
|
|
newly_added = parent.children.pop(-1)
|
|
|
parent.children.insert(target_index + 1, newly_added)
|
|
|
|
|
|
except Exception as e:
|
|
|
print(f"[PluginManager] ERROR processing insert_after for {request.target_component_id}: {str(e)}")
|
|
|
traceback.print_exc()
|
|
|
|
|
|
class WAN2GPApplication:
|
|
|
def __init__(self):
|
|
|
self.plugin_manager = PluginManager()
|
|
|
self.tab_to_plugin_map: Dict[str, WAN2GPPlugin] = {}
|
|
|
self.all_rendered_tabs: List[gr.Tab] = []
|
|
|
self.enabled_plugins: List[str] = []
|
|
|
|
|
|
def initialize_plugins(self, wgp_globals: dict):
|
|
|
if not hasattr(self, 'plugin_manager'):
|
|
|
return
|
|
|
|
|
|
auto_install_and_enable_default_plugins(self.plugin_manager, wgp_globals)
|
|
|
|
|
|
server_config = wgp_globals.get("server_config")
|
|
|
if not server_config:
|
|
|
print("[PluginManager] ERROR: server_config not found in globals.")
|
|
|
return
|
|
|
|
|
|
self.enabled_plugins = server_config.get("enabled_plugins", [])
|
|
|
self.plugin_manager.load_plugins_from_directory(self.enabled_plugins)
|
|
|
self.plugin_manager.inject_globals(wgp_globals)
|
|
|
|
|
|
def setup_ui_tabs(self, main_tabs_component: gr.Tabs, state_component: gr.State):
|
|
|
self._create_plugin_tabs()
|
|
|
self._setup_tab_events(main_tabs_component, state_component)
|
|
|
|
|
|
def _create_plugin_tabs(self):
|
|
|
if not hasattr(self, 'plugin_manager'):
|
|
|
return
|
|
|
|
|
|
loaded_plugins = self.plugin_manager.get_all_plugins()
|
|
|
system_tabs, user_tabs = [], []
|
|
|
|
|
|
for plugin_id, plugin in loaded_plugins.items():
|
|
|
for tab_id, tab in plugin.tabs.items():
|
|
|
self.tab_to_plugin_map[tab.label] = plugin
|
|
|
tab_info = {'id': tab_id, 'label': tab.label, 'component_constructor': tab.component_constructor, 'position': tab.position}
|
|
|
if plugin_id in SYSTEM_PLUGINS:
|
|
|
system_tabs.append(tab_info)
|
|
|
else:
|
|
|
user_tabs.append((plugin_id, tab_info))
|
|
|
|
|
|
system_tabs.sort(key=lambda t: (t.get('position', -1), t['label']))
|
|
|
|
|
|
sorted_user_tabs = [tab_info for plugin_id in self.enabled_plugins for pid, tab_info in user_tabs if pid == plugin_id]
|
|
|
|
|
|
pre_user_tabs = [t for t in system_tabs if t.get('position', -1) < USER_PLUGIN_INSERT_POSITION]
|
|
|
post_user_tabs = [t for t in system_tabs if t.get('position', -1) >= USER_PLUGIN_INSERT_POSITION]
|
|
|
|
|
|
all_tabs_to_render = pre_user_tabs + sorted_user_tabs + post_user_tabs
|
|
|
|
|
|
for tab_info in all_tabs_to_render:
|
|
|
with gr.Tab(tab_info['label'], id=f"plugin_{tab_info['id']}") as new_tab:
|
|
|
self.all_rendered_tabs.append(new_tab)
|
|
|
tab_info['component_constructor']()
|
|
|
|
|
|
def _setup_tab_events(self, main_tabs_component: gr.Tabs, state_component: gr.State):
|
|
|
if main_tabs_component and state_component:
|
|
|
main_tabs_component.select(
|
|
|
fn=self._handle_tab_selection,
|
|
|
inputs=[state_component],
|
|
|
outputs=None,
|
|
|
show_progress="hidden",
|
|
|
)
|
|
|
|
|
|
def _handle_tab_selection(self, state: dict, evt: gr.SelectData):
|
|
|
if not hasattr(self, 'previous_tab_id'):
|
|
|
self.previous_tab_id = "video_gen"
|
|
|
|
|
|
new_tab_id = evt.value
|
|
|
|
|
|
if self.previous_tab_id == new_tab_id:
|
|
|
return
|
|
|
|
|
|
if self.previous_tab_id and self.previous_tab_id in self.tab_to_plugin_map:
|
|
|
plugin_to_deselect = self.tab_to_plugin_map[self.previous_tab_id]
|
|
|
try:
|
|
|
plugin_to_deselect.on_tab_deselect(state)
|
|
|
except Exception as e:
|
|
|
print(f"[PluginManager] Error in on_tab_deselect for plugin {plugin_to_deselect.name}: {e}")
|
|
|
traceback.print_exc()
|
|
|
|
|
|
if new_tab_id and new_tab_id in self.tab_to_plugin_map:
|
|
|
plugin_to_select = self.tab_to_plugin_map[new_tab_id]
|
|
|
try:
|
|
|
plugin_to_select.on_tab_select(state)
|
|
|
except Exception as e:
|
|
|
print(f"[PluginManager] Error in on_tab_select for plugin {plugin_to_select.name}: {e}")
|
|
|
traceback.print_exc()
|
|
|
|
|
|
self.previous_tab_id = new_tab_id
|
|
|
|
|
|
def run_component_insertion(self, components_dict: Dict[str, Any]):
|
|
|
if hasattr(self, 'plugin_manager'):
|
|
|
self.plugin_manager.run_component_insertion_and_setup(components_dict)
|
|
|
|
