service-forge 0.1.11__py3-none-any.whl

service_forge/llm/__init__.py

@@ -0,0 +1,62 @@
+import os
+from .llm import LLM
+from enum import Enum
+from typing import Iterator
+
+_llm_dicts = {}
+
+class Model(Enum):
+    GPT_4_1_NANO = "gpt-4.1-nano"
+    QWEN_TURBO_LATEST = "qwen-turbo-latest"
+    QWEN_PLUS_LATEST = "qwen-plus-latest"
+    QWEN_MAX_LATEST = "qwen-max-latest"
+    DOUBO_SEED_1_6_250615 = "doubao-seed-1-6-250615"
+    DOUBO_SEED_1_6_THINKING_250615 = "doubao-seed-1-6-thinking-250615"
+    DOUBO_SEED_1_6_FLASH_250615 = "doubao-seed-1-6-flash-250615"
+    DEEPSEEK_V3_250324 = "deepseek-v3-250324"
+    AZURE_GPT_4O_MINI = "azure-gpt-4o-mini"
+
+    def provider(self) -> str:
+        if self.value.startswith("gpt"):
+            return "openai"
+        elif self.value.startswith("qwen"):
+            return "dashscope"
+        elif self.value.startswith("doubao"):
+            return "doubao"
+        elif self.value.startswith("deepseek"):
+            return "deepseek"
+        elif self.value.startswith("azure"):
+            return "azure"
+        raise ValueError(f"Invalid model: {self.value}")
+
+def get_model(model: str) -> Model:
+    if model in Model.__members__:
+        return Model[model]
+
+    model = model.upper().replace("-", "_")
+    if model in Model.__members__:
+        return Model[model]
+
+    raise ValueError(f"Invalid model: {model}")
+            
+def get_llm(provider: str) -> LLM:
+    if provider not in _llm_dicts:
+        if provider == "openai":
+            _llm_dicts[provider] = LLM(os.environ.get("OPENAI_API_KEY", ""), os.environ.get("OPENAI_BASE_URL", ""), int(os.environ.get("OPENAI_TIMEOUT", 2000)))
+        elif provider == "doubao":
+            _llm_dicts[provider] = LLM(os.environ.get("DOUBAO_API_KEY", ""), os.environ.get("DOUBAO_BASE_URL", ""), int(os.environ.get("DOUBAO_TIMEOUT", 2000)))
+        elif provider == "dashscope":
+            _llm_dicts[provider] = LLM(os.environ.get("DASHSCOPE_API_KEY", ""), os.environ.get("DASHSCOPE_BASE_URL", ""), int(os.environ.get("DASHSCOPE_TIMEOUT", 2000)))
+        elif provider == "deepseek":
+            _llm_dicts[provider] = LLM(os.environ.get("DEEPSEEK_API_KEY", ""), os.environ.get("DEEPSEEK_BASE_URL", ""), int(os.environ.get("DEEPSEEK_TIMEOUT", 2000)))
+        elif provider == "azure":
+            _llm_dicts[provider] = LLM(os.environ.get("AZURE_API_KEY", ""), os.environ.get("AZURE_BASE_URL", ""), int(os.environ.get("AZURE_TIMEOUT", 2000)), os.environ.get("AZURE_API_VERSION", ""))
+        else:
+            raise ValueError(f"Invalid provider: {provider}")
+    return _llm_dicts[provider]
+
+def chat(input: str, system_prompt: str, model: Model, temperature: float) -> str:
+    return get_llm(model.provider()).chat(input, system_prompt, model.value, temperature)
+
+def chat_stream(input: str, system_prompt: str, model: Model, temperature: float) -> Iterator[str]:
+    return get_llm(model.provider()).chat_stream(input, system_prompt, model.value, temperature)

service_forge/llm/llm.py

