model-compose 0.4.68__tar.gz → 0.4.69__tar.gz

{model_compose-0.4.68 → model_compose-0.4.69}/PKG-INFO

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

{model_compose-0.4.68 → model_compose-0.4.69}/pyproject.toml

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

{model_compose-0.4.68 → model_compose-0.4.69}/src/mindor/core/component/services/http_client.py

@@ -6,6 +6,7 @@ from mindor.dsl.schema.transport.http import HttpStreamFormat
 from mindor.core.listener import HttpCallbackListener
 from mindor.core.utils.http_client import HttpClient
 from mindor.core.utils.http_status import is_status_code_matched
+from mindor.core.utils.rate_limit import RateLimiter
 from mindor.core.utils.streaming import StreamResource
 from mindor.core.utils.time import parse_duration
 from ..base import ComponentService, ComponentType, ComponentGlobalConfigs, register_component
@@ -158,15 +159,20 @@ class HttpClientComponent(ComponentService):
         super().__init__(id, config, global_configs, daemon)
 
         self.client: Optional[HttpClient] = None
+        self.rate_limiter: Optional[RateLimiter] = None
 
     async def _start(self) -> None:
         self.client = HttpClient(self.config.base_url, self.config.headers)
+        self.rate_limiter = RateLimiter(self.config.rate_limit) if self.config.rate_limit else None
         await super()._start()
 
     async def _stop(self) -> None:
         await super()._stop()
         await self.client.close()
         self.client = None
+        self.rate_limiter = None
 
     async def _run(self, action: ActionConfig, context: ComponentActionContext) -> Any:
+        if self.rate_limiter:
+            await self.rate_limiter.acquire()
         return await HttpClientAction(action).run(context, self.client)

{model_compose-0.4.68 → model_compose-0.4.69}/src/mindor/core/component/services/model/tasks/chat_completion/custom/custom.py

@@ -1,4 +1,4 @@
-from mindor.dsl.schema.component import ModelComponentConfig, CustomChatCompletionModelFamily
+from mindor.dsl.schema.component import ModelComponentConfig, ChatCompletionModelFamily
 from ....base import ModelTaskType, ModelDriver, register_model_task_service
 
 @register_model_task_service(ModelTaskType.CHAT_COMPLETION, ModelDriver.CUSTOM)

{model_compose-0.4.68 → model_compose-0.4.69}/src/mindor/core/component/services/model/tasks/face_embedding/custom/custom.py

@@ -1,10 +1,10 @@
-from mindor.dsl.schema.component import ModelComponentConfig, CustomFaceEmbeddingModelFamily
+from mindor.dsl.schema.component import ModelComponentConfig, FaceEmbeddingModelFamily
 from ....base import ModelTaskType, ModelDriver, register_model_task_service
 
 @register_model_task_service(ModelTaskType.FACE_EMBEDDING, ModelDriver.CUSTOM)
 class CustomFaceEmbeddingTaskService:
     def __new__(cls, id: str, config: ModelComponentConfig, daemon: bool):
-        if config.family == CustomFaceEmbeddingModelFamily.INSIGHTFACE:
+        if config.family == FaceEmbeddingModelFamily.INSIGHTFACE:
             from .insightface import InsightfaceFaceEmbeddingTaskService
             return InsightfaceFaceEmbeddingTaskService(id, config, daemon)
 

{model_compose-0.4.68 → model_compose-0.4.69}/src/mindor/core/component/services/model/tasks/image_generation/custom/custom.py

@@ -1,10 +1,10 @@
-from mindor.dsl.schema.component import ModelComponentConfig, CustomImageGenerationModelFamily
+from mindor.dsl.schema.component import ModelComponentConfig, ImageGenerationModelFamily
 from ....base import ModelTaskType, ModelDriver, register_model_task_service
 
 @register_model_task_service(ModelTaskType.IMAGE_GENERATION, ModelDriver.CUSTOM)
 class CustomImageGenerationTaskService:
     def __new__(cls, id: str, config: ModelComponentConfig, daemon: bool):
-        if config.family == CustomImageGenerationModelFamily.HUNYUAN_IMAGE:
+        if config.family == ImageGenerationModelFamily.HUNYUAN_IMAGE:
             from .hunyuan_image import HunyuanImageGenerationTaskService
             return HunyuanImageGenerationTaskService(id, config, daemon)
 

