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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model-compose
-Version: 0.4.7
+Version: 0.4.9
 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.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "model-compose"
-version = "0.4.7"
+version = "0.4.9"
 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.9}/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.9}/src/mindor/core/component/context.py

@@ -1,6 +1,7 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from mindor.core.utils.renderers import VariableRenderer, ImageValueRenderer
 from mindor.core.gateway import find_gateway_by_port
+from PIL import Image as PILImage
 
 class ComponentActionContext:
     def __init__(self, run_id: str, input: Dict[str, Any]):
@@ -16,7 +17,7 @@ class ComponentActionContext:
     async def render_variable(self, value: Any, ignore_files: bool = False) -> Any:
         return await self.renderer.render(value, ignore_files)
 
-    async def render_image(self, value: Any) -> Any:
+    async def render_image(self, value: Any) -> Optional[PILImage.Image]:
         return await ImageValueRenderer().render(await self.render_variable(value))
 
     def contains_variable_reference(self, key: str, value: Any) -> bool:

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

@@ -3,7 +3,9 @@ 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 *
 from .text_splitter import *
+from .image_processor import *

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

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

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

@@ -0,0 +1,129 @@
+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
+from .utils import format_template_example
+
+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)
+
+        if self.config.method == DatasetsActionMethod.MAP:
+            return await self._map(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)
+
+        for dataset in datasets:
+            if not isinstance(dataset, Dataset):
+                raise ValueError(f"Expected Dataset instance, but got {type(dataset).__name__}")
+
+        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 not isinstance(dataset, Dataset):
+            raise ValueError(f"Expected Dataset instance, but got {type(dataset).__name__}")
+
+        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}")
+
+    async def _map(self, context: ComponentActionContext) -> Dataset:
+        dataset        = await context.render_variable(self.config.dataset)
+        template       = await context.render_variable(self.config.template)
+        output_column  = await context.render_variable(self.config.output_column)
+        remove_columns = await context.render_variable(self.config.remove_columns)
+
+        if not isinstance(dataset, Dataset):
+            raise ValueError(f"Expected Dataset instance, but got {type(dataset).__name__}")
+
+        def format_example(example):
+            return { output_column: format_template_example(template, example) }
+
+        return dataset.map(format_example, remove_columns=remove_columns)
+
+@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.9/src/mindor/core/component/services/datasets/providers/__init__.py

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

model_compose-0.4.9/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.9/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.9/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.9/src/mindor/core/component/services/datasets/utils.py

@@ -0,0 +1,12 @@
+from typing import Dict, List, Any
+import re
+
+def format_template_example(template: str, example: Dict[str, Any]) -> str:
+    column_names = set(re.findall(r"\{(\w+)\}", template))
+    formatted = template
+
+    for column in column_names:
+        if column in example:
+            formatted = formatted.replace(f"{{{column}}}", str(example[column]))
+
+    return formatted

{model_compose-0.4.7 → model_compose-0.4.9}/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.9}/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.9/src/mindor/core/component/services/image_processor.py