@@ -0,0 +1,56 @@
+import random
+from openai import OpenAI
+from openai import AzureOpenAI
+from typing import Iterator
+
+class LLM():
+    def __init__(self, api_key: str, base_url: str, timeout: int, api_version: str | None = None):
+        if api_version is not None:
+            self.client = AzureOpenAI(
+                api_key=api_key,
+                azure_endpoint=base_url,
+                timeout=timeout,
+                api_version=api_version,
+            )
+        else:
+            self.client = OpenAI(
+                api_key=api_key,
+                base_url=base_url,
+                timeout=timeout,
+            )
+
+    def chat(self, input: str, system_prompt: str, model: str, temperature: float) -> str:
+        if model.startswith("azure"):
+            model = model.replace("azure-", "")
+
+        response = self.client.chat.completions.create(
+            model=model,
+            messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": input},
+            ],
+            temperature=temperature,
+        )
+
+        if response.choices[0].message.content is None:
+            return "Error"
+        else:
+            return response.choices[0].message.content
+
+    def chat_stream(self, input: str, system_prompt: str, model: str, temperature: float) -> Iterator[str]:
+        if model.startswith("azure"):
+            model = model.replace("azure-", "")
+
+        stream = self.client.chat.completions.create(
+            model=model,
+            messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": input},
+            ],
+            temperature=temperature,
+            stream=True,
+        )
+
+        for chunk in stream:
+            if chunk.choices[0].delta.content is not None:
+                yield chunk.choices[0].delta.content

service_forge/model/websocket.py

@@ -0,0 +1,13 @@
+
+from pydantic import BaseModel
+
+class WebSocketMessage(BaseModel):
+    """WebSocket消息模型"""
+    message: str = None
+    client_id: str
+
+class WebSocketResponse(BaseModel):
+    """WebSocket响应模型"""
+    status: str
+    message: str
+    data: dict = None

service_forge/proto/foo_input.py

@@ -0,0 +1,5 @@
+from pydantic import BaseModel
+
+class FooInput(BaseModel):
+    user_id: int
+    data: str

service_forge/service.py