{model_compose-0.4.68 → model_compose-0.4.69}/src/mindor/core/component/services/model/tasks/image_to_text/custom/custom.py

@@ -1,4 +1,4 @@
-from mindor.dsl.schema.component import ModelComponentConfig, CustomImageToTextModelFamily
+from mindor.dsl.schema.component import ModelComponentConfig, ImageToTextModelFamily
 from ....base import ModelTaskType, ModelDriver, register_model_task_service
 
 @register_model_task_service(ModelTaskType.IMAGE_TO_TEXT, ModelDriver.CUSTOM)

{model_compose-0.4.68 → model_compose-0.4.69}/src/mindor/core/component/services/model/tasks/image_upscale/custom/custom.py

@@ -1,22 +1,22 @@
-from mindor.dsl.schema.component import ModelComponentConfig, CustomImageUpscaleModelFamily
+from mindor.dsl.schema.component import ModelComponentConfig, ImageUpscaleModelFamily
 from ....base import ModelTaskType, ModelDriver, register_model_task_service
 
 @register_model_task_service(ModelTaskType.IMAGE_UPSCALE, ModelDriver.CUSTOM)
 class CustomImageUpscaleTaskService:
     def __new__(cls, id: str, config: ModelComponentConfig, daemon: bool):
-        if config.family == CustomImageUpscaleModelFamily.ESRGAN:
+        if config.family == ImageUpscaleModelFamily.ESRGAN:
             from .esrgan import EsrganImageUpscaleTaskService
             return EsrganImageUpscaleTaskService(id, config, daemon)
 
-        if config.family == CustomImageUpscaleModelFamily.REAL_ESRGAN:
+        if config.family == ImageUpscaleModelFamily.REAL_ESRGAN:
             from .real_esrgan import RealEsrganImageUpscaleTaskService
             return RealEsrganImageUpscaleTaskService(id, config, daemon)
 
-        if config.family == CustomImageUpscaleModelFamily.LDSR:
+        if config.family == ImageUpscaleModelFamily.LDSR:
             from .ldsr import LdsrImageUpscaleTaskService
             return LdsrImageUpscaleTaskService(id, config, daemon)
 
-        if config.family == CustomImageUpscaleModelFamily.SWINIR:
+        if config.family == ImageUpscaleModelFamily.SWINIR:
             from .swinir import SwinIRImageUpscaleTaskService
             return SwinIRImageUpscaleTaskService(id, config, daemon)
 

{model_compose-0.4.68 → model_compose-0.4.69}/src/mindor/core/component/services/model/tasks/music_generation/custom/custom.py

@@ -1,10 +1,10 @@
-from mindor.dsl.schema.component import ModelComponentConfig, CustomMusicGenerationModelFamily
+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 == CustomMusicGenerationModelFamily.ACE_STEP:
+        if config.family == MusicGenerationModelFamily.ACE_STEP:
             from .ace_step import AceStepMusicGenerationTaskService
             return AceStepMusicGenerationTaskService(id, config, daemon)
 

{model_compose-0.4.68 → model_compose-0.4.69}/src/mindor/core/component/services/model/tasks/speech_to_text/custom/custom.py

@@ -1,4 +1,4 @@
-from mindor.dsl.schema.component import ModelComponentConfig, CustomSpeechToTextModelFamily
+from mindor.dsl.schema.component import ModelComponentConfig, SpeechToTextModelFamily
 from ....base import ModelTaskType, ModelDriver, register_model_task_service
 
 @register_model_task_service(ModelTaskType.SPEECH_TO_TEXT, ModelDriver.CUSTOM)

{model_compose-0.4.68 → model_compose-0.4.69}/src/mindor/core/component/services/model/tasks/text_classification/custom/custom.py

@@ -1,4 +1,4 @@
-from mindor.dsl.schema.component import ModelComponentConfig, CustomTextClassificationModelFamily
+from mindor.dsl.schema.component import ModelComponentConfig, TextClassificationModelFamily
 from ....base import ModelTaskType, ModelDriver, register_model_task_service
 
 @register_model_task_service(ModelTaskType.TEXT_CLASSIFICATION, ModelDriver.CUSTOM)

{model_compose-0.4.68 → model_compose-0.4.69}/src/mindor/core/component/services/model/tasks/text_embedding/custom/custom.py