@@ -0,0 +1,210 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from mindor.dsl.schema.component import ImageProcessorComponentConfig
+from mindor.dsl.schema.action import ActionConfig, ImageProcessorActionConfig, ImageProcessorActionMethod, ImageScaleMode, FlipDirection
+from ..base import ComponentService, ComponentType, ComponentGlobalConfigs, register_component
+from ..context import ComponentActionContext
+from PIL import Image as PILImage, ImageFilter, ImageEnhance
+
+class ImageProcessorAction:
+    def __init__(self, config: ImageProcessorActionConfig):
+        self.config: ImageProcessorActionConfig = 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) -> Any:
+        if self.config.method == ImageProcessorActionMethod.RESIZE:
+            return await self._resize(context)
+
+        if self.config.method == ImageProcessorActionMethod.CROP:
+            return await self._crop(context)
+
+        if self.config.method == ImageProcessorActionMethod.ROTATE:
+            return await self._rotate(context)
+
+        if self.config.method == ImageProcessorActionMethod.FLIP:
+            return await self._flip(context)
+
+        if self.config.method == ImageProcessorActionMethod.GRAYSCALE:
+            return await self._grayscale(context)
+
+        if self.config.method == ImageProcessorActionMethod.BLUR:
+            return await self._blur(context)
+
+        if self.config.method == ImageProcessorActionMethod.SHARPEN:
+            return await self._sharpen(context)
+
+        if self.config.method == ImageProcessorActionMethod.ADJUST_BRIGHTNESS:
+            return await self._adjust_brightness(context)
+
+        if self.config.method == ImageProcessorActionMethod.ADJUST_CONTRAST:
+            return await self._adjust_contrast(context)
+
+        if self.config.method == ImageProcessorActionMethod.ADJUST_SATURATION:
+            return await self._adjust_saturation(context)
+
+        raise ValueError(f"Unsupported image processing action method: {self.config.method}")
+
+    async def _resize(self, context: ComponentActionContext) -> Optional[PILImage.Image]:
+        image      = await context.render_image(self.config.image)
+        width      = await context.render_variable(self.config.width) if self.config.width else None
+        height     = await context.render_variable(self.config.height) if self.config.height else None
+        scale_mode = await context.render_variable(self.config.scale_mode)
+
+        if width is None and height is None:
+            raise ValueError("At least one of width or height must be specified for resize")
+
+        if image:
+            return self._resize_image(image, width, height, scale_mode)
+        
+        return None
+
+    async def _crop(self, context: ComponentActionContext) -> Optional[PILImage.Image]:
+        image  = await context.render_image(self.config.image)
+        x      = await context.render_variable(self.config.x)
+        y      = await context.render_variable(self.config.y)
+        width  = await context.render_variable(self.config.width)
+        height = await context.render_variable(self.config.height)
+
+        if image:
+            return image.crop(x, y, x + width, y + height)
+        
+        return None
+
+    async def _rotate(self, context: ComponentActionContext) -> Optional[PILImage.Image]:
+        image  = await context.render_image(self.config.image)
+        angle  = await context.render_variable(self.config.angle)
+        expand = await context.render_variable(self.config.expand)
+
+        if image:
+            return image.rotate(-angle, expand=expand, resample=PILImage.Resampling.BICUBIC)
+
+        return None
+
+    async def _flip(self, context: ComponentActionContext) -> Optional[PILImage.Image]:
+        image     = await context.render_image(self.config.image)
+        direction = await context.render_variable(self.config.direction)
+
+        if image:
+            if direction == FlipDirection.HORIZONTAL:
+                return image.transpose(PILImage.Transpose.FLIP_LEFT_RIGHT)
+
+            if direction == FlipDirection.VERTICAL:
+                return image.transpose(PILImage.Transpose.FLIP_TOP_BOTTOM)
+
+        return None
+
+    async def _grayscale(self, context: ComponentActionContext) -> Optional[PILImage.Image]:
+        image = await context.render_image(self.config.image)
+
+        if image:
+            return image.convert("L")
+
+        return None
+
+    async def _blur(self, context: ComponentActionContext) -> Optional[PILImage.Image]:
+        image  = await context.render_image(self.config.image)
+        radius = await context.render_variable(self.config.radius)
+
+        if image:
+            return image.filter(ImageFilter.GaussianBlur(radius=radius))
+
+    async def _sharpen(self, context: ComponentActionContext) -> Optional[PILImage.Image]:
+        image  = await context.render_image(self.config.image)
+        factor = await context.render_variable(self.config.factor)
+
+        if image:
+            return ImageEnhance.Sharpness(image).enhance(factor)
+
+        return FileNotFoundError
+
+    async def _adjust_brightness(self, context: ComponentActionContext) -> Optional[PILImage.Image]:
+        image  = await context.render_image(self.config.image)
+        factor = await context.render_variable(self.config.factor)
+
+        if image:
+            return ImageEnhance.Brightness(image).enhance(factor)
+
+        return None
+
+    async def _adjust_contrast(self, context: ComponentActionContext) -> Optional[PILImage.Image]:
+        image  = await context.render_image(self.config.image)
+        factor = await context.render_variable(self.config.factor)
+
+        if image:
+            return ImageEnhance.Contrast(image).enhance(factor)
+
+        return image
+
+    async def _adjust_saturation(self, context: ComponentActionContext) -> Optional[PILImage.Image]:
+        image  = await context.render_image(self.config.image)
+        factor = await context.render_variable(self.config.factor)
+
+        if image:
+            return ImageEnhance.Color(image).enhance(factor)
+
+        return None
+
+    def _resize_image(self, image: PILImage.Image, width: int, height: int, scale_mode: str) -> PILImage.Image:
+        original_width, original_height = image.size
+        target_width  = width  or original_width
+        target_height = height or original_height
+
+        if scale_mode == ImageScaleMode.FIT:
+            new_width, new_height = self._get_size_aspect_fit(target_width, target_height, original_width, original_height)
+            return image.resize((new_width, new_height), PILImage.Resampling.LANCZOS)
+
+        if scale_mode == ImageScaleMode.FILL:
+            new_width, new_height = self._get_size_aspect_fill(target_width, target_height, original_width, original_height)
+            image = image.resize((new_width, new_height), PILImage.Resampling.LANCZOS)
+
+            crop_box = self._get_center_crop_box(new_width, new_height, target_width, target_height)
+            return image.crop(crop_box)
+
+        if scale_mode == ImageScaleMode.STRETCH:
+            return image.resize((target_width, target_height), PILImage.Resampling.LANCZOS)
+
+        raise ValueError(f"Invalid scale_mode: {scale_mode}")
+
+    def _get_size_aspect_fit(self, target_width: int, target_height: int, original_width: int, original_height: int) -> Tuple[int, int]:
+        aspect_ratio = original_width / original_height
+
+        height = target_height
+        width  = height * aspect_ratio
+
+        if width > target_width:
+            width  = target_width
+            height = width / aspect_ratio
+
+        return (int(width), int(height))
+
+    def _get_size_aspect_fill(self, target_width: int, target_height: int, original_width: int, original_height: int) -> Tuple[int, int]:
+        aspect_ratio = original_width / original_height
+
+        height = target_height
+        width  = height * aspect_ratio
+
+        if width < target_width:
+            width  = target_width
+            height = width / aspect_ratio
+
+        return (int(width), int(height))
+
+    def _get_center_crop_box(self, image_width: int, image_height: int, target_width: int, target_height: int) -> Tuple[int, int, int, int]:
+        left   = (image_width  - target_width ) // 2
+        top    = (image_height - target_height) // 2
+        right  = left + target_width
+        bottom = top + target_height
+
+        return (left, top, right, bottom)
+
+@register_component(ComponentType.IMAGE_PROCESSOR)
+class ImageProcessorComponent(ComponentService):
+    def __init__(self, id: str, config: ImageProcessorComponentConfig, global_configs: ComponentGlobalConfigs, daemon: bool):
+        super().__init__(id, config, global_configs, daemon)
+
+    async def _run(self, action: ActionConfig, context: ComponentActionContext) -> Any:
+        return await ImageProcessorAction(action).run(context)

{model_compose-0.4.7 → model_compose-0.4.9}/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