service-forge 0.1.11__py3-none-any.whl

service_forge/api/routers/service/service_router.py

@@ -0,0 +1,137 @@
+from fastapi import APIRouter, HTTPException, UploadFile, File, Form
+from fastapi.responses import JSONResponse
+from loguru import logger
+from typing import Optional, TYPE_CHECKING
+import tempfile
+import os
+from pydantic import BaseModel
+from omegaconf import OmegaConf
+
+if TYPE_CHECKING:
+    from service_forge.service import Service
+
+# TODO: refactor this, do not use global variable
+_current_service: Optional['Service'] = None
+
+def set_service(service: 'Service') -> None:
+    global _current_service
+    _current_service = service
+
+def get_service() -> Optional['Service']:
+    return _current_service
+
+service_router = APIRouter(prefix="/sdk/service", tags=["service"])
+
+class WorkflowStatusResponse(BaseModel):
+    name: str
+    version: str
+    description: str
+    workflows: list[dict]
+
+class WorkflowActionResponse(BaseModel):
+    success: bool
+    message: str
+
+@service_router.get("/status", response_model=WorkflowStatusResponse)
+async def get_service_status():
+    service = get_service()
+    if service is None:
+        raise HTTPException(status_code=503, detail="Service not initialized")
+    
+    try:
+        status = service.get_service_status()
+        return status
+    except Exception as e:
+        logger.error(f"Error getting service status: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@service_router.post("/workflow/{workflow_name}/start", response_model=WorkflowActionResponse)
+async def start_workflow(workflow_name: str):
+    service = get_service()
+    if service is None:
+        raise HTTPException(status_code=503, detail="Service not initialized")
+    
+    try:
+        success = await service.start_workflow(workflow_name)
+        if success:
+            return WorkflowActionResponse(success=True, message=f"Workflow {workflow_name} started successfully")
+        else:
+            return WorkflowActionResponse(success=False, message=f"Failed to start workflow {workflow_name}")
+    except Exception as e:
+        logger.error(f"Error starting workflow {workflow_name}: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@service_router.post("/workflow/{workflow_name}/stop", response_model=WorkflowActionResponse)
+async def stop_workflow(workflow_name: str):
+    service = get_service()
+    if service is None:
+        raise HTTPException(status_code=503, detail="Service not initialized")
+    
+    try:
+        success = await service.stop_workflow(workflow_name)
+        if success:
+            return WorkflowActionResponse(success=True, message=f"Workflow {workflow_name} stopped successfully")
+        else:
+            return WorkflowActionResponse(success=False, message=f"Failed to stop workflow {workflow_name}")
+    except Exception as e:
+        logger.error(f"Error stopping workflow {workflow_name}: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@service_router.post("/workflow/upload", response_model=WorkflowActionResponse)
+async def upload_workflow_config(
+    file: Optional[UploadFile] = File(None),
+    config_content: Optional[str] = Form(None),
+    workflow_name: Optional[str] = Form(None)
+):
+    service = get_service()
+    if service is None:
+        raise HTTPException(status_code=503, detail="Service not initialized")
+    
+    if file is None and config_content is None:
+        raise HTTPException(status_code=400, detail="Either file or config_content must be provided")
+    
+    if file is not None and config_content is not None:
+        raise HTTPException(status_code=400, detail="Cannot provide both file and config_content")
+    
+    temp_file_path = None
+    try:
+        if file is not None:
+            if not file.filename or not file.filename.endswith(('.yaml', '.yml')):
+                raise HTTPException(status_code=400, detail="Only YAML files are supported")
+            
+            suffix = '.yaml' if file.filename.endswith('.yaml') else '.yml'
+            with tempfile.NamedTemporaryFile(mode='wb', delete=False, suffix=suffix) as temp_file:
+                content = await file.read()
+                temp_file.write(content)
+                temp_file_path = temp_file.name
+            
+            success = await service.load_workflow_from_config(config_path=temp_file_path, workflow_name=workflow_name)
+        else:
+            try:
+                config = OmegaConf.to_object(OmegaConf.create(config_content))
+            except Exception as e:
+                raise HTTPException(status_code=400, detail=f"Invalid YAML format: {str(e)}")
+            
+            success = await service.load_workflow_from_config(config=config, workflow_name=workflow_name)
+        
+        if success:
+            return WorkflowActionResponse(
+                success=True,
+                message=f"Workflow configuration uploaded and loaded successfully"
+            )
+        else:
+            raise HTTPException(status_code=500, detail="Failed to load workflow configuration")
+    
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error uploading workflow config: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+    
+    finally:
+        if temp_file_path and os.path.exists(temp_file_path):
+            try:
+                os.unlink(temp_file_path)
+            except Exception as e:
+                logger.warning(f"Failed to delete temp file {temp_file_path}: {e}")
+

service_forge/api/routers/websocket/websocket_manager.py

@@ -0,0 +1,83 @@
+from fastapi import WebSocket
+from typing import Dict, Set
+import uuid
+import json
+import asyncio
+from loguru import logger
+
+class WebSocketManager:
+    def __init__(self):
+        self.task_connections: Dict[uuid.UUID, Set[WebSocket]] = {}
+        self.websocket_tasks: Dict[WebSocket, Set[uuid.UUID]] = {}
+        self.all_task_subscribers: Set[WebSocket] = set()
+        self.websocket_subscribes_all: Dict[WebSocket, bool] = {}
+        self._lock = asyncio.Lock()
+    
+    async def subscribe(self, websocket: WebSocket, task_id: uuid.UUID | None) -> bool:
+        async with self._lock:
+            if task_id is None:
+                self.all_task_subscribers.add(websocket)
+                self.websocket_subscribes_all[websocket] = True
+            else:
+                if task_id not in self.task_connections:
+                    self.task_connections[task_id] = set()
+                self.task_connections[task_id].add(websocket)
+                
+                if websocket not in self.websocket_tasks:
+                    self.websocket_tasks[websocket] = set()
+                self.websocket_tasks[websocket].add(task_id)
+            return True
+    
+    async def unsubscribe(self, websocket: WebSocket, task_id: uuid.UUID | None) -> bool:
+        async with self._lock:
+            if task_id is None:
+                self.all_task_subscribers.discard(websocket)
+                self.websocket_subscribes_all.pop(websocket, None)
+            else:
+                if task_id in self.task_connections:
+                    self.task_connections[task_id].discard(websocket)
+                    if not self.task_connections[task_id]:
+                        del self.task_connections[task_id]
+                
+                if websocket in self.websocket_tasks:
+                    self.websocket_tasks[websocket].discard(task_id)
+                    if not self.websocket_tasks[websocket]:
+                        del self.websocket_tasks[websocket]
+            return True
+    
+    async def disconnect(self, websocket: WebSocket):
+        async with self._lock:
+            if websocket in self.websocket_tasks:
+                task_ids = self.websocket_tasks[websocket].copy()
+                for task_id in task_ids:
+                    if task_id in self.task_connections:
+                        self.task_connections[task_id].discard(websocket)
+                        if not self.task_connections[task_id]:
+                            del self.task_connections[task_id]
+                del self.websocket_tasks[websocket]
+            
+            self.all_task_subscribers.discard(websocket)
+            self.websocket_subscribes_all.pop(websocket, None)
+    
+    async def send_to_task(self, task_id: uuid.UUID, message: dict):
+        async with self._lock:
+            specific_subscribers = list(self.task_connections.get(task_id, set()))
+            all_subscribers = list(self.all_task_subscribers)
+            websockets = list(set(specific_subscribers + all_subscribers))
+        
+        disconnected = set()
+        message_str = json.dumps(message)
+        
+        # logger.debug(f"向 {len(websockets)} 个 websocket 连接发送消息 (task_id: {task_id})")
+        
+        for websocket in websockets:
+            try:
+                await websocket.send_text(message_str)
+            except Exception as e:
+                logger.error(f"向 task_id {task_id} 的 websocket 发送消息失败: {e}")
+                disconnected.add(websocket)
+        
+        for ws in disconnected:
+            await self.disconnect(ws)
+
+websocket_manager = WebSocketManager()

service_forge/api/routers/websocket/websocket_router.py

@@ -0,0 +1,78 @@
+from fastapi import WebSocket, WebSocketDisconnect
+from fastapi.routing import APIRouter
+from loguru import logger
+import json
+import uuid
+from .websocket_manager import websocket_manager
+
+websocket_router = APIRouter()
+
+@websocket_router.websocket("/sdk/ws")
+async def sdk_websocket_endpoint(websocket: WebSocket):
+    await websocket.accept()
+    try:
+        while True:
+            data = await websocket.receive_text()
+            try:
+                message = json.loads(data)
+                message_type = message.get("type")
+                
+                if message_type == "subscribe":
+                    task_id_str = message.get("task_id")
+                    if not task_id_str:
+                        await websocket.send_text(
+                            json.dumps({"error": "Missing task_id in subscribe message"})
+                        )
+                        continue
+                    
+                    if task_id_str.lower() == "all":
+                        success = await websocket_manager.subscribe(websocket, None)
+                        response = {"success": success, "type": "subscribe_response", "task_id": "all"}
+                        await websocket.send_text(json.dumps(response))
+                    else:
+                        try:
+                            task_id = uuid.UUID(task_id_str)
+                            success = await websocket_manager.subscribe(websocket, task_id)
+                            response = {"success": success, "type": "subscribe_response", "task_id": task_id_str}
+                            await websocket.send_text(json.dumps(response))
+                        except ValueError:
+                            await websocket.send_text(
+                                json.dumps({"error": "Invalid task_id format"})
+                            )
+                elif message_type == "unsubscribe":
+                    task_id_str = message.get("task_id")
+                    if not task_id_str:
+                        await websocket.send_text(
+                            json.dumps({"error": "Missing task_id in unsubscribe message"})
+                        )
+                        continue
+                    
+                    if task_id_str.lower() == "all":
+                        success = await websocket_manager.unsubscribe(websocket, None)
+                        response = {"success": success, "type": "unsubscribe_response", "task_id": "all"}
+                        await websocket.send_text(json.dumps(response))
+                    else:
+                        try:
+                            task_id = uuid.UUID(task_id_str)
+                            success = await websocket_manager.unsubscribe(websocket, task_id)
+                            response = {"success": success, "type": "unsubscribe_response", "task_id": task_id_str}
+                            await websocket.send_text(json.dumps(response))
+                        except ValueError:
+                            await websocket.send_text(
+                                json.dumps({"error": "Invalid task_id format"})
+                            )
+                else:
+                    await websocket.send_text(
+                        json.dumps({"error": f"Unknown message type: {message_type}"})
+                    )
+            except json.JSONDecodeError:
+                logger.error(f"收到无效JSON消息: {data}")
+                await websocket.send_text(
+                    json.dumps({"error": "Invalid JSON format"})
+                )
+    except WebSocketDisconnect:
+        await websocket_manager.disconnect(websocket)
+    except Exception as e:
+        logger.error(f"SDK WebSocket连接处理异常: {e}")
+        await websocket_manager.disconnect(websocket)
+

service_forge/api/task_manager.py

@@ -0,0 +1,141 @@
+
+from __future__ import annotations
+import asyncio
+import uuid
+import datetime
+from typing import Dict, List, Set, Any, Optional
+
+class TaskManager:
+    """任务管理器，用于跟踪任务状态和队列信息"""
+
+    def __init__(self):
+        # 存储所有任务信息: {task_id: task_info}
+        self.tasks: Dict[uuid.UUID, Dict[str, Any]] = {}
+        # 任务队列，按添加顺序排列
+        self.task_queue: List[uuid.UUID] = []
+        # 正在执行的任务ID集合
+        self.running_tasks: Set[uuid.UUID] = set()
+        # 已完成的任务ID集合
+        self.completed_tasks: Set[uuid.UUID] = set()
+        # 客户端与任务的映射: {client_id: set(task_id)}
+        self.client_tasks: Dict[str, Set[uuid.UUID]] = {}
+
+    def add_task(self, task_id: uuid.UUID, client_id: str, workflow_name: str, steps: int) -> Dict[str, Any]:
+        """添加新任务到队列"""
+        current_time = asyncio.get_event_loop().time()
+        task_info = {
+            "task_id": task_id,
+            "client_id": client_id,
+            "workflow_name": workflow_name,
+            "steps": steps,
+            "current_step": 0,  # 当前步骤，从0开始
+            "status": "pending",  # pending, running, completed, failed
+            "created_at": datetime.datetime.fromtimestamp(current_time).isoformat(),
+            "queue_position": len(self.task_queue) + 1
+        }
+        self.tasks[task_id] = task_info
+        self.task_queue.append(task_id)
+
+        # 更新客户端任务映射
+        if client_id not in self.client_tasks:
+            self.client_tasks[client_id] = set()
+        self.client_tasks[client_id].add(task_id)
+
+        return task_info
+
+    def start_task(self, task_id: uuid.UUID) -> bool:
+        """标记任务开始执行"""
+        if task_id not in self.tasks:
+            return False
+
+        current_time = asyncio.get_event_loop().time()
+        self.tasks[task_id]["status"] = "running"
+        self.tasks[task_id]["started_at"] = datetime.datetime.fromtimestamp(current_time).isoformat()
+        self.tasks[task_id]["current_step"] = 1  # 开始执行第一步
+        self.running_tasks.add(task_id)
+
+        # 从队列中移除
+        if task_id in self.task_queue:
+            self.task_queue.remove(task_id)
+
+        # 更新队列中所有任务的位置
+        for i, q_task_id in enumerate(self.task_queue):
+            self.tasks[q_task_id]["queue_position"] = i + 1
+
+        return True
+
+    def complete_task(self, task_id: uuid.UUID) -> bool:
+        """标记任务完成"""
+        if task_id not in self.tasks:
+            return False
+
+        current_time = asyncio.get_event_loop().time()
+        self.tasks[task_id]["status"] = "completed"
+        self.tasks[task_id]["completed_at"] = datetime.datetime.fromtimestamp(current_time).isoformat()
+        self.tasks[task_id]["current_step"] = self.tasks[task_id]["steps"]  # 完成所有步骤
+        self.running_tasks.discard(task_id)
+        self.completed_tasks.add(task_id)
+
+        return True
+
+    def fail_task(self, task_id: uuid.UUID, error: str = None) -> bool:
+        """标记任务失败"""
+        if task_id not in self.tasks:
+            return False
+
+        current_time = asyncio.get_event_loop().time()
+        self.tasks[task_id]["status"] = "failed"
+        self.tasks[task_id]["failed_at"] = datetime.datetime.fromtimestamp(current_time).isoformat()
+        if error:
+            self.tasks[task_id]["error"] = error
+        self.running_tasks.discard(task_id)
+
+        return True
+
+    def get_client_tasks(self, client_id: str) -> List[Dict[str, Any]]:
+        """获取客户端的所有任务"""
+        if client_id not in self.client_tasks:
+            return []
+
+        return [
+            self.tasks[task_id] 
+            for task_id in self.client_tasks[client_id] 
+            if task_id in self.tasks
+        ]
+
+    def get_queue_position(self, task_id: uuid.UUID) -> int:
+        """获取任务在队列中的位置，从1开始计数，如果不在队列中返回-1"""
+        if task_id not in self.tasks:
+            return -1
+
+        return self.tasks[task_id].get("queue_position", -1)
+
+    def get_global_queue_info(self) -> Dict[str, int]:
+        """获取全局队列信息"""
+        return {
+            "total": len(self.running_tasks) + len(self.task_queue),
+            "waiting": len(self.task_queue),
+            "running": len(self.running_tasks),
+        }
+
+    def get_task_info(self, task_id: uuid.UUID) -> Optional[Dict[str, Any]]:
+        """获取特定任务的详细信息"""
+        task_info = self.tasks.get(task_id)
+        if task_info:
+            # 创建任务信息的副本，并将UUID转换为字符串
+            task_copy = task_info.copy()
+            task_copy["task_id"] = str(task_id)
+            return task_copy
+        return None
+        
+    def update_current_step(self, task_id: uuid.UUID, step: int) -> bool:
+        """更新当前任务的步骤"""
+        if task_id not in self.tasks:
+            return False
+            
+        # 确保步骤在有效范围内
+        if step < 0 or step > self.tasks[task_id]["steps"]:
+            return False
+            
+        self.tasks[task_id]["current_step"] = step
+        return True

service_forge/db/__init__.py

@@ -0,0 +1 @@
+from .database import DatabaseManager, PostgresDatabase, MongoDatabase, RedisDatabase

service_forge/db/database.py

@@ -0,0 +1,240 @@
+from __future__ import annotations
+
+import redis
+import pymongo
+import psycopg2
+from typing import AsyncGenerator
+from loguru import logger
+from omegaconf import OmegaConf
+from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession, async_sessionmaker, create_async_engine
+from sqlalchemy import text
+
+class PostgresDatabase:
+    def __init__(
+        self,
+        name: str,
+        postgres_user: str,
+        postgres_password: str,
+        postgres_host: str,
+        postgres_port: int,
+        postgres_db: str,
+    ) -> None:
+        self.name = name
+        self.postgres_user = postgres_user
+        self.postgres_password = postgres_password
+        self.postgres_host = postgres_host
+        self.postgres_port = postgres_port
+        self.postgres_db = postgres_db
+        self.engine = None
+        self.session_factory = None
+        self.test_connection()
+
+    @property
+    def database_url(self) -> str:
+        return f"postgresql+asyncpg://{self.postgres_user}:{self.postgres_password}@{self.postgres_host}:{self.postgres_port}/{self.postgres_db}"
+
+    @property
+    def database_base_url(self) -> str:
+        return f"postgresql+asyncpg://{self.postgres_user}:{self.postgres_password}@{self.postgres_host}:{self.postgres_port}/postgres"
+
+    async def init(self) -> None:
+        if self.engine is None:
+            self.engine = await self.create_engine()
+            self.session_factory = async_sessionmaker(bind=self.engine, class_=AsyncSession, expire_on_commit=False)
+
+    async def close(self) -> None:
+        if self.engine:
+            await self.engine.dispose()
+            self.engine = None
+            self.session_factory = None
+            logger.info("Database connection closed")
+
+    async def create_engine(self) -> AsyncEngine:
+        if not all([self.postgres_user, self.postgres_host, self.postgres_port, self.postgres_db]):
+            raise ValueError("Missing required database configuration. Please check your .env file or configuration.")
+        logger.info(f"Creating database engine: {self.database_url}")
+        return create_async_engine(self.database_url)
+
+    async def get_async_session(self) -> AsyncGenerator[AsyncSession, None]:
+        if self.session_factory is None:
+            await self.init()
+        
+        if self.session_factory is None:
+            raise RuntimeError("Session factory is not initialized")
+        
+        async with self.session_factory() as session:
+            try:
+                yield session
+            except Exception:
+                await session.rollback()
+                raise
+            finally:
+                await session.close()
+            yield session
+
+    async def get_session_factory(self) -> async_sessionmaker[AsyncSession]:
+        if self.engine is None:
+            await self.init()
+
+        if self.session_factory is None:
+            raise RuntimeError("Session factory is not initialized")
+
+        return self.session_factory
+
+    def test_connection(self) -> bool:
+        try:
+            conn = psycopg2.connect(
+                host=self.postgres_host,
+                port=self.postgres_port,
+                user=self.postgres_user,
+                password=self.postgres_password,
+                database=self.postgres_db,
+                connect_timeout=5
+            )
+            conn.close()
+            logger.info(f"PostgreSQL connection test successful for database '{self.name}'")
+            return True
+        except Exception as e:
+            logger.warning(f"PostgreSQL connection test failed for database '{self.name}': {e}")
+            return False
+
+class MongoDatabase:
+    def __init__(
+        self,
+        name: str,
+        mongo_host: str,
+        mongo_port: int,
+        mongo_user: str,
+        mongo_password: str,
+        mongo_db: str,
+    ) -> None:
+        self.name = name
+        self.mongo_host = mongo_host
+        self.mongo_port = mongo_port
+        self.mongo_user = mongo_user
+        self.mongo_password = mongo_password
+        self.mongo_db = mongo_db or ""
+        self.client = pymongo.MongoClient(self.database_url)
+        self.test_connection()
+
+    @property
+    def database_url(self) -> str:
+        return f"mongodb://{self.mongo_user}:{self.mongo_password}@{self.mongo_host}:{self.mongo_port}/{self.mongo_db}"
+
+    def test_connection(self) -> bool:
+        try:
+            self.client.admin.command('ping')
+            logger.info(f"MongoDB connection test successful for database '{self.name}'")
+            return True
+        except Exception as e:
+            logger.error(f"MongoDB connection test failed for database '{self.name}': {e}")
+            return False
+
+class RedisDatabase:
+    def __init__(
+        self,
+        name: str,
+        redis_host: str,
+        redis_port: int,
+        redis_password: str,
+    ) -> None:
+        self.name = name
+        self.redis_host = redis_host
+        self.redis_port = redis_port
+        self.redis_password = redis_password
+        self.client = redis.Redis(host=redis_host, port=redis_port, password=redis_password)
+        self.test_connection()
+
+    def test_connection(self) -> bool:
+        try:
+            self.client.ping()
+            logger.info(f"Redis connection test successful for database '{self.name}'")
+            return True
+        except Exception as e:
+            logger.error(f"Redis connection test failed for database '{self.name}': {e}")
+            return False
+
+
+class DatabaseManager:
+    def __init__(
+        self,
+        postgres_databases: list[PostgresDatabase],
+        mongo_databases: list[MongoDatabase],
+        redis_databases: list[RedisDatabase],
+    ) -> None:
+        self.postgres_databases = postgres_databases
+        self.mongo_databases = mongo_databases
+        self.redis_databases = redis_databases
+
+    def get_database(self, name: str) ->  PostgresDatabase | MongoDatabase | RedisDatabase | None:
+        for database in self.postgres_databases:
+            if database.name == name:
+                return database
+        return None
+
+    def get_default_postgres_database(self) -> PostgresDatabase | None:
+        if len(self.postgres_databases) > 0:
+            return self.postgres_databases[0]
+        return None
+
+    def get_default_mongo_database(self) -> MongoDatabase | None:
+        if len(self.mongo_databases) > 0:
+            return self.mongo_databases[0]
+        return None
+
+    def get_default_redis_database(self) -> RedisDatabase | None:
+        if len(self.redis_databases) > 0:
+            return self.redis_databases[0]
+        return None
+
+    @staticmethod
+    def from_config(config_path: str = None, config = None) -> DatabaseManager:
+        if config is None:
+            config = OmegaConf.to_object(OmegaConf.load(config_path))
+
+        databases_config = config.get('databases', None)
+        postgres_databases = []
+        mongo_databases = []
+        redis_databases = []
+        if databases_config is not None:
+            for database_config in databases_config:
+                if ('postgres_host' in database_config and database_config['postgres_host'] is not None) + \
+                    ('mongo_host' in database_config and database_config['mongo_host'] is not None) + \
+                    ('redis_host' in database_config and database_config['redis_host'] is not None) == 0:
+                    raise ValueError(f"Database '{database_config['name']}' is missing required configuration. Please check your service.yaml file.")
+
+                if ('postgres_host' in database_config and database_config['postgres_host'] is not None) + \
+                    ('mongo_host' in database_config and database_config['mongo_host'] is not None) + \
+                    ('redis_host' in database_config and database_config['redis_host'] is not None) > 1:
+                    raise ValueError(f"Database '{database_config['name']}' has multiple host configurations. Please check your service.yaml file.")
+
+                if 'postgres_host' in database_config and database_config['postgres_host'] is not None:
+                    postgres_databases.append(PostgresDatabase(
+                        name=database_config['name'],
+                        postgres_user=database_config['postgres_user'],
+                        postgres_password=database_config['postgres_password'],
+                        postgres_host=database_config['postgres_host'],
+                        postgres_port=database_config['postgres_port'],
+                        postgres_db=database_config['postgres_db'],
+                    ))
+                if 'mongo_host' in database_config and database_config['mongo_host'] is not None:
+                    mongo_databases.append(MongoDatabase(
+                        name=database_config['name'],
+                        mongo_host=database_config['mongo_host'],
+                        mongo_port=database_config['mongo_port'],
+                        mongo_user=database_config['mongo_user'],
+                        mongo_password=database_config['mongo_password'],
+                        mongo_db=database_config['mongo_db'],
+                    ))
+                if 'redis_host' in database_config and database_config['redis_host'] is not None:
+                    redis_databases.append(RedisDatabase(
+                        name=database_config['name'],
+                        redis_host=database_config['redis_host'],
+                        redis_port=database_config['redis_port'],
+                        redis_password=database_config['redis_password'],
+                    ))
+
+        return DatabaseManager(postgres_databases=postgres_databases, mongo_databases=mongo_databases, redis_databases=redis_databases)
+
+def create_database_manager(config_path: str = None, config = None) -> DatabaseManager:
+    return DatabaseManager.from_config(config_path, config)