mirror of
https://github.com/willmiao/ComfyUI-Lora-Manager.git
synced 2026-03-22 05:32:12 -03:00
103 lines
3.8 KiB
Python
103 lines
3.8 KiB
Python
import asyncio
|
|
import logging
|
|
from typing import Optional, Dict, Any, TypeVar, Type
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
T = TypeVar('T') # Define a type variable for service types
|
|
|
|
class ServiceRegistry:
|
|
"""Centralized registry for service singletons"""
|
|
|
|
_instance = None
|
|
_services: Dict[str, Any] = {}
|
|
_lock = asyncio.Lock()
|
|
|
|
@classmethod
|
|
def get_instance(cls):
|
|
"""Get singleton instance of the registry"""
|
|
if cls._instance is None:
|
|
cls._instance = cls()
|
|
return cls._instance
|
|
|
|
@classmethod
|
|
async def register_service(cls, service_name: str, service_instance: Any) -> None:
|
|
"""Register a service instance with the registry"""
|
|
registry = cls.get_instance()
|
|
async with cls._lock:
|
|
registry._services[service_name] = service_instance
|
|
logger.debug(f"Registered service: {service_name}")
|
|
|
|
@classmethod
|
|
async def get_service(cls, service_name: str) -> Any:
|
|
"""Get a service instance by name"""
|
|
registry = cls.get_instance()
|
|
async with cls._lock:
|
|
if service_name not in registry._services:
|
|
logger.debug(f"Service {service_name} not found in registry")
|
|
return None
|
|
return registry._services[service_name]
|
|
|
|
# Convenience methods for common services
|
|
@classmethod
|
|
async def get_lora_scanner(cls):
|
|
"""Get the LoraScanner instance"""
|
|
from .lora_scanner import LoraScanner
|
|
scanner = await cls.get_service("lora_scanner")
|
|
if scanner is None:
|
|
scanner = await LoraScanner.get_instance()
|
|
await cls.register_service("lora_scanner", scanner)
|
|
return scanner
|
|
|
|
@classmethod
|
|
async def get_checkpoint_scanner(cls):
|
|
"""Get the CheckpointScanner instance"""
|
|
from .checkpoint_scanner import CheckpointScanner
|
|
scanner = await cls.get_service("checkpoint_scanner")
|
|
if scanner is None:
|
|
scanner = await CheckpointScanner.get_instance()
|
|
await cls.register_service("checkpoint_scanner", scanner)
|
|
return scanner
|
|
|
|
@classmethod
|
|
async def get_civitai_client(cls):
|
|
"""Get the CivitaiClient instance"""
|
|
from .civitai_client import CivitaiClient
|
|
client = await cls.get_service("civitai_client")
|
|
if client is None:
|
|
client = await CivitaiClient.get_instance()
|
|
await cls.register_service("civitai_client", client)
|
|
return client
|
|
|
|
@classmethod
|
|
async def get_download_manager(cls):
|
|
"""Get the DownloadManager instance"""
|
|
from .download_manager import DownloadManager
|
|
manager = await cls.get_service("download_manager")
|
|
if manager is None:
|
|
manager = await DownloadManager.get_instance()
|
|
await cls.register_service("download_manager", manager)
|
|
return manager
|
|
|
|
@classmethod
|
|
async def get_recipe_scanner(cls):
|
|
"""Get the RecipeScanner instance"""
|
|
from .recipe_scanner import RecipeScanner
|
|
scanner = await cls.get_service("recipe_scanner")
|
|
if scanner is None:
|
|
lora_scanner = await cls.get_lora_scanner()
|
|
scanner = RecipeScanner(lora_scanner)
|
|
await cls.register_service("recipe_scanner", scanner)
|
|
return scanner
|
|
|
|
@classmethod
|
|
async def get_websocket_manager(cls):
|
|
"""Get the WebSocketManager instance"""
|
|
from .websocket_manager import ws_manager
|
|
manager = await cls.get_service("websocket_manager")
|
|
if manager is None:
|
|
# ws_manager is already a global instance in websocket_manager.py
|
|
from .websocket_manager import ws_manager
|
|
await cls.register_service("websocket_manager", ws_manager)
|
|
manager = ws_manager
|
|
return manager |