@@ -1,4 +1,4 @@
-from mindor.dsl.schema.component import ModelComponentConfig, CustomTextEmbeddingModelFamily
+from mindor.dsl.schema.component import ModelComponentConfig, TextEmbeddingModelFamily
 from ....base import ModelTaskType, ModelDriver, register_model_task_service
 
 @register_model_task_service(ModelTaskType.TEXT_EMBEDDING, ModelDriver.CUSTOM)

{model_compose-0.4.68 → model_compose-0.4.69}/src/mindor/core/component/services/model/tasks/text_generation/custom/custom.py

@@ -1,4 +1,4 @@
-from mindor.dsl.schema.component import ModelComponentConfig, CustomTextGenerationModelFamily
+from mindor.dsl.schema.component import ModelComponentConfig, TextGenerationModelFamily
 from ....base import ModelTaskType, ModelDriver, register_model_task_service
 
 @register_model_task_service(ModelTaskType.TEXT_GENERATION, ModelDriver.CUSTOM)

model_compose-0.4.69/src/mindor/core/component/services/model/tasks/text_to_speech/custom/chatterbox.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+from typing import Optional, List, Tuple, Any
+from mindor.dsl.schema.component import ModelComponentConfig
+from mindor.dsl.schema.action import ModelActionConfig, TextToSpeechActionMethod
+from mindor.core.utils.audio import PcmStreamResource
+from .....base import ComponentActionContext
+from ...common import TextToSpeechTaskService, TextToSpeechTaskAction
+import asyncio
+
+if TYPE_CHECKING:
+    import torch
+
+class ChatterboxTextToSpeechTaskAction(TextToSpeechTaskAction):
+    def __init__(self, config: ModelActionConfig, model: Any, device: Optional[torch.device]):
+        super().__init__(config, device)
+
+        self.model = model
+
+    async def _generate(self, text: str, context: ComponentActionContext) -> Any:
+        exaggeration  = await context.render_variable(self.config.exaggeration)
+        cfg_weight    = await context.render_variable(self.config.cfg_weight)
+        temperature   = await context.render_variable(self.config.temperature)
+        audio_path    = await self._get_reference_audio(context)
+
+        generate_params = {}
+        if exaggeration is not None:
+            generate_params["exaggeration"] = float(exaggeration)
+        if cfg_weight is not None:
+            generate_params["cfg_weight"] = float(cfg_weight)
+        if temperature is not None:
+            generate_params["temperature"] = float(temperature)
+        if audio_path is not None:
+            generate_params["audio_prompt_path"] = audio_path
+
+        samples, sample_rate = await asyncio.get_event_loop().run_in_executor(
+            None, self._synthesize, text, generate_params
+        )
+        frames, channels = self._encode_samples_to_pcm16(samples)
+
+        return PcmStreamResource(frames, {
+            "sample_rate": str(sample_rate),
+            "channels": str(channels),
+            "bit_depth": "16",
+        })
+
+    async def _get_reference_audio(self, context: ComponentActionContext) -> Optional[str]:
+        return None
+
+    def _synthesize(self, text: str, generate_params: dict) -> Tuple[Any, int]:
+        wav = self.model.generate(text, **generate_params)
+        return wav.squeeze(0).cpu(), self.model.sr
+
+class ChatterboxTextToSpeechGenerateTaskAction(ChatterboxTextToSpeechTaskAction):
+    pass
+
+class ChatterboxTextToSpeechCloneTaskAction(ChatterboxTextToSpeechTaskAction):
+    async def _get_reference_audio(self, context: ComponentActionContext) -> Optional[str]:
+        return await context.render_file(self.config.reference_audio)
+
+class ChatterboxTextToSpeechTaskService(TextToSpeechTaskService):
+    def __init__(self, id: str, config: ModelComponentConfig, daemon: bool):
+        super().__init__(id, config, daemon)
+
+        self.model: Optional[Any] = None
+        self.device: Optional[torch.device] = None
+
+    def get_setup_requirements(self) -> Optional[List[str]]:
+        return ["chatterbox-tts", "numpy", "soundfile"]
+
+    def _load_model(self) -> None:
+        self.model, self.device = self._load_pretrained_model()
+
+    def _unload_model(self) -> None:
+        self.model = None
+        self.device = None
+
+    def _load_pretrained_model(self) -> Tuple[Any, Any]:
+        from chatterbox.tts import ChatterboxTTS
+
+        device = self._resolve_device()
+        model = ChatterboxTTS.from_pretrained(str(device))
+
+        return model, device
+
+    async def _run(
+        self,
+        action: ModelActionConfig,
+        context: ComponentActionContext,
+        loop: asyncio.AbstractEventLoop,
+    ) -> Any:
+        if action.method == TextToSpeechActionMethod.GENERATE:
+            return await ChatterboxTextToSpeechGenerateTaskAction(action, self.model, self.device).run(context)
+
+        if action.method == TextToSpeechActionMethod.CLONE:
+            return await ChatterboxTextToSpeechCloneTaskAction(action, self.model, self.device).run(context)
+
+        raise ValueError(f"Unknown method: {action.method}")

