service-forge 0.1.11__py3-none-any.whl → 0.1.21__py3-none-any.whl

service_forge/sft/config/sft_config.py

@@ -21,6 +21,8 @@ class SftConfig:
         "inject_postgres_port": "Postgres port for services",
         "inject_postgres_user": "Postgres user for services",
         "inject_postgres_password": "Postgres password for services",
+        "inject_feedback_api_url": "Feedback API URL for services",
+        "inject_feedback_api_timeout": "Feedback API timeout for services",
         "deepseek_api_key": "DeepSeek API key",
         "deepseek_base_url": "DeepSeek base URL",
     }
@@ -52,6 +54,9 @@ class SftConfig:
         inject_redis_port: int = 6379,
         inject_redis_password: str = "rDdM2Y2gX9",
 
+        inject_feedback_api_url: str = "http://vps.shiweinan.com:37919/api/v1/feedback",
+        inject_feedback_api_timeout: int = 5,
+
         deepseek_api_key: str = "82c9df22-f6ed-411e-90d7-c5255376b7ca",
         deepseek_base_url: str = "https://ark.cn-beijing.volces.com/api/v3",
     ):
@@ -80,6 +85,9 @@ class SftConfig:
         self.inject_redis_port = inject_redis_port
         self.inject_redis_password = inject_redis_password
 
+        self.inject_feedback_api_url = inject_feedback_api_url
+        self.inject_feedback_api_timeout = inject_feedback_api_timeout
+
         self.deepseek_api_key = deepseek_api_key
         self.deepseek_base_url = deepseek_base_url
 
@@ -91,10 +99,23 @@ class SftConfig:
     def upload_timeout(self) -> int:
         return 300  # 5 minutes default timeout
 
-    @classmethod
-    def get_config_keys(cls) -> list[str]:
-        sig = inspect.signature(cls.__init__)
-        return [param for param in sig.parameters.keys() if param != 'self']
+    def get_config_keys(self) -> list[str]:
+        # Get initial configuration parameters from __init__ method
+        sig = inspect.signature(self.__class__.__init__)
+        init_keys = [param for param in sig.parameters.keys() if param != 'self']
+        
+        # Get all instance attributes (including dynamically added configurations)
+        instance_keys = []
+        for attr_name in dir(self):
+            # Exclude special methods, private attributes, class attributes, and methods
+            if (not attr_name.startswith('_') and
+                not callable(getattr(self, attr_name)) and
+                attr_name not in ['CONFIG_ROOT', 'CONFIG_DESCRIPTIONS']):
+                instance_keys.append(attr_name)
+        
+        # Merge and deduplicate, maintaining order (initial configs first, then dynamically added)
+        all_keys = list(dict.fromkeys(init_keys + instance_keys))
+        return all_keys
     
     @property
     def config_file_path(self) -> Path:
@@ -105,13 +126,30 @@ class SftConfig:
     
     def to_dict(self) -> dict:
         config_keys = self.get_config_keys()
-        return {key: getattr(self, key) for key in config_keys}
+        result = {}
+        for key in config_keys:
+            value = getattr(self, key)
+            # Convert Path objects to strings for JSON serialization
+            if isinstance(value, Path):
+                value = str(value)
+            result[key] = value
+        return result
     
     def from_dict(self, data: dict) -> None:
-        config_keys = self.get_config_keys()
-        for key in config_keys:
+        # Get initial configuration parameters from __init__ method
+        sig = inspect.signature(self.__class__.__init__)
+        init_keys = [param for param in sig.parameters.keys() if param != 'self']
+        
+        # First, set all initial configuration parameters
+        for key in init_keys:
             if key in data:
                 setattr(self, key, data[key])
+        
+        # Then, handle any additional keys that might be dynamically added configurations
+        for key, value in data.items():
+            if key not in init_keys and key not in ['CONFIG_ROOT', 'CONFIG_DESCRIPTIONS']:
+                # This might be a dynamically added configuration
+                setattr(self, key, value)
     
     def save(self) -> None:
         self.ensure_config_dir()
