model-compose 0.4.59__tar.gz → 0.4.61__tar.gz

{model_compose-0.4.59/src/model_compose.egg-info → model_compose-0.4.61}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model-compose
-Version: 0.4.59
+Version: 0.4.61
 Summary: model-compose: Declarative AI Workflow Orchestrator
 Author-email: Hanyeol Cho <hanyeol.cho@gmail.com>
 License-Expression: MIT

{model_compose-0.4.59 → model_compose-0.4.61}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "model-compose"
-version = "0.4.59"
+version = "0.4.61"
 description = "model-compose: Declarative AI Workflow Orchestrator"
 authors = [
     { name = "Hanyeol Cho", email = "hanyeol.cho@gmail.com" }

{model_compose-0.4.59 → model_compose-0.4.61}/src/mindor/core/component/services/__init__.py

@@ -5,6 +5,7 @@ from .websocket_client import *
 from .mcp_server import *
 from .mcp_client import *
 from .model import *
+from .model_memory import *
 from .datasets import *
 from .vector_store import *
 from .workflow import *

{model_compose-0.4.59 → model_compose-0.4.61}/src/mindor/core/component/services/graph_store/drivers/arangodb.py

@@ -234,23 +234,23 @@ class ArangoDBGraphStoreService(GraphStoreService):
         super().__init__(id, config, daemon)
 
         self.client: Optional[ArangoClient] = None
-        self.db: Optional[StandardDatabase] = None
+        self.database: Optional[StandardDatabase] = None
 
     def get_setup_requirements(self) -> Optional[List[str]]:
         return ["python-arango"]
 
     async def _serve(self) -> None:
-        self.client, self.db = self._create_client()
+        self.client, self.database = self._create_client()
 
     async def _shutdown(self) -> None:
         if self.client:
             self.client.close()
             self.client = None
-            self.db = None
+            self.database = None
 
     async def _run(self, action: GraphStoreActionConfig, context: ComponentActionContext) -> Any:
         async def _run():
-            return await ArangoDBGraphStoreAction(action).run(context, self.db)
+            return await ArangoDBGraphStoreAction(action).run(context, self.database)
 
         return await self.run_in_thread(_run)
 

{model_compose-0.4.59 → model_compose-0.4.61}/src/mindor/core/component/services/model/tasks/__init__.py

@@ -7,3 +7,4 @@ from .image_upscale import *
 from .face_embedding import *
 from .text_to_speech import *
 from .speech_to_text import *
+from .music_generation import *

{model_compose-0.4.59 → model_compose-0.4.61}/src/mindor/core/component/services/model/tasks/face_embedding/common.py

@@ -35,12 +35,11 @@ class FaceEmbeddingTaskAction:
     async def _prepare_input(self, context: ComponentActionContext) -> Union[PILImage.Image, List[PILImage.Image]]:
         return await context.render_image(self.config.image)
 
-    @abstractmethod
-    async def _embed(self, images: List[PILImage.Image], params: Dict[str, Any]) -> List[List[float]]:
-        pass
+    async def _resolve_embedding_params(self, context: ComponentActionContext) -> Dict[str, Any]:
+        return {}
 
     @abstractmethod
-    async def _resolve_embedding_params(self, context: ComponentActionContext) -> Dict[str, Any]:
+    async def _embed(self, images: List[PILImage.Image], params: Dict[str, Any]) -> List[List[float]]:
         pass
 
 class FaceEmbeddingTaskService(ModelTaskService):

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

@@ -18,6 +18,7 @@ class InsightfaceFaceEmbeddingTaskAction(FaceEmbeddingTaskAction):
     def __init__(self, config: InsightfaceFaceEmbeddingModelActionConfig, model: FaceAnalysis):
         super().__init__(config, None)
 
+        self.config: InsightfaceFaceEmbeddingModelActionConfig = config
         self.model: FaceAnalysis = model
 
     async def _embed(self, images: List[PILImage.Image], params: Dict[str, Any]) -> List[List[float]]:
@@ -31,9 +32,6 @@ class InsightfaceFaceEmbeddingTaskAction(FaceEmbeddingTaskAction):
 
         return embeddings
 
-    async def _resolve_embedding_params(self, context: ComponentActionContext) -> Dict[str, Any]:
-        return {}
-
 class InsightfaceFaceEmbeddingTaskService(FaceEmbeddingTaskService):
     def __init__(self, id: str, config: ModelComponentConfig, daemon: bool):
         super().__init__(id, config, daemon)

{model_compose-0.4.59 → model_compose-0.4.61}/src/mindor/core/component/services/model/tasks/image_generation/common.py

@@ -35,12 +35,11 @@ class ImageGenerationTaskAction:
     async def _prepare_input(self, context: ComponentActionContext) -> Union[str, List[str]]:
         return await context.render_variable(self.config.text)
 
-    @abstractmethod
-    async def _generate(self, images: List[PILImage.Image], params: Dict[str, Any]) -> List[PILImage.Image]:
-        pass
+    async def _resolve_generation_params(self, context: ComponentActionContext) -> Dict[str, Any]:
+        return {}
 
     @abstractmethod
-    async def _resolve_generation_params(self, context: ComponentActionContext) -> Dict[str, Any]:
+    async def _generate(self, images: List[PILImage.Image], params: Dict[str, Any]) -> List[PILImage.Image]:
         pass
 
 class ImageGenerationTaskService(ModelTaskService):

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

@@ -22,14 +22,12 @@ class FluxImageGenerationTaskAction(ImageGenerationTaskAction):
     ):
         super().__init__(config, device)
 