model_compose-0.4.69/src/mindor/core/component/services/model/tasks/text_to_speech/custom/custom.py

@@ -0,0 +1,19 @@
+from mindor.dsl.schema.component import ModelComponentConfig, TextToSpeechModelFamily
+from ....base import ModelTaskType, ModelDriver, register_model_task_service
+
+@register_model_task_service(ModelTaskType.TEXT_TO_SPEECH, ModelDriver.CUSTOM)
+class CustomTextToSpeechTaskService:
+    def __new__(cls, id: str, config: ModelComponentConfig, daemon: bool):
+        if config.family == TextToSpeechModelFamily.QWEN:
+            from .qwen import QwenTextToSpeechTaskService
+            return QwenTextToSpeechTaskService(id, config, daemon)
+
+        if config.family == TextToSpeechModelFamily.KOKORO:
+            from .kokoro import KokoroTextToSpeechTaskService
+            return KokoroTextToSpeechTaskService(id, config, daemon)
+
+        if config.family == TextToSpeechModelFamily.CHATTERBOX:
+            from .chatterbox import ChatterboxTextToSpeechTaskService
+            return ChatterboxTextToSpeechTaskService(id, config, daemon)
+
+        raise ValueError(f"Unknown family: {config.family}")

model_compose-0.4.69/src/mindor/core/component/services/model/tasks/text_to_speech/custom/kokoro.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+from typing import Optional, List, Tuple, Any
+from mindor.dsl.schema.component import ModelComponentConfig
+from mindor.dsl.schema.action import ModelActionConfig, TextToSpeechActionMethod
+from mindor.core.utils.audio import PcmStreamResource
+from .....base import ComponentActionContext
+from ...common import TextToSpeechTaskService, TextToSpeechTaskAction
+import asyncio
+
+if TYPE_CHECKING:
+    import torch
+
+class KokoroTextToSpeechGenerateTaskAction(TextToSpeechTaskAction):
+    def __init__(self, config: ModelActionConfig, pipeline: Any, device: Optional[torch.device]):
+        super().__init__(config, device)
+
+        self.pipeline = pipeline
+
+    async def _generate(self, text: str, context: ComponentActionContext) -> Any:
+        voice = await context.render_variable(self.config.voice)
+        speed = await context.render_variable(self.config.speed)
+
+        samples, sample_rate = await asyncio.get_event_loop().run_in_executor(
+            None, self._synthesize, text, voice or "af_heart", float(speed) if speed else 1.0
+        )
+        frames, channels = self._encode_samples_to_pcm16(samples)
+
+        return PcmStreamResource(frames, {
+            "sample_rate": str(sample_rate),
+            "channels": str(channels),
+            "bit_depth": "16",
+        })
+
+    def _synthesize(self, text: str, voice: str, speed: float) -> Tuple[Any, int]:
+        import numpy as np
+
+        chunks = []
+        for _, _, audio in self.pipeline(text, voice=voice, speed=speed):
+            chunks.append(audio)
+
+        samples = np.concatenate(chunks, axis=0) if len(chunks) > 1 else chunks[0]
+        return samples, 24000
+
+class KokoroTextToSpeechTaskService(TextToSpeechTaskService):
+    def __init__(self, id: str, config: ModelComponentConfig, daemon: bool):
+        super().__init__(id, config, daemon)
+
+        self.pipeline: Optional[Any] = None
+        self.device: Optional[torch.device] = None
+
+    def get_setup_requirements(self) -> Optional[List[str]]:
+        return ["kokoro", "numpy", "soundfile"]
+
+    def _load_model(self) -> None:
+        self.pipeline, self.device = self._load_pretrained_model()
+
+    def _unload_model(self) -> None:
+        self.pipeline = None
+        self.device = None
+
+    def _load_pretrained_model(self) -> Tuple[Any, Any]:
+        from kokoro import KPipeline
+
+        device = self._resolve_device()
+        lang_code = "a"  # American English default
+        pipeline = KPipeline(lang_code=lang_code, device=str(device))
+
+        return pipeline, device
+
+    async def _run(
+        self,
+        action: ModelActionConfig,
+        context: ComponentActionContext,
+        loop: asyncio.AbstractEventLoop,
+    ) -> Any:
+        if action.method == TextToSpeechActionMethod.GENERATE:
+            return await KokoroTextToSpeechGenerateTaskAction(action, self.pipeline, self.device).run(context)
+
+        raise ValueError(f"Unknown method: {action.method}")