@@ -121,13 +159,22 @@ class SftConfig:
     def get(self, key: str, default: Optional[str] = None) -> Optional[str]:
         return getattr(self, key, default)
     
-    def set(self, key: str, value: str) -> None:
+    def set(self, key: str, value: str, description: Optional[str] = None) -> None:
         if key in ["config_root"]:
             raise ValueError(f"{key} is read-only")
         if hasattr(self, key):
             setattr(self, key, value)
+            if description:
+                self.CONFIG_DESCRIPTIONS[key] = description
         else:
             raise ValueError(f"Unknown config key: {key}")
+        
+    def add(self, key: str, value: str, description: Optional[str] = None) -> None:
+        if hasattr(self, key):
+            raise ValueError(f"{key} already exists")
+        setattr(self, key, value)
+        if description:
+            self.CONFIG_DESCRIPTIONS[key] = description
     
     def update(self, updates: dict) -> None:
         for key, value in updates.items():

service_forge/storage/__init__.py

@@ -0,0 +1,5 @@
+"""Storage layer for business logic."""
+
+from .feedback_storage import FeedbackStorage, feedback_storage
+
+__all__ = ["FeedbackStorage", "feedback_storage"]

service_forge/storage/feedback_storage.py

@@ -0,0 +1,245 @@
+from typing import Optional, Any
+from datetime import datetime
+from uuid import uuid4
+from loguru import logger
+from sqlalchemy import select, and_
+from sqlalchemy.exc import SQLAlchemyError
+
+from ..db.models.feedback import FeedbackBase
+from ..db.database import DatabaseManager
+
+
+class FeedbackStorage:
+    """反馈存储管理器 - 使用 PostgreSQL 数据库存储"""
+
+    def __init__(self, database_manager: DatabaseManager = None):
+        self.database_manager = database_manager
+        self._db = None
+        # 内存存储后备(用于数据库未配置时)
+        self._storage: dict[str, dict[str, Any]] = {}
+        self._task_index: dict[str, list[str]] = {}
+        self._workflow_index: dict[str, list[str]] = {}
+
+    @property
+    def db(self):
+        """延迟获取数据库连接"""
+        if self._db is None and self.database_manager is not None:
+            self._db = self.database_manager.get_default_postgres_database()
+        return self._db
+
+    async def create_feedback(
+        self,
+        task_id: str,
+        workflow_name: str,
+        rating: Optional[int] = None,
+        comment: Optional[str] = None,
+        metadata: Optional[dict[str, Any]] = None,
+    ) -> dict[str, Any]:
+        """创建新的反馈记录"""
+        if self.db is None:
+            logger.warning("数据库未初始化,使用内存存储(数据将在重启后丢失)")
+            return self._create_feedback_in_memory(task_id, workflow_name, rating, comment, metadata)
+
+        try:
+            feedback_id = uuid4()
+            created_at = datetime.now()
+
+            feedback = FeedbackBase(
+                feedback_id=feedback_id,
+                task_id=task_id,
+                workflow_name=workflow_name,
+                rating=rating,
+                comment=comment,
+                extra_metadata=metadata or {},
+                created_at=created_at,
+            )
+
+            session_factory = await self.db.get_session_factory()
+            async with session_factory() as session:
+                session.add(feedback)
+                await session.commit()
+                await session.refresh(feedback)
+
+                logger.info(f"创建反馈: feedback_id={feedback_id}, task_id={task_id}, workflow={workflow_name}")
+                return feedback.to_dict()
+
+        except SQLAlchemyError as e:
+            logger.error(f"数据库创建反馈失败: {e}")
+            raise
+        except Exception as e:
+            logger.error(f"创建反馈失败: {e}")
+            raise
+
+    async def get_feedback(self, feedback_id: str) -> Optional[dict[str, Any]]:
+        """根据反馈ID获取反馈"""
+        if self.db is None:
+            return self._get_feedback_from_memory(feedback_id)
+
+        try:
+            session_factory = await self.db.get_session_factory()
+            async with session_factory() as session:
+                result = await session.execute(
+                    select(FeedbackBase).where(FeedbackBase.feedback_id == feedback_id)
+                )
+                feedback = result.scalar_one_or_none()
+                return feedback.to_dict() if feedback else None
+
+        except SQLAlchemyError as e:
+            logger.error(f"查询反馈失败: {e}")
+            return None
+
+    async def get_feedbacks_by_task(self, task_id: str) -> list[dict[str, Any]]:
+        """根据任务ID获取所有反馈"""
+        if self.db is None:
+            return self._get_feedbacks_by_task_from_memory(task_id)
+
+        try:
+            session_factory = await self.db.get_session_factory()
+            async with session_factory() as session:
+                result = await session.execute(
+                    select(FeedbackBase)
+                    .where(FeedbackBase.task_id == task_id)
+                    .order_by(FeedbackBase.created_at.desc())
+                )
+                feedbacks = result.scalars().all()
+                return [f.to_dict() for f in feedbacks]
+
+        except SQLAlchemyError as e:
+            logger.error(f"查询任务反馈失败: {e}")
+            return []
+
+    async def get_feedbacks_by_workflow(self, workflow_name: str) -> list[dict[str, Any]]:
+        """根据工作流名称获取所有反馈"""
+        if self.db is None:
+            return self._get_feedbacks_by_workflow_from_memory(workflow_name)
+
+        try:
+            session_factory = await self.db.get_session_factory()
+            async with session_factory() as session:
+                result = await session.execute(
+                    select(FeedbackBase)
+                    .where(FeedbackBase.workflow_name == workflow_name)
+                    .order_by(FeedbackBase.created_at.desc())
+                )
+                feedbacks = result.scalars().all()
+                return [f.to_dict() for f in feedbacks]
+
+        except SQLAlchemyError as e:
+            logger.error(f"查询工作流反馈失败: {e}")
+            return []
+
+    async def get_all_feedbacks(self) -> list[dict[str, Any]]:
+        """获取所有反馈"""
+        if self.db is None:
+            return self._get_all_feedbacks_from_memory()
+
+        try:
+            session_factory = await self.db.get_session_factory()
+            async with session_factory() as session:
+                result = await session.execute(
+                    select(FeedbackBase).order_by(FeedbackBase.created_at.desc())
+                )
+                feedbacks = result.scalars().all()
+                return [f.to_dict() for f in feedbacks]
+
+        except SQLAlchemyError as e:
+            logger.error(f"查询所有反馈失败: {e}")
+            return []
+
+    async def delete_feedback(self, feedback_id: str) -> bool:
+        """删除反馈"""
+        if self.db is None:
+            return self._delete_feedback_from_memory(feedback_id)
+
+        try:
+            session_factory = await self.db.get_session_factory()
+            async with session_factory() as session:
+                result = await session.execute(
+                    select(FeedbackBase).where(FeedbackBase.feedback_id == feedback_id)
+                )
+                feedback = result.scalar_one_or_none()
+
+                if not feedback:
+                    return False
+
+                await session.delete(feedback)
+                await session.commit()
+
+                logger.info(f"删除反馈: feedback_id={feedback_id}")
+                return True
+
+        except SQLAlchemyError as e:
+            logger.error(f"删除反馈失败: {e}")
+            return False
+
+    # ========== 内存存储后备方法(用于数据库未配置时) ==========
+
+    def _create_feedback_in_memory(
+        self,
+        task_id: str,
+        workflow_name: str,
+        rating: Optional[int],
+        comment: Optional[str],
+        metadata: Optional[dict[str, Any]],
+    ) -> dict[str, Any]:
+        """内存存储版本"""
+        feedback_id = str(uuid4())
+        created_at = datetime.now()
+
+        feedback_data = {
+            "feedback_id": feedback_id,
+            "task_id": task_id,
+            "workflow_name": workflow_name,
+            "rating": rating,
+            "comment": comment,
+            "metadata": metadata or {},
+            "created_at": created_at,
+        }
+
+        self._storage[feedback_id] = feedback_data
+
+        if task_id not in self._task_index:
+            self._task_index[task_id] = []
+        self._task_index[task_id].append(feedback_id)
+
+        if workflow_name not in self._workflow_index:
+            self._workflow_index[workflow_name] = []
+        self._workflow_index[workflow_name].append(feedback_id)
+
+        logger.info(f"[内存存储]创建反馈: feedback_id={feedback_id}")
+        return feedback_data
+
+    def _get_feedback_from_memory(self, feedback_id: str) -> Optional[dict[str, Any]]:
+        return self._storage.get(feedback_id)
+
+    def _get_feedbacks_by_task_from_memory(self, task_id: str) -> list[dict[str, Any]]:
+        feedback_ids = self._task_index.get(task_id, [])
+        return [self._storage[fid] for fid in feedback_ids if fid in self._storage]
+
+    def _get_feedbacks_by_workflow_from_memory(self, workflow_name: str) -> list[dict[str, Any]]:
+        feedback_ids = self._workflow_index.get(workflow_name, [])
+        return [self._storage[fid] for fid in feedback_ids if fid in self._storage]
+
+    def _get_all_feedbacks_from_memory(self) -> list[dict[str, Any]]:
+        return list(self._storage.values())
+
+    def _delete_feedback_from_memory(self, feedback_id: str) -> bool:
+        if feedback_id not in self._storage:
+            return False
+
+        feedback = self._storage[feedback_id]
+        task_id = feedback["task_id"]
+        workflow_name = feedback["workflow_name"]
+
+        if task_id in self._task_index:
+            self._task_index[task_id].remove(feedback_id)
+        if workflow_name in self._workflow_index:
+            self._workflow_index[workflow_name].remove(feedback_id)
+
+        del self._storage[feedback_id]
+        logger.info(f"[内存存储]删除反馈: feedback_id={feedback_id}")
+        return True
+
+
+# 全局单例实例
+feedback_storage = FeedbackStorage()