+        self.config: FluxImageGenerationModelActionConfig = config
         self.pipeline = pipeline
 
     async def _generate(self, params: Dict[str, Any]) -> List[PILImage.Image]:
         pass
 
-    async def _resolve_generation_params(self, context: ComponentActionContext) -> Dict[str, Any]:
-        pass
-
 class FluxImageGenerationTaskService(ImageGenerationTaskService):
     def __init__(self, id: str, config: ModelComponentConfig, daemon: bool):
         super().__init__(id, config, daemon)

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

@@ -22,14 +22,12 @@ class HunyuanImageGenerationTaskAction(ImageGenerationTaskAction):
     ):
         super().__init__(config, device)
 
+        self.config: HunyuanImageGenerationModelActionConfig = config
         self.pipeline = pipeline
 
     async def _generate(self, params: Dict[str, Any]) -> List[PILImage.Image]:
         pass
 
-    async def _resolve_generation_params(self, context: ComponentActionContext) -> Dict[str, Any]:
-        pass
-
 class HunyuanImageGenerationTaskService(ImageGenerationTaskService):
     def __init__(self, id: str, config: ModelComponentConfig, daemon: bool):
         super().__init__(id, config, daemon)

{model_compose-0.4.59 → model_compose-0.4.61}/src/mindor/core/component/services/model/tasks/image_generation/sdxl.py

@@ -22,14 +22,12 @@ class SdxlImageGenerationTaskAction(ImageGenerationTaskAction):
     ):
         super().__init__(config, device)
 
+        self.config: SdxlImageGenerationModelActionConfig = config
         self.pipeline = pipeline
 
     async def _generate(self, params: Dict[str, Any]) -> List[PILImage.Image]:
         pass
 
-    async def _resolve_generation_params(self, context: ComponentActionContext) -> Dict[str, Any]:
-        pass
-
 class SdxlImageGenerationTaskService(ImageGenerationTaskService):
     def __init__(self, id: str, config: ModelComponentConfig, daemon: bool):
         super().__init__(id, config, daemon)

{model_compose-0.4.59 → model_compose-0.4.61}/src/mindor/core/component/services/model/tasks/image_to_text/huggingface.py