@@ -0,0 +1,288 @@
+from __future__ import annotations
+
+import os
+import asyncio
+import threading
+import uuid
+from omegaconf import OmegaConf
+from service_forge.workflow.node import node_register
+from service_forge.workflow.workflow_factory import create_workflows
+from service_forge.api.http_api import start_fastapi_server
+from service_forge.api.kafka_api import start_kafka_server
+from service_forge.db.database import DatabaseManager
+from loguru import logger
+from typing import Callable, AsyncIterator, Awaitable, Any, TYPE_CHECKING
+from service_forge.api.http_api_doc import generate_service_http_api_doc
+from service_forge.api.routers.service.service_router import set_service
+from service_forge.sft.config.sf_metadata import SfMetadata
+
+if TYPE_CHECKING:
+    from service_forge.workflow.workflow_group import WorkflowGroup
+
+class Service:
+    def __init__(
+        self,
+        metadata: SfMetadata,
+        config_path: str,
+        workflow_config_paths: list[str],
+        _handle_stream_output: Callable[[str, AsyncIterator[str]], Awaitable[None]] = None,
+        _handle_query_user: Callable[[str, str], Awaitable[str]] = None,
+        enable_http: bool = True,
+        http_host: str = "0.0.0.0",
+        http_port: int = 8000,
+        enable_kafka: bool = True,
+        kafka_host: str = "localhost",
+        kafka_port: int = 9092,
+        service_env: dict[str, Any] = None,
+        database_manager: DatabaseManager = None,
+    ) -> None:
+        self.metadata = metadata
+        self.config_path = config_path
+        self.workflow_config_paths = workflow_config_paths
+        self._handle_stream_output = _handle_stream_output
+        self._handle_query_user = _handle_query_user
+        self.enable_http = enable_http
+        self.http_host = http_host
+        self.http_port = http_port
+        self.enable_kafka = enable_kafka
+        self.kafka_host = kafka_host
+        self.kafka_port = kafka_port
+        self.service_env = {} if service_env is None else service_env
+        self.database_manager = database_manager
+        self.workflow_groups: list[WorkflowGroup] = []
+        self.workflow_tasks: dict[str, asyncio.Task] = {}  # workflow_name -> task mapping
+        self.workflow_config_map: dict[str, str] = {}  # workflow_name -> config_path mapping
+        self.fastapi_thread: threading.Thread | None = None
+        self.fastapi_loop: asyncio.AbstractEventLoop | None = None
+
+    @property
+    def name(self) -> str:
+        return self.metadata.name
+    
+    @property
+    def version(self) -> str:
+        return self.metadata.version
+    
+    @property
+    def description(self) -> str:
+        return self.metadata.description
+
+    async def start(self):
+        set_service(self)
+        
+        if self.enable_http:
+            fastapi_task = asyncio.create_task(start_fastapi_server(self.http_host, self.http_port))
+            doc_task = asyncio.create_task(generate_service_http_api_doc(self))
+        else:
+            fastapi_task = None
+            doc_task = None
+        if self.enable_kafka:
+            kafka_task = asyncio.create_task(start_kafka_server(f"{self.kafka_host}:{self.kafka_port}"))
+        else:
+            kafka_task = None
+
+        workflow_tasks: list[asyncio.Task] = []
+
+        for workflow_config_path in self.workflow_config_paths:
+            workflow_group = create_workflows(
+                self.parse_workflow_path(workflow_config_path),
+                service_env=self.service_env,
+                _handle_stream_output=self._handle_stream_output, 
+                _handle_query_user=self._handle_query_user,
+                database_manager=self.database_manager,
+            )
+            self.workflow_groups.append(workflow_group)
+            main_workflow = workflow_group.get_main_workflow()
+            task = asyncio.create_task(workflow_group.run())
+            workflow_tasks.append(task)
+            self.workflow_tasks[main_workflow.name] = task
+            self.workflow_config_map[main_workflow.name] = workflow_config_path
+
+        try:
+            core_tasks = []
+            if fastapi_task:
+                core_tasks.append(fastapi_task)
+            if doc_task:
+                core_tasks.append(doc_task)
+            if kafka_task:
+                core_tasks.append(kafka_task)
+            
+            all_tasks = core_tasks + workflow_tasks
+            results = await asyncio.gather(*all_tasks, return_exceptions=True)
+            
+            # Check core tasks
+            for i, result in enumerate(results[:len(core_tasks)]):
+                if isinstance(result, Exception):
+                    logger.error(f"Error in service {self.name} core task {i}: {result}")
+                    raise result
+            
+            # Check workflow tasks
+            for i, result in enumerate(results[len(core_tasks):], start=len(core_tasks)):
+                if isinstance(result, Exception) and not isinstance(result, asyncio.CancelledError):
+                    # Workflow task exception should not stop the service
+                    logger.error(f"Error in service {self.name} workflow task {i}: {result}")
+
+        except Exception as e:
+            logger.error(f"Error in service {self.name}: {e}")
+            if fastapi_task:
+                fastapi_task.cancel()
+            if kafka_task:
+                kafka_task.cancel()
+            for workflow_task in workflow_tasks:
+                workflow_task.cancel()
+            raise
+
+    def parse_workflow_path(self, workflow_config_path: str) -> str:
+        if os.path.isabs(workflow_config_path):
+            return workflow_config_path
+        else:
+            return os.path.join(os.path.dirname(self.config_path), workflow_config_path)
+    
+    def get_workflow_group_by_name(self, workflow_name: str) -> WorkflowGroup | None:
+        for workflow_group in self.workflow_groups:
+            if workflow_group.get_workflow(workflow_name) is not None:
+                return workflow_group
+        return None
+    
+    def trigger_workflow(self, workflow_name: str, trigger_name: str, **kwargs) -> uuid.UUID:
+        workflow_group = self.get_workflow_group_by_name(workflow_name)
+        if workflow_group is None:
+            logger.error(f"Workflow {workflow_name} not found")
+            return False
+        
+        workflow = workflow_group.get_main_workflow()
+        if workflow is None:
+            logger.error(f"Workflow {workflow_name} not found")
+            return False
+
+        return workflow.trigger(trigger_name, **kwargs)
+
+    async def start_workflow(self, workflow_name: str) -> bool:
+        if workflow_name in self.workflow_tasks:
+            task = self.workflow_tasks[workflow_name]
+            if not task.done():
+                logger.warning(f"Workflow {workflow_name} is already running")
+                return False
+            del self.workflow_tasks[workflow_name]
+        
+        workflow_group = self.get_workflow_group_by_name(workflow_name)
+        if workflow_group is None:
+            logger.error(f"Workflow {workflow_name} not found")
+            return False
+        
+        task = asyncio.create_task(workflow_group.run(workflow_name))
+        self.workflow_tasks[workflow_name] = task
+        logger.info(f"Started workflow {workflow_name}")
+        return True
+    
+    async def stop_workflow(self, workflow_name: str) -> bool:
+        if workflow_name not in self.workflow_tasks:
+            logger.warning(f"Workflow {workflow_name} is not running")
+            return False
+        
+        task = self.workflow_tasks[workflow_name]
+        if task.done():
+            logger.warning(f"Workflow {workflow_name} is already stopped")
+            del self.workflow_tasks[workflow_name]
+            return False
+        
+        task.cancel()
+        try:
+            await task
+        except asyncio.CancelledError:
+            pass
+        
+        del self.workflow_tasks[workflow_name]
+        logger.info(f"Stopped workflow {workflow_name}")
+        return True
+    
+    async def load_workflow_from_config(self, config_path: str = None, config: dict = None, workflow_name: str = None) -> bool:
+        try:
+            if config is None:
+                if config_path is None:
+                    raise ValueError("Either config_path or config must be provided")
+                if os.path.isabs(config_path):
+                    full_path = config_path
+                else:
+                    full_path = self.parse_workflow_path(config_path)
+                workflow_group = create_workflows(
+                    config_path=full_path,
+                    service_env=self.service_env,
+                    _handle_stream_output=self._handle_stream_output,
+                    _handle_query_user=self._handle_query_user,
+                    database_manager=self.database_manager,
+                )
+                config_identifier = config_path
+            else:
+                workflow_group = create_workflows(
+                    config=config,
+                    service_env=self.service_env,
+                    _handle_stream_output=self._handle_stream_output,
+                    _handle_query_user=self._handle_query_user,
+                    database_manager=self.database_manager,
+                )
+                config_identifier = config_path if config_path else "config_dict"
+            
+            self.workflow_groups.append(workflow_group)
+            main_workflow = workflow_group.get_main_workflow()
+            actual_name = workflow_name if workflow_name else main_workflow.name
+            
+            if workflow_name and workflow_name != main_workflow.name:
+                actual_name = main_workflow.name
+            
+            if actual_name in self.workflow_tasks:
+                await self.stop_workflow(actual_name)
+            
+            task = asyncio.create_task(workflow_group.run(actual_name))
+            self.workflow_tasks[actual_name] = task
+            self.workflow_config_map[actual_name] = config_identifier
+            
+            logger.info(f"Loaded and started workflow {actual_name} from {config_identifier}")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to load workflow from {config_path or 'config_dict'}: {e}")
+            return False
+    
+    def get_service_status(self) -> dict[str, Any]:
+        workflow_statuses = []
+        for workflow_group in self.workflow_groups:
+            for workflow in workflow_group.workflows:
+                workflow_name = workflow.name
+                is_running = workflow_name in self.workflow_tasks and not self.workflow_tasks[workflow_name].done()
+                config_path = self.workflow_config_map.get(workflow_name, "unknown")
+                workflow_statuses.append({
+                    "name": workflow_name,
+                    "description": workflow.description,
+                    "status": "running" if is_running else "stopped",
+                    "config_path": config_path,
+                })
+        
+        return {
+            "name": self.name,
+            "version": self.version,
+            "description": self.description,
+            "workflows": workflow_statuses,
+        }
+    
+    @staticmethod
+    def from_config(metadata, service_env: dict[str, Any] = None) -> Service:
+        config = OmegaConf.to_object(OmegaConf.load(metadata.service_config))
+        database_manager = DatabaseManager.from_config(config=config)
+        return Service(
+            metadata=metadata,
+            config_path=metadata.service_config,
+            workflow_config_paths=config.get('workflows', []),
+            _handle_stream_output=None,
+            _handle_query_user=None,
+            enable_http=config.get('enable_http', True),
+            http_host=config.get('http_host', '0.0.0.0'),
+            http_port=config.get('http_port', 8000),
+            enable_kafka=config.get('enable_kafka', True),
+            kafka_host=config.get('kafka_host', 'localhost'),
+            kafka_port=config.get('kafka_port', 9092),
+            service_env=service_env,
+            database_manager=database_manager,
+        )
+
+def create_service(config_path: str, name: str, version: str, service_env: dict[str, Any] = None) -> Service:
+    return Service.from_config(config_path, name, version, service_env)

