service-forge 0.1.18__py3-none-any.whl

service_forge/api/routers/feedback/feedback_router.py

@@ -0,0 +1,148 @@
+import os
+import httpx
+from fastapi import APIRouter, HTTPException, Query, BackgroundTasks
+from loguru import logger
+from typing import Optional
+
+from service_forge.model.feedback import FeedbackCreate, FeedbackResponse, FeedbackListResponse
+from service_forge.storage.feedback_storage import feedback_storage
+from service_forge.db.database import create_database_manager
+from service_forge.current_service import get_service
+
+router = APIRouter(prefix="/sdk/feedback", tags=["feedback"])
+
+def get_forward_api_url():
+    if not get_service():
+        return None
+    if not get_service().config.feedback:
+        return None
+    return get_service().config.feedback.api_url
+
+def get_forward_api_timeout():
+    if not get_service():
+        return None
+    if not get_service().config.feedback:
+        return None
+    return get_service().config.feedback.api_timeout
+
+async def forward_feedback_to_api(feedback_data: dict):
+    """
+    将反馈数据转发到外部 API
+
+    Args:
+        feedback_data: 反馈数据字典
+    """
+    forward_api_url = get_forward_api_url()
+    forward_api_timeout = get_forward_api_timeout()
+    print(forward_api_url)
+    print(forward_api_timeout)
+    if not forward_api_url:
+        logger.debug("未配置转发 API URL，跳过转发")
+        return
+    try:
+        # 处理 datetime 对象，转换为 ISO 格式字符串
+        serializable_data = feedback_data.copy()
+        if 'created_at' in serializable_data and serializable_data['created_at']:
+            serializable_data['created_at'] = serializable_data['created_at'].isoformat()
+
+        async with httpx.AsyncClient(timeout=forward_api_timeout) as client:
+            response = await client.post(
+                forward_api_url,
+                json=serializable_data,
+                headers={"Content-Type": "application/json"}
+            )
+            response.raise_for_status()
+            logger.info(f"反馈转发成功: feedback_id={feedback_data.get('feedback_id')}, status={response.status_code}")
+    except httpx.TimeoutException:
+        logger.warning(f"反馈转发超时: {forward_api_url}")
+    except httpx.ConnectError as e:
+        logger.warning(f"反馈转发连接失败: {forward_api_url} - {e}")
+    except httpx.HTTPStatusError as e:
+        logger.error(f"反馈转发失败: status={e.response.status_code}, detail={e.response.text}")
+    except Exception as e:
+        logger.error(f"反馈转发异常: {type(e).__name__}: {e}")
+
+
+
+@router.post("/", response_model=FeedbackResponse, summary="创建工作流反馈")
+async def create_feedback(feedback: FeedbackCreate, background_tasks: BackgroundTasks):
+    """
+    创建工作流执行完成后的用户反馈
+    - **task_id**: 工作流任务ID - workflow的id
+    - **workflow_name**: 工作流名称 - workflow的名称
+    - **rating**: 可选的评分 (1-5) - 反馈中的一种，评分，可以为空
+    - **comment**: 可选的用户评论 - 反馈中的一种，可以为空
+    - **metadata**: 可选的额外元数据
+    还少什么？ - trace_id?
+    """
+    try:
+        # 保存到数据库
+        feedback_data = await feedback_storage.create_feedback(
+            task_id=feedback.task_id,
+            workflow_name=feedback.workflow_name,
+            rating=feedback.rating,
+            comment=feedback.comment,
+            metadata=feedback.metadata,
+        )
+
+        # 后台任务转发到外部 API (不阻塞响应)
+        background_tasks.add_task(forward_feedback_to_api, feedback_data)
+
+        return FeedbackResponse(**feedback_data)
+    except Exception as e:
+        logger.error(f"创建反馈失败: {e}")
+        raise HTTPException(status_code=500, detail=f"创建反馈失败: {str(e)}")
+
+
+@router.get("/{feedback_id}", response_model=FeedbackResponse, summary="获取单个反馈")
+async def get_feedback(feedback_id: str):
+    """
+    根据反馈ID获取反馈详情
+
+    - **feedback_id**: 反馈ID
+    """
+    feedback = await feedback_storage.get_feedback(feedback_id)
+    if not feedback:
+        raise HTTPException(status_code=404, detail="反馈不存在")
+    return FeedbackResponse(**feedback)
+
+
+@router.get("/", response_model=FeedbackListResponse, summary="获取反馈列表")
+async def list_feedbacks(
+    task_id: Optional[str] = Query(None, description="按任务ID筛选"),
+    workflow_name: Optional[str] = Query(None, description="按工作流名称筛选"),
+):
+    """
+    获取反馈列表,支持按任务ID或工作流名称筛选
+
+    - **task_id**: 可选,按任务ID筛选
+    - **workflow_name**: 可选,按工作流名称筛选
+    """
+    try:
+        if task_id:
+            feedbacks = await feedback_storage.get_feedbacks_by_task(task_id)
+        elif workflow_name:
+            feedbacks = await feedback_storage.get_feedbacks_by_workflow(workflow_name)
+        else:
+            feedbacks = await feedback_storage.get_all_feedbacks()
+
+        return FeedbackListResponse(
+            total=len(feedbacks),
+            feedbacks=[FeedbackResponse(**f) for f in feedbacks]
+        )
+    except Exception as e:
+        logger.error(f"获取反馈列表失败: {e}")
+        raise HTTPException(status_code=500, detail=f"获取反馈列表失败: {str(e)}")
+
+
+@router.delete("/{feedback_id}", summary="删除反馈")
+async def delete_feedback(feedback_id: str):
+    """
+    删除指定的反馈
+
+    - **feedback_id**: 反馈ID
+    """
+    success = await feedback_storage.delete_feedback(feedback_id)
+    if not success:
+        raise HTTPException(status_code=404, detail="反馈不存在")
+    return {"message": "反馈删除成功", "feedback_id": feedback_id}

