service-forge 0.1.11__py3-none-any.whl

service_forge/workflow/workflow_callback.py

@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+import json
+from abc import abstractmethod
+from typing import TYPE_CHECKING, Any
+from typing_extensions import override
+from enum import Enum
+from .workflow_event import WorkflowResult
+from loguru import logger
+
+if TYPE_CHECKING:
+    from .node import Node
+    from .workflow import Workflow
+
+class CallbackEvent(Enum):
+    ON_WORKFLOW_START = "on_workflow_start"
+    ON_WORKFLOW_END = "on_workflow_end"
+    ON_WORKFLOW_ERROR = "on_workflow_error"
+    ON_NODE_START = "on_node_start"
+    ON_NODE_END = "on_node_end"
+    ON_NODE_OUTPUT = "on_node_output"
+    ON_NODE_STREAM_OUTPUT = "on_node_stream_output"
+
+class WorkflowCallback:
+    @abstractmethod
+    async def on_workflow_start(self, workflow: Workflow) -> None:
+        ...
+
+    @abstractmethod
+    async def on_workflow_end(self, workflow: Workflow, output: Any) -> None:
+        pass
+
+    @abstractmethod
+    async def on_workflow_error(self, workflow: Workflow, error: Any) -> None:
+        pass
+
+    @abstractmethod
+    async def on_node_start(self, node: Node) -> None:
+        ...
+
+    @abstractmethod
+    async def on_node_end(self, node: Node) -> None:
+        ...
+
+    @abstractmethod
+    async def on_node_stream_output(self, node: Node, output: Any) -> None:
+        ...
+
+class BuiltinWorkflowCallback(WorkflowCallback):
+    def __init__(self):
+        self._websocket_manager = None
+    
+    def _get_websocket_manager(self):
+        if self._websocket_manager is None:
+            from service_forge.api.routers.websocket.websocket_manager import websocket_manager
+            self._websocket_manager = websocket_manager
+        return self._websocket_manager
+    
+    def _serialize_result(self, result: Any) -> Any:
+        try:
+            json.dumps(result)
+            return result
+        except (TypeError, ValueError):
+            return str(result)
+    
+    @override
+    async def on_workflow_start(self, workflow: Workflow) -> None:
+        ...
+
+    @override
+    async def on_workflow_end(self, workflow: Workflow, output: Any) -> None:
+        workflow_result = WorkflowResult(result=output, is_end=True, is_error=False)
+        
+        if workflow.task_id in workflow.real_trigger_node.result_queues:
+            workflow.real_trigger_node.result_queues[workflow.task_id].put_nowait(workflow_result)
+        if workflow.task_id in workflow.real_trigger_node.stream_queues:
+            workflow.real_trigger_node.stream_queues[workflow.task_id].put_nowait(workflow_result)
+        
+        try:
+            manager = self._get_websocket_manager()
+            message = {
+                "type": "workflow_end",
+                "task_id": str(workflow.task_id),
+                "result": self._serialize_result(output),
+                "is_end": True,
+                "is_error": False
+            }
+            await manager.send_to_task(workflow.task_id, message)
+        except Exception as e:
+            logger.error(f"发送 workflow_end 消息到 websocket 失败: {e}")
+
+    @override
+    async def on_workflow_error(self, workflow: Workflow, error: Any) -> None:
+        workflow_result = WorkflowResult(result=error, is_end=False, is_error=True)
+        
+        if workflow.task_id in workflow.real_trigger_node.result_queues:
+            workflow.real_trigger_node.result_queues[workflow.task_id].put_nowait(workflow_result)
+        if workflow.task_id in workflow.real_trigger_node.stream_queues:
+            workflow.real_trigger_node.stream_queues[workflow.task_id].put_nowait(workflow_result)
+        
+        try:
+            manager = self._get_websocket_manager()
+            message = {
+                "type": "workflow_error",
+                "task_id": str(workflow.task_id),
+                "error": self._serialize_result(error),
+                "is_end": False,
+                "is_error": True
+            }
+            await manager.send_to_task(workflow.task_id, message)
+        except Exception as e:
+            logger.error(f"发送 workflow_error 消息到 websocket 失败: {e}")
+
+    @override
+    async def on_node_start(self, node: Node) -> None:
+        ...
+
+    @override
+    async def on_node_end(self, node: Node) -> None:
+        ...
+
+    @override
+    async def on_node_stream_output(self, node: Node, output: Any) -> None:
+        workflow_result = WorkflowResult(result=output, is_end=False, is_error=False)
+        
+        if node.workflow.task_id in node.workflow.real_trigger_node.stream_queues:
+            node.workflow.real_trigger_node.stream_queues[node.workflow.task_id].put_nowait(workflow_result)
+        
+        try:
+            manager = self._get_websocket_manager()
+            message = {
+                "type": "node_stream_output",
+                "task_id": str(node.workflow.task_id),
+                "node": node.name,
+                "output": self._serialize_result(output),
+                "is_end": False,
+                "is_error": False
+            }
+            await manager.send_to_task(node.workflow.task_id, message)
+        except Exception as e:
+            logger.error(f"发送 node_stream_output 消息到 websocket 失败: {e}")