service_forge/utils/workflow_clone.py

@@ -57,8 +57,8 @@ def workflow_clone(self: Workflow, task_id: uuid.UUID, trigger_node: Trigger) ->
         }
 
     workflow = Workflow(
-        name=self.name,
-        description=self.description,
+        id=self.id,
+        config=self.config,
         nodes=[node_map[node] for node in self.nodes],
         input_ports=[port_map[port] for port in self.input_ports],
         output_ports=[port_map[port] for port in self.output_ports],
@@ -69,6 +69,7 @@ def workflow_clone(self: Workflow, task_id: uuid.UUID, trigger_node: Trigger) ->
         callbacks=self.callbacks,
         task_id=task_id,
         real_trigger_node=trigger_node,
+        global_context=self.global_context,
     )
 
     for node in workflow.nodes:

service_forge/workflow/node.py

@@ -10,6 +10,7 @@ from .context import Context
 from ..utils.register import Register
 from ..db.database import DatabaseManager, PostgresDatabase, MongoDatabase, RedisDatabase
 from ..utils.workflow_clone import node_clone
+from .workflow_callback import CallbackEvent
 
 if TYPE_CHECKING:
     from .workflow import Workflow
@@ -62,6 +63,10 @@ class Node(ABC):
     def database_manager(self) -> DatabaseManager:
         return self.workflow.database_manager
 