@@ -108,7 +108,7 @@ class HuggingfaceImageToTextTaskAction:
     async def _resolve_processor_params(self, context: ComponentActionContext) -> Dict[str, Any]:
         max_input_length = await context.render_variable(self.config.max_input_length)
 
-        params = {
+        params: Dict[str, Any] = {
             "return_tensors": "pt",
             "padding": True,
             "truncation": False

{model_compose-0.4.59 → model_compose-0.4.61}/src/mindor/core/component/services/model/tasks/image_upscale/common.py

@@ -28,7 +28,7 @@ class ImageUpscaleTaskAction:
         results = []
 
         batch_size   = await context.render_variable(self.config.batch_size)
-        color_format = await context.render_variable(self.config.params.color_format)
+        color_format = await context.render_variable(self.config.color_format)
         params       = await self._resolve_upscale_params(context)
 
         for index in range(0, len(images), batch_size):
@@ -41,6 +41,9 @@ class ImageUpscaleTaskAction:
     async def _prepare_input(self, context: ComponentActionContext) -> Union[PILImage.Image, List[PILImage.Image]]:
         return await context.render_image(self.config.image)
 
+    async def _resolve_upscale_params(self, context: ComponentActionContext) -> Dict[str, Any]:
+        return {}
+
     def _normalize_image(self, image: PILImage.Image, color_format: ColorFormat) -> PILImage.Image:
         if color_format == ColorFormat.RGB:
             return image.convert("RGB")
@@ -66,9 +69,5 @@ class ImageUpscaleTaskAction:
     async def _upscale(self, images: List[PILImage.Image], params: Dict[str, Any]) -> List[PILImage.Image]:
         pass
 
-    @abstractmethod
-    async def _resolve_upscale_params(self, context: ComponentActionContext) -> Dict[str, Any]:
-        pass
-
 class ImageUpscaleTaskService(ModelTaskService):
     pass

{model_compose-0.4.59 → model_compose-0.4.61}/src/mindor/core/component/services/model/tasks/image_upscale/esrgan.py

@@ -23,14 +23,12 @@ class EsrganImageUpscaleTaskAction(ImageUpscaleTaskAction):
     ):
         super().__init__(config, device)
 
+        self.config: EsrganImageUpscaleModelActionConfig = config
         self.model: RRDBNet = model
 
     async def _upscale(self, images: List[PILImage.Image], params: Dict[str, Any]) -> List[PILImage.Image]:
         pass
 
-    async def _resolve_upscale_params(self, context: ComponentActionContext) -> Dict[str, Any]:
-        pass
-
 class EsrganImageUpscaleTaskService(ImageUpscaleTaskService):
     def __init__(self, id: str, config: ModelComponentConfig, daemon: bool):
         super().__init__(id, config, daemon)

{model_compose-0.4.59 → model_compose-0.4.61}/src/mindor/core/component/services/model/tasks/image_upscale/ldsr.py

@@ -23,6 +23,7 @@ class LdsrImageUpscaleTaskAction(ImageUpscaleTaskAction):
     ):
         super().__init__(config, device)
 
+        self.config: LdsrImageUpscaleModelActionConfig = config
         self.model: PreTrainedModel = model
 
     async def _upscale(self, images: List[PILImage.Image], params: Dict[str, Any]) -> List[PILImage.Image]:
@@ -70,13 +71,13 @@ class LdsrImageUpscaleTaskAction(ImageUpscaleTaskAction):
         pass
 
     async def _resolve_upscale_params(self, context: ComponentActionContext) -> Dict[str, Any]:
-        params: Dict[str, Any] = {}
-        
+        params = await super()._resolve_upscale_params(context)
+
         params["steps"            ] = await context.render_variable(self.config.params.steps)
         params["eta"              ] = await context.render_variable(self.config.params.eta)
         params["downsample_method"] = await context.render_variable(self.config.params.downsample_method)
         params["half_precision"   ] = await context.render_variable(self.config.params.half_precision)
