model-compose 0.4.6__tar.gz → 0.4.7__tar.gz

{model_compose-0.4.6/src/model_compose.egg-info → model_compose-0.4.7}/PKG-INFO

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

{model_compose-0.4.6 → model_compose-0.4.7}/pyproject.toml

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

{model_compose-0.4.6 → model_compose-0.4.7}/src/mindor/core/component/base.py

@@ -114,10 +114,11 @@ class ComponentService(AsyncService):
 
     async def _install_packages(self, packages: List[str]) -> None:
         for package_spec in packages:
+            package_spec, repository = (package_spec.split("@") + [ None ])[:2]
             requirement = parse_requirement(package_spec)
             if not requirement or not is_requirement_satisfied(requirement):
                 logging.info(f"Installing missing module: {package_spec}")
-                await install_package(package_spec)
+                await install_package(repository or package_spec)
 
 def register_component(type: ComponentType):
     def decorator(cls: Type[ComponentService]) -> Type[ComponentService]:

model_compose-0.4.7/src/mindor/core/component/services/model/tasks/image_generation/common.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, TypeAlias, Any
+from abc import ABC, abstractmethod
+from mindor.dsl.schema.action import ImageGenerationModelActionConfig, ColorFormat
+from mindor.core.logger import logging
+from ...base import ModelTaskService, ComponentActionContext
+from PIL import Image as PILImage
+
+if TYPE_CHECKING:
+    import torch
+
+class ImageGenerationTaskAction:
+    def __init__(self, config: ImageGenerationModelActionConfig, device: torch.device):
+        self.config: ImageGenerationModelActionConfig = config
+        self.device: torch.device = device
+
+    async def run(self, context: ComponentActionContext) -> Any:
+        text = await self._prepare_input(context)
+        is_single_input = not isinstance(text, list)
+        texts: List[PILImage.Image] = [ text ] if is_single_input else text
+        results = []
+
+        batch_size   = await context.render_variable(self.config.batch_size)
+        params       = await self._resolve_generation_params(context)
+
+        for index in range(0, len(texts), batch_size):
+            batch_texts = texts[index:index + batch_size]
+            upscaled_images = await self._upscale(batch_texts, params)
+            results.extend(upscaled_images)
+
+        return results[0] if is_single_input else results
+
+    async def _prepare_input(self, context: ComponentActionContext) -> Union[str, List[str]]:
+        return await context.render_image(self.config.image)
+
+    @abstractmethod
+    async def _generate(self, images: List[PILImage.Image], params: Dict[str, Any]) -> List[PILImage.Image]:
+        pass
+
+    @abstractmethod
+    async def _resolve_generation_params(self, context: ComponentActionContext) -> Dict[str, Any]:
+        pass
+
+class ImageGenerationTaskService(ModelTaskService):
+    pass

model_compose-0.4.7/src/mindor/core/component/services/model/tasks/image_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, 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 == ImageGenerationModelFamily.HUNYUAN_IMAGE:
+            from .hunyuan_image import HunyuanImageGenerationTaskService
+            return HunyuanImageGenerationTaskService(id, config, daemon)
+
+        raise ValueError(f"Unknown architecture: {config.architecture}")

model_compose-0.4.7/src/mindor/core/component/services/model/tasks/image_generation/flux.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, TypeAlias, Any
+from mindor.dsl.schema.component import ModelComponentConfig
+from mindor.dsl.schema.action import ModelActionConfig, FluxImageGenerationModelActionConfig
+from mindor.core.logger import logging
+from ...base import ComponentActionContext
+from .common import ImageGenerationTaskService, ImageGenerationTaskAction
+from PIL import Image as PILImage
+import asyncio
+
+if TYPE_CHECKING:
+    import torch
+
+class FluxImageGenerationTaskAction(ImageGenerationTaskAction):
+    def __init__(self, config: FluxImageGenerationModelActionConfig, pipeline: Any, device: torch.device):
+        super().__init__(config, device)
+
+        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)
+
+        self.pipeline: Optional[Any] = None
+        self.device: Optional[torch.device] = None
+
+    def get_setup_requirements(self) -> Optional[List[str]]:
+        return None
+
+    async def _serve(self) -> None:
+        try:
+            self.pipeline, self.device = self._load_pretrained_pipeline()
+            logging.info(f"Model loaded successfully on device '{self.device}': {self.config.model}")
+        except Exception as e:
+            logging.error(f"Failed to load model '{self.config.model}': {e}")
+            raise
+
+    async def _shutdown(self) -> None:
+        self.pipeline = None
+        self.device = None
+
+    def _load_pretrained_pipeline(self) -> Tuple[Any, torch.device]:
+        pass
+
+    async def _run(self, action: ModelActionConfig, context: ComponentActionContext, loop: asyncio.AbstractEventLoop) -> Any:
+        return FluxImageGenerationModelActionConfig(action, self.model).run(context)