+    @property
+    def global_context(self) -> Context:
+        return self.workflow.global_context
+
     def backup(self) -> None:
         # do NOT use deepcopy here
         # self.bak_context = deepcopy(self.context)
@@ -181,4 +186,7 @@ class Node(ABC):
     def _clone(self, context: Context) -> Node:
         return node_clone(self, context)
 
+    async def stream_output(self, data: Any) -> None:
+         await self.workflow.call_callbacks(CallbackEvent.ON_NODE_STREAM_OUTPUT, node=self, output=data)
+
 node_register = Register[Node]()

service_forge/workflow/nodes/llm/query_llm_node.py

@@ -36,6 +36,6 @@ class QueryLLMNode(Node):
                 prompt = f.read()
 
         print(f"prompt: {prompt} temperature: {temperature}")
-        response = chat_stream(prompt, system_prompt, Model.DEEPSEEK_V3_250324, temperature)
+        response = chat_stream(prompt, system_prompt, Model.GEMINI, temperature)
         for chunk in response:
             yield chunk

service_forge/workflow/trigger.py

@@ -19,6 +19,10 @@ class Trigger(Node, ABC):
     async def _run(self) -> AsyncIterator[bool]:
         ...
 
+    @abstractmethod
+    async def _stop(self) -> AsyncIterator[bool]:
+        ...
+
     def trigger(self, task_id: uuid.UUID) -> bool:
         self.prepare_output_edges(self.get_output_port_by_name('trigger'), True)
         return task_id