service_forge/api/routers/service/service_router.py

@@ -0,0 +1,127 @@
+import os
+import uuid
+import tempfile
+from fastapi import APIRouter, HTTPException, UploadFile, File, Form
+from fastapi.responses import JSONResponse
+from loguru import logger
+from typing import Optional, TYPE_CHECKING
+from pydantic import BaseModel
+from omegaconf import OmegaConf
+from service_forge.current_service import get_service
+
+service_router = APIRouter(prefix="/sdk/service", tags=["service"])
+
+class WorkflowStatusResponse(BaseModel):
+    name: str
+    version: str
+    description: str
+    workflows: list[dict]
+
+class WorkflowActionResponse(BaseModel):
+    workflow_id: str
+    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_id}/start", response_model=WorkflowActionResponse)
+async def start_workflow(workflow_id: str):
+    service = get_service()
+    if service is None:
+        raise HTTPException(status_code=503, detail="Service not initialized")
+    
+    try:
+        success = service.start_workflow_by_id(uuid.UUID(workflow_id))
+        if success:
+            return WorkflowActionResponse(success=True, message=f"Workflow {workflow_id} started successfully")
+        else:
+            return WorkflowActionResponse(success=False, message=f"Failed to start workflow {workflow_id}")
+    except Exception as e:
+        logger.error(f"Error starting workflow {workflow_id}: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@service_router.post("/workflow/{workflow_id}/stop", response_model=WorkflowActionResponse)
+async def stop_workflow(workflow_id: str):
+    service = get_service()
+    if service is None:
+        raise HTTPException(status_code=503, detail="Service not initialized")
+    
+    try:
+        success = await service.stop_workflow_by_id(uuid.UUID(workflow_id))
+        if success:
+            return WorkflowActionResponse(success=True, message=f"Workflow {workflow_id} stopped successfully")
+        else:
+            return WorkflowActionResponse(success=False, message=f"Failed to stop workflow {workflow_id}")
+    except Exception as e:
+        logger.error(f"Error stopping workflow {workflow_id}: {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),
+):
+    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
+           
+            workflow_id = await service.load_workflow_from_config(config_path=temp_file_path)
+        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)}")
+            
+            workflow_id = await service.load_workflow_from_config(config=config)
+        
+        if workflow_id:
+            return WorkflowActionResponse(
+                workflow_id=str(workflow_id),
+                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/current_service.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from service_forge.service import Service
+
+_current_service: Service | None = None
+
+def set_service(service: Service) -> None:
+    global _current_service
+    _current_service = service
+
+def get_service() -> Service | None:
+    return _current_service

service_forge/db/__init__.py

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