model_compose-0.4.7/src/mindor/core/component/services/model/tasks/image_generation/hunyuan_image.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, TypeAlias, Any
+from mindor.dsl.schema.component import ModelComponentConfig
+from mindor.dsl.schema.action import ModelActionConfig, HunyuanImageGenerationModelActionConfig
+from mindor.core.logger import logging
+from ...base import ComponentActionContext
+from .common import ImageGenerationTaskService, ImageGenerationTaskAction
+from PIL import Image as PILImage
+import asyncio
+
+if TYPE_CHECKING:
+    import torch
+
+class HunyuanImageGenerationTaskAction(ImageGenerationTaskAction):
+    def __init__(self, config: HunyuanImageGenerationModelActionConfig, pipeline: Any, device: torch.device):
+        super().__init__(config, device)
+
+        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)
+
+        self.pipeline: Optional[Any] = None
+        self.device: Optional[torch.device] = None
+
+    def get_setup_requirements(self) -> Optional[List[str]]:
+        return None
+
+    async def _serve(self) -> None:
+        try:
+            self.pipeline, self.device = self._load_pretrained_pipeline()
+            logging.info(f"Model loaded successfully on device '{self.device}': {self.config.model}")
+        except Exception as e:
+            logging.error(f"Failed to load model '{self.config.model}': {e}")
+            raise
+
+    async def _shutdown(self) -> None:
+        self.pipeline = None
+        self.device = None
+
+    def _load_pretrained_pipeline(self) -> Tuple[Any, torch.device]:
+        pass
+
+    async def _run(self, action: ModelActionConfig, context: ComponentActionContext, loop: asyncio.AbstractEventLoop) -> Any:
+        return HunyuanImageGenerationModelActionConfig(action, self.model).run(context)

model_compose-0.4.7/src/mindor/core/component/services/model/tasks/image_generation/sdxl.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, TypeAlias, Any
+from mindor.dsl.schema.component import ModelComponentConfig
+from mindor.dsl.schema.action import ModelActionConfig, SdxlImageGenerationModelActionConfig
+from mindor.core.logger import logging
+from ...base import ComponentActionContext
+from .common import ImageGenerationTaskService, ImageGenerationTaskAction
+from PIL import Image as PILImage
+import asyncio
+
+if TYPE_CHECKING:
+    import torch
+
+class SdxlImageGenerationTaskAction(ImageGenerationTaskAction):
+    def __init__(self, config: SdxlImageGenerationModelActionConfig, pipeline: Any, device: torch.device):
+        super().__init__(config, device)
+
+        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)
+
+        self.pipeline: Optional[Any] = None
+        self.device: Optional[torch.device] = None
+
+    def get_setup_requirements(self) -> Optional[List[str]]:
+        return None
+
+    async def _serve(self) -> None:
+        try:
+            self.pipeline, self.device = self._load_pretrained_pipeline()
+            logging.info(f"Model loaded successfully on device '{self.device}': {self.config.model}")
+        except Exception as e:
+            logging.error(f"Failed to load model '{self.config.model}': {e}")
+            raise
+
+    async def _shutdown(self) -> None:
+        self.pipeline = None
+        self.device = None
+
+    def _load_pretrained_pipeline(self) -> Tuple[Any, torch.device]:
+        pass
+
+    async def _run(self, action: ModelActionConfig, context: ComponentActionContext, loop: asyncio.AbstractEventLoop) -> Any:
+        return SdxlImageGenerationModelActionConfig(action, self.model).run(context)

model_compose-0.4.7/src/mindor/core/component/services/model/tasks/image_upscale/__init__.py

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

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

@@ -57,7 +57,7 @@ class RealEsrganImageUpscaleTaskService(ImageUpscaleTaskService):
             hub.cached_download = cached_download
 
     def get_setup_requirements(self) -> Optional[List[str]]:
-        return [ "realesrgan" ]
+        return [ "realesrgan>=1.0@git+https://github.com/sberbank-ai/Real-ESRGAN.git" ]
 
     async def _serve(self) -> None:
         try:

{model_compose-0.4.6 → model_compose-0.4.7}/src/mindor/core/utils/package.py

@@ -1,4 +1,4 @@
-from typing import Optional
+from typing import Optional, Tuple
 from packaging.requirements import Requirement, SpecifierSet
 from packaging.utils import canonicalize_name
 from importlib.metadata import version, PackageNotFoundError
@@ -9,7 +9,7 @@ async def install_package(package_spec: str) -> None:
     """Install a package using pip.
     
     Args:
-        package_spec: Package specification to install (e.g., "torch>=2.0.0")
+        package_spec: Package specification to install (e.g., "torch>=2.0.0" or "git+https://github.com/...")
     """
     process = await asyncio.create_subprocess_exec(
         sys.executable, "-m", "pip", "install", package_spec,
@@ -31,7 +31,7 @@ def parse_requirement(package_spec: str) -> Optional[Requirement]:
     """Attempt to parse the package specification as a PEP 508 requirement.
 
     Args:
-        package_spec: A package specification string (e.g., "torch>=2.0.0")
+        package_spec: A package specification string (e.g., "torch>=2.0.0" or "git+https://github.com/...")
 
     Returns:
         A Requirement object if the specification can be parsed, None otherwise

{model_compose-0.4.6/src/mindor/dsl/schema/component → model_compose-0.4.7/src/mindor/dsl/schema/action}/impl/model/impl/__init__.py

@@ -4,4 +4,5 @@ from .chat_completion import *
 from .text_classification import *
 from .text_embedding import *
 from .image_to_text import *
+from .image_generation import *
 from .image_upscale import *

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

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

model_compose-0.4.7/src/mindor/dsl/schema/action/impl/model/impl/image_generation/image_generation.py

@@ -0,0 +1,6 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from .impl import *
+
+ImageGenerationModelActionConfig = Union[
+    HunyuanImageGenerationModelActionConfig,
+]

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

@@ -0,0 +1,4 @@
+from .common import *
+from .sdxl import *
+from .flux import *
+from .hunyuan_image import *

model_compose-0.4.7/src/mindor/dsl/schema/action/impl/model/impl/image_generation/impl/common.py

@@ -0,0 +1,13 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from enum import Enum
+from pydantic import BaseModel, Field
+from pydantic import model_validator
+from ...common import CommonModelActionConfig
+
+class CommonImageGenerationParamsConfig(BaseModel):
+    pass
+
+class CommonImageGenerationModelActionConfig(CommonModelActionConfig):
+    text: Union[str, List[str]] = Field(..., description="Text prompt describing the image to generate.")
+    batch_size: Union[int, str] = Field(default=1, description="Number of images to generate simultaneously in each batch.")
+    params: CommonImageGenerationParamsConfig = Field(..., description="Model-specific parameters for image generation.")

model_compose-0.4.7/src/mindor/dsl/schema/action/impl/model/impl/image_generation/impl/flux.py

@@ -0,0 +1,11 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from enum import Enum
+from pydantic import BaseModel, Field
+from pydantic import model_validator
+from .common import CommonImageGenerationModelActionConfig
+
+class FluxImageGenerationParamsConfig(BaseModel):
+    pass
+
+class FluxImageGenerationModelActionConfig(CommonImageGenerationModelActionConfig):
+    params: FluxImageGenerationParamsConfig = Field(..., description="Image generation configuration parameters.")

model_compose-0.4.7/src/mindor/dsl/schema/action/impl/model/impl/image_generation/impl/hunyuan_image.py

@@ -0,0 +1,11 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from enum import Enum
+from pydantic import BaseModel, Field
+from pydantic import model_validator
+from .common import CommonImageGenerationModelActionConfig
+
+class HunyuanImageGenerationParamsConfig(BaseModel):
+    pass
+
+class HunyuanImageGenerationModelActionConfig(CommonImageGenerationModelActionConfig):
+    params: HunyuanImageGenerationParamsConfig = Field(..., description="Image generation configuration parameters.")

model_compose-0.4.7/src/mindor/dsl/schema/action/impl/model/impl/image_generation/impl/sdxl.py

@@ -0,0 +1,11 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from enum import Enum
+from pydantic import BaseModel, Field
+from pydantic import model_validator
+from .common import CommonImageGenerationModelActionConfig
+
+class SdxlImageGenerationParamsConfig(BaseModel):
+    pass
+
+class SdxlImageGenerationModelActionConfig(CommonImageGenerationModelActionConfig):
+    params: SdxlImageGenerationParamsConfig = Field(..., description="Image generation configuration parameters.")

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

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

model_compose-0.4.7/src/mindor/dsl/schema/action/impl/model/impl/image_upscale/image_upscale.py

@@ -0,0 +1,9 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from .impl import *
+
+ImageUpscaleModelActionConfig = Union[
+    EsrganImageUpscaleModelActionConfig,
+    RealEsrganImageUpscaleModelActionConfig,
+    LdsrImageUpscaleModelActionConfig,
+    SwinIRImageUpscaleModelActionConfig,
+]

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

@@ -0,0 +1,5 @@
+from .common import *
+from .esrgan import *
+from .real_esrgan import *
+from .ldsr import *
+from .swinir import *

model_compose-0.4.7/src/mindor/dsl/schema/action/impl/model/impl/image_upscale/impl/common.py

@@ -0,0 +1,17 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from enum import Enum
+from pydantic import BaseModel, Field
+from pydantic import model_validator
+from ...common import CommonModelActionConfig
+
+class ColorFormat(str, Enum):
+    RGB = "rgb"
+    BGR = "bgr"
+
+class CommonImageUpscaleParamsConfig(BaseModel):
+    color_format: ColorFormat = Field(default=ColorFormat.RGB, description="Color format for image processing.")
+
+class CommonImageUpscaleModelActionConfig(CommonModelActionConfig):
+    image: Union[str, List[str]] = Field(..., description="Input image to upscale.")
+    batch_size: Union[int, str] = Field(default=1, description="Number of images to process in a single batch.")
+    params: CommonImageUpscaleParamsConfig = Field(..., description="Image upscale configuration parameters.")

model_compose-0.4.7/src/mindor/dsl/schema/action/impl/model/impl/image_upscale/impl/esrgan.py

@@ -0,0 +1,14 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from enum import Enum
+from pydantic import BaseModel, Field
+from pydantic import model_validator
+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).")
+    tile_pad_size: Union[int, str] = Field(default=10, description="Padding for tiles to avoid seam artifacts.")
+    pre_pad_size: Union[int, str] = Field(default=0, description="Pre-padding before processing.")
+    half_precision: Union[bool, str] = Field(default=False, description="Use half precision (FP16) for faster inference.")
+
+class EsrganImageUpscaleModelActionConfig(CommonImageUpscaleModelActionConfig):
+    params: EsrganImageUpscaleParamsConfig = Field(default_factory=EsrganImageUpscaleParamsConfig)

model_compose-0.4.7/src/mindor/dsl/schema/action/impl/model/impl/image_upscale/impl/ldsr.py

@@ -0,0 +1,14 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from enum import Enum
+from pydantic import BaseModel, Field
+from pydantic import model_validator
+from .common import CommonImageUpscaleModelActionConfig, CommonImageUpscaleParamsConfig
+
+class LdsrImageUpscaleParamsConfig(CommonImageUpscaleParamsConfig):
+    steps: Union[int, str] = Field(default=50, description="Number of diffusion steps.")
+    eta: Union[float, str] = Field(default=1.0, description="DDIM eta parameter.")
+    downsample_method: Optional[str] = Field(default=None, description="Downsampling method for preprocessing.")
+    half_precision: Union[bool, str] = Field(default=False, description="Use half precision (FP16) for faster inference.")
+
+class LdsrImageUpscaleModelActionConfig(CommonImageUpscaleModelActionConfig):
+    params: LdsrImageUpscaleParamsConfig = Field(default_factory=LdsrImageUpscaleParamsConfig)

model_compose-0.4.7/src/mindor/dsl/schema/action/impl/model/impl/image_upscale/impl/real_esrgan.py

@@ -0,0 +1,16 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from enum import Enum
+from pydantic import BaseModel, Field
+from pydantic import model_validator
+from .common import CommonImageUpscaleModelActionConfig, CommonImageUpscaleParamsConfig
+
+class RealEsrganImageUpscaleParamsConfig(CommonImageUpscaleParamsConfig):
+    denoise_strength: Union[float, str] = Field(default=0.5, description="Denoising strength (0.0-1.0).")
+    tile_batch_size: Union[int, str] = Field(default=4, description="Number of tiles to process in a single batch.")
+    tile_size: Union[int, str] = Field(default=192, description="Tile size for large image processing.")
+    tile_pad_size: Union[int, str] = Field(default=24, description="Tile padding size.")
+    pre_pad_size: Union[int, str] = Field(default=15, description="Pre-padding size.")
+    half_precision: Union[bool, str] = Field(default=False, description="Use half precision (FP16) for faster inference.")
+
+class RealEsrganImageUpscaleModelActionConfig(CommonImageUpscaleModelActionConfig):
+    params: RealEsrganImageUpscaleParamsConfig = Field(default_factory=RealEsrganImageUpscaleParamsConfig)

model_compose-0.4.7/src/mindor/dsl/schema/action/impl/model/impl/image_upscale/impl/swinir.py

@@ -0,0 +1,16 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from enum import Enum
+from pydantic import BaseModel, Field
+from pydantic import model_validator
+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.")
+    tile: Union[int, str] = Field(default=None, description="Tile size for large image processing.")
+    tile_overlap: Union[int, str] = Field(default=32, description="Overlap between tiles.")
+    scale: Union[int, str] = Field(default=4, description="Upscaling factor.")
+    window_size: Union[int, str] = Field(default=8, description="Window size for attention computation.")
+    jpeg_quality: Union[int, str] = Field(default=40, description="JPEG quality for compression artifacts removal task.")
+
+class SwinIRImageUpscaleModelActionConfig(CommonImageUpscaleModelActionConfig):
+    params: SwinIRImageUpscaleParamsConfig = Field(default_factory=SwinIRImageUpscaleParamsConfig)

{model_compose-0.4.6/src/mindor/dsl/schema/action → model_compose-0.4.7/src/mindor/dsl/schema/component}/impl/model/impl/__init__.py

@@ -4,4 +4,5 @@ from .chat_completion import *
 from .text_classification import *
 from .text_embedding import *
 from .image_to_text import *
+from .image_generation import *
 from .image_upscale import *

model_compose-0.4.7/src/mindor/dsl/schema/component/impl/model/impl/image_generation/__init__.py

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

model_compose-0.4.7/src/mindor/dsl/schema/component/impl/model/impl/image_generation/image_generation.py

@@ -0,0 +1,10 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field
+from .impl import *
+
+ImageGenerationModelComponentConfig = Annotated[
+    Union[
+        HunyuanImageGenerationModelComponentConfig
+    ],
+    Field(discriminator="family")
+]

model_compose-0.4.7/src/mindor/dsl/schema/component/impl/model/impl/image_generation/impl/__init__.py

@@ -0,0 +1,2 @@
+from .common import *
+from .hunyuan_image import *

model_compose-0.4.7/src/mindor/dsl/schema/component/impl/model/impl/image_generation/impl/common.py

@@ -0,0 +1,28 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Type, Any
+from enum import Enum
+from pydantic import BaseModel, Field
+from pydantic import model_validator
+from ...common import CommonModelComponentConfig, ModelTaskType, ModelDriver
+
+class ImageGenerationModelFamily(str, Enum):
+    SDXL          = "sdxl"
+    FLUX          = "flux"
+    HUNYUAN_IMAGE = "hunyuan-image"
+
+class CommonImageGenerationModelComponentConfig(CommonModelComponentConfig):
+    task: Literal[ModelTaskType.IMAGE_GENERATION]
+    driver: ModelDriver = Field(default=ModelDriver.CUSTOM)
+    family: ImageGenerationModelFamily = Field(..., description="Model family.")
+    version: Optional[str] = Field(default=None, description="")
+
+    @model_validator(mode="before")
+    def inflate_single_action(cls, values: Dict[str, Any]):
+        if "actions" not in values:
+            action_keys = set(cls._get_action_class().model_fields.keys()) - set(CommonModelComponentConfig.model_fields.keys())
+            if any(k in values for k in action_keys):
+                values["actions"] = [ { k: values.pop(k) for k in action_keys if k in values } ]
+        return values
+
+    @classmethod
+    def _get_action_class(cls) -> Type[BaseModel]:
+        return None

model_compose-0.4.7/src/mindor/dsl/schema/component/impl/model/impl/image_generation/impl/flux.py

@@ -0,0 +1,14 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Type, Any
+from enum import Enum
+from pydantic import BaseModel, Field
+from pydantic import model_validator
+from mindor.dsl.schema.action import FluxImageGenerationModelActionConfig
+from .common import CommonImageGenerationModelComponentConfig, ImageGenerationModelFamily
+
+class FluxImageGenerationModelComponentConfig(CommonImageGenerationModelComponentConfig):
+    family: Literal[ImageGenerationModelFamily.FLUX]
+    actions: List[FluxImageGenerationModelActionConfig] = Field(default_factory=list)
+
+    @classmethod
+    def _get_action_class(cls) -> Type[BaseModel]:
+        return FluxImageGenerationModelActionConfig

model_compose-0.4.7/src/mindor/dsl/schema/component/impl/model/impl/image_generation/impl/hunyuan_image.py

@@ -0,0 +1,14 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Type, Any
+from enum import Enum
+from pydantic import BaseModel, Field
+from pydantic import model_validator
+from mindor.dsl.schema.action import HunyuanImageGenerationModelActionConfig
+from .common import CommonImageGenerationModelComponentConfig, ImageGenerationModelFamily
+
+class HunyuanImageGenerationModelComponentConfig(CommonImageGenerationModelComponentConfig):
+    family: Literal[ImageGenerationModelFamily.HUNYUAN_IMAGE]
+    actions: List[HunyuanImageGenerationModelActionConfig] = Field(default_factory=list)
+
+    @classmethod
+    def _get_action_class(cls) -> Type[BaseModel]:
+        return HunyuanImageGenerationModelActionConfig

model_compose-0.4.7/src/mindor/dsl/schema/component/impl/model/impl/image_generation/impl/sdxl.py

@@ -0,0 +1,14 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Type, Any
+from enum import Enum
+from pydantic import BaseModel, Field
+from pydantic import model_validator
+from mindor.dsl.schema.action import SdxlImageGenerationModelActionConfig
+from .common import CommonImageGenerationModelComponentConfig, ImageGenerationModelFamily
+
+class SdxlImageGenerationModelComponentConfig(CommonImageGenerationModelComponentConfig):
+    family: Literal[ImageGenerationModelFamily.SDXL]
+    actions: List[SdxlImageGenerationModelActionConfig] = Field(default_factory=list)
+
+    @classmethod
+    def _get_action_class(cls) -> Type[BaseModel]:
+        return SdxlImageGenerationModelActionConfig

model_compose-0.4.7/src/mindor/dsl/schema/component/impl/model/impl/image_upscale/__init__.py

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

model_compose-0.4.7/src/mindor/dsl/schema/component/impl/model/impl/image_upscale/image_upscale.py

@@ -0,0 +1,13 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field
+from .impl import *
+
+ImageUpscaleModelComponentConfig = Annotated[
+    Union[ 
+        EsrganImageUpscaleModelComponentConfig,
+        RealEsrganImageUpscaleModelComponentConfig,
+        LdsrImageUpscaleModelComponentConfig,
+        SwinIRImageUpscaleModelComponentConfig,
+    ],
+    Field(discriminator="architecture")
+]

model_compose-0.4.7/src/mindor/dsl/schema/component/impl/model/impl/image_upscale/impl/__init__.py

@@ -0,0 +1,5 @@
+from .common import *
+from .esrgan import *
+from .real_esrgan import *
+from .ldsr import *
+from .swinir import *

model_compose-0.4.7/src/mindor/dsl/schema/component/impl/model/impl/image_upscale/impl/common.py

@@ -0,0 +1,28 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Type, Any
+from enum import Enum
+from pydantic import BaseModel, Field
+from pydantic import model_validator
+from ...common import CommonModelComponentConfig, ModelTaskType, ModelDriver
+
+class ImageUpscaleModelArchitecture(str, Enum):
+    ESRGAN      = "esrgan"
+    REAL_ESRGAN = "real-esrgan"
+    LDSR        = "ldsr"
+    SWINIR      = "swinir"
+
+class CommonImageUpscaleModelComponentConfig(CommonModelComponentConfig):
+    task: Literal[ModelTaskType.IMAGE_UPSCALE]
+    driver: ModelDriver = Field(default=ModelDriver.CUSTOM)
+    architecture: ImageUpscaleModelArchitecture = Field(..., description="Model architecture.")
+
+    @model_validator(mode="before")
+    def inflate_single_action(cls, values: Dict[str, Any]):
+        if "actions" not in values:
+            action_keys = set(cls._get_action_class().model_fields.keys()) - set(CommonModelComponentConfig.model_fields.keys())
+            if any(k in values for k in action_keys):
+                values["actions"] = [ { k: values.pop(k) for k in action_keys if k in values } ]
+        return values
+
+    @classmethod
+    def _get_action_class(cls) -> Type[BaseModel]:
+        return None