{model_compose-0.4.68 → model_compose-0.4.69}/src/mindor/core/component/services/model/tasks/text_to_speech/custom/qwen.py

@@ -7,8 +7,8 @@ from mindor.dsl.schema.component import ModelComponentConfig, HuggingfaceModelCo
 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
+from .....base import ComponentActionContext
+from ...common import TextToSpeechTaskService, TextToSpeechTaskAction
 import asyncio
 
 if TYPE_CHECKING:

{model_compose-0.4.68 → model_compose-0.4.69}/src/mindor/core/component/services/web_scraper.py

@@ -1,6 +1,7 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from mindor.dsl.schema.component import WebScraperComponentConfig
 from mindor.dsl.schema.action import ActionConfig, WebScraperActionConfig
+from mindor.core.utils.rate_limit import RateLimiter
 from mindor.core.utils.time import parse_duration
 from ..base import ComponentService, ComponentType, ComponentGlobalConfigs, register_component
 from ..context import ComponentActionContext
@@ -254,6 +255,8 @@ class WebScraperComponent(ComponentService):
     ):
         super().__init__(id, config, global_configs, daemon)
 
+        self.rate_limiter: Optional[RateLimiter] = None
+
     def _get_setup_requirements(self) -> Optional[List[str]]:
         return [ "playwright", "beautifulsoup4", "lxml" ]
 
@@ -269,5 +272,15 @@ class WebScraperComponent(ComponentService):
             capture_output=True
         )
 
+    async def _start(self) -> None:
+        self.rate_limiter = RateLimiter(self.config.rate_limit) if self.config.rate_limit else None
+        await super()._start()
+
+    async def _stop(self) -> None:
+        await super()._stop()
+        self.rate_limiter = None
+
     async def _run(self, action: ActionConfig, context: ComponentActionContext) -> Any:
+        if self.rate_limiter:
+            await self.rate_limiter.acquire()
         return await WebScraperAction(action, self.config.headers, self.config.cookies, self.config.timeout).run(context)

model_compose-0.4.69/src/mindor/core/utils/rate_limit.py

@@ -0,0 +1,56 @@
+from typing import Optional
+from mindor.dsl.schema.component.impl.rate_limit import RateLimitConfig
+from .time import parse_duration
+import asyncio, time
+
+class RateLimiter:
+    def __init__(self, config: RateLimitConfig):
+        self.config: RateLimitConfig = config
+        self._lock: asyncio.Lock = asyncio.Lock()
+
+        self._token_bucket_enabled: bool = config.requests is not None
+        self._interval_enabled: bool = config.interval is not None
+
+        if self._token_bucket_enabled:
+            self._period_seconds: float = parse_duration(config.period).total_seconds()
+            self._refill_rate: float = config.requests / self._period_seconds
+            self._capacity: float = float(config.burst if config.burst is not None else config.requests)
+            self._tokens: float = self._capacity
+            self._last_refill: float = time.monotonic()
+        else:
+            self._period_seconds = 0.0
+            self._refill_rate = 0.0
+            self._capacity = 0.0
+            self._tokens = 0.0
+            self._last_refill = 0.0
+
+        if self._interval_enabled:
+            self._interval_seconds: float = parse_duration(config.interval).total_seconds()
+            self._next_allowed_at: float = 0.0
+        else:
+            self._interval_seconds = 0.0
+            self._next_allowed_at = 0.0
+
+    async def acquire(self) -> None:
+        async with self._lock:
+            now = time.monotonic()
+
+            if self._token_bucket_enabled:
+                self._tokens = min(self._capacity, self._tokens + (now - self._last_refill) * self._refill_rate)
+                self._last_refill = now
+                self._tokens -= 1
+                token_allowed_at = now + max(0.0, -self._tokens / self._refill_rate)
+            else:
+                token_allowed_at = now
+
+            if self._interval_enabled:
+                interval_wait = max(0.0, self._next_allowed_at - token_allowed_at)
+                send_at = token_allowed_at + interval_wait
+                self._next_allowed_at = send_at + self._interval_seconds
+            else:
+                send_at = token_allowed_at
+
+            wait_seconds = send_at - now
+
+        if wait_seconds > 0:
+            await asyncio.sleep(wait_seconds)

