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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model-compose
-Version: 0.4.7
+Version: 0.4.8
 Summary: model-compose: Declarative AI Model and Workflow Orchestrator
 Author-email: Hanyeol Cho <hanyeol.cho@gmail.com>
 License-Expression: MIT
@@ -16,7 +16,6 @@ Requires-Dist: requests
 Requires-Dist: fastapi
 Requires-Dist: uvicorn
 Requires-Dist: mcp>=1.10.1
-Requires-Dist: pyngrok
 Requires-Dist: ulid
 Requires-Dist: gradio
 Requires-Dist: Pillow

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

@@ -1,6 +1,6 @@
 [project]
 name = "model-compose"
-version = "0.4.7"
+version = "0.4.8"
 description = "model-compose: Declarative AI Model and Workflow Orchestrator"
 authors = [
     { name = "Hanyeol Cho", email = "hanyeol.cho@gmail.com" }
@@ -17,7 +17,6 @@ dependencies = [
     "fastapi", 
     "uvicorn",
     "mcp>=1.10.1",
-    "pyngrok", 
     "ulid", 
     "gradio",
     "Pillow",

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

@@ -5,9 +5,8 @@ from mindor.dsl.schema.action import ActionConfig
 from mindor.dsl.schema.listener import ListenerConfig
 from mindor.dsl.schema.gateway import GatewayConfig
 from mindor.dsl.schema.workflow import WorkflowConfig
-from mindor.core.services import AsyncService
-from mindor.core.utils.workqueue import WorkQueue
-from mindor.core.utils.package import install_package, parse_requirement, is_requirement_satisfied
+from mindor.core.foundation import AsyncService
+from mindor.core.utils.work_queue import WorkQueue
 from mindor.core.logger import logging
 from .context import ComponentActionContext
 
@@ -50,20 +49,10 @@ class ComponentService(AsyncService):
         self.id: str = id
         self.config: ComponentConfig = config
         self.global_configs: ComponentGlobalConfigs = global_configs
-        self.queue: Optional[WorkQueue] = None
+        self.work_queue: Optional[WorkQueue] = None
 
         if self.config.max_concurrent_count > 0:
-            self.queue = WorkQueue(self.config.max_concurrent_count, self._run)
-
-    async def setup(self) -> None:
-        dependencies = self._get_setup_requirements()
-        if dependencies:
-            await self._install_packages(dependencies)
-
-        await self._setup()
-
-    async def teardown(self) -> None:
-        await self._teardown()
+            self.work_queue = WorkQueue(self.config.max_concurrent_count, self._run)
 
     async def start(self, background: bool = False) -> None:
         await super().start(background)
@@ -73,29 +62,20 @@ class ComponentService(AsyncService):
         _, action = ActionResolver(self.config.actions).resolve(action_id)
         context = ComponentActionContext(run_id, input)
 
-        if self.queue:
-            return await (await self.queue.schedule(action, context))
+        if self.work_queue:
+            return await (await self.work_queue.schedule(action, context))
 
         return await self._run(action, context)
 
-    async def _setup(self) -> None:
-        pass
-
-    async def _teardown(self) -> None:
-        pass
-
-    def _get_setup_requirements(self) -> Optional[List[str]]:
-        return None
-
     async def _start(self) -> None:
-        if self.queue:
-            await self.queue.start()
+        if self.work_queue:
+            await self.work_queue.start()
 
         await super()._start()
 
     async def _stop(self) -> None:
-        if self.queue:
-            await self.queue.stop()
+        if self.work_queue:
+            await self.work_queue.stop()
 
         await super()._stop()
 
@@ -111,14 +91,10 @@ class ComponentService(AsyncService):
     @abstractmethod
     async def _run(self, action: ActionConfig, context: ComponentActionContext) -> Any:
         pass
-
-    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(repository or package_spec)
+  
+    async def _install_package(self, package_spec: str, repository: Optional[str]) -> None:
+        logging.info(f"Installing required module: {package_spec}")
+        await super()._install_package(package_spec, repository)
 
 def register_component(type: ComponentType):
     def decorator(cls: Type[ComponentService]) -> Type[ComponentService]:

{model_compose-0.4.7 → model_compose-0.4.8}/src/mindor/core/component/services/__init__.py

@@ -3,6 +3,7 @@ from .http_client import *
 from .mcp_server import *
 from .mcp_client import *
 from .model import *
+from .datasets import *
 from .vector_store import *
 from .workflow import *
 from .shell import *

model_compose-0.4.8/src/mindor/core/component/services/datasets/__init__.py

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

model_compose-0.4.8/src/mindor/core/component/services/datasets/datasets.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, AsyncIterator, Any
+from mindor.dsl.schema.action import DatasetsActionConfig, DatasetsActionMethod, DatasetsProvider
+from ...base import ComponentService, ComponentType, ComponentGlobalConfigs, register_component
+from ...context import ComponentActionContext
+from .providers import HuggingfaceDatasetsProvider, LocalDatasetsProvider
+
+if TYPE_CHECKING:
+    from datasets import Dataset
+
+class DatasetsAction:
+    def __init__(self, config: DatasetsActionConfig):
+        self.config: DatasetsActionConfig = config
+
+    async def run(self, context: ComponentActionContext) -> Any:
+        result = await self._dispatch(context)
+        context.register_source("result", result)
+
+        return (await context.render_variable(self.config.output, ignore_files=True)) if self.config.output else result
+
+    async def _dispatch(self, context: ComponentActionContext) -> Dataset:
+        if self.config.method == DatasetsActionMethod.LOAD:
+            return await self._load(context)
+
+        if self.config.method == DatasetsActionMethod.CONCAT:
+            return await self._concat(context)
+
+        if self.config.method == DatasetsActionMethod.SELECT:
+            return await self._select(context)
+
+        raise ValueError(f"Unsupported datasets action method: {self.config.method}")
+
+    async def _load(self, context: ComponentActionContext) -> Dataset:
+        fraction = await context.render_variable(self.config.fraction)
+        shuffle  = await context.render_variable(self.config.shuffle)
+
+        dataset = await self._load_dataset(context)
+
+        if shuffle:
+            dataset = dataset.shuffle()
+
+        if isinstance(fraction, float) and fraction < 1.0:
+            sample_size = max(int(len(dataset) * fraction), 1)
+            dataset = dataset.select(range(sample_size))
+
+        return dataset
+
+    async def _load_dataset(self, context: ComponentActionContext) -> Dataset:
+        if self.config.provider == DatasetsProvider.HUGGINGFACE:
+            return await HuggingfaceDatasetsProvider(self.config).load(context)
+
+        if self.config.provider == DatasetsProvider.LOCAL:
+            return await LocalDatasetsProvider(self.config).load(context)
+
+        raise ValueError(f"Unsupported dataset provider: {self.config.provider}")
+
+    async def _concat(self, context: ComponentActionContext) -> Dataset:
+        from datasets import concatenate_datasets
+
+        datasets  = await context.render_variable(self.config.datasets)
+        direction = await context.render_variable(self.config.direction)
+        info      = await context.render_variable(self.config.info)
+        split     = await context.render_variable(self.config.split)
+
+        return concatenate_datasets(
+            datasets,
+            info=info,
+            split=split,
+            axis=0 if direction == "vertical" else 1
+        )
+
+    async def _select(self, context: ComponentActionContext) -> Dataset:
+        dataset = await context.render_variable(self.config.dataset)
+        axis    = await context.render_variable(self.config.axis)
+        indices = await context.render_variable(self.config.indices)
+        columns = await context.render_variable(self.config.columns)
+
+        if axis == "rows":
+            if indices is None:
+                raise ValueError("indices must be provided when axis='rows'")
+            return dataset.select([ int(index) for index in indices ])
+
+        if axis == "columns":
+            if columns is None:
+                raise ValueError("columns must be provided when axis='columns'")
+            return dataset.select_columns(columns)
+
+        raise ValueError(f"Unsupported axis: {axis}")
+
+@register_component(ComponentType.DATASETS)
+class DatasetsComponent(ComponentService):
+    def __init__(self, id: str, config: DatasetsActionConfig, global_configs: ComponentGlobalConfigs, daemon: bool):
+        super().__init__(id, config, global_configs, daemon)
+
+    def _get_setup_requirements(self) -> Optional[List[str]]:
+        return [ "datasets" ]
+
+    async def _run(self, action: DatasetsActionConfig, context: ComponentActionContext) -> Any:
+        async def _run():
+            return await DatasetsAction(action).run(context)
+
+        return await self.run_in_thread(_run)

model_compose-0.4.8/src/mindor/core/component/services/datasets/providers/__init__.py

@@ -0,0 +1,2 @@
+from .huggingface import *
+from .local import *

model_compose-0.4.8/src/mindor/core/component/services/datasets/providers/common.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, AsyncIterator, Any
+from abc import ABC, abstractmethod
+from mindor.dsl.schema.action import DatasetsLoadActionConfig
+from ....context import ComponentActionContext
+
+if TYPE_CHECKING:
+    from datasets import Dataset
+
+class CommonDatasetsProvider(ABC):
+    def __init__(self, config: DatasetsLoadActionConfig):
+        self.config: DatasetsLoadActionConfig = config
+
+    @abstractmethod
+    async def load(self, context: ComponentActionContext) -> Dataset:
+        pass

model_compose-0.4.8/src/mindor/core/component/services/datasets/providers/huggingface.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, AsyncIterator, Any
+from .common import CommonDatasetsProvider, ComponentActionContext
+
+if TYPE_CHECKING:
+    from datasets import Dataset
+
+class HuggingfaceDatasetsProvider(CommonDatasetsProvider):
+    async def load(self, context: ComponentActionContext) -> Dataset:
+        from datasets import load_dataset
+
+        path              = await context.render_variable(self.config.path)
+        name              = await context.render_variable(self.config.name)
+        revision          = await context.render_variable(self.config.revision)
+        token             = await context.render_variable(self.config.token)
+        split             = await context.render_variable(self.config.split)
+        streaming         = await context.render_variable(self.config.streaming)
+        keep_in_memory    = await context.render_variable(self.config.keep_in_memory)
+        cache_dir         = await context.render_variable(self.config.cache_dir)
+        save_infos        = await context.render_variable(self.config.save_infos)
+        trust_remote_code = await context.render_variable(self.config.trust_remote_code)
+
+        return load_dataset(
+            path=path,
+            name=name,
+            revision=revision,
+            token=token,
+            split=split,
+            streaming=streaming,
+            keep_in_memory=keep_in_memory,
+            cache_dir=cache_dir,
+            save_infos=save_infos,
+            trust_remote_code=trust_remote_code
+        )

model_compose-0.4.8/src/mindor/core/component/services/datasets/providers/local.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, AsyncIterator, Any
+from .common import CommonDatasetsProvider, ComponentActionContext
+
+if TYPE_CHECKING:
+    from datasets import Dataset
+
+class LocalDatasetsProvider(CommonDatasetsProvider):
+    async def load(self, context: ComponentActionContext) -> Dataset:
+        from datasets import load_dataset
+
+        loader         = await context.render_variable(self.config.loader)
+        data_files     = await context.render_variable(self.config.data_files)
+        data_dir       = await context.render_variable(self.config.data_dir)
+        split          = await context.render_variable(self.config.split)
+        streaming      = await context.render_variable(self.config.streaming)
+        keep_in_memory = await context.render_variable(self.config.keep_in_memory)
+        cache_dir      = await context.render_variable(self.config.cache_dir)
+        save_infos     = await context.render_variable(self.config.save_infos)
+
+        return load_dataset(
+            path=loader,
+            data_files=data_files,
+            data_dir=data_dir,
+            split=split,
+            streaming=streaming,
+            keep_in_memory=keep_in_memory,
+            cache_dir=cache_dir,
+            save_infos=save_infos
+        )

{model_compose-0.4.7 → model_compose-0.4.8}/src/mindor/core/component/services/http_client.py

@@ -43,16 +43,16 @@ class HttpClientPollingCompletion(HttpClientCompletion):
                 if status in (self.config.success_when or []):
                     return response
                 if status in (self.config.fail_when or []):
-                    raise RuntimeError(f"Polling failed: status '{status}' matched a failure condition.")
+                    raise RuntimeError(f"Polling failed: status '{status}' matched a failure condition")
             else: # use status code
                 if is_status_code_matched(status_code, self.config.success_when or []):
                     return response
                 if is_status_code_matched(status_code, self.config.fail_when or []):
-                    raise RuntimeError(f"Polling failed: status code '{status_code}' matched a failure condition.")
+                    raise RuntimeError(f"Polling failed: status code '{status_code}' matched a failure condition")
 
             await asyncio.sleep(interval.total_seconds())
 
-        raise TimeoutError(f"Polling timed out after {timeout}.")
+        raise TimeoutError(f"Polling timed out after {timeout}")
 
     async def _resolve_url_or_path(self, context: ComponentActionContext) -> str:
         if self.config.path:
@@ -128,13 +128,13 @@ class HttpClientAction:
         return await context.render_variable(self.config.endpoint)
 
     def _convert_stream_chunk(self, chunk: bytes) -> Any:
-        if self.config.stream_format == HttpStreamFormat.JSON:
+        if self.config.streaming_format == HttpStreamFormat.JSON:
             try:
                 return json.loads(chunk)
             except:
                 return None
 
-        if self.config.stream_format == HttpStreamFormat.TEXT:
+        if self.config.streaming_format == HttpStreamFormat.TEXT:
             return chunk.decode("utf-8", errors="replace")
 
         return chunk

{model_compose-0.4.7 → model_compose-0.4.8}/src/mindor/core/component/services/http_server.py

@@ -117,13 +117,13 @@ class HttpServerAction:
         return (await context.render_variable(self.config.output, ignore_files=True)) if self.config.output else (result or response)
 
     def _convert_stream_chunk(self, chunk: bytes) -> Any:
-        if self.config.stream_format == HttpStreamFormat.JSON:
+        if self.config.streaming_format == HttpStreamFormat.JSON:
             try:
                 return json.loads(chunk)
             except:
                 return None
 
-        if self.config.stream_format == HttpStreamFormat.TEXT:
+        if self.config.streaming_format == HttpStreamFormat.TEXT:
             return chunk.decode("utf-8", errors="replace")
 
         return chunk

{model_compose-0.4.7 → model_compose-0.4.8}/src/mindor/core/component/services/model/base/common.py

@@ -5,7 +5,7 @@ from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annot
 from abc import ABC, abstractmethod
 from mindor.dsl.schema.component import ModelComponentConfig, ModelTaskType, ModelDriver, HuggingfaceModelConfig, LocalModelConfig
 from mindor.dsl.schema.action import ModelActionConfig
-from mindor.core.services import AsyncService
+from mindor.core.foundation import AsyncService
 from mindor.core.logger import logging
 from ....context import ComponentActionContext
 import asyncio

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

@@ -4,3 +4,4 @@ from .text_classification import *
 from .text_embedding import *
 from .image_to_text import *
 from .image_upscale import *
+from .face_embedding import *

model_compose-0.4.8/src/mindor/core/component/services/model/tasks/face_embedding/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 FaceEmbeddingModelActionConfig
+from mindor.core.logger import logging
+from ...base import ModelTaskService, ComponentActionContext
+from PIL import Image as PILImage
+
+if TYPE_CHECKING:
+    import torch
+
+class FaceEmbeddingTaskAction:
+    def __init__(self, config: FaceEmbeddingModelActionConfig, device: Optional[torch.device]):
+        self.config: FaceEmbeddingModelActionConfig = config
+        self.device: Optional[torch.device] = device
+
+    async def run(self, context: ComponentActionContext) -> Any:
+        image = await self._prepare_input(context)
+        is_single_input = not isinstance(image, list)
+        images: List[PILImage.Image] = [ image ] if is_single_input else image
+        results = []
+
+        batch_size = await context.render_variable(self.config.batch_size)
+        params     = await self._resolve_embedding_params(context)
+
+        for index in range(0, len(images), batch_size):
+            batch_images = images[index:index + batch_size]
+            embeddings = await self._embed(batch_images, params)
+            results.extend(embeddings)
+
+        return results[0] if is_single_input else results
+
+    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[PILImage.Image]:
+        pass
+
+    @abstractmethod
+    async def _resolve_embedding_params(self, context: ComponentActionContext) -> Dict[str, Any]:
+        pass
+
+class FaceEmbeddingTaskService(ModelTaskService):
+    pass

model_compose-0.4.8/src/mindor/core/component/services/model/tasks/face_embedding/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, 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 == FaceEmbeddingModelFamily.INSIGHTFACE:
+            from .insightface import InsightfaceFaceEmbeddingTaskService
+            return InsightfaceFaceEmbeddingTaskService(id, config, daemon)
+
+        raise ValueError(f"Unknown family: {config.family}")

model_compose-0.4.8/src/mindor/core/component/services/model/tasks/face_embedding/insightface.py

@@ -0,0 +1,95 @@
+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, LocalModelConfig
+from mindor.dsl.schema.action import ModelActionConfig, InsightfaceFaceEmbeddingModelActionConfig
+from mindor.core.logger import logging
+from .common import FaceEmbeddingTaskService, FaceEmbeddingTaskAction
+from ...base import ComponentActionContext
+from PIL import Image as PILImage
+import asyncio, os
+
+if TYPE_CHECKING:
+    from insightface.app import FaceAnalysis
+    from torch import Tensor
+
+class InsightfaceFaceEmbeddingTaskAction(FaceEmbeddingTaskAction):
+    def __init__(self, config: InsightfaceFaceEmbeddingModelActionConfig, model: FaceAnalysis):
+        super().__init__(config, None)
+
+        self.model: FaceAnalysis = model
+
+    async def _embed(self, images: List[PILImage.Image], params: Dict[str, Any]) -> List[Tensor]:
+        import numpy as np
+        import cv2
+
+        embeddings = []
+        for image in images:
+            image_cv = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2BGR)
+            for face in self.model.get(image_cv):
+                embeddings.append(face.embedding)
+
+        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)
+
+        self.model: Optional[FaceAnalysis] = None
+
+    def get_setup_requirements(self) -> Optional[List[str]]:
+        return [ "insightface", "opencv-python", "onnxruntime" ]
+
+    async def _serve(self) -> None:
+        try:
+            self.model = self._load_pretrained_model()
+            logging.info(f"Model loaded successfully: {self.config.model}")
+        except Exception as e:
+            logging.error(f"Failed to load model '{self.config.model}': {e}")
+            raise
+
+    def _load_pretrained_model(self) -> FaceAnalysis:
+        from insightface.app import FaceAnalysis
+
+        model = FaceAnalysis(**self._resolve_model_params())
+        model.prepare(ctx_id=self._get_device_id())
+
+        return model
+
+    def _resolve_model_params(self) -> Dict[str, Any]:
+        if isinstance(self.config.model, LocalModelConfig):
+            path = os.path.dirname(self.config.model.path)
+
+            if os.path.basename(path) != "models":
+                raise ValueError(f"Expected 'models' directory in path, got: {path}")
+
+            return { 
+                "name": os.path.basename(self.config.model.path),
+                "root": os.path.dirname(path)
+            }
+
+        if isinstance(self.config.model, str):
+            path = os.path.dirname(self.config.model)
+
+            if os.path.basename(path) != "models":
+                raise ValueError(f"Expected 'models' directory in path, got: {path}")
+
+            return { 
+                "name": os.path.basename(self.config.model),
+                "root": os.path.dirname(path)
+            }
+
+        raise ValueError(f"Unsupported model type: {type(self.config.model)}")
+
+    def _get_device_id(self) -> int:
+        return 0
+
+    async def _shutdown(self) -> None:
+        pass
+
+    async def _run(self, action: ModelActionConfig, context: ComponentActionContext, loop: asyncio.AbstractEventLoop) -> Any:
+        return await InsightfaceFaceEmbeddingTaskAction(action, self.model).run(context)

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