service_forge/workflow/workflow_event.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from typing import Any
+
+class WorkflowResult:
+    def __init__(
+        self,
+        result: Any | None,
+        is_end: bool,
+        is_error: bool,
+    ) -> None:
+        # when is_end is True, result is from the output port of the workflow
+        self.result = result
+        self.is_end = is_end
+        self.is_error = is_error

service_forge/workflow/workflow_factory.py

@@ -0,0 +1,246 @@
+from omegaconf import OmegaConf
+from typing import Callable, Awaitable, AsyncIterator, Any
+from copy import deepcopy
+
+from service_forge.workflow.workflow_callback import BuiltinWorkflowCallback
+from .workflow import Workflow
+from .workflow_group import WorkflowGroup
+from .node import Node
+from .edge import Edge
+from .port import Port, parse_port_name, create_workflow_input_port, create_sub_workflow_input_port
+from .node import node_register
+from .nodes import *
+from .triggers import *
+from .context import Context
+from ..db.database import DatabaseManager
+
+WORKFLOW_KEY_NAME = 'name'
+WORKFLOW_KEY_DESCRIPTION = 'description'
+WORKFLOW_KEY_NODES = 'nodes'
+WORKFLOW_KEY_INPUTS = 'inputs'
+WORKFLOW_KEY_OUTPUTS = 'outputs'
+
+NODE_KEY_NAME = 'name'
+NODE_KEY_TYPE = 'type'
+NODE_KEY_ARGS = 'args'
+NODE_KEY_OUTPUTS = 'outputs'
+# NODE_KEY_INPUT_PORTS = 'input_ports'
+# NODE_KEY_OUTPUT_PORTS = 'output_ports'
+NODE_KEY_SUB_WORKFLOWS = 'sub_workflows'
+NODE_KEY_SUB_WORKFLOWS_INPUT_PORTS = 'sub_workflows_input_ports'
+
+PORT_KEY_NAME = 'name'
+PORT_KEY_PORT = 'port'
+PORT_KEY_VALUE = 'value'
+
+def parse_argument(arg: Any, service_env: dict[str, Any] = None) -> Any:
+    # TODO: support import variables
+    if type(arg) == str and arg.startswith(f'<{{') and arg.endswith(f'}}>'):
+        key = arg[2:-2]
+        if key not in service_env:
+            raise ValueError(f"Key {key} not found in service env.")
+        return service_env[key]
+    return arg
+
+def create_workflow(
+    config_path: str = None,
+    service_env: dict[str, Any] = None,
+    config: dict = None,
+    workflows: WorkflowGroup = None,
+    _handle_stream_output: Callable[[str, AsyncIterator[str]], Awaitable[None]] | None = None,
+    _handle_query_user: Callable[[str, str], Awaitable[str]] | None = None,
+    database_manager: DatabaseManager = None,
+) -> Workflow:
+    if config is None:
+        if config_path is None:
+            raise ValueError("Either config_path or config must be provided")
+        config = OmegaConf.to_object(OmegaConf.load(config_path))
+
+    if WORKFLOW_KEY_NAME not in config:
+        if config_path is None:
+            raise ValueError(f"{WORKFLOW_KEY_NAME} is required in workflow config in {config}.")
+        else:
+            raise ValueError(f"{WORKFLOW_KEY_NAME} is required in workflow config at {config_path}.")
+    
+    if WORKFLOW_KEY_DESCRIPTION not in config:
+        config[WORKFLOW_KEY_DESCRIPTION] = ""
+
+    workflow = Workflow(
+        name = config[WORKFLOW_KEY_NAME],
+        description = config[WORKFLOW_KEY_DESCRIPTION],
+        nodes = [],
+        input_ports = [],
+        output_ports = [],
+        _handle_stream_output = _handle_stream_output,
+        _handle_query_user = _handle_query_user,
+        database_manager = database_manager,
+        # TODO: max_concurrent_runs
+        callbacks = [BuiltinWorkflowCallback()],
+    )
+
+    nodes: dict[str, Node] = {}
+
+    # Nodes
+    for node_config in config[WORKFLOW_KEY_NODES]:
+        params = {
+            "name": node_config[NODE_KEY_NAME],
+        }
+        
+        node: Node = node_register.instance(node_config[NODE_KEY_TYPE], ignore_keys=['type'], kwargs=params)
+
+        # Context
+        node.context = Context(variables = {})
+
+        # Input ports
+        node.input_ports = deepcopy(node.DEFAULT_INPUT_PORTS)
+        for input_port in node.input_ports:
+            input_port.node = node
+
+        # Output ports
+        node.output_ports = deepcopy(node.DEFAULT_OUTPUT_PORTS)
+        for output_port in node.output_ports:
+            output_port.node = node
+        
+        # Sub workflows
+        if node_key_sub_workflows := node_config.get(NODE_KEY_SUB_WORKFLOWS, None):
+            sub_workflows: WorkflowGroup = WorkflowGroup(workflows=[])
+            for sub_workflow_config in node_key_sub_workflows:
+                sub_workflow = workflows.get_workflow(sub_workflow_config['name'])
+                sub_workflows.add_workflow(deepcopy(sub_workflow))
+            node.sub_workflows = sub_workflows
+
+        # Sub workflows input ports
+        if node_key_sub_network_input_ports := node_config.get(NODE_KEY_SUB_WORKFLOWS_INPUT_PORTS, None):
+            for sub_workflow_input_port_config in node_key_sub_network_input_ports:
+                name = sub_workflow_input_port_config[PORT_KEY_NAME]
+                sub_workflow_name, sub_workflow_port_name = parse_port_name(sub_workflow_input_port_config[PORT_KEY_PORT])
+                sub_workflow = node.sub_workflows.get_workflow(sub_workflow_name)
+                if sub_workflow is None:
+                    raise ValueError(f"{sub_workflow_name} is not a valid sub workflow.")
+                sub_workflow_port = sub_workflow.get_input_port_by_name(sub_workflow_port_name)
+                if sub_workflow_port is None:
+                    raise ValueError(f"{sub_workflow_port_name} is not a valid input port.")
+                value = sub_workflow_input_port_config.get(PORT_KEY_VALUE, None)
+                node.input_ports.append(create_sub_workflow_input_port(name=name, node=node, port=sub_workflow_port, value=value))
+
+        # Sub workflows output ports
+        ...
+
+        # Hooks
+        if _handle_query_user is None:
+            node.query_user = workflow.handle_query_user
+        else:
+            node.query_user = _handle_query_user
+
+        nodes[node_config[NODE_KEY_NAME]] = node
+
+    # Edges
+    for node_config in config[WORKFLOW_KEY_NODES]:
+        start_node = nodes[node_config[NODE_KEY_NAME]]
+        if NODE_KEY_OUTPUTS in node_config and node_config[NODE_KEY_OUTPUTS]:
+            for key, value in node_config[NODE_KEY_OUTPUTS].items():
+                if value is None:
+                    continue
+
+                if type(value) is str:
+                    value = [value]
+
+                for edge_value in value:
+                    end_node_name, end_port_name = parse_port_name(edge_value)
+                    end_node = nodes[end_node_name]
+
+                    start_node.try_create_extended_output_port(key)
+                    end_node.try_create_extended_input_port(end_port_name)
+
+                    start_port = start_node.get_output_port_by_name(key)
+                    end_port = end_node.get_input_port_by_name(end_port_name)
+
+                    if start_port is None:
+                        raise ValueError(f"{key} is not a valid output port.")
+                    if end_port is None:
+                        raise ValueError(f"{end_port_name} is not a valid input port.")
+
+                    edge = Edge(start_node, end_node, start_port, end_port)
+
+                    start_node.output_edges.append(edge)
+                    end_node.input_edges.append(edge)
+
+    workflow.add_nodes(list(nodes.values()))
+    
+    # Inputs
+    if workflow_key_inputs := config.get(WORKFLOW_KEY_INPUTS, None):
+        for port_config in workflow_key_inputs:
+            name = port_config[PORT_KEY_NAME]
+            node_name, node_port_name = parse_port_name(port_config[PORT_KEY_PORT])
+            if node_name not in nodes:
+                raise ValueError(f"{node_name} is not a valid node.")
+            node = nodes[node_name]
+            port = node.get_input_port_by_name(node_port_name)
+            if port is None:
+                raise ValueError(f"{node_port_name} is not a valid input port.")
+            value = port_config.get(PORT_KEY_VALUE, None)
+            workflow.input_ports.append(create_workflow_input_port(name=name, port=port, value=value))
+
+    # Outputs
+    if workflow_key_outputs := config.get(WORKFLOW_KEY_OUTPUTS, None):
+        for port_config in workflow_key_outputs:
+            name = port_config[PORT_KEY_NAME]
+            node_name, node_port_name = parse_port_name(port_config[PORT_KEY_PORT])
+            if node_name not in nodes:
+                raise ValueError(f"{node_name} is not a valid node.")
+            node = nodes[node_name]
+            port = node.get_output_port_by_name(node_port_name)
+            if port is None:
+                raise ValueError(f"{node_port_name} is not a valid output port.")
+            output_port = Port(name=name, type=Any, port=port)
+            workflow.output_ports.append(output_port)
+            edge = Edge(node, None, port, output_port)
+            node.output_edges.append(edge)
+
+    for node_config in config[WORKFLOW_KEY_NODES]:
+        node = nodes[node_config[NODE_KEY_NAME]]
+        # Arguments
+        if node_key_args := node_config.get(NODE_KEY_ARGS, None):
+            for key, value in node_key_args.items():
+                node.fill_input_by_name(key, parse_argument(value, service_env=service_env))
+
+    return workflow
+
+def create_workflows(
+    config_path: str = None,
+    service_env: dict[str, Any] = None,
+    config: dict = None,
+    _handle_stream_output: Callable[[str, AsyncIterator[str]], Awaitable[None]] = None,
+    _handle_query_user: Callable[[str, str], Awaitable[str]] = None,
+    database_manager: DatabaseManager = None,
+) -> WorkflowGroup:
+    WORKFLOW_KEY_WORKFLOWS = 'workflows'
+    WORKFLOW_KEY_MAIN_WORKFLOW_NAME = 'main'
+
+    if config is None:
+        if config_path is None:
+            raise ValueError("Either config_path or config must be provided")
+        config = OmegaConf.to_object(OmegaConf.load(config_path))
+
+    if WORKFLOW_KEY_WORKFLOWS not in config:
+        workflow = create_workflow(
+            config_path=config_path if config_path else None,
+            config=config,
+            service_env=service_env,
+            _handle_stream_output=_handle_stream_output,
+            _handle_query_user=_handle_query_user,
+            database_manager=database_manager,
+        )
+        return WorkflowGroup(workflows=[workflow], main_workflow_name=workflow.name)
+
+    workflows = WorkflowGroup(workflows=[], main_workflow_name=config.get(WORKFLOW_KEY_MAIN_WORKFLOW_NAME, None))
+    for workflow_config in config[WORKFLOW_KEY_WORKFLOWS]:
+        workflows.add_workflow(create_workflow(
+            config=workflow_config,
+            workflows=workflows,
+            service_env=service_env,
+            _handle_stream_output=_handle_stream_output,
+            _handle_query_user=_handle_query_user,
+            database_manager=database_manager,
+        ))
+    return workflows