model_compose-0.4.69/src/mindor/dsl/schema/action/impl/model/impl/face_embedding/impl/custom/__init__.py

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

{model_compose-0.4.68/src/mindor/dsl/schema/action/impl/model/impl/face_embedding/impl/custom → model_compose-0.4.69/src/mindor/dsl/schema/action/impl/model/impl/face_embedding/impl/custom/impl}/dlib.py

@@ -1,5 +1,5 @@
 from pydantic import Field
-from ..common import CommonFaceEmbeddingModelActionConfig
+from ...common import CommonFaceEmbeddingModelActionConfig
 
 class DlibFaceEmbeddingModelActionConfig(CommonFaceEmbeddingModelActionConfig):
     # Model paths

{model_compose-0.4.68/src/mindor/dsl/schema/action/impl/model/impl/face_embedding/impl/custom → model_compose-0.4.69/src/mindor/dsl/schema/action/impl/model/impl/face_embedding/impl/custom/impl}/facenet.py

@@ -1,6 +1,6 @@
 from typing import Tuple
 from pydantic import Field
-from ..common import CommonFaceEmbeddingModelActionConfig
+from ...common import CommonFaceEmbeddingModelActionConfig
 
 class FacenetFaceEmbeddingModelActionConfig(CommonFaceEmbeddingModelActionConfig):
     # FaceNet specific settings

{model_compose-0.4.68/src/mindor/dsl/schema/action/impl/model/impl/face_embedding/impl/custom → model_compose-0.4.69/src/mindor/dsl/schema/action/impl/model/impl/face_embedding/impl/custom/impl}/insightface.py

@@ -1,6 +1,6 @@
 from typing import Union, Tuple
 from pydantic import Field
-from ..common import CommonFaceEmbeddingModelActionConfig
+from ...common import CommonFaceEmbeddingModelActionConfig
 
 class InsightfaceFaceEmbeddingModelActionConfig(CommonFaceEmbeddingModelActionConfig):
     # Detection settings

model_compose-0.4.69/src/mindor/dsl/schema/action/impl/model/impl/image_generation/impl/custom/__init__.py

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

{model_compose-0.4.68/src/mindor/dsl/schema/action/impl/model/impl/image_generation/impl/custom → model_compose-0.4.69/src/mindor/dsl/schema/action/impl/model/impl/image_generation/impl/custom/impl}/flux.py

@@ -1,5 +1,5 @@
 from pydantic import BaseModel, Field
-from ..common import CommonImageGenerationModelActionConfig
+from ...common import CommonImageGenerationModelActionConfig
 
 class FluxImageGenerationParamsConfig(BaseModel):
     pass

{model_compose-0.4.68/src/mindor/dsl/schema/action/impl/model/impl/image_generation/impl/custom → model_compose-0.4.69/src/mindor/dsl/schema/action/impl/model/impl/image_generation/impl/custom/impl}/hunyuan_image.py

@@ -1,5 +1,5 @@
 from pydantic import BaseModel, Field
-from ..common import CommonImageGenerationModelActionConfig
+from ...common import CommonImageGenerationModelActionConfig
 
 class HunyuanImageGenerationParamsConfig(BaseModel):
     pass

{model_compose-0.4.68/src/mindor/dsl/schema/action/impl/model/impl/image_generation/impl/custom → model_compose-0.4.69/src/mindor/dsl/schema/action/impl/model/impl/image_generation/impl/custom/impl}/sdxl.py