@@ -12,9 +12,9 @@ if TYPE_CHECKING:
     import torch
 
 class ImageGenerationTaskAction:
-    def __init__(self, config: ImageGenerationModelActionConfig, device: torch.device):
+    def __init__(self, config: ImageGenerationModelActionConfig, device: Optional[torch.device]):
         self.config: ImageGenerationModelActionConfig = config
-        self.device: torch.device = device
+        self.device: Optional[torch.device] = device
 
     async def run(self, context: ComponentActionContext) -> Any:
         text = await self._prepare_input(context)
@@ -22,18 +22,18 @@ class ImageGenerationTaskAction:
         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)
+        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)
+            upscaled_images = await self._generate(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)
+        return await context.render_variable(self.config.text)
 
     @abstractmethod
     async def _generate(self, images: List[PILImage.Image], params: Dict[str, Any]) -> List[PILImage.Image]:

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

@@ -9,4 +9,4 @@ class CustomImageGenerationTaskService:
             from .hunyuan_image import HunyuanImageGenerationTaskService
             return HunyuanImageGenerationTaskService(id, config, daemon)
 
-        raise ValueError(f"Unknown architecture: {config.architecture}")
+        raise ValueError(f"Unknown family: {config.family}")

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

@@ -14,7 +14,7 @@ if TYPE_CHECKING:
     import torch
 
 class FluxImageGenerationTaskAction(ImageGenerationTaskAction):
-    def __init__(self, config: FluxImageGenerationModelActionConfig, pipeline: Any, device: torch.device):
+    def __init__(self, config: FluxImageGenerationModelActionConfig, pipeline: Any, device: Optional[torch.device]):
         super().__init__(config, device)
 
         self.pipeline = pipeline

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

@@ -14,7 +14,7 @@ if TYPE_CHECKING:
     import torch
 
 class HunyuanImageGenerationTaskAction(ImageGenerationTaskAction):
-    def __init__(self, config: HunyuanImageGenerationModelActionConfig, pipeline: Any, device: torch.device):
+    def __init__(self, config: HunyuanImageGenerationModelActionConfig, pipeline: Any, device: Optional[torch.device]):
         super().__init__(config, device)
 
         self.pipeline = pipeline

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

@@ -14,7 +14,7 @@ if TYPE_CHECKING:
     import torch
 
 class SdxlImageGenerationTaskAction(ImageGenerationTaskAction):
-    def __init__(self, config: SdxlImageGenerationModelActionConfig, pipeline: Any, device: torch.device):
+    def __init__(self, config: SdxlImageGenerationModelActionConfig, pipeline: Any, device: Optional[torch.device]):
         super().__init__(config, device)
 
         self.pipeline = pipeline