model-compose 0.4.64__tar.gz → 0.4.65__tar.gz

{model_compose-0.4.64/src/model_compose.egg-info → model_compose-0.4.65}/PKG-INFO

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

{model_compose-0.4.64 → model_compose-0.4.65}/pyproject.toml

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

{model_compose-0.4.64 → model_compose-0.4.65}/src/mindor/core/component/services/model/tasks/music_generation/ace_step.py

@@ -5,9 +5,10 @@ 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 mindor.core.utils.audio import PcmStreamResource
 from ...base import ComponentActionContext
 from .common import MusicGenerationTaskService, MusicGenerationTaskAction
-import asyncio, io
+import asyncio
 
 if TYPE_CHECKING:
     from acestep.handler import AceStepHandler
@@ -19,9 +20,8 @@ class AceStepMusicGenerationTaskAction(MusicGenerationTaskAction):
         self.config: AceStepMusicGenerationModelActionConfig = config
         self.handler: AceStepHandler = handler
 
-    async def _generate(self, prompt: str, lyrics: Optional[str], params: Dict[str, Any]) -> bytes:
+    async def _generate(self, prompt: str, lyrics: Optional[str], params: Dict[str, Any]) -> Any:
         from acestep.inference import generate_music, GenerationParams, GenerationConfig