-        
+
         return params
 
 class LdsrImageUpscaleTaskService(ImageUpscaleTaskService):

{model_compose-0.4.59 → model_compose-0.4.61}/src/mindor/core/component/services/model/tasks/image_upscale/real_esrgan.py

@@ -23,6 +23,7 @@ class RealEsrganImageUpscaleTaskAction(ImageUpscaleTaskAction):
     ):
         super().__init__(config, device)
 
+        self.config: RealEsrganImageUpscaleModelActionConfig = config
         self.model: RealESRGAN = model
 
     async def _upscale(self, images: List[PILImage.Image], params: Dict[str, Any]) -> List[PILImage.Image]:
@@ -36,7 +37,7 @@ class RealEsrganImageUpscaleTaskAction(ImageUpscaleTaskAction):
         return upscaled_images
 
     async def _resolve_upscale_params(self, context: ComponentActionContext) -> Dict[str, Any]:
-        params: Dict[str, Any] = {}
+        params = await super()._resolve_upscale_params(context)
 
         params["batch_size"  ] = await context.render_variable(self.config.params.tile_batch_size)
         params["patches_size"] = await context.render_variable(self.config.params.tile_size)

{model_compose-0.4.59 → model_compose-0.4.61}/src/mindor/core/component/services/model/tasks/image_upscale/swinir.py

@@ -24,6 +24,7 @@ class SwinIRImageUpscaleTaskAction(ImageUpscaleTaskAction):
     ):
         super().__init__(config, device)
 
+        self.config: SwinIRImageUpscaleModelActionConfig = config
         self.model: SwinIR = model
 
     async def _upscale(self, images: List[PILImage.Image], params: Dict[str, Any]) -> List[PILImage.Image]:
@@ -144,15 +145,15 @@ class SwinIRImageUpscaleTaskAction(ImageUpscaleTaskAction):
         return output
 
     async def _resolve_upscale_params(self, context: ComponentActionContext) -> Dict[str, Any]:
-        params: Dict[str, Any] = {}
-        
+        params = await super()._resolve_upscale_params(context)
+
         params["task"        ] = await context.render_variable(self.config.params.task)
         params["tile"        ] = await context.render_variable(self.config.params.tile)
         params["tile_overlap"] = await context.render_variable(self.config.params.tile_overlap)
         params["scale"       ] = await context.render_variable(self.config.params.scale)
         params["window_size" ] = await context.render_variable(self.config.params.window_size)
         params["jpeg_quality"] = await context.render_variable(self.config.params.jpeg_quality)
-        
+
         return params
 
 class SwinIRImageUpscaleTaskService(ImageUpscaleTaskService):