service_forge/service_config.py

@@ -0,0 +1,158 @@
+from __future__ import annotations
+
+class ServiceDatabaseConfig:
+    def __init__(
+        self,
+        name: str,
+
+        postgres_user: str,
+        postgres_password: str,
+        postgres_host: str,
+        postgres_port: int,
+        postgres_db: str,
+
+        mongo_host: str,
+        mongo_port: int,
+        mongo_user: str,
+        mongo_password: str,
+        mongo_db: str,
+
+        redis_host: str,
+        redis_port: int,
+        redis_password: str,
+    ) -> None:
+        self.name = name
+
+        self.postgres_user = postgres_user
+        self.postgres_password = postgres_password
+        self.postgres_host = postgres_host
+        self.postgres_port = postgres_port
+        self.postgres_db = postgres_db
+
+        self.mongo_host = mongo_host
+        self.mongo_port = mongo_port
+        self.mongo_user = mongo_user
+        self.mongo_password = mongo_password
+        self.mongo_db = mongo_db
+
+        self.redis_host = redis_host
+        self.redis_port = redis_port
+        self.redis_password = redis_password
+    
+    @staticmethod
+    def from_dict(config: dict) -> ServiceDatabaseConfig:
+        return ServiceDatabaseConfig(
+            name=config['name'],
+            postgres_user=config.get('postgres_user', None),
+            postgres_password=config.get('postgres_password', None),
+            postgres_host=config.get('postgres_host', None),
+            postgres_port=config.get('postgres_port', None),
+            postgres_db=config.get('postgres_db', None),
+
+            mongo_host=config.get('mongo_host', None),
+            mongo_port=config.get('mongo_port', None),
+            mongo_user=config.get('mongo_user', None),
+            mongo_password=config.get('mongo_password', None),
+            mongo_db=config.get('mongo_db', None),
+
+            redis_host=config.get('redis_host', None),
+            redis_port=config.get('redis_port', None),
+            redis_password=config.get('redis_password', None),
+        )
+
+    def to_dict(self) -> dict:
+        return {
+            'name': self.name,
+
+            'postgres_user': self.postgres_user,
+            'postgres_password': self.postgres_password,
+            'postgres_host': self.postgres_host,
+            'postgres_port': self.postgres_port,
+            'postgres_db': self.postgres_db,
+
+            'mongo_host': self.mongo_host,
+            'mongo_port': self.mongo_port,
+            'mongo_user': self.mongo_user,
+            'mongo_password': self.mongo_password,
+            'mongo_db': self.mongo_db,
+
+            'redis_host': self.redis_host,
+            'redis_port': self.redis_port,
+            'redis_password': self.redis_password,
+        }
+
+class ServiceConfig:
+    def __init__(
+        self,
+        name: str,
+        workflows: list[str],
+        enable_http: bool,
+        http_host: str,
+        http_port: int,
+        enable_kafka: bool,
+        kafka_host: str,
+        kafka_port: int,
+        databases: list[ServiceDatabaseConfig],
+    ) -> None:
+        self.name = name
+        self.workflows = workflows
+        self.enable_http = enable_http
+        self.http_host = http_host
+        self.http_port = http_port
+        self.enable_kafka = enable_kafka
+        self.kafka_host = kafka_host
+        self.kafka_port = kafka_port
+        self.databases = databases
+
+    @staticmethod
+    def from_dict(config: dict) -> ServiceConfig:
+        return ServiceConfig(
+            name=config['name'],
+            workflows=config['workflows'],
+            enable_http=config['enable_http'],
+            http_host=config['http_host'],
+            http_port=config['http_port'],
+            enable_kafka=config['enable_kafka'],
+            kafka_host=config['kafka_host'],
+            kafka_port=config['kafka_port'],
+            databases=[ServiceDatabaseConfig.from_dict(database) for database in config['databases']],
+        )
+
+    def to_dict(self) -> dict:
+        return {
+            'name': self.name,
+            'workflows': self.workflows,
+            'enable_http': self.enable_http,
+            'http_host': self.http_host,
+            'http_port': self.http_port,
+            'enable_kafka': self.enable_kafka,
+            'kafka_host': self.kafka_host,
+            'kafka_port': self.kafka_port,
+            'databases': [database.to_dict() for database in self.databases],
+        }
+
+# name: tag_service
+# workflows:
+#   # - ./workflow/kafka_workflow.yaml
+#   - ./workflow/query_tags_workflow.yaml
+#   - ./workflow/create_tag_workflow.yaml
+#   - ./workflow/update_tag_workflow.yaml
+#   - ./workflow/delete_tag_workflow.yaml
+#   - ./workflow/get_tags_from_record.yaml
+
+# enable_http: true
+# enable_kafka: false
+
+# # Following configs will be auto-injected by sft.
+# http_host: 0.0.0.0
+# http_port: 37200
+# kafka_host: localhost
+# kafka_port: 9092
+
+# databases:
+#   - name: tag
+#     postgres_user: postgres
+#     postgres_password: "gnBGWg7aL4"
+#     postgres_host: second-brain-postgres-postgresql
+#     postgres_port: 5432
+#     postgres_db: tag-service-tag

