service-forge 0.1.18__py3-none-any.whl

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/default_type_converter.py

@@ -0,0 +1,12 @@
+from ..utils.type_converter import TypeConverter
+from ..workflow.workflow import Workflow
+from ..api.http_api import fastapi_app
+from ..api.kafka_api import KafkaApp, kafka_app
+from fastapi import FastAPI
+from ..workflow.workflow_type import WorkflowType, workflow_type_register
+
+type_converter = TypeConverter()
+type_converter.register(str, Workflow, lambda s, node: node.sub_workflows.get_workflow(s))
+type_converter.register(str, FastAPI, lambda s, node: fastapi_app)
+type_converter.register(str, KafkaApp, lambda s, node: kafka_app)
+type_converter.register(str, type, lambda s, node: workflow_type_register.items[s].type)

service_forge/utils/register.py

@@ -0,0 +1,39 @@
+from typing import TypeVar, Generic, Any
+from loguru import logger
+
+T = TypeVar('T')
+
+class Register(Generic[T]):
+  def __init__(self) -> None:
+    self.items:dict[str, T] = {}
+
+  def register(
+      self,
+      name: str,
+      item: T,
+      show_info_log: bool = False,
+  ) -> None:
+    if name not in self.items:
+      self.items[name] = item
+      if show_info_log:
+        logger.info(f'Register {name}.')
+    else:
+      logger.warning(f'{name} has been registered.')
+
+  def instance(
+      self,
+      name: str,
+      kwargs: dict[str, Any] = {},
+      ignore_keys: list[str] = []
+  ) -> None:
+    for key in ignore_keys:
+      try:
+        kwargs.pop(key)
+      except:
+        pass
+    if name not in self.items:
+      logger.error(f'{name} has not been registered.')
+    return self.items[name](**kwargs)
+  
+  def __len__(self) -> int:
+    return len(self.items)

service_forge/utils/type_converter.py

@@ -0,0 +1,99 @@
+from typing import Any, Callable, Type, Dict, Tuple, Set, List
+from collections import deque
+import inspect
+from typing_extensions import get_origin, get_args
+
+def is_type(value, dst_type):
+    origin = get_origin(dst_type)
+    if origin is None:
+        return isinstance(value, dst_type)
+    
+    if not isinstance(value, origin):
+        return False
+    
+    args = get_args(dst_type)
+    if not args:
+        return True
+    
+    if origin is list:
+        elem_type = args[0]
+        return all(is_type(item, elem_type) for item in value)
+    elif origin is dict:
+        key_type, value_type = args
+        return all(
+            is_type(k, key_type) and is_type(v, value_type)
+            for k, v in value.items()
+        )
+    
+    return True
+
+class TypeConverter:
+    def __init__(self):
+        self._registry: Dict[Tuple[Type, Type], Callable[..., Any]] = {}
+
+    def register(self, src_type: Type, dst_type: Type, func: Callable[..., Any]):
+        self._registry[(src_type, dst_type)] = func
+
+    def can_convert(self, src_type: Type, dst_type: Type) -> bool:
+        return self._find_path(src_type, dst_type) is not None
+
+    def convert(self, value: Any, dst_type: Type, **kwargs) -> Any:
+        if value is None:
+            return None
+        
+        if dst_type == Any:
+            return value
+
+        src_type = type(value)
+
+        if is_type(value, dst_type):
+            return value
+
+        if (src_type, dst_type) in self._registry:
+            return self._call_func(self._registry[(src_type, dst_type)], value, **kwargs)
+
+        try:
+            return dst_type(value)
+        except Exception:
+            pass
+
+        path = self._find_path(src_type, dst_type)
+        if not path:
+            raise TypeError(f"No conversion path found from {src_type.__name__} to {dst_type.__name__}.")
+
+        result = value
+        for i in range(len(path) - 1):
+            func = self._registry[(path[i], path[i + 1])]
+            result = self._call_func(func, result, **kwargs)
+        return result
+
+    def _call_func(self, func: Callable[..., Any], value: Any, **kwargs) -> Any:
+        sig = inspect.signature(func)
+        if len(sig.parameters) == 1:
+            return func(value)
+        else:
+            return func(value, **kwargs)
+
+    def _find_path(self, src_type: Type, dst_type: Type) -> List[Type] | None:
+        if src_type == dst_type:
+            return [src_type]
+
+        graph: Dict[Type, Set[Type]] = {}
+        for (s, d) in self._registry.keys():
+            graph.setdefault(s, set()).add(d)
+
+        queue = deque([[src_type]])
+        visited = {src_type}
+
+        while queue:
+            path = queue.popleft()
+            current = path[-1]
+            for neighbor in graph.get(current, []):
+                if neighbor in visited:
+                    continue
+                new_path = path + [neighbor]
+                if neighbor == dst_type:
+                    return new_path
+                queue.append(new_path)
+                visited.add(neighbor)
+        return None

service_forge/utils/workflow_clone.py

