model-compose 0.4.72__tar.gz → 0.4.74__tar.gz

{model_compose-0.4.72 → model_compose-0.4.74}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model-compose
-Version: 0.4.72
+Version: 0.4.74
 Summary: model-compose: Declarative AI Workflow Orchestrator
 Author-email: Hanyeol Cho <hanyeol.cho@gmail.com>
 License-Expression: MIT
@@ -12,6 +12,7 @@ Requires-Dist: click
 Requires-Dist: pyyaml
 Requires-Dist: pydantic
 Requires-Dist: python-dotenv
+Requires-Dist: packaging
 Requires-Dist: docker
 Requires-Dist: aiohttp
 Requires-Dist: aiofiles
@@ -48,9 +49,9 @@ Dynamic: license-file
 
 **Compose AI Systems, Deploy Anywhere.**
 
-Define AI workflows, agents, models, and tools in a single YAML file — then run them locally, in containers, or in production without rewriting your stack.
+Build AI agents, RAG pipelines, MCP servers, and multi-model workflows in a single YAML file. Run the same system locally, in containers, or in production without rewriting your stack.
 
-Inspired by `docker-compose` — one YAML file defines your entire AI system.
+Inspired by `docker-compose`, model-compose provides a portable runtime for AI systems — combining cloud APIs and local models without vendor lock-in.
 
 <div align="center">
 
@@ -107,16 +108,24 @@ The goal of model-compose is not to build another closed platform, but to restor
 
 ## Installation
 
+Using pip:
+
 ```
 pip install model-compose
 ```
 
