model-compose 0.4.29__tar.gz → 0.4.30__tar.gz

{model_compose-0.4.29/src/model_compose.egg-info → model_compose-0.4.30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model-compose
-Version: 0.4.29
+Version: 0.4.30
 Summary: model-compose: Declarative AI Workflow Orchestrator
 Author-email: Hanyeol Cho <hanyeol.cho@gmail.com>
 License-Expression: MIT
@@ -23,6 +23,7 @@ Requires-Dist: gradio>=6.0.0
 Requires-Dist: Pillow
 Requires-Dist: beautifulsoup4
 Requires-Dist: lxml
+Requires-Dist: async_timeout>=4.0; python_version < "3.11"
 Dynamic: license-file
 
 <div align="center">
@@ -81,6 +82,9 @@ Build multi-step pipelines with conditional logic, data transformation, and para
 ### 🚀 **Production-Ready Deployment**
 Deploy as HTTP REST API or MCP (Model Context Protocol) server by changing one line. Includes concurrency control, health checks, and automatic API documentation.
 
+### 📡 **Distributed Workflow Execution**
+Scale AI workloads across multiple machines using Redis-backed queue dispatch. Dispatcher instances route workflow requests to remote subscribers—no shared filesystem or code changes needed. Add workers to scale horizontally.
+
 ### 🎯 **Event-Driven Architecture**
 HTTP Callback listeners for async workflows (image generation, video processing). HTTP Trigger listeners for webhooks and external events. Build reactive AI systems that respond to real-world events.
 

{model_compose-0.4.29 → model_compose-0.4.30}/README.md

@@ -54,6 +54,9 @@ Build multi-step pipelines with conditional logic, data transformation, and para
 ### 🚀 **Production-Ready Deployment**
 Deploy as HTTP REST API or MCP (Model Context Protocol) server by changing one line. Includes concurrency control, health checks, and automatic API documentation.
 
+### 📡 **Distributed Workflow Execution**
+Scale AI workloads across multiple machines using Redis-backed queue dispatch. Dispatcher instances route workflow requests to remote subscribers—no shared filesystem or code changes needed. Add workers to scale horizontally.
+
 ### 🎯 **Event-Driven Architecture**
 HTTP Callback listeners for async workflows (image generation, video processing). HTTP Trigger listeners for webhooks and external events. Build reactive AI systems that respond to real-world events.
 

{model_compose-0.4.29 → model_compose-0.4.30}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "model-compose"
-version = "0.4.29"
+version = "0.4.30"
 description = "model-compose: Declarative AI Workflow Orchestrator"
 authors = [
     { name = "Hanyeol Cho", email = "hanyeol.cho@gmail.com" }
@@ -23,7 +23,8 @@ dependencies = [
     "gradio>=6.0.0",
     "Pillow",
     "beautifulsoup4",
-    "lxml"
+    "lxml",
+    "async_timeout>=4.0; python_version < '3.11'"
 ]
 
 [project.scripts]

{model_compose-0.4.29 → model_compose-0.4.30}/src/mindor/core/component/base.py

@@ -5,7 +5,7 @@ from mindor.dsl.schema.action import ActionConfig
 from mindor.dsl.schema.listener import ListenerConfig
 from mindor.dsl.schema.gateway import GatewayConfig
 from mindor.dsl.schema.workflow import WorkflowConfig
-from mindor.dsl.schema.runtime import ProcessRuntimeConfig
+from mindor.dsl.schema.runtime import RuntimeType
 from mindor.core.foundation import AsyncService
 from mindor.core.utils.work_queue import WorkQueue
 from mindor.core.utils.active_counter import ActiveCounter
@@ -45,7 +45,13 @@ class ComponentGlobalConfigs:
         self.workflows: List[WorkflowConfig] = workflows
 
 class ComponentService(AsyncService):
-    def __init__(self, id: str, config: ComponentConfig, global_configs: ComponentGlobalConfigs, daemon: bool):
+    def __init__(
+        self,
+        id: str,
+        config: ComponentConfig,
+        global_configs: ComponentGlobalConfigs,
+        daemon: bool
+    ):
         super().__init__(daemon)
 
         self.id: str = id
@@ -53,27 +59,33 @@ class ComponentService(AsyncService):
         self.global_configs: ComponentGlobalConfigs = global_configs
         self.work_queue: Optional[WorkQueue] = None
         self._process_manager = None
+        self._docker_manager = None
         self._active_counter: ActiveCounter = ActiveCounter()
 
         if self.config.max_concurrent_count > 0:
             self.work_queue = WorkQueue(self.config.max_concurrent_count, self._run)
 
     async def start(self, background: bool = False) -> None:
-        if isinstance(self.config.runtime, ProcessRuntimeConfig):
-            from mindor.core.component.runtime import ComponentProcessRuntimeManager
-
-            self._process_manager = ComponentProcessRuntimeManager(
-                self.id,
-                self.config,
-                self.global_configs
-            )
-            await self._process_manager.start()
-            logging.info(f"Component {self.id} started in separate process")
+        if self.config.runtime.type == RuntimeType.PROCESS:
+            await self._start_process_runtime()
             return
-        
+
+        if self.config.runtime.type == RuntimeType.DOCKER:
+            await self._start_docker_runtime()
+
         await super().start(background)
         await self.wait_until_ready()
 
+    async def stop(self) -> None:
+        if self._process_manager:
+            await self._stop_process_runtime()
+            return
+
+        await super().stop()
+
+        if self._docker_manager:
+            await self._stop_docker_runtime()
+
     async def run(self, action_id: str, run_id: str, input: Dict[str, Any], workflow=None) -> Dict[str, Any]:
         if self._process_manager:
             return await self._process_manager.run(action_id, run_id, input)
@@ -90,13 +102,6 @@ class ComponentService(AsyncService):
         finally:
             self._active_counter.release()
 
-    async def stop(self) -> None:
-        if self._process_manager:
-            await self._process_manager.stop()
-            return
-        
-        await super().stop()
-
     async def _start(self) -> None:
         if self.work_queue:
             await self.work_queue.start()
@@ -110,23 +115,42 @@ class ComponentService(AsyncService):
         await self._active_counter.wait_for_zero()
         await super()._stop()
 
-    async def _serve(self) -> None:
-        pass
-
-    async def _shutdown(self) -> None:
-        pass
-
     async def _is_ready(self) -> bool:
         return True
 
     @abstractmethod
     async def _run(self, action: ActionConfig, context: ComponentActionContext) -> Any:
         pass
-  
+
     async def _install_package(self, package_spec: str, repository: Optional[str]) -> None:
         logging.info(f"Installing required module: {package_spec}")
         await super()._install_package(package_spec, repository)
 
+    async def _start_process_runtime(self) -> None:
+        from mindor.core.component.runtime import ComponentProcessRuntimeManager
+        self._process_manager = ComponentProcessRuntimeManager(self.id, self.config, self.global_configs)
+        await self._process_manager.start()
+        logging.info(f"Component '{self.id}' started with process runtime")
+
+    async def _stop_process_runtime(self) -> None:
+        await self._process_manager.stop()
+        logging.info(f"Component '{self.id}' process runtime stopped")
+
+    async def _start_docker_runtime(self) -> None:
+        from mindor.core.runtime.docker import DockerRuntimeManager
+        self._docker_manager = DockerRuntimeManager(self.config.runtime, verbose=False)
+        if not await self._docker_manager.exists_image():
+            await self._docker_manager.pull_image()
+        if await self._docker_manager.exists_container():
+            await self._docker_manager.remove_container(force=True)
+        await self._docker_manager.start_container(detach=True)
+        logging.info(f"Component '{self.id}' started with Docker runtime")
+
+    async def _stop_docker_runtime(self) -> None:
+        await self._docker_manager.stop_container()
+        await self._docker_manager.remove_container(force=True)
+        logging.info(f"Component '{self.id}' Docker container stopped")
+
 def register_component(type: ComponentType):
     def decorator(cls: Type[ComponentService]) -> Type[ComponentService]:
         ComponentRegistry[type] = cls

{model_compose-0.4.29 → model_compose-0.4.30}/src/mindor/core/component/runtime/process_manager.py

@@ -18,9 +18,6 @@ class ComponentProcessRuntimeManager(ProcessRuntimeManager):
         config: ComponentConfig,
         global_configs: ComponentGlobalConfigs
     ):
-        if not isinstance(config.runtime, ProcessRuntimeConfig):
-            raise ValueError("ComponentProcessRuntimeManager requires ProcessRuntimeConfig")
-
         self.config = config
         self.global_configs = global_configs
 
@@ -35,11 +32,7 @@ class ComponentProcessRuntimeManager(ProcessRuntimeManager):
         # Convert ProcessRuntimeConfig to ProcessWorkerParams
         worker_params = self._convert_runtime_config(config.runtime)
 
-        super().__init__(
-            worker_id=component_id,
-            worker_factory=worker_factory,
-            worker_params=worker_params
-        )
+        super().__init__(component_id, worker_factory, worker_params)
 
     @staticmethod
     def _convert_runtime_config(config: ProcessRuntimeConfig) -> ProcessWorkerParams:

{model_compose-0.4.29 → model_compose-0.4.30}/src/mindor/core/component/runtime/process_worker.py

@@ -8,8 +8,6 @@ from mindor.core.logger import logging
 from multiprocessing import Queue
 
 class ComponentProcessWorker(ProcessWorker):
-    """Worker for running components in separate processes"""
-
     def __init__(
         self,
         component_id: str,
@@ -23,8 +21,7 @@ class ComponentProcessWorker(ProcessWorker):
         self.global_configs = global_configs
         self.component = None
 
-    async def _initialize(self) -> None:
-        """Initialize and start the component"""
+    async def _start(self) -> None:
         embedded_config = self.config.model_copy(deep=True)
         embedded_config.runtime = EmbeddedRuntimeConfig(type="embedded")
 
@@ -40,16 +37,14 @@ class ComponentProcessWorker(ProcessWorker):
 
         logging.info(f"Component {self.worker_id} started in subprocess")
 
+    async def _stop(self) -> None:
+        if self.component:
+            await self.component.stop()
+            await self.component.teardown()
+
     async def _execute_task(self, payload: Dict[str, Any]) -> Any:
-        """Execute component action"""
-        action_id = payload["action_id"]
-        run_id = payload["run_id"]
+        action_id  = payload["action_id"]
+        run_id     = payload["run_id"]
         input_data = payload["input"]
 
         return await self.component.run(action_id, run_id, input_data)
-
-    async def _cleanup(self) -> None:
-        """Clean up the component"""
-        if self.component:
-            await self.component.stop()
-            await self.component.teardown()

{model_compose-0.4.29 → model_compose-0.4.30}/src/mindor/core/component/services/__init__.py

@@ -12,3 +12,4 @@ from .image_processor import *
 from .web_scraper import *
 from .web_browser import *
 from .agent import *
+from .video_scene_detector import *

{model_compose-0.4.29 → model_compose-0.4.30}/src/mindor/core/component/services/agent.py

@@ -12,7 +12,14 @@ import asyncio, ulid, json
 _JSON_SCHEMA_TYPE_MAP = { "int": "integer", "float": "number", "bool": "boolean", "list[dict]": "array" }
 
 class AgentAction:
-    def __init__(self, action: AgentActionConfig, config: AgentComponentConfig, global_configs: ComponentGlobalConfigs, tools: Dict[str, WorkflowTool], function_schemas: List[Dict[str, Any]]):
+    def __init__(
+        self,
+        action: AgentActionConfig,
+        config: AgentComponentConfig,
+        global_configs: ComponentGlobalConfigs,
+        tools: Dict[str, WorkflowTool],
+        function_schemas: List[Dict[str, Any]]
+    ):
         self.action: AgentActionConfig = action
         self.config: AgentComponentConfig = config
         self.global_configs: ComponentGlobalConfigs = global_configs
@@ -90,7 +97,13 @@ class AgentAction:
         _, config = ComponentResolver(self.global_configs.components).resolve(component_id)
         return create_component(component_id, config, self.global_configs, daemon=False)
 
-    async def _render_model_input(self, context: ComponentActionContext, input_mapping: Dict[str, Any], messages: List[Dict[str, Any]], tools: Optional[List[Dict[str, Any]]]) -> Dict[str, Any]:
+    async def _render_model_input(
+        self,
+        context: ComponentActionContext,
+        input_mapping: Dict[str, Any],
+        messages: List[Dict[str, Any]],
+        tools: Optional[List[Dict[str, Any]]]
+    ) -> Dict[str, Any]:
         context.register_source("messages", messages)
         if tools:
             context.register_source("tools", tools)
@@ -161,7 +174,13 @@ async def _build_function_schema(name: str, tool: WorkflowTool) -> Dict[str, Any
 
 @register_component(ComponentType.AGENT)
 class AgentComponent(ComponentService):
-    def __init__(self, id: str, config: AgentComponentConfig, global_configs: ComponentGlobalConfigs, daemon: bool):
+    def __init__(
+        self,
+        id: str,
+        config: AgentComponentConfig,
+        global_configs: ComponentGlobalConfigs,
+        daemon: bool
+    ):
         super().__init__(id, config, global_configs, daemon)
 
         self.tools: Optional[Dict[str, WorkflowTool]] = None

{model_compose-0.4.29 → model_compose-0.4.30}/src/mindor/core/component/services/datasets/datasets.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 from typing import TYPE_CHECKING
 
-from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, AsyncIterator, Any
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from collections.abc import AsyncIterator
 from mindor.dsl.schema.action import DatasetsActionConfig, DatasetsActionMethod, DatasetsProvider
 from ...base import ComponentService, ComponentType, ComponentGlobalConfigs, register_component
 from ...context import ComponentActionContext
@@ -116,7 +117,13 @@ class DatasetsAction:
 
 @register_component(ComponentType.DATASETS)
 class DatasetsComponent(ComponentService):
-    def __init__(self, id: str, config: DatasetsActionConfig, global_configs: ComponentGlobalConfigs, daemon: bool):
+    def __init__(
+        self,
+        id: str,
+        config: DatasetsActionConfig,
+        global_configs: ComponentGlobalConfigs,
+        daemon: bool
+    ):
         super().__init__(id, config, global_configs, daemon)
 
     def _get_setup_requirements(self) -> Optional[List[str]]:

{model_compose-0.4.29 → model_compose-0.4.30}/src/mindor/core/component/services/datasets/providers/common.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 from typing import TYPE_CHECKING
 
-from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, AsyncIterator, Any
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from collections.abc import AsyncIterator
 from abc import ABC, abstractmethod
 from mindor.dsl.schema.action import DatasetsLoadActionConfig
 from ....context import ComponentActionContext

{model_compose-0.4.29 → model_compose-0.4.30}/src/mindor/core/component/services/datasets/providers/huggingface.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 from typing import TYPE_CHECKING
 
-from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, AsyncIterator, Any
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from collections.abc import AsyncIterator
 from .common import CommonDatasetsProvider, ComponentActionContext
 
 if TYPE_CHECKING:

{model_compose-0.4.29 → model_compose-0.4.30}/src/mindor/core/component/services/datasets/providers/local.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 from typing import TYPE_CHECKING
 
-from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, AsyncIterator, Any
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from collections.abc import AsyncIterator
 from .common import CommonDatasetsProvider, ComponentActionContext
 
 if TYPE_CHECKING:

{model_compose-0.4.29 → model_compose-0.4.30}/src/mindor/core/component/services/http_client.py

@@ -1,4 +1,5 @@
-from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, AsyncIterator, Any
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from collections.abc import AsyncIterator
 from abc import ABC, abstractmethod
 from mindor.dsl.schema.component import HttpClientComponentConfig
 from mindor.dsl.schema.action import ActionConfig, HttpClientActionConfig, HttpClientCompletionType, HttpClientCompletionConfig
@@ -141,7 +142,13 @@ class HttpClientAction:
 
 @register_component(ComponentType.HTTP_CLIENT)
 class HttpClientComponent(ComponentService):
-    def __init__(self, id: str, config: HttpClientComponentConfig, global_configs: ComponentGlobalConfigs, daemon: bool):
+    def __init__(
+        self,
+        id: str,
+        config: HttpClientComponentConfig,
+        global_configs: ComponentGlobalConfigs,
+        daemon: bool
+    ):
         super().__init__(id, config, global_configs, daemon)
 
         self.client: Optional[HttpClient] = None

{model_compose-0.4.29 → model_compose-0.4.30}/src/mindor/core/component/services/http_server.py

@@ -130,7 +130,13 @@ class HttpServerAction:
 
 @register_component(ComponentType.HTTP_SERVER)
 class HttpServerComponent(ComponentService):
-    def __init__(self, id: str, config: HttpServerComponentConfig, global_configs: ComponentGlobalConfigs, daemon: bool):
+    def __init__(
+        self,
+        id: str,
+        config: HttpServerComponentConfig,
+        global_configs: ComponentGlobalConfigs,
+        daemon: bool
+    ):
         super().__init__(id, config, global_configs, daemon)
 
         self.client: Optional[HttpClient] = None
@@ -163,9 +169,6 @@ class HttpServerComponent(ComponentService):
         if self.config.manage.scripts.start:
             await run_command_streaming(self.config.manage.scripts.start, self.config.manage.working_dir, self.config.manage.env)
 
-    async def _shutdown(self) -> None:
-        pass
-
     async def _is_ready(self) -> bool:
         try:
             _, writer = await asyncio.open_connection("localhost", self.config.port)

{model_compose-0.4.29 → model_compose-0.4.30}/src/mindor/core/component/services/image_processor.py

@@ -169,7 +169,13 @@ class ImageProcessorAction:
 
         raise ValueError(f"Invalid scale_mode: {scale_mode}")
 
-    def _get_size_aspect_fit(self, target_width: int, target_height: int, original_width: int, original_height: int) -> Tuple[int, int]:
+    def _get_size_aspect_fit(
+        self,
+        target_width: int,
+        target_height: int,
+        original_width: int,
+        original_height: int
+    ) -> Tuple[int, int]:
         aspect_ratio = original_width / original_height
 
         height = target_height
@@ -181,7 +187,13 @@ class ImageProcessorAction:
 
         return (int(width), int(height))
 
-    def _get_size_aspect_fill(self, target_width: int, target_height: int, original_width: int, original_height: int) -> Tuple[int, int]:
+    def _get_size_aspect_fill(
+        self,
+        target_width: int,
+        target_height: int,
+        original_width: int,
+        original_height: int
+    ) -> Tuple[int, int]:
         aspect_ratio = original_width / original_height
 
         height = target_height
@@ -203,7 +215,13 @@ class ImageProcessorAction:
 
 @register_component(ComponentType.IMAGE_PROCESSOR)
 class ImageProcessorComponent(ComponentService):
-    def __init__(self, id: str, config: ImageProcessorComponentConfig, global_configs: ComponentGlobalConfigs, daemon: bool):
+    def __init__(
+        self,
+        id: str,
+        config: ImageProcessorComponentConfig,
+        global_configs: ComponentGlobalConfigs,
+        daemon: bool
+    ):
         super().__init__(id, config, global_configs, daemon)
 
     async def _run(self, action: ActionConfig, context: ComponentActionContext) -> Any:

{model_compose-0.4.29 → model_compose-0.4.30}/src/mindor/core/component/services/mcp_client.py

@@ -29,7 +29,13 @@ class McpClientAction:
 
 @register_component(ComponentType.MCP_CLIENT)
 class McpClientComponent(ComponentService):
-    def __init__(self, id: str, config: McpClientComponentConfig, global_configs: ComponentGlobalConfigs, daemon: bool):
+    def __init__(
+        self,
+        id: str,
+        config: McpClientComponentConfig,
+        global_configs: ComponentGlobalConfigs,
+        daemon: bool
+    ):
         super().__init__(id, config, global_configs, daemon)
 
         self.client: Optional[McpClient] = None 

{model_compose-0.4.29 → model_compose-0.4.30}/src/mindor/core/component/services/mcp_server.py

@@ -31,7 +31,13 @@ class McpServerAction:
 
 @register_component(ComponentType.MCP_SERVER)
 class McpServerComponent(ComponentService):
-    def __init__(self, id: str, config: McpServerComponentConfig, global_configs: ComponentGlobalConfigs, daemon: bool):
+    def __init__(
+        self,
+        id: str,
+        config: McpServerComponentConfig,
+        global_configs: ComponentGlobalConfigs,
+        daemon: bool
+    ):
         super().__init__(id, config, global_configs, daemon)
 
         self.client: Optional[McpClient] = None 
@@ -64,9 +70,6 @@ class McpServerComponent(ComponentService):
         if self.config.manage.scripts.start:
             await run_command_streaming(self.config.manage.scripts.start, self.config.manage.working_dir, self.config.manage.env)
 
-    async def _shutdown(self) -> None:
-        pass
-
     async def _is_ready(self) -> bool:
         try:
             _, writer = await asyncio.open_connection("localhost", self.config.port)

{model_compose-0.4.29 → model_compose-0.4.30}/src/mindor/core/component/services/model/base/common.py

@@ -64,7 +64,12 @@ class ModelTaskService(AsyncService):
         pass
 
     @abstractmethod
-    async def _run(self, action: ModelActionConfig, context: ComponentActionContext, loop: asyncio.AbstractEventLoop) -> Any:
+    async def _run(
+        self,
+        action: ModelActionConfig,
+        context: ComponentActionContext,
+        loop: asyncio.AbstractEventLoop
+    ) -> Any:
         pass
 
     def _get_model_path(self) -> str:

{model_compose-0.4.29 → model_compose-0.4.30}/src/mindor/core/component/services/model/model.py

@@ -1,4 +1,5 @@
-from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, AsyncIterator, Any
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from collections.abc import AsyncIterator
 from mindor.dsl.schema.component import ModelComponentConfig, ModelTaskType, ModelDriver
 from mindor.dsl.schema.action import ActionConfig, ModelActionConfig
 from ...base import ComponentService, ComponentType, ComponentGlobalConfigs, register_component
@@ -14,7 +15,13 @@ class ModelAction:
 
 @register_component(ComponentType.MODEL)
 class ModelComponent(ComponentService):
-    def __init__(self, id: str, config: ModelComponentConfig, global_configs: ComponentGlobalConfigs, daemon: bool):
+    def __init__(
+        self,
+        id: str,
+        config: ModelComponentConfig,
+        global_configs: ComponentGlobalConfigs,
+        daemon: bool
+    ):
         super().__init__(id, config, global_configs, daemon)
 
         self.task_service: ModelTaskService = self._create_task_service(self.config.task, self.config.driver)

{model_compose-0.4.29 → model_compose-0.4.30}/src/mindor/core/component/services/model/tasks/chat_completion/huggingface.py

@@ -13,7 +13,13 @@ if TYPE_CHECKING:
     import torch
 
 class HuggingfaceChatCompletionTaskAction(HuggingfaceTextGenerationTaskAction):
-    def __init__(self, config: ChatCompletionModelActionConfig, model: PreTrainedModel, tokenizer: PreTrainedTokenizer, device: torch.device):
+    def __init__(
+        self,
+        config: ChatCompletionModelActionConfig,
+        model: PreTrainedModel,
+        tokenizer: PreTrainedTokenizer,
+        device: torch.device
+    ):
         super().__init__(config, model, tokenizer, device)
 
         self.config: ChatCompletionModelActionConfig = config # For type only
@@ -39,7 +45,12 @@ class HuggingfaceChatCompletionTaskAction(HuggingfaceTextGenerationTaskAction):
 
 @register_model_task_service(ModelTaskType.CHAT_COMPLETION, ModelDriver.HUGGINGFACE)
 class HuggingfaceChatCompletionTaskService(HuggingfaceLanguageModelTaskService):
-    async def _run(self, action: ModelActionConfig, context: ComponentActionContext, loop: asyncio.AbstractEventLoop) -> Any:
+    async def _run(
+        self,
+        action: ModelActionConfig,
+        context: ComponentActionContext,
+        loop: asyncio.AbstractEventLoop
+    ) -> Any:
         return await HuggingfaceChatCompletionTaskAction(action, self.model, self.tokenizer, self.device).run(context, loop)
 
     def _get_model_class(self) -> Type[PreTrainedModel]:

{model_compose-0.4.29 → model_compose-0.4.30}/src/mindor/core/component/services/model/tasks/face_embedding/insightface.py

@@ -51,9 +51,6 @@ class InsightfaceFaceEmbeddingTaskService(FaceEmbeddingTaskService):
             logging.error(f"Failed to load model '{self.config.model}': {e}")
             raise
 
-    async def _shutdown(self) -> None:
-        pass
-
     def _load_pretrained_model(self) -> FaceAnalysis:
         from insightface.app import FaceAnalysis
 
@@ -109,5 +106,10 @@ class InsightfaceFaceEmbeddingTaskService(FaceEmbeddingTaskService):
     def _get_device_id(self) -> int:
         return 0
 
-    async def _run(self, action: ModelActionConfig, context: ComponentActionContext, loop: asyncio.AbstractEventLoop) -> Any:
+    async def _run(
+        self,
+        action: ModelActionConfig,
+        context: ComponentActionContext,
+        loop: asyncio.AbstractEventLoop
+    ) -> Any:
         return await InsightfaceFaceEmbeddingTaskAction(action, self.model).run(context)

{model_compose-0.4.29 → model_compose-0.4.30}/src/mindor/core/component/services/model/tasks/image_generation/flux.py

@@ -14,7 +14,12 @@ if TYPE_CHECKING:
     import torch
 
 class FluxImageGenerationTaskAction(ImageGenerationTaskAction):
-    def __init__(self, config: FluxImageGenerationModelActionConfig, pipeline: Any, device: Optional[torch.device]):
+    def __init__(
+        self,
+        config: FluxImageGenerationModelActionConfig,
+        pipeline: Any,
+        device: Optional[torch.device]
+    ):
         super().__init__(config, device)
 
         self.pipeline = pipeline
@@ -50,5 +55,10 @@ class FluxImageGenerationTaskService(ImageGenerationTaskService):
     def _load_pretrained_pipeline(self) -> Tuple[Any, torch.device]:
         pass
 
-    async def _run(self, action: ModelActionConfig, context: ComponentActionContext, loop: asyncio.AbstractEventLoop) -> Any:
+    async def _run(
+        self,
+        action: ModelActionConfig,
+        context: ComponentActionContext,
+        loop: asyncio.AbstractEventLoop
+    ) -> Any:
         return FluxImageGenerationModelActionConfig(action, self.model).run(context)

{model_compose-0.4.29 → model_compose-0.4.30}/src/mindor/core/component/services/model/tasks/image_generation/hunyuan_image.py

@@ -14,7 +14,12 @@ if TYPE_CHECKING:
     import torch
 
 class HunyuanImageGenerationTaskAction(ImageGenerationTaskAction):
-    def __init__(self, config: HunyuanImageGenerationModelActionConfig, pipeline: Any, device: Optional[torch.device]):
+    def __init__(
+        self,
+        config: HunyuanImageGenerationModelActionConfig,
+        pipeline: Any,
+        device: Optional[torch.device]
+    ):
         super().__init__(config, device)
 
         self.pipeline = pipeline
@@ -50,5 +55,10 @@ class HunyuanImageGenerationTaskService(ImageGenerationTaskService):
     def _load_pretrained_pipeline(self) -> Tuple[Any, torch.device]:
         pass
 
-    async def _run(self, action: ModelActionConfig, context: ComponentActionContext, loop: asyncio.AbstractEventLoop) -> Any:
+    async def _run(
+        self,
+        action: ModelActionConfig,
+        context: ComponentActionContext,
+        loop: asyncio.AbstractEventLoop
+    ) -> Any:
         return HunyuanImageGenerationModelActionConfig(action, self.model).run(context)