service_forge/sft/cli.py

@@ -0,0 +1,91 @@
+#!/usr/bin/env python3
+import sys
+from typing import Optional
+
+import typer
+from service_forge.sft.util.logger import log_error, log_info
+from service_forge.sft.cmd.list_tars import list_tars
+from service_forge.sft.cmd.upload_service import upload_service
+from service_forge.sft.cmd.deploy_service import deploy_service
+from service_forge.sft.cmd.config_command import list_config, get_config, set_config
+from service_forge.sft.cmd.service_command import list_services, delete_service, show_service_logs
+
+app = typer.Typer(
+    name="sft",
+    help="Service Forge CLI - Service management tool",
+    add_completion=False,
+)
+
+@app.command(name="upload")
+def upload_service_command(
+    project_path: Optional[str] = typer.Argument(
+        default=".",
+        help="Project path, default is the current directory"
+    )
+) -> None:
+    upload_service(project_path)
+
+@app.command(name="list")
+def list_tars_command() -> None:
+    list_tars()
+
+@app.command(name="deploy")
+def deploy_service_command(name: str, version: str) -> None:
+    deploy_service(name, version)
+
+config_app = typer.Typer(
+    name="config",
+    help="Configuration management commands",
+    add_completion=False,
+)
+
+@config_app.command(name="list")
+def config_list_command() -> None:
+    list_config()
+
+@config_app.command(name="get")
+def config_get_command(
+    key: str = typer.Argument(help="Configuration item key")
+) -> None:
+    get_config(key)
+
+@config_app.command(name="set")
+def config_set_command(
+    key: str = typer.Argument(help="Configuration item key"),
+    value: str = typer.Argument(help="Configuration item value")
+) -> None:
+    set_config(key, value)
+
+app.add_typer(config_app)
+
+service_app = typer.Typer(
+    name="service",
+    help="Kubernetes service management commands",
+    add_completion=False,
+)
+
+@service_app.command(name="list")
+def service_list_command() -> None:
+    list_services()
+
+@service_app.command(name="delete")
+def service_delete_command(
+    service_name: str = typer.Argument(help="Service name to delete (must start with sf-)"),
+    force: bool = typer.Option(False, "--force", "-f", help="Force delete")
+) -> None:
+    delete_service(service_name, force)
+
+@service_app.command(name="logs")
+def service_logs_command(
+    service_name: str = typer.Argument(help="Service name to view logs for (must start with sf-)"),
+    container: Optional[str] = typer.Option(None, "--container", "-c", help="Container name (if pod has multiple containers)"),
+    tail: int = typer.Option(100, "--tail", "-n", help="Number of lines to show from the end of logs"),
+    follow: bool = typer.Option(False, "--follow", "-f", help="Follow log output"),
+    previous: bool = typer.Option(False, "--previous", "-p", help="Get logs from previous instance of container")
+) -> None:
+    show_service_logs(service_name, container, tail, follow, previous)
+
+app.add_typer(service_app)
+
+def main() -> None:
+    app()