service_forge/workflow/triggers/a2a_api_trigger.py

@@ -253,3 +253,5 @@ class A2AAPITrigger(Trigger):
                 logger.error(f"Error in A2AAPITrigger._run: {e}")
                 continue
 
+    async def _stop(self) -> AsyncIterator[bool]:
+        pass

service_forge/workflow/triggers/fast_api_trigger.py

@@ -33,6 +33,9 @@ class FastAPITrigger(Trigger):
         super().__init__(name)
         self.events = {}
         self.is_setup_route = False
+        self.app = None
+        self.route_path = None
+        self.route_method = None
 
     @staticmethod
     def serialize_result(result: Any):
@@ -141,6 +144,11 @@ class FastAPITrigger(Trigger):
         async def handler(request: Request):
             return await self.handle_request(request, data_type, extractor, is_stream)
 
+        # Save route information for cleanup
+        self.app = app
+        self.route_path = path
+        self.route_method = method.upper()
+
         if method == "GET":
             app.get(path)(handler)
         elif method == "POST":
@@ -167,3 +175,27 @@ class FastAPITrigger(Trigger):
                 logger.error(f"Error in FastAPITrigger._run: {e}")
                 continue
 
+    async def _stop(self) -> AsyncIterator[bool]:
+        if self.is_setup_route:
+            # Remove the route from the app
+            if self.app and self.route_path and self.route_method:
+                # Find and remove matching route
+                routes_to_remove = []
+                for route in self.app.routes:
+                    if hasattr(route, "path") and hasattr(route, "methods"):
+                        if route.path == self.route_path and self.route_method in route.methods:
+                            routes_to_remove.append(route)
+                
+                # Remove found routes
+                for route in routes_to_remove:
+                    try:
+                        self.app.routes.remove(route)
+                        logger.info(f"Removed route {self.route_method} {self.route_path} from FastAPI app")
+                    except ValueError:
+                        logger.warning(f"Route {self.route_method} {self.route_path} not found in app.routes")
+            
+            # Reset route information
+            self.app = None
+            self.route_path = None
+            self.route_method = None
+            self.is_setup_route = False

service_forge/workflow/triggers/kafka_api_trigger.py

@@ -42,3 +42,6 @@ class KafkaAPITrigger(Trigger):
             trigger = await self.trigger_queue.get()
             self.prepare_output_edges(self.get_output_port_by_name('data'), trigger['data'])
             yield self.trigger(trigger['id'])
+
+    async def _stop(self) -> AsyncIterator[bool]:
+        pass

service_forge/workflow/triggers/once_trigger.py

@@ -17,4 +17,7 @@ class OnceTrigger(Trigger):
         super().__init__(name)
 
     async def _run(self) -> AsyncIterator[bool]:
-        yield self.trigger(uuid.uuid4())
+        yield self.trigger(uuid.uuid4())
+
+    async def _stop(self) -> AsyncIterator[bool]:
+        pass

service_forge/workflow/triggers/period_trigger.py