model_compose-0.4.61/src/mindor/core/component/services/model/tasks/music_generation/ace_step.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+from typing import Type, Union, Literal, Optional, Dict, List, Any
+from mindor.dsl.schema.component import ModelComponentConfig, HuggingfaceModelConfig
+from mindor.dsl.schema.action import ModelActionConfig, AceStepMusicGenerationModelActionConfig
+from mindor.core.logger import logging
+from ...base import ComponentActionContext
+from .common import MusicGenerationTaskService, MusicGenerationTaskAction
+import asyncio, io
+
+if TYPE_CHECKING:
+    from acestep.handler import AceStepHandler
+
+class AceStepMusicGenerationTaskAction(MusicGenerationTaskAction):
+    def __init__(self, config: AceStepMusicGenerationModelActionConfig, handler: AceStepHandler):
+        super().__init__(config)
+
+        self.config: AceStepMusicGenerationModelActionConfig = config
+        self.handler: AceStepHandler = handler
+
+    async def _generate(self, prompt: str, lyrics: Optional[str], params: Dict[str, Any]) -> bytes:
+        from acestep.inference import generate_music, GenerationParams, GenerationConfig
+        import soundfile as sf
+
+        generation_params = GenerationParams(
+            caption=prompt,
+            lyrics=lyrics or "",
+            duration=int(params["duration"]),
+            bpm=int(params["bpm"]),
+            key_scale=params["key_scale"],
+            time_signature=params["time_signature"],
+            inference_steps=int(params["inference_steps"]),
+            guidance_scale=float(params["guidance_scale"]),
+            seed=int(params["seed"]) if params["seed"] is not None else None,
+        )
+
+        generation_config = GenerationConfig(
+            batch_size=1,
+            audio_format="wav",
+        )
+
+        result = generate_music(
+            dit_handler=self.handler,
+            llm_handler=None,
+            params=generation_params,
+            config=generation_config,
+        )
+
+        if not result.success:
+            raise RuntimeError(f"Music generation failed: {result.error}")
+
+        audio_tensor = result.audios[0]["tensor"]
+        sample_rate = result.audios[0].get("sample_rate", 48000)
+
+        buffer = io.BytesIO()
+        sf.write(buffer, audio_tensor, sample_rate, format="WAV")
+
+        return buffer.getvalue()
+
+    async def _resolve_generation_params(self, context: ComponentActionContext) -> Dict[str, Any]:
+        params = await super()._resolve_generation_params(context)
+
+        params["time_signature" ] = await context.render_variable(self.config.params.time_signature)
+        params["inference_steps"] = await context.render_variable(self.config.params.inference_steps)
+        params["guidance_scale" ] = await context.render_variable(self.config.params.guidance_scale)
+        params["seed"           ] = await context.render_variable(self.config.params.seed)
+
+        return params
+
+class AceStepMusicGenerationTaskService(MusicGenerationTaskService):
+    def __init__(self, id: str, config: ModelComponentConfig, daemon: bool):
+        super().__init__(id, config, daemon)
+
+        self.handler: Optional[AceStepHandler] = None
+
+    def get_setup_requirements(self) -> Optional[List[str]]:
+        return [ "ace-step@git+https://github.com/ace-step/ACE-Step-1.5.git", "soundfile" ]
+
+    def _load_model(self) -> None:
+        if isinstance(self.config.model, HuggingfaceModelConfig):
+            raise ValueError("ACE-Step does not support HuggingFace Hub models. Use a local model path instead.")
+
+        self.handler = self._load_generation_handler()
+
+    def _unload_model(self) -> None:
+        self.handler = None
+
+    def _load_generation_handler(self) -> AceStepHandler:
+        from acestep.handler import AceStepHandler
+
+        handler = AceStepHandler()
+        handler.initialize_service(
+            project_root=self._get_model_path(),
+            config_path=self.config.preset,
+            device=str(self.config.device),
+        )
+
+        return handler
+
+    async def _run(
+        self,
+        action: ModelActionConfig,
+        context: ComponentActionContext,
+        loop: asyncio.AbstractEventLoop
+    ) -> Any:
+        return await AceStepMusicGenerationTaskAction(action, self.handler).run(context)

model_compose-0.4.61/src/mindor/core/component/services/model/tasks/music_generation/common.py

@@ -0,0 +1,36 @@
+from typing import Optional, Dict, Any
+from abc import ABC, abstractmethod
+from mindor.dsl.schema.action import MusicGenerationModelActionConfig
+from mindor.core.logger import logging
+from ...base import ModelTaskService, ComponentActionContext
+
+class MusicGenerationTaskAction:
+    def __init__(self, config: MusicGenerationModelActionConfig):
+        self.config: MusicGenerationModelActionConfig = config
+
+    async def run(self, context: ComponentActionContext) -> Any:
+        prompt = await context.render_variable(self.config.prompt)
+        lyrics = await context.render_variable(self.config.lyrics) if self.config.lyrics is not None else None
+        params = await self._resolve_generation_params(context)
+
+        return await self._generate(prompt, lyrics, params)
+
+    async def _resolve_generation_params(self, context: ComponentActionContext) -> Dict[str, Any]:
+        duration  = await context.render_variable(self.config.params.duration)
+        bpm       = await context.render_variable(self.config.params.bpm)
+        key_scale = await context.render_variable(self.config.params.key_scale)
+
+        params: Dict[str, Any] = {
+            "duration": duration,
+            "bpm": bpm,
+            "key_scale": key_scale,
+        }
+
+        return params
+
+    @abstractmethod
+    async def _generate(self, prompt: str, lyrics: Optional[str], params: Dict[str, Any]) -> bytes:
+        pass
+
+class MusicGenerationTaskService(ModelTaskService):
+    pass