service_forge/workflow/workflow_group.py

@@ -0,0 +1,27 @@
+from service_forge.workflow.workflow import Workflow
+
+class WorkflowGroup:
+    def __init__(self, workflows: list[Workflow], main_workflow_name: str = "main") -> None:
+        self.workflows = workflows
+        self.main_workflow_name = main_workflow_name
+
+    def add_workflow(self, workflow: Workflow) -> None:
+        self.workflows.append(workflow)
+
+    def get_workflow(self, name: str) -> Workflow | None:
+        for workflow in self.workflows:
+            if workflow.name == name:
+                return workflow
+        return None
+
+    def get_main_workflow(self) -> Workflow:
+        return self.get_workflow(self.main_workflow_name)
+
+    async def run(self, name: str = None) -> None:
+        if name is None:
+            workflow = self.get_main_workflow()
+        else:
+            workflow = self.get_workflow(name)
+        if workflow is None:
+            raise ValueError(f"Workflow with name {name} not found in workflow group.")
+        await workflow.run()

service_forge/workflow/workflow_type.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+import os
+import importlib
+import inspect
+from pathlib import Path
+from typing import Type, Any
+
+from service_forge.utils.register import Register
+
+class WorkflowType:
+    CLASS_NOT_REQUIRED_TO_REGISTER = ['WorkflowType']
+
+    def __init__(self, name: str, type: type) -> None:
+        self.name = name
+        self.type = type
+
+    def __init_subclass__(cls) -> None:
+        if cls.__name__ not in WorkflowType.CLASS_NOT_REQUIRED_TO_REGISTER:
+            workflow_type_register.register(cls.__name__, cls)
+        return super().__init_subclass__()
+
+workflow_type_register = Register[WorkflowType]()
+
+def _load_proto_classes():
+    # TODO: load from config
+    proto_dir = Path(__file__).parent.parent / "proto"
+    
+    if not proto_dir.exists():
+        return
+    
+    for py_file in proto_dir.glob("*.py"):
+        if py_file.name == "__init__.py":
+            continue
+            
+        module_name = py_file.stem
+        module_path = f"service_forge.proto.{module_name}"
+        
+        try:
+            module = importlib.import_module(module_path)
+            
+            for name, obj in inspect.getmembers(module, inspect.isclass):
+                if (not name.startswith('_') and 
+                    obj.__module__ == module_path and
+                    hasattr(obj, '__bases__')):
+                    
+                    workflow_type = WorkflowType(name, obj)
+                    workflow_type_register.register(name, workflow_type)
+                    
+        except Exception as e:
+            print(f"Failed to load module {module_path}: {e}")
+
+_load_proto_classes()