@@ -0,0 +1,124 @@
+from __future__ import annotations
+
+import uuid
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from service_forge.workflow.node import Node
+    from service_forge.workflow.port import Port
+    from service_forge.workflow.edge import Edge
+    from service_forge.workflow.workflow import Workflow
+    from service_forge.workflow.trigger import Trigger
+    from service_forge.workflow.context import Context
+
+def workflow_clone(self: Workflow, task_id: uuid.UUID, trigger_node: Trigger) -> Workflow:
+    from service_forge.workflow.workflow import Workflow
+
+    if self.nodes is not None and len(self.nodes) > 0:
+        context = self.nodes[0].context._clone()
+    else:
+        context = Context(variables={})
+
+    node_map: dict[Node, Node] = {node: node._clone(context) for node in self.nodes}
+
+    port_map: dict[Port, Port] = {}
+    port_map.update({port: port._clone(node_map) for port in self.input_ports})
+    port_map.update({port: port._clone(node_map) for port in self.output_ports})
+    for node in self.nodes:
+        for port in node.input_ports:
+            if port not in port_map:
+                port_map[port] = port._clone(node_map)
+        for port in node.output_ports:
+            if port not in port_map:
+                port_map[port] = port._clone(node_map)
+
+    edge_map: dict[Edge, Edge] = {}
+    for node in self.nodes:
+        for edge in node.input_edges:
+            if edge not in edge_map:
+                edge_map[edge] = edge._clone(node_map, port_map)
+        for edge in node.output_edges:
+            if edge not in edge_map:
+                edge_map[edge] = edge._clone(node_map, port_map)
+
+    # fill port.port
+    for old_port, new_port in port_map.items():
+        if old_port.port is not None:
+            new_port.port = port_map[old_port.port]
+
+
+    # fill ports and edges in nodes
+    for old_node, new_node in node_map.items():
+        new_node.input_edges = [edge_map[edge] for edge in old_node.input_edges]
+        new_node.output_edges = [edge_map[edge] for edge in old_node.output_edges]
+        new_node.input_ports = [port_map[port] for port in old_node.input_ports]
+        new_node.output_ports = [port_map[port] for port in old_node.output_ports]
+        new_node.input_variables = {
+            port_map[port]: value for port, value in old_node.input_variables.items()
+        }
+
+    workflow = Workflow(
+        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],
+        _handle_stream_output=self._handle_stream_output,
+        _handle_query_user=self._handle_query_user,
+        database_manager=self.database_manager,
+        max_concurrent_runs=self.max_concurrent_runs,
+        callbacks=self.callbacks,
+        task_id=task_id,
+        real_trigger_node=trigger_node,
+    )
+
+    for node in workflow.nodes:
+        node.workflow = workflow
+
+    return workflow
+
+def port_clone(self: Port, node_map: dict[Node, Node]) -> Port:
+    from service_forge.workflow.port import Port
+    node = node_map[self.node] if self.node is not None else None
+    port = Port(
+        name=self.name,
+        type=self.type,
+        node=node,
+        port=None,
+        value=self.value,
+        default=self.default,
+        is_extended=self.is_extended,
+        is_extended_generated=self.is_extended_generated,
+    )
+    port.is_prepared = self.is_prepared
+    return port
+
+def node_clone(self: Node, context: Context) -> Node:
+    node = self.__class__(
+        name=self.name
+    )
+    node.context = context
+    node.input_edges = []
+    node.output_edges = []
+    node.input_ports = []
+    node.output_ports = []
+    node.query_user = self.query_user
+    node.workflow = None
+
+    if self.sub_workflows is not None:
+        raise ValueError("Sub workflows are not supported in node clone.")
+    node.sub_workflows = None
+    node.input_variables = {}
+    node.num_activated_input_edges = self.num_activated_input_edges
+
+    return node
+
+def edge_clone(self: Edge, node_map: dict[Node, Node], port_map: dict[Port, Port]) -> Edge:
+    from service_forge.workflow.edge import Edge
+    start_node = node_map[self.start_node] if self.start_node is not None else None
+    end_node = node_map[self.end_node] if self.end_node is not None else None
+    return Edge(
+        start_node=start_node,
+        end_node=end_node,
+        start_port=port_map[self.start_port],
+        end_port=port_map[self.end_port],
+    )

service_forge/workflow/__init__.py

@@ -0,0 +1 @@
+from .workflow_type import workflow_type_register

service_forge/workflow/context.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+from typing import Any
+
+class Context():
+    def __init__(
+        self,
+        variables: dict[Any, Any] = dict(),
+    ) -> None:
+        self.variables = variables
+
+    def _clone(self) -> Context:
+        return Context(
+            variables={key: value for key, value in self.variables.items()},
+        )

service_forge/workflow/edge.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+from ..utils.workflow_clone import edge_clone
+
+if TYPE_CHECKING:
+    from .node import Node
+    from .port import Port
+
+class Edge:
+    def __init__(
+        self,
+        start_node: Node,
+        end_node: Node,
+        start_port: Port,
+        end_port: Port,
+    ) -> None:
+        self.start_node = start_node
+        self.end_node = end_node
+        self.start_port = start_port
+        self.end_port = end_port
+
+    def _clone(self, node_map: dict[Node, Node], port_map: dict[Port, Port]) -> Edge:
+        return edge_clone(self, node_map, port_map)