model_compose-0.4.61/src/mindor/core/component/services/model/tasks/music_generation/custom.py

@@ -0,0 +1,12 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, TypeAlias, Any
+from mindor.dsl.schema.component import ModelComponentConfig, MusicGenerationModelFamily
+from ...base import ModelTaskType, ModelDriver, register_model_task_service
+
+@register_model_task_service(ModelTaskType.MUSIC_GENERATION, ModelDriver.CUSTOM)
+class CustomMusicGenerationTaskService:
+    def __new__(cls, id: str, config: ModelComponentConfig, daemon: bool):
+        if config.family == MusicGenerationModelFamily.ACE_STEP:
+            from .ace_step import AceStepMusicGenerationTaskService
+            return AceStepMusicGenerationTaskService(id, config, daemon)
+
+        raise ValueError(f"Unknown family: {config.family}")

{model_compose-0.4.59 → model_compose-0.4.61}/src/mindor/core/component/services/model/tasks/text_classification/huggingface.py

@@ -112,7 +112,7 @@ class HuggingfaceTextClassificationTaskAction:
     async def _resolve_tokenizer_params(self, context: ComponentActionContext) -> Dict[str, Any]:
         max_input_length = await context.render_variable(self.config.max_input_length)
 
-        params = {
+        params: Dict[str, Any] = {
             "return_tensors": "pt",
             "padding": True,
             "truncation": False

{model_compose-0.4.59 → model_compose-0.4.61}/src/mindor/core/component/services/model/tasks/text_embedding/huggingface.py

@@ -103,7 +103,7 @@ class HuggingfaceTextEmbeddingTaskAction:
     async def _resolve_tokenizer_params(self, context: ComponentActionContext) -> Dict[str, Any]:
         max_input_length = await context.render_variable(self.config.max_input_length)
 
-        params = {
+        params: Dict[str, Any] = {
             "return_tensors": "pt",
             "padding": True,
             "truncation": False

{model_compose-0.4.59 → model_compose-0.4.61}/src/mindor/core/component/services/model/tasks/text_generation/huggingface.py

@@ -99,7 +99,7 @@ class HuggingfaceTextGenerationTaskAction:
     async def _resolve_tokenizer_params(self, context: ComponentActionContext) -> Dict[str, Any]:
         max_input_length = await context.render_variable(self.config.max_input_length)
 
-        params = {
+        params: Dict[str, Any] = {
             "return_tensors": "pt",
             "padding": True,
             "truncation": False
@@ -123,7 +123,7 @@ class HuggingfaceTextGenerationTaskAction:
         length_penalty       = await context.render_variable(self.config.params.length_penalty) if num_beams > 1 else None
         early_stopping       = await context.render_variable(self.config.params.early_stopping) if num_beams > 1 else False
 
-        params = {
+        params: Dict[str, Any] = {
             "max_new_tokens": max_output_length,
             "min_length": min_output_length,
             "num_return_sequences": num_return_sequences,

model_compose-0.4.61/src/mindor/core/component/services/model/tasks/text_to_speech/__init__.py

@@ -0,0 +1 @@
+from .custom import *

model_compose-0.4.61/src/mindor/core/component/services/model_memory/__init__.py

@@ -0,0 +1 @@
+from .model_memory import *

model_compose-0.4.61/src/mindor/core/component/services/model_memory/buffer/__init__.py

@@ -0,0 +1 @@
+from .drivers import *