service_forge-0.1.11.dist-info/METADATA

@@ -0,0 +1,98 @@
+Metadata-Version: 2.4
+Name: service-forge
+Version: 0.1.11
+Summary: Add your description here
+Author-email: euxcet <zcc.qwer@gmail.com>
+Requires-Python: >=3.11
+Requires-Dist: a2a-sdk>=0.3.22
+Requires-Dist: aiokafka>=0.12.0
+Requires-Dist: alembic>=1.17.0
+Requires-Dist: asyncpg>=0.30.0
+Requires-Dist: dotenv>=0.9.9
+Requires-Dist: fastapi>=0.119.1
+Requires-Dist: greenlet>=3.2.4
+Requires-Dist: jinja2>=3.1.6
+Requires-Dist: kubernetes>=28.0.0
+Requires-Dist: loguru>=0.7.3
+Requires-Dist: omegaconf>=2.3.0
+Requires-Dist: openai>=2.3.0
+Requires-Dist: protobuf>=6.33.1
+Requires-Dist: psycopg2-binary>=2.9.11
+Requires-Dist: pydantic>=2.12.0
+Requires-Dist: pymongo>=4.15.5
+Requires-Dist: pytest-asyncio>=1.2.0
+Requires-Dist: pytest>=8.4.2
+Requires-Dist: python-dotenv>=1.1.1
+Requires-Dist: python-jose>=3.5.0
+Requires-Dist: python-multipart>=0.0.20
+Requires-Dist: redis>=7.1.0
+Requires-Dist: requests>=2.32.5
+Requires-Dist: restrictedpython>=8.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: sqlalchemy>=2.0.44
+Requires-Dist: typer>=0.12.0
+Requires-Dist: uvicorn>=0.38.0
+Requires-Dist: websockets>=15.0.1
+Description-Content-Type: text/markdown
+
+# Service Forge
+
+Automated service creation and maintenance tool.
+
+## Install
+
+```bash
+pip install -e .
+```
+
+## CLI Usage (sft)
+
+Service Forge 提供了命令行工具 `sft` 用于服务管理。
+
+### 服务上传和部署
+
+```bash
+# 上传服务（打包并上传到服务器）
+sft upload [project_path]
+
+# 列出本地已打包的服务包
+sft list
+
+# 部署服务（只在服务器上使用）
+sft deploy <name> <version>
+```
+
+### 配置管理
+
+```bash
+# 列出所有配置项
+sft config list
+
+# 获取指定配置项的值
+sft config get <key>
+
+# 设置配置项的值
+sft config set <key> <value>
+```
+
+### 服务管理
+
+```bash
+# 列出所有服务
+sft service list
+
+# 删除服务（只在服务器上使用）
+sft service delete <service_name> [--force, -f]
+
+# 查看服务日志（只在服务器上使用）
+sft service logs <service_name> [--container, -c] [--tail, -n] [--follow, -f] [--previous, -p]
+```
+
+## TODO
+
+- [x] 多次 trigger 并行执行
+- [x] 支持 websocket 来做 trigger、输入和输出
+- [x] 优化 websocket 客户端映射和重连支持
+- [x] 节点和 workflow 运行情况的回调函数
+- [ ] 支持 a2a
+- [ ] workflow 执行异常处理