@@ -1,5 +1,5 @@
 from pydantic import BaseModel, Field
-from ..common import CommonImageGenerationModelActionConfig
+from ...common import CommonImageGenerationModelActionConfig
 
 class SdxlImageGenerationParamsConfig(BaseModel):
     pass

model_compose-0.4.69/src/mindor/dsl/schema/action/impl/model/impl/image_upscale/impl/custom/__init__.py

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

{model_compose-0.4.68/src/mindor/dsl/schema/action/impl/model/impl/image_upscale/impl/custom → model_compose-0.4.69/src/mindor/dsl/schema/action/impl/model/impl/image_upscale/impl/custom/impl}/esrgan.py

@@ -1,6 +1,6 @@
 from typing import Union
 from pydantic import Field
-from ..common import CommonImageUpscaleModelActionConfig, CommonImageUpscaleParamsConfig
+from ...common import CommonImageUpscaleModelActionConfig, CommonImageUpscaleParamsConfig
 
 class EsrganImageUpscaleParamsConfig(CommonImageUpscaleParamsConfig):
     tile_size: Union[int, str] = Field(default=0, description="Tile size for processing large images (0 = no tiling).")

{model_compose-0.4.68/src/mindor/dsl/schema/action/impl/model/impl/image_upscale/impl/custom → model_compose-0.4.69/src/mindor/dsl/schema/action/impl/model/impl/image_upscale/impl/custom/impl}/ldsr.py

@@ -1,6 +1,6 @@
 from typing import Union, Optional
 from pydantic import Field
-from ..common import CommonImageUpscaleModelActionConfig, CommonImageUpscaleParamsConfig
+from ...common import CommonImageUpscaleModelActionConfig, CommonImageUpscaleParamsConfig
 
 class LdsrImageUpscaleParamsConfig(CommonImageUpscaleParamsConfig):
     steps: Union[int, str] = Field(default=50, description="Number of diffusion steps.")

{model_compose-0.4.68/src/mindor/dsl/schema/action/impl/model/impl/image_upscale/impl/custom → model_compose-0.4.69/src/mindor/dsl/schema/action/impl/model/impl/image_upscale/impl/custom/impl}/real_esrgan.py

@@ -1,6 +1,6 @@
 from typing import Union
 from pydantic import Field
-from ..common import CommonImageUpscaleModelActionConfig, CommonImageUpscaleParamsConfig
+from ...common import CommonImageUpscaleModelActionConfig, CommonImageUpscaleParamsConfig
 
 class RealEsrganImageUpscaleParamsConfig(CommonImageUpscaleParamsConfig):
     denoise_strength: Union[float, str] = Field(default=0.5, description="Denoising strength (0.0-1.0).")

{model_compose-0.4.68/src/mindor/dsl/schema/action/impl/model/impl/image_upscale/impl/custom → model_compose-0.4.69/src/mindor/dsl/schema/action/impl/model/impl/image_upscale/impl/custom/impl}/swinir.py

@@ -1,6 +1,6 @@
 from typing import Union
 from pydantic import Field
-from ..common import CommonImageUpscaleModelActionConfig, CommonImageUpscaleParamsConfig
+from ...common import CommonImageUpscaleModelActionConfig, CommonImageUpscaleParamsConfig
 
 class SwinIRImageUpscaleParamsConfig(CommonImageUpscaleParamsConfig):
     task: Union[str, str] = Field(default="real_sr", description="SwinIR task type: real_sr, classical_sr, dn, etc.")

model_compose-0.4.69/src/mindor/dsl/schema/action/impl/model/impl/music_generation/impl/custom/__init__.py

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

{model_compose-0.4.68/src/mindor/dsl/schema/action/impl/model/impl/music_generation/impl/custom → model_compose-0.4.69/src/mindor/dsl/schema/action/impl/model/impl/music_generation/impl/custom/impl}/ace_step.py

@@ -1,6 +1,6 @@
 from typing import Union, Optional
 from pydantic import Field
-from ..common import CommonMusicGenerationParamsConfig, CommonMusicGenerationModelActionConfig
+from ...common import CommonMusicGenerationParamsConfig, CommonMusicGenerationModelActionConfig
 
 class AceStepMusicGenerationParamsConfig(CommonMusicGenerationParamsConfig):
     time_signature: Optional[Union[str, str]] = Field(default="4/4", description="Time signature (e.g. '4/4', '3/4').")