+Or using [uv](https://docs.astral.sh/uv/):
+
+```
+uv pip install model-compose
+```
+
 Or install from source:
 
 ```
 git clone https://github.com/hanyeol/model-compose.git
 cd model-compose
-pip install -e .
+pip install -e .   # or: uv pip install -e .
 ```
 
 > Requires: Python 3.10 or higher

{model_compose-0.4.72 → model_compose-0.4.74}/README.md

@@ -18,9 +18,9 @@
 
 **Compose AI Systems, Deploy Anywhere.**
 
-Define AI workflows, agents, models, and tools in a single YAML file — then run them locally, in containers, or in production without rewriting your stack.
+Build AI agents, RAG pipelines, MCP servers, and multi-model workflows in a single YAML file. Run the same system locally, in containers, or in production without rewriting your stack.
 
-Inspired by `docker-compose` — one YAML file defines your entire AI system.
+Inspired by `docker-compose`, model-compose provides a portable runtime for AI systems — combining cloud APIs and local models without vendor lock-in.
 
 <div align="center">
 
@@ -77,16 +77,24 @@ The goal of model-compose is not to build another closed platform, but to restor
 
 ## Installation
 
+Using pip:
+
 ```
 pip install model-compose
 ```
 
+Or using [uv](https://docs.astral.sh/uv/):
+
+```
+uv pip install model-compose
+```
+
 Or install from source:
 
 ```
 git clone https://github.com/hanyeol/model-compose.git
 cd model-compose
-pip install -e .
+pip install -e .   # or: uv pip install -e .
 ```
 
 > Requires: Python 3.10 or higher

{model_compose-0.4.72 → model_compose-0.4.74}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "model-compose"
-version = "0.4.72"
+version = "0.4.74"
 description = "model-compose: Declarative AI Workflow Orchestrator"
 authors = [
     { name = "Hanyeol Cho", email = "hanyeol.cho@gmail.com" }
@@ -13,6 +13,7 @@ dependencies = [
     "pyyaml",
     "pydantic",
     "python-dotenv",
+    "packaging",
     "docker",
     "aiohttp",
     "aiofiles",

{model_compose-0.4.72 → model_compose-0.4.74}/src/mindor/core/component/base.py

@@ -25,7 +25,7 @@ class ActionResolver:
 
         if action is None:
             if raise_on_error:
-                raise ValueError(f"Action not found: {action_id}")
+                raise LookupError(f"Action not found: {action_id}")
             else:
                 return (None, None)
 
@@ -91,7 +91,14 @@ class ComponentService(AsyncService):
             return await self._process_manager.run(action_id, run_id, input)
 
         _, action = ActionResolver(self.config.actions).resolve(action_id)
-        context = ComponentActionContext(run_id, input, workflow=workflow, component_id=self.id, job_id=job_id)
+        context = ComponentActionContext(
+            run_id,
+            input,
+            workflow=workflow,
+            component_id=self.id,
+            component_type=self.config.type.value,
+            job_id=job_id
+        )
 
         await context.event_notifier.notify("started", input=input)
 

{model_compose-0.4.72 → model_compose-0.4.74}/src/mindor/core/component/component.py

@@ -17,7 +17,7 @@ class ComponentResolver:
 
         if component is None:
             if raise_on_error:
-                raise ValueError(f"Component not found: {component_id}")
+                raise LookupError(f"Component not found: {component_id}")
             else:
                 return None, None
 

{model_compose-0.4.72 → model_compose-0.4.74}/src/mindor/core/component/context.py

@@ -2,7 +2,9 @@ from __future__ import annotations
 from typing import TYPE_CHECKING
 
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
-from mindor.core.utils.renderers import VariableRenderer, ImageValueRenderer, FileValueRenderer
+from collections.abc import AsyncIterator
+from mindor.core.utils.renderers import VariableRenderer, ImageValueRenderer, AudioValueRenderer, VideoValueRenderer, FileValueRenderer, SizeValueRenderer
+from mindor.core.utils.media import MediaSource
 from mindor.core.gateway import find_gateway_by_port
 from PIL import Image as PILImage
 
@@ -11,9 +13,10 @@ if TYPE_CHECKING:
     from mindor.core.workflow.workflow import ComponentEventNotifier
 
 class ComponentActionEventNotifier:
-    def __init__(self, notifier: Optional[ComponentEventNotifier], component_id: Optional[str], job_id: Optional[str], run_id: Optional[str]):
+    def __init__(self, notifier: Optional[ComponentEventNotifier], component_id: Optional[str], component_type: Optional[str], job_id: Optional[str], run_id: Optional[str]):
         self.notifier: Optional[ComponentEventNotifier] = notifier
         self.component_id: Optional[str] = component_id
+        self.component_type: Optional[str] = component_type
         self.job_id: Optional[str] = job_id
         self.run_id: Optional[str] = run_id
 
@@ -31,6 +34,7 @@ class ComponentActionEventNotifier:
             event=event,
             job_id=self.job_id,
             component_id=self.component_id,
+            component_type=self.component_type,
             run_id=self.run_id,
             kind=kind,
             input=input,
@@ -45,34 +49,45 @@ class ComponentActionContext:
         input: Dict[str, Any],
         workflow: Optional[WorkflowContext] = None,
         component_id: Optional[str] = None,
+        component_type: Optional[str] = None,
         job_id: Optional[str] = None,
     ):
         self.run_id: str = run_id
         self.input: Dict[str, Any] = input
         self.workflow: Optional[WorkflowContext] = workflow
         self.component_id: Optional[str] = component_id
+        self.component_type: Optional[str] = component_type
         self.job_id: Optional[str] = job_id
         self.context: Dict[str, Any] = { "run_id": run_id }
         self.sources: Dict[str, Any] = {}
-        self.renderer: VariableRenderer = VariableRenderer(self._resolve_source)
+        self.renderer: VariableRenderer = VariableRenderer(self.resolve_source)
         self.event_notifier: ComponentActionEventNotifier = self._build_event_notifier()
 
     def register_source(self, key: str, source: Any) -> None:
         self.sources[key] = source
 
-    async def render_variable(self, value: Any, ignore_files: bool = False) -> Any:
-        return await self.renderer.render(value, ignore_files)
+    async def render_variable(self, value: Any) -> Any:
+        return await self.renderer.render(value)
 
-    async def render_image(self, value: Any) -> Any:
+    async def render_image(self, value: Any) -> Optional[Union[PILImage.Image, AsyncIterator, List[Union[PILImage.Image, AsyncIterator]]]]:
         return await ImageValueRenderer().render(await self.render_variable(value))
 
-    async def render_file(self, value: Any) -> Optional[str]:
+    async def render_audio(self, value: Any) -> Union[MediaSource, List[MediaSource]]:
+        return await AudioValueRenderer().render(await self.render_variable(value))
+
+    async def render_video(self, value: Any) -> Union[MediaSource, List[MediaSource]]:
+        return await VideoValueRenderer().render(await self.render_variable(value))
+
+    async def render_file(self, value: Any) -> Any:
         return await FileValueRenderer().render(await self.render_variable(value))
 
+    async def render_size(self, value: Any, default: Optional[int] = None) -> Optional[int]:
+        return await SizeValueRenderer().render(await self.render_variable(value), default)
+
     def contains_variable_reference(self, key: str, value: Any) -> bool:
         return self.renderer.contains_reference(key, value)
 
-    async def _resolve_source(self, key: str, index: Optional[int]) -> Any:
+    async def resolve_source(self, key: str, index: Optional[int], scope: Optional[str]) -> Any:
         if key in self.sources:
             return self.sources[key][index] if index is not None else self.sources[key]
 
@@ -100,6 +115,7 @@ class ComponentActionContext:
         return ComponentActionEventNotifier(
             self.workflow.component_event_notifier if self.workflow else None,
             self.component_id,
+            self.component_type,
             self.job_id,
             self.run_id
         )

{model_compose-0.4.72 → model_compose-0.4.74}/src/mindor/core/component/runtime/process_worker.py

@@ -17,6 +17,7 @@ class ComponentProcessWorker(ProcessWorker):
         response_queue: Queue
     ):
         super().__init__(component_id, request_queue, response_queue)
+
         self.config = config
         self.global_configs = global_configs
         self.component = None

{model_compose-0.4.72 → model_compose-0.4.74}/src/mindor/core/component/services/__init__.py

@@ -4,6 +4,7 @@ from .websocket_server import *
 from .websocket_client import *
 from .mcp_server import *
 from .mcp_client import *
+from .agent import *
 from .model import *
 from .model_memory import *
 from .model_tokenizer import *
@@ -15,11 +16,12 @@ from .text_splitter import *
 from .image_processor import *
 from .web_scraper import *
 from .web_browser import *
-from .agent import *
 from .video_converter import *
 from .video_scene_detector import *
+from .video_frame_extractor import *
 from .audio_extractor import *
 from .audio_converter import *
 from .key_value_store import *
 from .graph_store import *
+from .file_store import *
 from .search_engine import *

{model_compose-0.4.72 → model_compose-0.4.74}/src/mindor/core/component/services/agent.py

@@ -1,5 +1,5 @@
-from typing import Optional, Dict, List, Any
-from mindor.dsl.schema.component import AgentComponentConfig
+from typing import Optional, Dict, List, Tuple, Union, Any
+from mindor.dsl.schema.component import AgentComponentConfig, ComponentConfig
 from mindor.dsl.schema.action import ActionConfig, AgentActionConfig, AgentModelConfig
 from mindor.core.component import ComponentService, ComponentGlobalConfigs, ComponentResolver, create_component
 from mindor.core.workflow import Workflow, WorkflowResolver, create_workflow
@@ -29,8 +29,7 @@ class AgentAction:
     async def run(self, context: ComponentActionContext) -> Any:
         messages: List[Dict[str, Any]] = await self._build_initial_messages(context)
 
-        model_config = self.action.model
-        model_component = self._create_component(model_config.component)
+        model_component = self._create_component(self.action.model.component, self.action.model.component)
         if not model_component.started:
             await model_component.start()
 
@@ -44,8 +43,8 @@ class AgentAction:
                     yield message
 
                 for _ in range(max_iteration_count):
-                    model_input = await self._render_model_input(context, model_config.input, messages, tools)
-                    response = await model_component.run(model_config.action, ulid.ulid(), model_input)
+                    model_input = await self._render_model_input(context, self.action.model.input, messages, tools)
+                    response = await model_component.run(self.action.model.action, ulid.ulid(), model_input)
 
                     assistant_message = await self._build_assistant_message(response)
                     messages.append(assistant_message)
@@ -65,8 +64,8 @@ class AgentAction:
             return _stream_message_generator()
 
         for _ in range(max_iteration_count):
-            model_input = await self._render_model_input(context, model_config.input, messages, tools)
-            response = await model_component.run(model_config.action, ulid.ulid(), model_input)
+            model_input = await self._render_model_input(context, self.action.model.input, messages, tools)
+            response = await model_component.run(self.action.model.action, ulid.ulid(), model_input)
 
             assistant_message = await self._build_assistant_message(response)
             messages.append(assistant_message)
@@ -76,7 +75,7 @@ class AgentAction:
             if not tool_calls:
                 break
 
-            tool_messages = await asyncio.gather(*[self._execute_tool_call(tc, context) for tc in tool_calls])
+            tool_messages = await asyncio.gather(*[self._execute_tool_call(tool_call, context) for tool_call in tool_calls])
             for tool_message in tool_messages:
                 messages.append(tool_message)
                 await context.event_notifier.notify("internal", kind="tool", output=tool_message)
@@ -97,10 +96,6 @@ class AgentAction:
 
         return { "role": "tool", "tool_call_id": tool_call.get("id", ""), "content": content }
 
-    def _create_component(self, component_id: str) -> ComponentService:
-        _, 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,
@@ -147,34 +142,14 @@ class AgentAction:
             return message
         return { "role": "assistant", "content": str(response) }
 
-async def _build_function_schema(name: str, tool: WorkflowTool) -> Dict[str, Any]:
-    properties: Dict[str, Any] = {}
-    required: List[str] = []
-
-    for param in tool.parameters:
-        prop: Dict[str, Any] = { "type": _JSON_SCHEMA_TYPE_MAP.get(param.type, "string") }
-        if param.description:
-            prop["description"] = param.description
-        if param.default is not None:
-            prop["default"] = param.default
-        if param.required:
-            required.append(param.name)
-        properties[param.name] = prop
-
-    schema: Dict[str, Any] = {
-        "type": "function",
-        "function": {
-            "name": name,
-            "parameters": {"type": "object", "properties": properties}
-        }
-    }
+    def _create_component(self, id: str, component: Union[ComponentConfig, str]) -> ComponentService:
+        return create_component(*self._resolve_component(id, component), self.global_configs, daemon=False)
 
-    if tool.description:
-        schema["function"]["description"] = tool.description
-    if required:
-        schema["function"]["parameters"]["required"] = required
+    def _resolve_component(self, id: str, component: Union[ComponentConfig, str]) -> Tuple[str, ComponentConfig]:
+        if isinstance(component, str):
+            return ComponentResolver(self.global_configs.components).resolve(component)
 
-    return schema
+        return id, component
 
 @register_component(ComponentType.AGENT)
 class AgentComponent(ComponentService):
@@ -192,7 +167,7 @@ class AgentComponent(ComponentService):
 
     async def _start(self) -> None:
         self.tools = await self._generate_tools()
-        self.function_schemas = await asyncio.gather(*[ _build_function_schema(name, tool) for name, tool in self.tools.items() ])
+        self.function_schemas = await asyncio.gather(*[ self._build_function_schema(name, tool) for name, tool in self.tools.items() ])
         await super()._start()
 
     async def _run(self, action: ActionConfig, context: ComponentActionContext) -> Any:
@@ -204,7 +179,7 @@ class AgentComponent(ComponentService):
 
         for workflow_id in self.config.tools:
             if workflow_id not in workflow_schemas:
-                raise ValueError(f"Workflow not found for tool: {workflow_id}")
+                raise LookupError(f"Workflow not found for tool: {workflow_id}")
 
             workflow = workflow_schemas[workflow_id]
             tool = WorkflowToolGenerator().generate(workflow_id, workflow, self._run_workflow)
@@ -212,6 +187,35 @@ class AgentComponent(ComponentService):
 
         return tools
 
+    async def _build_function_schema(self, name: str, tool: WorkflowTool) -> Dict[str, Any]:
+        properties: Dict[str, Any] = {}
+        required: List[str] = []
+
+        for param in tool.parameters:
+            prop: Dict[str, Any] = { "type": _JSON_SCHEMA_TYPE_MAP.get(param.type, "string") }
+            if param.description:
+                prop["description"] = param.description
+            if param.default is not None:
+                prop["default"] = param.default
+            if param.required:
+                required.append(param.name)
+            properties[param.name] = prop
+
+        schema: Dict[str, Any] = {
+            "type": "function",
+            "function": {
+                "name": name,
+                "parameters": {"type": "object", "properties": properties}
+            }
+        }
+
+        if tool.description:
+            schema["function"]["description"] = tool.description
+        if required:
+            schema["function"]["parameters"]["required"] = required
+
+        return schema
+
     async def _run_workflow(self, workflow_id: str, input: Any, context=None) -> Any:
         workflow = create_workflow(*WorkflowResolver(self.global_configs.workflows).resolve(workflow_id), self.global_configs)
         task_id = context.task_id if context else ulid.ulid()

{model_compose-0.4.72 → model_compose-0.4.74}/src/mindor/core/component/services/audio_converter/audio_converter.py

@@ -15,6 +15,7 @@ class AudioConverterComponent(ComponentService):
         daemon: bool
     ):
         super().__init__(id, config, global_configs, daemon)
+
         self.service: AudioConverterService = self._create_service(self.config.driver)
 
     def _create_service(self, driver: AudioConverterDriver) -> AudioConverterService:
@@ -28,10 +29,12 @@ class AudioConverterComponent(ComponentService):
     def _get_setup_requirements(self) -> Optional[List[str]]:
         return self.service.get_setup_requirements()
 
-    async def _serve(self) -> None:
+    async def _start(self) -> None:
         await self.service.start()
+        await super()._start()
 
-    async def _shutdown(self) -> None:
+    async def _stop(self) -> None:
+        await super()._stop()
         await self.service.stop()
 
     async def _run(self, action: ActionConfig, context: ComponentActionContext) -> Any:

{model_compose-0.4.72 → model_compose-0.4.74}/src/mindor/core/component/services/audio_converter/base.py

@@ -8,6 +8,7 @@ from ...context import ComponentActionContext
 class AudioConverterService(AsyncService):
     def __init__(self, id: str, config: AudioConverterComponentConfig, daemon: bool):
         super().__init__(daemon)
+
         self.id: str = id
         self.config: AudioConverterComponentConfig = config
 

model_compose-0.4.74/src/mindor/core/component/services/audio_converter/drivers/common.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+from mindor.dsl.schema.action import AudioConverterActionConfig
+
+class AudioConverterAction:
+    def __init__(self, config: AudioConverterActionConfig):
+        self.config: AudioConverterActionConfig = config

{model_compose-0.4.72 → model_compose-0.4.74}/src/mindor/core/component/services/audio_converter/drivers/ffmpeg.py

@@ -3,13 +3,15 @@ from __future__ import annotations
 from typing import Optional, Union, Any
 from mindor.dsl.schema.component import AudioConverterComponentConfig
 from mindor.dsl.schema.action import AudioConverterActionConfig
+from mindor.core.utils.audio import AudioStreamResource
+from mindor.core.utils.media import MediaSource
+from mindor.core.utils.streaming import FileStreamResource, StreamResource
+from mindor.core.utils.files import create_temporary_file
 from mindor.core.logger import logging
 from ..base import AudioConverterService, AudioConverterDriver, register_audio_converter_service
 from ..base import ComponentActionContext
-from .common import AudioConverterAction, AudioSource
+from .common import AudioConverterAction
 import asyncio
-import tempfile
-import os
 
 _FORMAT_CODEC_MAP: dict[str, str] = {
     "mp3":  "libmp3lame",
@@ -23,48 +25,43 @@ _FORMAT_CODEC_MAP: dict[str, str] = {
 
 class FFmpegAudioConverterAction(AudioConverterAction):
     async def run(self, context: ComponentActionContext) -> Any:
-        source      = await self._render_source(context)
+        source      = await context.render_audio(self.config.audio)
         format      = await context.render_variable(self.config.format) if self.config.format else "wav"
         codec       = await context.render_variable(self.config.codec) if self.config.codec else None
         bitrate     = await context.render_variable(self.config.bitrate) if self.config.bitrate else None
         sample_rate = await context.render_variable(self.config.sample_rate) if isinstance(self.config.sample_rate, str) else self.config.sample_rate
         channels    = await context.render_variable(self.config.channels) if isinstance(self.config.channels, str) else self.config.channels
 
-        output_path = await self._convert(source, format, codec, bitrate, sample_rate, channels)
-        result = {
-            "path": output_path,
-            "format": format
-        }
+        result = await self._convert(source, format, codec, bitrate, sample_rate, channels)
         context.register_source("result", result)
 
-        return (await context.render_variable(self.config.output, ignore_files=True)) if self.config.output else result
+        return (await context.render_variable(self.config.output)) if self.config.output else result
 
     async def _convert(
         self,
-        source: AudioSource,
+        source: MediaSource,
         format: str,
         codec: Optional[str],
         bitrate: Optional[str],
         sample_rate: Optional[Union[int, str]],
         channels: Optional[Union[int, str]],
-    ) -> str:
-        output_path = os.path.join(tempfile.gettempdir(), f"audio_converter_{os.getpid()}_{id(self)}.{format}")
+    ) -> AudioStreamResource:
+        output_path = create_temporary_file(format)
 
         command = [ "ffmpeg", "-hide_banner" ]
 
         if source.format:
             command.extend([ "-f", source.format ])
-        if source.sample_rate:
-            command.extend([ "-ar", str(source.sample_rate) ])
-        if source.channels:
-            command.extend([ "-ac", str(source.channels) ])
+        if source.attrs.get("sample_rate"):
+            command.extend([ "-ar", str(source.attrs["sample_rate"]) ])
+        if source.attrs.get("channels"):
+            command.extend([ "-ac", str(source.attrs["channels"]) ])
 
-        is_pipe = source.data is not None
-        command.extend([ "-i", "pipe:0" if is_pipe else source.path ])
+        command.extend([ "-i", "pipe:0" ])
 
-        resolved_codec = codec or _FORMAT_CODEC_MAP.get(format)
-        if resolved_codec:
-            command.extend([ "-c:a", resolved_codec ])
+        codec = codec or _FORMAT_CODEC_MAP.get(format)
+        if codec:
+            command.extend([ "-c:a", codec ])
         if bitrate:
             command.extend([ "-b:a", bitrate ])
         if sample_rate:
@@ -74,25 +71,43 @@ class FFmpegAudioConverterAction(AudioConverterAction):
 
         command.extend([ "-y", output_path ])
 
-        logging.info(f"Converting '{'pipe:0' if is_pipe else source.path}' to '{format}' format")
+        logging.debug(f"Converting audio stream to '{format}' format")
 
         process = await asyncio.create_subprocess_exec(
             *command,
-            stdin=asyncio.subprocess.PIPE if is_pipe else None,
+            stdin=asyncio.subprocess.PIPE,
             stdout=asyncio.subprocess.PIPE,
             stderr=asyncio.subprocess.PIPE
         )
 
-        raw = bytes(source.data) if isinstance(source.data, (bytes, bytearray)) else None
-        _, stderr = await process.communicate(input=raw)
+        stderr = await self._pipe_stream(process, source.stream)
 
         if process.returncode != 0:
-            error_output = stderr.decode("utf-8", errors="replace")
-            raise RuntimeError(f"ffmpeg audio conversion failed (exit code {process.returncode}): {error_output}")
-
-        logging.info(f"Audio conversion completed: '{output_path}'")
-
-        return output_path
+            error = stderr.decode("utf-8", errors="replace")
+            raise RuntimeError(f"ffmpeg audio conversion failed (exit code {process.returncode}): {error}")
+
+        logging.debug(f"Audio conversion completed: '{output_path}'")
+
+        return AudioStreamResource(FileStreamResource(output_path, auto_delete=True), format=format)
+
+    async def _pipe_stream(self, process: asyncio.subprocess.Process, source: StreamResource) -> bytes:
+        async def _feed() -> None:
+            try:
+                async for chunk in source:
+                    process.stdin.write(chunk)
+                    await process.stdin.drain()
+            finally:
+                process.stdin.close()
+                await source.close()
+
+        feeder = asyncio.create_task(_feed())
+        try:
+            stderr = await process.stderr.read()
+            await process.wait()
+        finally:
+            await feeder
+
+        return stderr
 
 @register_audio_converter_service(AudioConverterDriver.FFMPEG)
 class FFmpegAudioConverterService(AudioConverterService):

{model_compose-0.4.72 → model_compose-0.4.74}/src/mindor/core/component/services/audio_extractor/audio_extractor.py

@@ -16,6 +16,7 @@ class AudioExtractorComponent(ComponentService):
         daemon: bool
     ):
         super().__init__(id, config, global_configs, daemon)
+
         self.service: AudioExtractorService = self._create_service(self.config.driver)
 
     def _create_service(self, driver: AudioExtractorDriver) -> AudioExtractorService:
@@ -29,10 +30,12 @@ class AudioExtractorComponent(ComponentService):
     def _get_setup_requirements(self) -> Optional[List[str]]:
         return self.service.get_setup_requirements()
 
-    async def _serve(self) -> None:
+    async def _start(self) -> None:
         await self.service.start()
+        await super()._start()
 
-    async def _shutdown(self) -> None:
+    async def _stop(self) -> None:
+        await super()._stop()
         await self.service.stop()
 
     async def _run(self, action: ActionConfig, context: ComponentActionContext) -> Any:

{model_compose-0.4.72 → model_compose-0.4.74}/src/mindor/core/component/services/audio_extractor/base.py

@@ -8,6 +8,7 @@ from ...context import ComponentActionContext
 class AudioExtractorService(AsyncService):
     def __init__(self, id: str, config: AudioExtractorComponentConfig, daemon: bool):
         super().__init__(daemon)
+
         self.id: str = id
         self.config: AudioExtractorComponentConfig = config
 

{model_compose-0.4.72 → model_compose-0.4.74}/src/mindor/core/component/services/audio_extractor/drivers/ffmpeg.py

@@ -38,7 +38,7 @@ class FFmpegAudioExtractorAction:
         }
         context.register_source("result", result)
 
-        return (await context.render_variable(self.config.output, ignore_files=True)) if self.config.output else result
+        return (await context.render_variable(self.config.output)) if self.config.output else result
 
     async def _extract(
         self,