@@ -23,4 +23,7 @@ class PeriodTrigger(Trigger):
     async def _run(self, times: int, period: float) -> AsyncIterator[bool]:
         for _ in range(times):
             await asyncio.sleep(period)
-            yield uuid.uuid4()
+            yield uuid.uuid4()
+
+    async def _stop(self) -> AsyncIterator[bool]:
+        pass

service_forge/workflow/triggers/websocket_api_trigger.py

@@ -120,12 +120,16 @@ class WebSocketAPITrigger(Trigger):
         self.result_queues[task_id] = asyncio.Queue()
         self.stream_queues[task_id] = asyncio.Queue()
 
-        try:
-            converted_data = data_type(**message_data)
-        except Exception as e:
-            error_msg = {"error": f"Failed to convert data: {str(e)}"}
-            await websocket.send_text(json.dumps(error_msg))
-            return
+        if data_type is Any:
+            converted_data = message_data
+        else:
+            try:
+                # TODO: message_data is Message, need to convert to dict
+                converted_data = data_type(**message_data)
+            except Exception as e:
+                error_msg = {"error": f"Failed to convert data: {str(e)}"}
+                await websocket.send_text(json.dumps(error_msg))
+                return
 
         # Always start background task to handle stream output
         asyncio.create_task(self.handle_stream_output(websocket, task_id))
@@ -143,16 +147,14 @@ class WebSocketAPITrigger(Trigger):
             
             try:
                 while True:
-                    # Receive message from client
-                    data = await websocket.receive_text()
+                    data = await websocket.receive()
                     try:
-                        message = json.loads(data)
-                        
+                        # message = json.loads(data)
                         # Handle the message and trigger workflow
                         await self.handle_websocket_message(
                             websocket,
                             data_type,
-                            message
+                            data
                         )
                     except json.JSONDecodeError:
                         error_msg = {"error": "Invalid JSON format"}
@@ -182,3 +184,5 @@ class WebSocketAPITrigger(Trigger):
                 logger.error(f"Error in WebSocketAPITrigger._run: {e}")
                 continue
 
+    async def _stop(self) -> AsyncIterator[bool]:
+        pass

service_forge/workflow/workflow.py

@@ -12,12 +12,14 @@ from .edge import Edge
 from ..db.database import DatabaseManager
 from ..utils.workflow_clone import workflow_clone
 from .workflow_callback import WorkflowCallback, BuiltinWorkflowCallback, CallbackEvent
+from .workflow_config import WorkflowConfig
+from .context import Context
 
 class Workflow:
     def __init__(
         self,
-        name: str,
-        description: str,
+        id: uuid.UUID,
+        config: WorkflowConfig,
         nodes: list[Node],
         input_ports: list[Port],
         output_ports: list[Port],
@@ -30,9 +32,12 @@ class Workflow:
         # for run
         task_id: uuid.UUID = None,
         real_trigger_node: Trigger = None,
+
+        # global variables
+        global_context: Context = None,
     ) -> None:
-        self.name = name
-        self.description = description
+        self.id = id
+        self.config = config
         self.nodes = nodes
         self.ready_nodes: list[Node] = []
         self.input_ports = input_ports
@@ -47,7 +52,20 @@ class Workflow:
         self.callbacks = callbacks
         self.task_id = task_id
         self.real_trigger_node = real_trigger_node
+        self.global_context = global_context
         self._validate()
+    
+    @property
+    def name(self) -> str:
+        return self.config.name
+    
+    @property
+    def version(self) -> str:
+        return self.config.version
+    
+    @property
+    def description(self) -> str:
+        return self.config.description
 
     def register_callback(self, callback: WorkflowCallback) -> None:
         self.callbacks.append(callback)
@@ -186,6 +204,10 @@ class Workflow:
         if tasks:
             await asyncio.gather(*tasks)
 
+    async def stop(self):
+        trigger = self.get_trigger_node()
+        await trigger._stop()
+
     def trigger(self, trigger_name: str, **kwargs) -> uuid.UUID:
         trigger = self.get_trigger_node()
         task_id = uuid.uuid4()