model_compose-0.4.69/src/mindor/dsl/schema/action/impl/model/impl/text_to_speech/impl/custom/__init__.py

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

model_compose-0.4.69/src/mindor/dsl/schema/action/impl/model/impl/text_to_speech/impl/custom/impl/__init__.py

@@ -0,0 +1,3 @@
+from .qwen import *
+from .kokoro import *
+from .chatterbox import *

model_compose-0.4.69/src/mindor/dsl/schema/action/impl/model/impl/text_to_speech/impl/custom/impl/chatterbox.py

@@ -0,0 +1,24 @@
+from typing import Union, Literal, Optional, Annotated
+from pydantic import Field
+from ...common import CommonTextToSpeechModelActionConfig, TextToSpeechActionMethod
+
+class ChatterboxTextToSpeechGenerateModelActionConfig(CommonTextToSpeechModelActionConfig):
+    method: Literal[TextToSpeechActionMethod.GENERATE]
+    exaggeration: Optional[Union[float, str]] = Field(default=None, description="Emotional exaggeration (0.0 = monotone, 1.0 = dramatic).")
+    cfg_weight: Optional[Union[float, str]] = Field(default=None, description="Classifier-free guidance weight controlling how closely the output mimics the reference voice.")
+    temperature: Optional[Union[float, str]] = Field(default=None, description="Sampling temperature for controlling speech variation.")
+
+class ChatterboxTextToSpeechCloneModelActionConfig(CommonTextToSpeechModelActionConfig):
+    method: Literal[TextToSpeechActionMethod.CLONE]
+    reference_audio: Union[str, str] = Field(..., description="Path or URL to reference audio for voice cloning (5+ seconds recommended).")
+    exaggeration: Optional[Union[float, str]] = Field(default=None, description="Emotional exaggeration (0.0 = monotone, 1.0 = dramatic).")
+    cfg_weight: Optional[Union[float, str]] = Field(default=None, description="Classifier-free guidance weight controlling how closely the output mimics the reference voice.")
+    temperature: Optional[Union[float, str]] = Field(default=None, description="Sampling temperature for controlling speech variation.")
+
+ChatterboxTextToSpeechModelActionConfig = Annotated[
+    Union[
+        ChatterboxTextToSpeechGenerateModelActionConfig,
+        ChatterboxTextToSpeechCloneModelActionConfig,
+    ],
+    Field(discriminator="method")
+]

model_compose-0.4.69/src/mindor/dsl/schema/action/impl/model/impl/text_to_speech/impl/custom/impl/kokoro.py

@@ -0,0 +1,15 @@
+from typing import Union, Literal, Optional, Annotated
+from pydantic import Field
+from ...common import CommonTextToSpeechModelActionConfig, TextToSpeechActionMethod
+
+class KokoroTextToSpeechGenerateModelActionConfig(CommonTextToSpeechModelActionConfig):
+    method: Literal[TextToSpeechActionMethod.GENERATE]
+    voice: Union[str, str] = Field(default="af_heart", description="Voice ID (e.g. 'af_heart', 'af_bella', 'am_michael').")
+    speed: Optional[Union[float, str]] = Field(default=None, description="Speech speed multiplier (1.0 = normal).")
+
+KokoroTextToSpeechModelActionConfig = Annotated[
+    Union[
+        KokoroTextToSpeechGenerateModelActionConfig,
+    ],
+    Field(discriminator="method")
+]

{model_compose-0.4.68/src/mindor/dsl/schema/action/impl/model/impl/text_to_speech/impl/custom → model_compose-0.4.69/src/mindor/dsl/schema/action/impl/model/impl/text_to_speech/impl/custom/impl}/qwen.py

@@ -1,6 +1,6 @@
 from typing import Union, Literal
 from pydantic import Field
-from ..common import CommonTextToSpeechModelActionConfig, TextToSpeechActionMethod
+from ...common import CommonTextToSpeechModelActionConfig, TextToSpeechActionMethod
 
 class QwenTextToSpeechGenerateModelActionConfig(CommonTextToSpeechModelActionConfig):
     method: Literal[TextToSpeechActionMethod.GENERATE]