-        import soundfile as sf
 
         generation_params = GenerationParams(
             caption=prompt,
@@ -50,13 +50,14 @@ class AceStepMusicGenerationTaskAction(MusicGenerationTaskAction):
         if not result.success:
             raise RuntimeError(f"Music generation failed: {result.error}")
 
-        audio_tensor = result.audios[0]["tensor"]
+        frames, channels = self._encode_samples_to_pcm16(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()
+        return PcmStreamResource(frames, {
+            "sample_rate": str(sample_rate),
+            "channels": str(channels),
+            "bit_depth": "16",
+        })
 
     async def _resolve_generation_params(self, context: ComponentActionContext) -> Dict[str, Any]:
         params = await super()._resolve_generation_params(context)
@@ -81,6 +82,7 @@ class AceStepMusicGenerationTaskService(MusicGenerationTaskService):
             "torchvision==0.25.0+cu128@https://download.pytorch.org/whl/cu128",
             "nano-vllm@git+https://github.com/GeeeekExplorer/nano-vllm.git",
             "ace-step@git+https://github.com/ace-step/ACE-Step-1.5.git",
+            "numpy",
             "soundfile"
         ]
 

{model_compose-0.4.64 → model_compose-0.4.65}/src/mindor/core/component/services/model/tasks/music_generation/common.py

@@ -1,9 +1,16 @@
-from typing import Optional, Dict, Any
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+from typing import Optional, Dict, Any, Tuple, Union, List
 from abc import ABC, abstractmethod
 from mindor.dsl.schema.action import MusicGenerationModelActionConfig
 from mindor.core.logger import logging
 from ...base import ModelTaskService, ComponentActionContext
 
+if TYPE_CHECKING:
+    import numpy as np
+    import torch
+
 class MusicGenerationTaskAction:
     def __init__(self, config: MusicGenerationModelActionConfig):
         self.config: MusicGenerationModelActionConfig = config
@@ -29,8 +36,34 @@ class MusicGenerationTaskAction:
         return params
 
     @abstractmethod
-    async def _generate(self, prompt: str, lyrics: Optional[str], params: Dict[str, Any]) -> bytes:
+    async def _generate(self, prompt: str, lyrics: Optional[str], params: Dict[str, Any]) -> Any:
         pass
 
+    def _encode_samples_to_pcm16(self, samples: Union[torch.Tensor, np.typing.ArrayLike]) -> Tuple[bytes, int]:
+        import numpy as np
+
+        if hasattr(samples, "detach"):
+            samples = samples.detach()
+        if hasattr(samples, "cpu"):
+            samples = samples.cpu()
+        if hasattr(samples, "numpy"):
+            samples = samples.numpy()
+
+        array = np.asarray(samples)
+        if array.ndim == 1:
+            array = array[:, None]
+        elif array.ndim == 2 and array.shape[0] <= 8 and array.shape[0] < array.shape[1]:
+            array = array.T
+        elif array.ndim != 2:
+            raise ValueError(f"Expected mono or stereo audio samples, got shape {array.shape}")
+
+        if np.issubdtype(array.dtype, np.floating):
+            array = np.clip(array, -1.0, 1.0)
+            array = (array * 32767.0).astype("<i2")
+        elif array.dtype != np.int16:
+            array = array.astype("<i2")
+
+        return array.tobytes(), int(array.shape[1])
+
 class MusicGenerationTaskService(ModelTaskService):
     pass

{model_compose-0.4.64 → model_compose-0.4.65}/src/mindor/core/component/services/model/tasks/text_to_speech/common.py

@@ -8,6 +8,7 @@ from mindor.core.logger import logging
 from ...base import ModelTaskService, ComponentActionContext
 
 if TYPE_CHECKING:
+    import numpy as np
     import torch
 
 class TextToSpeechTaskAction:
@@ -21,8 +22,8 @@ class TextToSpeechTaskAction:
         texts: List[str] = [ text ] if is_single_input else text
         results = []
 
-        for t in texts:
-            audio_bytes = await self._generate(t, context)
+        for text in texts:
+            audio_bytes = await self._generate(text, context)
             results.append(audio_bytes)
 
         return results[0] if is_single_input else results
@@ -31,8 +32,34 @@ class TextToSpeechTaskAction:
         return await context.render_variable(self.config.text)
 
     @abstractmethod
-    async def _generate(self, text: str, context: ComponentActionContext) -> bytes:
+    async def _generate(self, text: str, context: ComponentActionContext) -> Any:
         pass
 
+    def _encode_samples_to_pcm16(self, samples: Union[torch.Tensor, np.typing.ArrayLike]) -> Tuple[bytes, int]:
+        import numpy as np
+
+        if hasattr(samples, "detach"):
+            samples = samples.detach()
+        if hasattr(samples, "cpu"):
+            samples = samples.cpu()
+        if hasattr(samples, "numpy"):
+            samples = samples.numpy()
+
+        array = np.asarray(samples)
+        if array.ndim == 1:
+            array = array[:, None]
+        elif array.ndim == 2 and array.shape[0] <= 8 and array.shape[0] < array.shape[1]:
+            array = array.T
+        elif array.ndim != 2:
+            raise ValueError(f"Expected mono or stereo audio samples, got shape {array.shape}")
+
+        if np.issubdtype(array.dtype, np.floating):
+            array = np.clip(array, -1.0, 1.0)
+            array = (array * 32767.0).astype("<i2")
+        elif array.dtype != np.int16:
+            array = array.astype("<i2")
+
+        return array.tobytes(), int(array.shape[1])
+
 class TextToSpeechTaskService(ModelTaskService):
     pass

{model_compose-0.4.64 → model_compose-0.4.65}/src/mindor/core/component/services/model/tasks/text_to_speech/qwen.py

@@ -6,9 +6,10 @@ from abc import abstractmethod
 from mindor.dsl.schema.component import ModelComponentConfig, HuggingfaceModelConfig
 from mindor.dsl.schema.action import ModelActionConfig, TextToSpeechActionMethod
 from mindor.core.logger import logging
+from mindor.core.utils.audio import PcmStreamResource
 from ...base import ComponentActionContext
 from .common import TextToSpeechTaskService, TextToSpeechTaskAction
-import asyncio, io
+import asyncio
 
 if TYPE_CHECKING:
     import torch
@@ -32,17 +33,17 @@ class QwenTextToSpeechTaskAction(TextToSpeechTaskAction):
 
         self.model = model
 
-    async def _generate(self, text: str, context: ComponentActionContext) -> bytes:
-        import soundfile as sf
-
+    async def _generate(self, text: str, context: ComponentActionContext) -> Any:
         language = await context.render_variable(self.config.language)
         language = self._resolve_language(language) if language else None
         samples, sample_rate = await self._synthesize(text, language, context)
+        frames, channels = self._encode_samples_to_pcm16(samples[0])
 
-        buffer = io.BytesIO()
-        sf.write(buffer, samples[0], sample_rate, format="WAV")
-
-        return buffer.getvalue()
+        return PcmStreamResource(frames, {
+            "sample_rate": str(sample_rate),
+            "channels": str(channels),
+            "bit_depth": "16",
+        })
 
     def _resolve_language(self, language: Optional[str]) -> Optional[str]:
         return _QWEN_LANGUAGE_MAP.get(language.split("-")[0])
@@ -93,7 +94,7 @@ class QwenTextToSpeechTaskService(TextToSpeechTaskService):
         self.device: Optional[torch.device] = None
 
     def get_setup_requirements(self) -> Optional[List[str]]:
-        return [ "transformers", "qwen_tts", "soundfile" ]
+        return [ "transformers", "qwen_tts", "numpy", "soundfile" ]
 
     def _load_model(self) -> None:
         self.model, self.device = self._load_pretrained_model()

{model_compose-0.4.64 → model_compose-0.4.65}/src/mindor/core/utils/renderers.py

@@ -6,6 +6,7 @@ from .streaming import encode_stream_to_base64, save_stream_to_temporary_file, B
 from .http_request import create_upload_file
 from .http_client import create_stream_with_url
 from .image import load_image_from_stream, ImageStreamResource
+from .audio import PcmStreamResource, WavStreamResource
 from .resolvers import FieldResolver
 from starlette.datastructures import UploadFile
 from PIL import Image as PILImage
@@ -149,6 +150,12 @@ class VariableRenderer:
         if type in [ "image", "audio", "video", "file" ]:
             if isinstance(value, UploadFile) and format == "path":
                 return await FileValueRenderer().render(value)
+            if type == "audio" and subtype == "pcm":
+                if isinstance(value, bytes):
+                    value = PcmStreamResource(value, attrs)
+            if type == "audio" and subtype == "wav":
+                if isinstance(value, PcmStreamResource):
+                    value = WavStreamResource(value)
             if not ignore_files and not isinstance(value, UploadFile):
                 if format != "path":
                     value = await self._save_value_to_temporary_file(value, subtype, attrs, format)

{model_compose-0.4.64 → model_compose-0.4.65/src/model_compose.egg-info}/PKG-INFO

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