model-compose 0.0.2__tar.gz → 0.0.3__tar.gz

{model_compose-0.0.2 → model_compose-0.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model-compose
-Version: 0.0.2
+Version: 0.0.3
 Summary: model-compose: Declarative AI Model and Workflow Orchestrator (from Mindor)
 Author-email: Hanyeol Cho <hanyeol.cho@gmail.com>
 License-Expression: MIT
@@ -11,7 +11,11 @@ Requires-Dist: click
 Requires-Dist: pyyaml
 Requires-Dist: pydantic
 Requires-Dist: python-dotenv
-Requires-Dist: jinja2
+Requires-Dist: aiohttp
+Requires-Dist: requests
+Requires-Dist: fastapi
+Requires-Dist: uvicorn
+Requires-Dist: ulid
 Dynamic: license-file
 
 # model-compose: Declarative AI Model and Workflow Orchestrator (from Mindor)

{model_compose-0.0.2 → model_compose-0.0.3}/pyproject.toml

@@ -1,16 +1,18 @@
 [project]
 name = "model-compose"
-version = "0.0.2"
+version = "0.0.3"
 description = "model-compose: Declarative AI Model and Workflow Orchestrator (from Mindor)"
 authors = [
     { name = "Hanyeol Cho", email = "hanyeol.cho@gmail.com" }
 ]
 readme = "README.md"
 license = "MIT"
-dependencies = ["click", "pyyaml", "pydantic", "python-dotenv", "jinja2"]
+dependencies = [
+    "click", "pyyaml", "pydantic", "python-dotenv", "aiohttp", "requests", "fastapi", "uvicorn", "ulid"
+]
 
 [project.scripts]
-model-compose = "mindor.cli.main:app"
+model-compose = "mindor.cli.compose:compose_command"
 
 [project.urls]
 "Homepage" = "https://github.com/hanyeol/model-compose"

model_compose-0.0.3/src/mindor/cli/compose.py

@@ -0,0 +1,180 @@
+import click
+import json
+from pathlib import Path
+import asyncio
+
+from mindor.dsl.loader import load_compose_config
+from mindor.core.runtime.env import load_env_files
+from mindor.core.compose import *
+
+@click.group()
+@click.option(
+    "--file", "-f", "config_files", multiple=True,
+    type=click.Path(exists=True, dir_okay=False, path_type=Path),
+    help="Compose configuration files",
+)
+@click.pass_context
+def compose_command(ctx: click.Context, config_files: List[Path]) -> None:
+    """model-compose (from Mindor)"""
+    ctx.ensure_object(dict)
+    ctx.obj["config_files"] = list(config_files)
+
+@click.command(name="up")
+@click.option("-d", "--detach", is_flag=True, help="Run in detached mode.")
+@click.option(
+    "--env-file", "env_files", multiple=True,
+    type=click.Path(exists=True, dir_okay=False, path_type=Path),
+    required=False,
+    help="Path to a .env file containing environment variables.",
+)
+@click.option(
+    "--env", "-e", "env_data", multiple=True,
+    help="Environment variable in the form KEY=VALUE. Repeatable.",
+)
+@click.pass_context
+def up_command(
+    ctx: click.Context, 
+    detach: bool,
+    env_files: List[Path],
+    env_data: List[str]
+) -> None:
+    config_files = ctx.obj.get("config_files", [])
+    async def _async_command():
+        try:
+            config = load_compose_config(".", config_files)
+            env = load_env_files(".", env_files or [])
+            await launch_services(config, detach, env)
+        except Exception as e:
+            click.echo(f"❌ {e}", err=True)
+    asyncio.run(_async_command())
+
+@click.command(name="down")
+@click.option(
+    "--env-file", "env_files", multiple=True,
+    type=click.Path(exists=True, dir_okay=False, path_type=Path),
+    required=False,
+    help="Path to a .env file containing environment variables.",
+)
+@click.option(
+    "--env", "-e", "env_data", multiple=True,
+    help="Environment variable in the form KEY=VALUE. Repeatable.",
+)
+@click.pass_context
+def down_command(
+    ctx: click.Context,
+    env_files: List[Path],
+    env_data: List[str],
+) -> None:
+    config_files = ctx.obj.get("config_files", [])
+    async def _async_command():
+        try:
+            config = load_compose_config(".", config_files)
+            env = load_env_files(".", env_files or [])
+            await shutdown_services(config, env)
+        except Exception as e:
+            click.echo(f"❌ {e}", err=True)
+    asyncio.run(_async_command())
+
+@click.command(name="start")
+@click.option(
+    "--env-file", "env_files", multiple=True,
+    type=click.Path(exists=True, dir_okay=False, path_type=Path),
+    required=False,
+    help="Path to a .env file containing environment variables.",
+)
+@click.option(
+    "--env", "-e", "env_data", multiple=True,
+    help="Environment variable in the form KEY=VALUE. Repeatable.",
+)
+@click.pass_context
+def start_command(
+    ctx: click.Context,
+    env_files: List[Path],
+    env_data: List[str],
+) -> None:
+    config_files = ctx.obj.get("config_files", [])
+    async def _async_command():
+        try:
+            config = load_compose_config(".", config_files)
+            env = load_env_files(".", env_files or [])
+            await start_services(config, env)
+        except Exception as e:
+            click.echo(f"❌ {e}", err=True)
+    asyncio.run(_async_command())
+
+@click.command(name="stop")
+@click.option(
+    "--env-file", "env_files", multiple=True,
+    type=click.Path(exists=True, dir_okay=False, path_type=Path),
+    required=False,
+    help="Path to a .env file containing environment variables.",
+)
+@click.option(
+    "--env", "-e", "env_data", multiple=True,
+    help="Environment variable in the form KEY=VALUE. Repeatable.",
+)
+@click.pass_context
+def stop_command(
+    ctx: click.Context,
+    env_files: List[Path],
+    env_data: List[str],
+) -> None:
+    config_files = ctx.obj.get("config_files", [])
+    async def _async_command():
+        try:
+            config = load_compose_config(".", config_files)
+            env = load_env_files(".", env_files or [])
+            await stop_services(config, env)
+        except Exception as e:
+            click.echo(f"❌ {e}", err=True)
+    asyncio.run(_async_command())
+
+@click.command(name="run")
+@click.argument("workflow", required=False)
+@click.option(
+    "--input", "-i", "input_json",
+    type=str,
+    required=False,
+    help="JSON input string for the workflow",
+)
+@click.option(
+    "--env-file", "env_files", multiple=True,
+    type=click.Path(exists=True, dir_okay=False, path_type=Path),
+    required=False,
+    help="Path to a .env file containing environment variables.",
+)
+@click.option(
+    "--env", "-e", "env_data", multiple=True,
+    help="Environment variable in the form KEY=VALUE. Repeatable.",
+)
+@click.pass_context
+def run_command(
+    ctx: click.Context,
+    workflow: Optional[str],
+    input_json: Optional[str],
+    env_files: List[Path],
+    env_data: List[str],
+) -> None:
+    config_files = ctx.obj.get("config_files", [])
+    async def _async_command():
+        try:
+            config = load_compose_config(".", config_files)
+            env = load_env_files(".", env_files or [])
+            input = json.loads(input_json) if input_json else {}
+            state = await run_workflow(config, workflow, input, env)
+            click.echo(json.dumps(
+                state.error if state.error else state.output, 
+                indent=2, 
+                ensure_ascii=False
+            ))
+        except json.JSONDecodeError:
+            click.echo("❌ Invalid JSON provided for --input", err=True)
+        except Exception as e:
+            click.echo(f"❌ {e}", err=True)
+    asyncio.run(_async_command())
+
+compose_command.add_command(up_command)
+compose_command.add_command(down_command)
+compose_command.add_command(start_command)
+compose_command.add_command(stop_command)
+compose_command.add_command(run_command)

model_compose-0.0.3/src/mindor/core/component/__init__.py

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

model_compose-0.0.3/src/mindor/core/component/component.py

@@ -0,0 +1,40 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from mindor.dsl.schema.component import ComponentConfig
+from .engine import BaseComponent, ComponentEngineMap
+
+ComponentInstances: Dict[str, BaseComponent] = {}
+
+class ComponentResolver:
+    def __init__(self, components: Dict[str, ComponentConfig]):
+        self.components: Dict[str, ComponentConfig] = components
+
+    def resolve(self, component_id: Optional[str]) -> Tuple[str, ComponentConfig]:
+        component_id = component_id or self._find_default_id(self.components)
+
+        if not component_id in self.components:
+            raise ValueError(f"Component not found: {component_id}")
+
+        return component_id, self.components[component_id]
+
+    def _find_default_id(self, components: Dict[str, ComponentConfig]) -> str:
+        default_ids = [ component_id for component_id, component in components.items() if component.default ]
+
+        if len(default_ids) > 1:
+            raise ValueError("Multiple components have default: true")
+
+        if not default_ids and "__default__" not in components:
+            raise ValueError("No default component defined.")
+
+        return default_ids[0] if default_ids else "__default__"
+
+def create_component(id: str, config: ComponentConfig, env: Dict[str, str], daemon: bool) -> BaseComponent:
+    try:
+        component = ComponentInstances[id] if id in ComponentInstances else None
+
+        if not component:
+            component = ComponentEngineMap[config.type](id, config, env, daemon)
+            ComponentInstances[id] = component
+
+        return component
+    except KeyError:
+        raise ValueError(f"Unsupported component type: {config.type}")

model_compose-0.0.3/src/mindor/core/component/engine/__init__.py

@@ -0,0 +1,4 @@
+from .base import *
+from .http_server import *
+from .http_client import *
+

model_compose-0.0.3/src/mindor/core/component/engine/base.py

@@ -0,0 +1,123 @@
+from abc import ABC, abstractmethod
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Callable, Any
+
+from mindor.dsl.schema.component import ComponentConfig, ComponentType
+from mindor.dsl.schema.action import ActionConfig
+from mindor.core.utils.workqueue import WorkQueue
+from .context import ComponentContext
+
+from threading import Thread
+import asyncio
+
+class ActionResolver:
+    def __init__(self, actions: Dict[str, ActionConfig]):
+        self.actions = actions
+
+    def resolve(self, action_id: Optional[str]) -> Tuple[str, ActionConfig]:
+        action_id = action_id or self._find_default_id(self.actions)
+
+        if not action_id in self.actions:
+            raise ValueError(f"Action not found: {action_id}")
+
+        return action_id, self.actions[action_id]
+
+    def _find_default_id(self, actions: Dict[str, ActionConfig]) -> str:
+        default_ids = [ action_id for action_id, action in actions.items() if action.default ]
+
+        if len(default_ids) > 1: 
+            raise ValueError("Multiple actions have default: true")
+
+        if not default_ids and "__default__" not in actions:
+            raise ValueError("No default action defined.")
+
+        return default_ids[0] if default_ids else "__default__"
+
+class BaseComponent(ABC):
+    def __init__(self, id: str, config: ComponentConfig, env: Dict[str, str], daemon: bool):
+        self.id: str = id
+        self.config: ComponentConfig = config
+        self.env: Dict[str, str] = env
+        self.daemon: bool = daemon
+
+        self.queue: Optional[WorkQueue] = None
+        self.thread: Optional[Thread] = None
+        self.thread_loop: Optional[asyncio.AbstractEventLoop] = None
+        self.daemon_task: Optional[asyncio.Task] = None
+        self.started: bool = False
+
+        if self.config.max_concurrent_count > 0:
+            self.queue = WorkQueue(self.config.max_concurrent_count, self._run)
+
+    async def start(self, background: bool = False) -> None:
+        if background:
+            def _start_in_thread():
+                self.thread_loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(self.thread_loop)
+                self.thread_loop.run_until_complete(self._start())
+    
+            self.thread = Thread(target=_start_in_thread)
+            self.thread.start()
+        else:
+            await self._start()
+
+    async def stop(self) -> None:
+        if self.thread:
+            future = asyncio.run_coroutine_threadsafe(self._stop(), self.thread_loop)
+            future.result()
+            self.thread_loop.close()
+            self.thread_loop = None
+            self.thread.join()
+            self.thread = None
+        else:
+            await self._stop()
+
+    async def wait_until_stopped(self) -> None:
+        if self.thread:
+            self.thread.join()
+
+        if self.daemon_task:
+            await self.daemon_task
+
+    async def run(self, action_id: Union[str, None], input: Dict[str, Any]) -> Dict[str, Any]:
+        _, action = ActionResolver(self.config.actions).resolve(action_id)
+        context = ComponentContext(input, self.env)
+
+        if self.queue:
+            return await (await self.queue.schedule(action, context))
+
+        return await self._run(action, context)
+
+    async def _start(self) -> None:
+        if self.queue:
+            await self.queue.start()
+
+        self.started = True
+
+        if self.daemon:
+            if not self.thread:
+                self.daemon_task = asyncio.create_task(self._serve())
+            else:
+                await self._serve()
+
+    async def _stop(self) -> None:
+        if self.queue:
+            await self.queue.stop()
+
+        if self.daemon:
+            await self._shutdown()
+
+        self.started = False
+
+    @abstractmethod
+    async def _serve(self) -> None:
+        pass
+
+    @abstractmethod
+    async def _shutdown(self) -> None:
+        pass
+
+    @abstractmethod
+    async def _run(self, action: ActionConfig, context: ComponentContext) -> Dict[str, Any]:
+        pass
+
+ComponentEngineMap: Dict[ComponentType, Type[BaseComponent]] = {}

model_compose-0.0.3/src/mindor/core/component/engine/context.py

@@ -0,0 +1,24 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from mindor.core.utils.template import TemplateRenderer
+
+class ComponentContext:
+    def __init__(self, input: Dict[str, Any], env: Dict[str, str]):
+        self.input: Dict[str, Any] = input
+        self.env: Dict[str, str] = env
+        self.sources: Dict[str, Any] = {}
+        self.renderer: TemplateRenderer = TemplateRenderer(self._resolve_source)
+
+    def register_source(self, key: str, source: Any) -> None:
+        self.sources[key] = source
+
+    def render_template(self, data: Dict[str, Any]) -> Any:
+        return self.renderer.render(data)
+
+    def _resolve_source(self, key: str) -> Any:
+        if key in self.sources:
+            return self.sources[key]
+        if key == "input":
+            return self.input
+        if key == "env":
+            return self.env
+        raise KeyError(f"Unknown source: {key}")

model_compose-0.0.3/src/mindor/core/component/engine/http_client.py

@@ -0,0 +1,87 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from mindor.dsl.schema.component import HttpClientComponentConfig, HttpClientActionConfig, HttpUrl
+from .base import BaseComponent, ComponentType, ComponentEngineMap, ActionConfig
+from .context import ComponentContext
+
+from requests.structures import CaseInsensitiveDict
+from urllib.parse import urlencode, urljoin
+import aiohttp, json
+
+class HttpClientAction:
+    def __init__(self, base_url: Union[str, None], config: HttpClientActionConfig):
+        self.base_url: Union[HttpUrl, None] = base_url
+        self.config: HttpClientActionConfig = config
+
+    async def run(self, context: ComponentContext) -> Dict[str, Any]:
+        url     = self._resolve_request_url(context)
+        method  = context.render_template(self.config.method)
+        params  = context.render_template(self.config.params)
+        body    = context.render_template(self.config.body)
+        headers = context.render_template(self.config.headers)
+
+        response = await self._request(url, method, params, body, headers)
+
+        if not self.config.output:
+            return response or {}
+
+        if response:
+            context.register_source("response", response)
+
+        return context.render_template(self.config.output)
+
+    async def _request(self, url: str, method: str, params: Optional[Dict[str, Any]], body: Optional[Dict[str, Any]], headers: Optional[Dict[str, str]]) -> Union[dict, str, bytes]:
+        async with aiohttp.ClientSession() as session:
+            async with session.request(
+                method,
+                url,
+                params=params,
+                data=self._serialize_request_body(body, headers) if body is not None else None, 
+                headers=headers
+            ) as response:
+                if response.status >= 400:
+                    raise ValueError(f"Request failed with status {response.status}")
+
+                return await self._deserialize_response_body(response)
+
+    def _resolve_request_url(self, context: ComponentContext) -> str:
+        if self.base_url and self.config.path:
+            return context.render_template(str(self.base_url)) + context.render_template(self.config.path)
+        
+        return context.render_template(str(self.config.endpoint))
+    
+    def _serialize_request_body(self, body: Dict[str, Any], headers: Optional[Dict[str, str]]) -> str:
+        content_type = CaseInsensitiveDict(headers or {}).get("Content-Type", "").lower()
+
+        if content_type == "application/json":
+            return json.dumps(body)
+
+        if content_type == "application/x-www-form-urlencoded":
+            return urlencode(body)
+        
+        return str(body)
+    
+    async def _deserialize_response_body(self, response: aiohttp.ClientResponse) -> Union[dict, str, bytes]:
+        content_type = response.headers.get("Content-Type", "").lower()
+
+        if content_type == "application/json":
+            return await response.json()
+        
+        if content_type.startswith("text/"):
+            return await response.text()
+
+        return await response.read()
+
+class HttpClientComponent(BaseComponent):
+    def __init__(self, id: str, config: HttpClientComponentConfig, env: Dict[str, str], daemon: bool):
+        super().__init__(id, config, env, daemon)
+
+    async def _serve(self) -> None:
+        pass
+
+    async def _shutdown(self) -> None:
+        pass
+
+    async def _run(self, action: ActionConfig, context: ComponentContext) -> Dict[str, Any]:
+        return await HttpClientAction(self.config.base_url, action).run(context)
+
+ComponentEngineMap[ComponentType.HTTP_CLIENT] = HttpClientComponent

model_compose-0.0.3/src/mindor/core/component/engine/http_server.py

@@ -0,0 +1,19 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from mindor.dsl.schema.component import HttpServerComponentConfig
+from .base import BaseComponent, ComponentType, ComponentEngineMap, ActionConfig
+from .context import ComponentContext
+
+class HttpServerComponent(BaseComponent):
+    def __init__(self, id: str, config: HttpServerComponentConfig, env: Dict[str, str], daemon: bool):
+        super().__init__(id, config, env, daemon)
+
+    async def _serve(self) -> None:
+        pass
+
+    async def _shutdown(self) -> None:
+        pass
+
+    async def _run(self, action: ActionConfig, context: ComponentContext) -> Dict[str, Any]:
+        return {}
+
+ComponentEngineMap[ComponentType.HTTP_SERVER] = HttpServerComponent

model_compose-0.0.3/src/mindor/core/compose/__init__.py

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

model_compose-0.0.3/src/mindor/core/compose/compose.py

@@ -0,0 +1,18 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from mindor.dsl.schema.compose import ComposeConfig
+from .manager import ComposeManager, TaskState
+
+async def launch_services(config: ComposeConfig, detach: bool, env: Dict[str, str]):
+    await ComposeManager(config, env, daemon=True).launch_services(detach=detach)
+
+async def shutdown_services(config: ComposeConfig, env: Dict[str, str]):
+    await ComposeManager(config, env, daemon=False).shutdown_services()
+
+async def start_services(config: ComposeConfig, detach: bool, env: Dict[str, str]):
+    await ComposeManager(config, env, daemon=False).start_services()
+
+async def stop_services(config: ComposeConfig, env: Dict[str, str]):
+    await ComposeManager(config, env, daemon=False).stop_services()
+
+async def run_workflow(config: ComposeConfig, workflow_id: Optional[str], input: Dict[str, Any], env: Dict[str, str]) -> TaskState:
+    return await ComposeManager(config, env, daemon=False).run_workflow(workflow_id, input)

model_compose-0.0.3/src/mindor/core/compose/manager.py

@@ -0,0 +1,28 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from mindor.dsl.schema.compose import ComposeConfig
+from mindor.core.controller import BaseController, TaskState, create_controller
+
+class ComposeManager:
+    def __init__(self, config: ComposeConfig, env: Dict[str, str], daemon: bool = True):
+        self.config: ComposeConfig = config
+        self.controller: BaseController = create_controller(self.config.controller, self.config.components, self.config.workflows, env, daemon)
+
+    async def launch_services(self, detach: bool, background: bool = False):
+        await self.controller.start(background=background)
+        await self.controller.wait_until_stopped()
+
+    async def shutdown_services(self):
+        await self.controller.stop()
+
+    async def start_services(self, background: bool = False):
+        await self.controller.start(background=background)
+        await self.controller.wait_until_stopped()
+
+    async def stop_services(self):
+        await self.controller.stop()
+
+    async def run_workflow(self, workflow_id: Optional[str], input: Dict[str, Any]) -> TaskState:
+        if not self.controller.started:
+            await self.controller.start()
+
+        return await self.controller.run_workflow(workflow_id, input)

model_compose-0.0.3/src/mindor/core/controller/__init__.py

@@ -0,0 +1,2 @@
+from .controller import *
+from .engine import TaskState

model_compose-0.0.3/src/mindor/core/controller/controller.py

@@ -0,0 +1,11 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from mindor.dsl.schema.controller import ControllerConfig
+from mindor.dsl.schema.component import ComponentConfig
+from mindor.dsl.schema.workflow import WorkflowConfig
+from .engine import BaseController, ControllerEngineMap
+
+def create_controller(config: ControllerConfig, components: Dict[str, ComponentConfig], workflows: Dict[str, WorkflowConfig], env: Dict[str, str], daemon: bool) -> BaseController:
+    try:
+        return ControllerEngineMap[config.type](config, components, workflows, env, daemon)
+    except KeyError:
+        raise ValueError(f"Unsupported controller type: {config.type}")

model_compose-0.0.3/src/mindor/core/controller/engine/__init__.py

@@ -0,0 +1,3 @@
+from .base import *
+from .http_server import *
+from .mcp_server import *