service_forge-0.1.11.dist-info/RECORD

@@ -0,0 +1,75 @@
+service_forge/service.py,sha256=D4lrpCrohUaG1lM2YdN1sfDVU_7EU1E01zonbZyktnk,12288
+service_forge/service_config.py,sha256=3r0uQeysCcAuiotQcs8zUhfNrKk1Aky2zIasbyGQLlc,5003
+service_forge/api/deprecated_websocket_api.py,sha256=E36-fpUPxzMJ2YGlCPeqwRbryk2FMMbQD_pbb8k1FYI,3343
+service_forge/api/deprecated_websocket_manager.py,sha256=Xiwg3zwXRVi63sXmVH-TgbpL2XH_djyLeo96STm4cNM,16757
+service_forge/api/http_api.py,sha256=RePGdIpxxWj3ZDMgbxa7-tpCFuMmtgRefUpZXo6TBD0,5488
+service_forge/api/http_api_doc.py,sha256=ASlxvsIiUzDcMhVoumRjt9CfEMbh0O1U4ZLC9eobLF8,20235
+service_forge/api/kafka_api.py,sha256=PInx2ZzKJRON7EaJFWroXkiOt_UeZY7WE6qK03gq4ak,4599
+service_forge/api/task_manager.py,sha256=9Lk-NV4cBnuv9b8V6GVLWJJ4MCiAwCp5TVAwmYgqXbs,5269
+service_forge/api/routers/service/__init__.py,sha256=hnoXBAxOzqCxtDHwoFNd6F1Yg6oGR3EHZhzrwjg1Dq4,130
+service_forge/api/routers/service/service_router.py,sha256=E6mPMVx6dOn515h1m125n--fmAjb1z5ZatZDYjp7iNQ,5381
+service_forge/api/routers/websocket/websocket_manager.py,sha256=j1AFqzXQhZZyaLQwhvZefXAS-zCOPzLcRMDEuusv6V0,3605
+service_forge/api/routers/websocket/websocket_router.py,sha256=V0B7eQP8toO94-WbTrGraadXD3qeZ9lnKFcxwx6kLgM,3777
+service_forge/db/__init__.py,sha256=EWLhH8bYsMOvRF_YXF6FgL3irKA6GZeLxSGvWDRM6f8,85
+service_forge/db/database.py,sha256=JrfBjvLZT7Op-rSqbRJgNDikVGVasQCmx3mzg_HtIxA,9850
+service_forge/llm/__init__.py,sha256=9sB5uqp2F8AboYV4jAvOQfMkVMWM811sUxBahJJ-_fE,2868
+service_forge/llm/llm.py,sha256=Sar99FkTPBJqkB6dwX81ww_hJp8cPYxlg7Go-zXPyg0,1865
+service_forge/model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+service_forge/model/websocket.py,sha256=YIUCW32sbHIEFPHjk5FiDM_rDe2aVD6OpzBQul2R5IM,267
+service_forge/proto/foo_input.py,sha256=-POJZSIFrGdBGz7FqZZ03r5uztpc5Apin9A0Yxbk6YI,90
+service_forge/sft/cli.py,sha256=stB_YPhZ7gAQeOxIq03-tLyl5VfU-gnRacAT05GSMis,2904
+service_forge/sft/cmd/config_command.py,sha256=I9t2HG28S6lCXpExHyZUc47b_1yB3i51tCFVk5J6TTU,2382
+service_forge/sft/cmd/deploy_service.py,sha256=5IYbCVI0Nlry1KXBhm9leJmr2bzUEXrSY-2BympLR0c,4686
+service_forge/sft/cmd/list_tars.py,sha256=Z3zvu2JLb_wNbTwi5TZXL5cZ8PxYrKks9AxkOzoUd_Q,1380
+service_forge/sft/cmd/service_command.py,sha256=69GMMN61KtuoEFuYzFJ74ivNt8RX8q0I6rbePfJfEwQ,5538
+service_forge/sft/cmd/upload_service.py,sha256=86PvvJSXCZKH4BU6rLytuc45grX-sRnQnOHCo9zUaPY,1232
+service_forge/sft/config/injector.py,sha256=T2MgQvrle6yDDDSFH8vQm6Yh_LbH-9C4nxAUA7QLrq8,5269
+service_forge/sft/config/injector_default_files.py,sha256=aTMQ2Tla3wdpvdaD_5VP2X6oeZbI0X414FM9NbirnO4,2716
+service_forge/sft/config/sf_metadata.py,sha256=Y9akhSCgOd11-oqRs3LIs8FL9pvWNw6hyy57fuFcBhc,866
+service_forge/sft/config/sft_config.py,sha256=-Wmsl0b2SE97yyWnPdv8SKyorV3Yc-DbGeOPU4fTIDY,5346
+service_forge/sft/file/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+service_forge/sft/file/ignore_pattern.py,sha256=UrVmR83wOx51XHFcZDTPp15dGYcvMTE5W1m07-SvHpw,2521
+service_forge/sft/file/sft_file_manager.py,sha256=poIM77tZZg7vfwBdCsdQctBbCczVLQePdTwVINEABvE,4337
+service_forge/sft/kubernetes/kubernetes_manager.py,sha256=IF2_X9U-k5Dx7EZuGrJ9lZ85ltbilrrZDfsl8qFyTu4,11339
+service_forge/sft/util/assert_util.py,sha256=8HreVkOzs9_ClKiFqG4qsFn_yyDLo5uXYhYUPXlmDjM,828
+service_forge/sft/util/logger.py,sha256=0Hi74IoxshE-wBgvBa2EZPXYj37tTrUYwlOBd9UMMMs,502
+service_forge/sft/util/name_util.py,sha256=WSYHM6c7SZULXCFON7nmGqsvAPPs_wavd6QjCa4UbRQ,301
+service_forge/sft/util/yaml_utils.py,sha256=9OhJNQlzj_C1NeQoUZVF8qpDovrE7RDWtNXe-H7tuNA,1703
+service_forge/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+service_forge/utils/default_type_converter.py,sha256=CuUZpMATdTwgcV1M3lbK64znwmEG85Zt3y_QGXr9tYQ,625
+service_forge/utils/register.py,sha256=nxiGQBCX238FoZZhsDoDdBMv_2QzeIZpM367HPNfaqM,874
+service_forge/utils/type_converter.py,sha256=IRphYxyGA0ICwFvDMvqAnRnSUTpY2ZQXvTE5o99CKpo,3046
+service_forge/utils/workflow_clone.py,sha256=rajbRrEuSkxATWn1-jZiYn_S9OypGMKUSpXayl7n0cM,4563
+service_forge/workflow/__init__.py,sha256=9oh4qPyA33RugrUYRAlLmFtmQPUN2wxruFQE3omTJF8,49
+service_forge/workflow/context.py,sha256=1PotSEN_l8Emd5p8_6mtXJngXGYd3NSbOs1EKHgvnlo,346
+service_forge/workflow/edge.py,sha256=88Ex-9_dHAGD38OHgiqP0DrfxK0FrhvDAxThR3ilUi4,627
+service_forge/workflow/node.py,sha256=jPzXuixmZBL6-_jjXikFZmierlu3SOBJOSdQxTyV0FY,7536
+service_forge/workflow/port.py,sha256=JVj0JrnQeOWCsp7n48Cm03bfmO8r3V5oTSEsC-HTGPE,2967
+service_forge/workflow/trigger.py,sha256=1XYY-zk_3ei53lA8UfBw6IQGfLkQDrSY4rhVrfhHEWA,796
+service_forge/workflow/workflow.py,sha256=KzfPhbJLkoIb6wBQLTPthVjJ5lYXaMF2QhmA3rb7PTk,7939
+service_forge/workflow/workflow_callback.py,sha256=S__F7s-7l5LgkIXcZMcG68qCyc8NgdWQX81F0hKWL1U,5135
+service_forge/workflow/workflow_event.py,sha256=QG1VFJwUUF1bTKKPKvqBICnYxkBwpfYDEoAuxwQYhhE,371
+service_forge/workflow/workflow_factory.py,sha256=ecaOI26KHdm2ho-niZcEnZpLacb3kML-6Pb4i9cDK1A,10202
+service_forge/workflow/workflow_group.py,sha256=ZZJpK92JyKjrLflNY0MRis1WUcB4Pkgde-UxWZW-IiY,977
+service_forge/workflow/workflow_type.py,sha256=zRc-gL2LBE-gOgTUCU5-VDWeGUzuQahkHIg98ipEvQg,1629
+service_forge/workflow/nodes/__init__.py,sha256=AUOoFUAMgRwfLiHNkjnDnWToMSe2AeV5vJO3NCG1eLw,381
+service_forge/workflow/nodes/control/if_node.py,sha256=fBRnSsz0SHW5Hcf4993Y1PsUOUt2Cg9I_zcduHUnMuI,643
+service_forge/workflow/nodes/control/switch_node.py,sha256=27mxdcQijSawNM5Fx6LdC1MB66vAoLAAI74DQyfqPqI,708
+service_forge/workflow/nodes/input/console_input_node.py,sha256=GhQjWRgYy3aRfYUfaEql-_Xi10cca75oz-vmSZkR54w,683
+service_forge/workflow/nodes/llm/query_llm_node.py,sha256=uwcWO6Q-qAG16yJqEGLJau8YxcJBGsBJoGVUBQTBWZk,1155
+service_forge/workflow/nodes/nested/workflow_node.py,sha256=h5NXhRCUGaoNmqMV2PXR6JNwTCM8MCRVA6ocOjoDzhs,747
+service_forge/workflow/nodes/output/kafka_output_node.py,sha256=mC6qRMGsuwU6qXAfXA-0ZFZudrlwmgRYOJRULUrtH40,682
+service_forge/workflow/nodes/output/print_node.py,sha256=OSgeRQOd3dq88a1plx30g9-VB793RbXnIa5X8MF9fCo,656
+service_forge/workflow/nodes/test/if_console_input_node.py,sha256=CtKHkFqr8PN974_iGP2VSBmNpXZ-KumRHCpoRR5RyF8,956
+service_forge/workflow/nodes/test/time_consuming_node.py,sha256=gB2qw2DdjRf82z1158u36nSnCHrheHaxscAzPRnXNyk,1813
+service_forge/workflow/triggers/__init__.py,sha256=iQ0WEYu6JgL191Y9XslMhZ7jS7JO8bL3SZ9YqIw5LCM,269
+service_forge/workflow/triggers/a2a_api_trigger.py,sha256=TCFNRKlj6rXjPU2pjTD0HCpYgs_o6KcwCat9byxvq1s,8520
+service_forge/workflow/triggers/fast_api_trigger.py,sha256=uRlDAh5PmaLE3fGnXhs825HmLJ1oxCiQ93rIqe4orSc,6093
+service_forge/workflow/triggers/kafka_api_trigger.py,sha256=jGnb4dkvh01Jy3CIOvgcQQ3RjsCZCGyXp2NxzCUrd6Y,1498
+service_forge/workflow/triggers/once_trigger.py,sha256=X0MidqEDNATzYEQY_MwpwKEqgzBFn1lc9q8ci14Mpt8,508
+service_forge/workflow/triggers/period_trigger.py,sha256=WE55k5ZpCmu666MPPQC5XSP_L_OzGlwt7v8mAnw4Qas,703
+service_forge/workflow/triggers/websocket_api_trigger.py,sha256=a7rJpdEMcrkdsJ0FtFUJOeFf2sn93dEmH9hhvCj16CI,6731
+service_forge-0.1.11.dist-info/METADATA,sha256=45d_RyoVahkhRu_vqCdrfRANTAKtEAWanK58eJie2GM,2308
+service_forge-0.1.11.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+service_forge-0.1.11.dist-info/entry_points.txt,sha256=WHntHW7GAyKQUEeMcMvHDZ7_xAb0-cZeAK4iJeu9lm8,51
+service_forge-0.1.11.dist-info/RECORD,,

service_forge-0.1.11.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

service_forge-0.1.11.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+sft = service_forge.sft.cli:main