model-compose 0.2.12__tar.gz → 0.3.0__tar.gz

{model_compose-0.2.12/src/model_compose.egg-info → model_compose-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model-compose
-Version: 0.2.12
+Version: 0.3.0
 Summary: model-compose: Declarative AI Model and Workflow Orchestrator
 Author-email: Hanyeol Cho <hanyeol.cho@gmail.com>
 License-Expression: MIT
@@ -24,6 +24,7 @@ Requires-Dist: transformers>=4.21.0
 Requires-Dist: torch
 Requires-Dist: sentencepiece
 Requires-Dist: accelerate
+Requires-Dist: docker
 Dynamic: license-file
 
 # model-compose: Declarative AI Model and Workflow Orchestrator

{model_compose-0.2.12 → model_compose-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "model-compose"
-version = "0.2.12"
+version = "0.3.0"
 description = "model-compose: Declarative AI Model and Workflow Orchestrator"
 authors = [
     { name = "Hanyeol Cho", email = "hanyeol.cho@gmail.com" }
@@ -24,7 +24,8 @@ dependencies = [
     "transformers>=4.21.0",
     "torch",
     "sentencepiece",
-    "accelerate"
+    "accelerate",
+    "docker"
 ]
 
 [project.scripts]
@@ -39,6 +40,10 @@ build-backend = "setuptools.build_meta"
 
 [tool.setuptools]
 package-dir = { "" = "src" }
+include-package-data = true
 
 [tool.setuptools.packages.find]
 where = ["src"]
+
+[tool.setuptools.package-data]
+"mindor.core.controller.runtime.docker" = ["context/*"]

{model_compose-0.2.12 → model_compose-0.3.0}/src/mindor/cli/compose.py

@@ -61,18 +61,20 @@ def up_command(
     "--env", "-e", "env_data", multiple=True,
     help="Environment variable in the form KEY=VALUE. Repeatable.",
 )
+@click.option("--verbose", "-v", is_flag=True, help="Enable verbose output.")
 @click.pass_context
 def down_command(
     ctx: click.Context,
     env_files: List[Path],
     env_data: List[str],
+    verbose: bool
 ) -> None:
     config_files = ctx.obj.get("config_files", [])
     async def _async_command():
         try:
             env = load_env_files(".", env_files or [])
             config = load_compose_config(".", config_files, env)
-            await shutdown_services(config)
+            await terminate_services(config, verbose)
         except Exception as e:
             click.echo(f"❌ {e}", err=True)
     asyncio.run(_async_command())
@@ -117,18 +119,20 @@ def start_command(
     "--env", "-e", "env_data", multiple=True,
     help="Environment variable in the form KEY=VALUE. Repeatable.",
 )
+@click.option("--verbose", "-v", is_flag=True, help="Enable verbose output.")
 @click.pass_context
 def stop_command(
     ctx: click.Context,
     env_files: List[Path],
     env_data: List[str],
+    verbose: bool
 ) -> None:
     config_files = ctx.obj.get("config_files", [])
     async def _async_command():
         try:
             env = load_env_files(".", env_files or [])
             config = load_compose_config(".", config_files, env)
-            await stop_services(config)
+            await stop_services(config, verbose)
         except Exception as e:
             click.echo(f"❌ {e}", err=True)
     asyncio.run(_async_command())
@@ -184,3 +188,6 @@ compose_command.add_command(down_command)
 compose_command.add_command(start_command)
 compose_command.add_command(stop_command)
 compose_command.add_command(run_command)
+
+if __name__ == "__main__":
+    compose_command()

{model_compose-0.2.12 → model_compose-0.3.0}/src/mindor/core/compose/compose.py

@@ -5,14 +5,14 @@ from .manager import ComposeManager, TaskState
 async def launch_services(config: ComposeConfig, detach: bool, verbose: bool):
     await ComposeManager(config, daemon=True).launch_services(detach, verbose)
 
-async def shutdown_services(config: ComposeConfig):
-    await ComposeManager(config, daemon=False).shutdown_services()
+async def terminate_services(config: ComposeConfig, verbose: bool):
+    await ComposeManager(config, daemon=False).terminate_services(verbose)
 
 async def start_services(config: ComposeConfig, verbose: bool):
     await ComposeManager(config, daemon=False).start_services(verbose)
 
-async def stop_services(config: ComposeConfig):
-    await ComposeManager(config, daemon=False).stop_services()
+async def stop_services(config: ComposeConfig, verbose: bool):
+    await ComposeManager(config, daemon=False).stop_services(verbose)
 
 async def run_workflow(config: ComposeConfig, workflow_id: Optional[str], input: Dict[str, Any], verbose: bool) -> TaskState:
     return await ComposeManager(config, daemon=False).run_workflow(workflow_id, input, verbose)

{model_compose-0.2.12 → model_compose-0.3.0}/src/mindor/core/compose/manager.py

@@ -16,17 +16,15 @@ class ComposeManager:
         )
 
     async def launch_services(self, detach: bool, verbose: bool):
-        await self.controller.start()
-        await self.controller.wait_until_stopped()
+        await self.controller.launch(detach, verbose)
 
-    async def shutdown_services(self):
-        await self.controller.stop()
+    async def terminate_services(self, verbose: bool):
+        await self.controller.terminate(verbose)
 
     async def start_services(self, verbose: bool):
         await self.controller.start()
-        await self.controller.wait_until_stopped()
 
-    async def stop_services(self):
+    async def stop_services(self, verbose: bool):
         await self.controller.stop()
 
     async def run_workflow(self, workflow_id: Optional[str], input: Dict[str, Any], verbose: bool) -> TaskState:

{model_compose-0.2.12 → model_compose-0.3.0}/src/mindor/core/controller/base.py

@@ -1,12 +1,14 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from enum import Enum
 from dataclasses import dataclass
+from pydantic import BaseModel
 from mindor.dsl.schema.controller import ControllerConfig, ControllerType
 from mindor.dsl.schema.component import ComponentConfig
 from mindor.dsl.schema.listener import ListenerConfig
 from mindor.dsl.schema.gateway import GatewayConfig
-from mindor.dsl.schema.logger import LoggerConfig, LoggerType, ConsoleLoggerConfig
 from mindor.dsl.schema.workflow import WorkflowConfig
+from mindor.dsl.schema.runtime import RuntimeType, DockerBuildConfig
+from mindor.dsl.schema.logger import LoggerConfig, LoggerType, ConsoleLoggerConfig
 from mindor.core.services import AsyncService
 from mindor.core.component import ComponentService, ComponentGlobalConfigs, create_component
 from mindor.core.listener import ListenerService, create_listener
@@ -16,6 +18,8 @@ from mindor.core.logger import LoggerService, create_logger
 from mindor.core.controller.webui import ControllerWebUI
 from mindor.core.utils.workqueue import WorkQueue
 from mindor.core.utils.expiring import ExpiringDict
+from .runtime.specs import ControllerRuntimeSpecs
+from .runtime.docker import DockerRuntimeLauncher
 from threading import Lock
 import asyncio, ulid
 
@@ -58,6 +62,29 @@ class ControllerService(AsyncService):
         if self.config.max_concurrent_count > 0:
             self.queue = WorkQueue(self.config.max_concurrent_count, self._run_workflow)
 
+    async def launch(self, detach: bool, verbose: bool) -> None:
+        if self.config.runtime.type == RuntimeType.NATIVE:
+            if detach:
+                pass
+            await self.start()
+            await self.wait_until_stopped()
+            return
+
+        if self.config.runtime.type == RuntimeType.DOCKER:
+            await self._start_loggers()
+            await DockerRuntimeLauncher(self.config, verbose).launch(self._get_runtime_specs(), detach)
+            return
+
+    async def terminate(self, verbose: bool) -> None:
+        if self.config.runtime.type == RuntimeType.NATIVE:
+            await self.stop()
+            return
+        
+        if self.config.runtime.type == RuntimeType.DOCKER:
+            await self._start_loggers()
+            await DockerRuntimeLauncher(self.config, verbose).terminate()
+            return
+
     async def run_workflow(self, workflow_id: Optional[str], input: Dict[str, Any], wait_for_completion: bool = True) -> TaskState:
         task_id = ulid.ulid()
         state = TaskState(task_id=task_id, status=TaskStatus.PENDING)
@@ -138,23 +165,6 @@ class ControllerService(AsyncService):
     async def _stop_webui(self) -> None:
         await asyncio.gather(*[ self._create_webui().stop() ])
 
-    async def _run_workflow(self, task_id: str, workflow_id: Optional[str], input: Dict[str, Any]) -> TaskState:
-        state = TaskState(task_id=task_id, status=TaskStatus.PROCESSING)
-        with self.task_states_lock:
-            self.task_states.set(task_id, state)
-        
-        try:
-            workflow = self._create_workflow(workflow_id)
-            output = await workflow.run(task_id, input)
-            state = TaskState(task_id=task_id, status=TaskStatus.COMPLETED, output=output)
-        except Exception as e:
-            state = TaskState(task_id=task_id, status=TaskStatus.FAILED, error=str(e))
-
-        with self.task_states_lock:
-            self.task_states.set(task_id, state, 1 * 3600)
-
-        return state
-
     def _create_listeners(self) -> List[ListenerService]:
         return [ create_listener(f"listener-{index}", config, self.daemon) for index, config in enumerate(self.listeners) ]
     
@@ -175,12 +185,32 @@ class ControllerService(AsyncService):
         global_configs = self._get_component_global_configs()
         return create_workflow(*WorkflowResolver(self.workflows).resolve(workflow_id), global_configs)
 
+    def _get_runtime_specs(self) -> ControllerRuntimeSpecs:
+        return ControllerRuntimeSpecs(self.config, self.components, self.listeners, self.gateways, self.workflows)
+
     def _get_component_global_configs(self) -> ComponentGlobalConfigs:
         return ComponentGlobalConfigs(self.components, self.listeners, self.gateways, self.workflows)
 
     def _get_default_logger_config(self) -> LoggerConfig:
         return ConsoleLoggerConfig(type=LoggerType.CONSOLE)
 
+    async def _run_workflow(self, task_id: str, workflow_id: Optional[str], input: Dict[str, Any]) -> TaskState:
+        state = TaskState(task_id=task_id, status=TaskStatus.PROCESSING)
+        with self.task_states_lock:
+            self.task_states.set(task_id, state)
+        
+        try:
+            workflow = self._create_workflow(workflow_id)
+            output = await workflow.run(task_id, input)
+            state = TaskState(task_id=task_id, status=TaskStatus.COMPLETED, output=output)
+        except Exception as e:
+            state = TaskState(task_id=task_id, status=TaskStatus.FAILED, error=str(e))
+
+        with self.task_states_lock:
+            self.task_states.set(task_id, state, 1 * 3600)
+
+        return state
+
 def register_controller(type: ControllerType):
     def decorator(cls: Type[ControllerService]) -> Type[ControllerService]:
         ControllerRegistry[type] = cls

model_compose-0.3.0/src/mindor/core/controller/runtime/docker/__init__.py

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

model_compose-0.3.0/src/mindor/core/controller/runtime/docker/context/Dockerfile

@@ -0,0 +1,42 @@
+FROM ubuntu:22.04
+
+WORKDIR /app
+
+RUN apt update && apt install -y \
+    python3.11 \
+    python3.11-venv \
+    python3-pip \
+    gcc \
+    && rm -rf /var/lib/apt/lists/*
+
+RUN ln -sf /usr/bin/python3.11 /usr/bin/python && \
+    ln -sf /usr/bin/python3.11 /usr/bin/python3
+
+RUN python -m pip install --upgrade pip
+RUN pip install --no-cache-dir \
+    click \
+    pyyaml \
+    pydantic \
+    python-dotenv \
+    aiohttp \
+    requests \
+    fastapi \
+    uvicorn \
+    'mcp>=1.10.1' \
+    pyngrok \
+    ulid \
+    gradio \
+    Pillow \
+    'transformers>=4.21.0' \
+    torch \
+    sentencepiece \
+    accelerate \
+    docker
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY src .
+COPY model-compose.yml .
+
+CMD [ "python", "-m", "mindor.cli.compose", "up" ]

model_compose-0.3.0/src/mindor/core/controller/runtime/docker/docker.py

@@ -0,0 +1,102 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from mindor.dsl.schema.controller import ControllerConfig
+from mindor.dsl.schema.runtime import DockerRuntimeConfig, DockerBuildConfig, DockerPortConfig, DockerVolumeConfig, DockerHealthCheck
+from mindor.core.runtime.docker import DockerRuntimeManager
+from mindor.core.logger import logging
+from ..specs import ControllerRuntimeSpecs
+from pathlib import Path
+import mindor, shutil, yaml
+
+class DockerRuntimeLauncher:
+    def __init__(self, config: ControllerConfig, verbose: bool):
+        self.config: ControllerConfig = config
+        self.verbose: bool = verbose
+
+        self._configure_runtime_config()
+
+    def _configure_runtime_config(self):
+        if not self.config.runtime.image:
+            if not self.config.runtime.build:
+                self.config.runtime.build = DockerBuildConfig(context=".docker", dockerfile="Dockerfile")
+            self.config.runtime.image = f"mindor/controller-{self.config.port}:latest"
+
+        if not self.config.runtime.container_name:
+            self.config.runtime.container_name = self.config.name or f"mindor-controller-{self.config.port}"
+
+        if not self.config.runtime.ports:
+            self.config.runtime.ports = [ port for port in [ self.config.port, getattr(self.config.webui, "port", None) ] if port ]
+
+    async def launch(self, specs: ControllerRuntimeSpecs, detach: bool):
+        docker = DockerRuntimeManager(self.config.runtime, self.verbose)
+
+        await self._prepare_docker_context(specs)
+
+        if not await docker.exists_image():
+            logging.debug("Checking if Docker image can be pulled...")
+            try:
+                await docker.pull_image()
+            except Exception as e:
+                logging.debug("Docker image pull failed: %s — will try building instead.", e)
+            else:
+                if not await docker.exists_image():
+                    raise RuntimeError("Docker image pull completed, but image is still missing.")
+                logging.info("Docker image pulled successfully.")
+ 
+        if not await docker.exists_image():
+            logging.debug("Building Docker image locally. This may take a few minutes...")
+            try:
+                await docker.build_image()
+                logging.info("Docker image build completed successfully.")
+            except Exception as e:
+                logging.error("Docker image build failed: %s", e)
+                raise
+
+        if await docker.is_container_running():
+            logging.info("Stopping running Docker container before restarting...")
+            await docker.stop_container()
+
+        logging.info("Starting Docker container (%s mode)...", "detached" if detach else "foreground")
+        await docker.start_container(detach)
+
+    async def terminate(self):
+        docker = DockerRuntimeManager(self.config.runtime, self.verbose)
+
+        if await docker.exists_container():
+            await docker.remove_container(force=True)
+
+        if await docker.exists_image():
+            await docker.remove_image()
+
+    async def _prepare_docker_context(self, specs: ControllerRuntimeSpecs) -> None:
+        # Prepare context directory
+        context_dir = Path.cwd() / ".docker"
+        if context_dir.exists():
+            shutil.rmtree(context_dir)
+
+        # Copy context files
+        context_files_root = Path(__file__).resolve().parent / "context"
+        shutil.copytree(
+            src=str(context_files_root), 
+            dst=context_dir
+        )
+
+        # Copy source files
+        source_files_root = Path(mindor.__file__).resolve().parent
+        target_dir = context_dir / "src" / source_files_root.name
+        shutil.copytree(
+            src=str(source_files_root), 
+            dst=target_dir, 
+            ignore=shutil.ignore_patterns("__pycache__", "*.pyc")
+        )
+
+        # Generate model-compose.yml
+        with open(context_dir / "model-compose.yml", "w") as f:
+            yaml.dump(specs.generate_native_runtime_specs(), f, sort_keys=False)
+
+        # Copy or generate requirements.txt
+        file_path = Path.cwd() / "requirements.txt"
+        target_path = Path(context_dir) / file_path.name
+        if file_path.exists():
+            shutil.copy(file_path, target_path)
+        else:
+            target_path.touch()

model_compose-0.3.0/src/mindor/core/controller/runtime/specs.py

@@ -0,0 +1,40 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Callable, Any
+from abc import ABC, abstractmethod
+from mindor.dsl.schema.controller import ControllerConfig
+from mindor.dsl.schema.component import ComponentConfig
+from mindor.dsl.schema.listener import ListenerConfig
+from mindor.dsl.schema.gateway import GatewayConfig
+from mindor.dsl.schema.workflow import WorkflowConfig
+from mindor.dsl.utils.enum import enum_union_to_str
+
+class ControllerRuntimeSpecs:
+    def __init__(
+        self,
+        controller: ControllerConfig,
+        components: Dict[str, ComponentConfig],
+        listeners: List[ListenerConfig],
+        gateways: List[GatewayConfig],
+        workflows: Dict[str, WorkflowConfig]
+    ):
+        self.controller: ControllerConfig = controller
+        self.components: Dict[str, ComponentConfig] = components
+        self.listeners: List[ListenerConfig] = listeners
+        self.gateways: List[GatewayConfig] = gateways
+        self.workflows: Dict[str, WorkflowConfig] = workflows
+
+    def generate_native_runtime_specs(self) -> Dict[str, Any]:
+        specs: Dict[str, Any] = {}
+
+        specs["controller"] = self.controller.model_dump()
+        specs["controller"]["runtime"] = "native"
+
+        specs["components"] = {}
+        for id, component in self.components.items():
+            specs["components"][id] = component.model_dump()
+            specs["components"][id]["runtime"] = "native"
+
+        specs["listeners"] = [ listener.model_dump() for listener in self.listeners ]
+        specs["gateways" ] = [ gateway.model_dump()  for gateway  in self.gateways  ]
+        specs["workflows"] = { id: workflow.model_dump() for id, workflow in self.workflows.items() }
+
+        return enum_union_to_str(specs)

{model_compose-0.2.12 → model_compose-0.3.0}/src/mindor/core/logger/services/console.py

@@ -2,7 +2,7 @@ from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annot
 from mindor.dsl.schema.logger import ConsoleLoggerConfig
 from ..base import LoggerService, LoggerType, LoggingLevel, register_logger
 from uvicorn.logging import ColourizedFormatter
-import logging
+import logging, sys
 
 _level_map = {
     LoggingLevel.DEBUG:    logging.DEBUG,

model_compose-0.3.0/src/mindor/core/runtime/docker/__init__.py

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