model-compose 0.1.1__tar.gz → 0.1.3__tar.gz

{model_compose-0.1.1 → model_compose-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model-compose
-Version: 0.1.1
+Version: 0.1.3
 Summary: model-compose: Declarative AI Model and Workflow Orchestrator (part of the Mindor project)
 Author-email: Hanyeol Cho <hanyeol.cho@gmail.com>
 License-Expression: MIT

{model_compose-0.1.1 → model_compose-0.1.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "model-compose"
-version = "0.1.1"
+version = "0.1.3"
 description = "model-compose: Declarative AI Model and Workflow Orchestrator (part of the Mindor project)"
 authors = [
     { name = "Hanyeol Cho", email = "hanyeol.cho@gmail.com" }

{model_compose-0.1.1 → model_compose-0.1.3}/src/mindor/core/component/engine/http_client.py

@@ -31,8 +31,8 @@ class HttpClientPollingCompletion:
 
         while datetime.now(timezone.utc) < deadline:
             response = await self.client.request(url, method, params, body, headers)
-
             context.register_source("result", response)
+
             status = (await context.render_template(self.config.status)) if self.config.status else response["status"]
 
             if not status:
@@ -82,15 +82,11 @@ class HttpClientAction:
         headers = await context.render_template({ **self.headers, **self.config.headers })
 
         response, result = await self.client.request(url, method, params, body, headers), None
-
-        if response:
-            context.register_source("response", response)
+        context.register_source("response", response)
 
         if self.config.completion:
             result = await self._handle_completion(self.config.completion, context)
-
-            if result:
-                context.register_source("result", result)
+            context.register_source("result", result)
 
         return (await context.render_template(self.config.output)) if self.config.output else (result or response)
 

{model_compose-0.1.1 → model_compose-0.1.3}/src/mindor/core/controller/engine/http_server.py

@@ -15,7 +15,7 @@ from fastapi import FastAPI, APIRouter, Request, Body, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import Response, JSONResponse, StreamingResponse
 from starlette.background import BackgroundTask
-import asyncio, uvicorn
+import uvicorn
 
 class WorkflowTaskRequestBody(BaseModel):
     workflow_id: Optional[str] = None
@@ -50,7 +50,7 @@ class HttpServerController(ControllerEngine):
         daemon: bool
     ):
         super().__init__(config, components, listeners, gateways, workflows, env, daemon)
-        
+
         self.server: Optional[uvicorn.Server] = None
         self.app: FastAPI = FastAPI(openapi_url=None, docs_url=None, redoc_url=None)
         self.router: APIRouter = APIRouter()

{model_compose-0.1.1 → model_compose-0.1.3}/src/mindor/core/controller/webui/gradio.py

@@ -1,31 +1,36 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Callable, Awaitable, Any
-from mindor.dsl.schema.workflow import WorkflowVariableConfig
-from mindor.core.utils.http_client import HttpStreamResource
+from mindor.dsl.schema.workflow import WorkflowVariableConfig, WorkflowVariableGroupConfig
+from mindor.core.utils.http_client import HttpClient, HttpStreamResource
 from mindor.core.utils.image import load_image_from_stream
 from mindor.core.utils.streaming import Base64StreamResource, save_stream_to_temporary_file
 from .schema import WorkflowSchema
 import gradio as gr
 import json
 
+class ComponentGroup:
+    def __init__(self, group: gr.Component, components: List[gr.Component]):
+        self.group: gr.Component = group
+        self.components: List[gr.Component] = components
+
 class GradioWebUIBuilder:
     def build(self, schema: Dict[str, WorkflowSchema], runner: Callable[[Optional[str], Any], Awaitable[Any]]) -> gr.Blocks:
         with gr.Blocks() as blocks:
             for workflow_id, workflow in schema.items():
-                async def run_workflow(input: Any, workflow_id=workflow_id) -> Any:
+                async def _run_workflow(input: Any, workflow_id=workflow_id) -> Any:
                     return await runner(workflow_id, input)
 
                 if len(schema) > 1:
                     with gr.Tab(label=workflow.name or workflow_id):
-                        self._build_workflow_section(workflow, run_workflow)
+                        self._build_workflow_section(workflow, _run_workflow)
                 else:
-                    self._build_workflow_section(workflow, run_workflow)
+                    self._build_workflow_section(workflow, _run_workflow)
 
         return blocks
 
     def _build_workflow_section(self, workflow: WorkflowSchema, runner: Callable[[Any], Awaitable[Any]]) -> gr.Column:
         with gr.Column() as section:
-            gr.Markdown(f"## **{workflow.title or 'Untitled Workflow'}**")  
-
+            gr.Markdown(f"## **{workflow.title or 'Untitled Workflow'}**")
+ 
             if workflow.description:
                 gr.Markdown(f"📝 {workflow.description}")
 
@@ -39,27 +44,16 @@ class GradioWebUIBuilder:
             if not output_components:
                 output_components = gr.Textbox(label="", lines=8, interactive=False, show_copy_button=True)
 
-            async def run_workflow(*args):
-                input = { variable.name: value for variable, value in zip(workflow.input, args) }
+            async def _run_workflow(*args):
+                input = { variable.name: value if value != "" else None for variable, value in zip(workflow.input, args) }
                 output = await runner(input)
-
-                if workflow.output:
-                    if isinstance(output, dict):
-                        outputs = []
-                        for variable in workflow.output:
-                            value = output[variable.name] if variable.name else output
-                            outputs.append(await self._convert_type(value, variable.type, variable.subtype, variable.format))
-                        output = outputs[0] if len(outputs) == 1 else outputs
-                    else:
-                        variable = workflow.output[0]
-                        output = await self._convert_type(output, variable.type, variable.subtype, variable.format)
-
-                return output
+                output = await self._flatten_output(output, workflow.output)
+                return output[0] if len(output) == 1 else output
 
             run_button.click(
-                fn=run_workflow,
+                fn=_run_workflow,
                 inputs=input_components,
-                outputs=output_components
+                outputs=self._flatten_output_components(output_components)
             )
 
         return section
@@ -80,16 +74,31 @@ class GradioWebUIBuilder:
         
         if variable.type == "boolean":
             return gr.Checkbox(label=label, value=default or False, info=info)
+        
+        if variable.type == "image":
+            return gr.Image(label=label, type="filepath")
+
+        if variable.type == "video":
+            return gr.Video(label=label)
 
         if variable.type == "file":
-            return gr.File(label=label, file_types=["*"], info=info)
+            return gr.File(label=label)
 
         if variable.type == "select":
             return gr.Dropdown(choices=variable.options or [], label=label, value=default, info=info)
-        
+
         return gr.Textbox(label=label, value=default, info=f"Unsupported type: {variable.type}")
 
-    def _build_output_component(self, variable: WorkflowVariableConfig) -> gr.Component:
+    def _build_output_component(self, variable: Union[WorkflowVariableConfig, WorkflowVariableGroupConfig]) -> Union[gr.Component, List[ComponentGroup]]:
+        if isinstance(variable, WorkflowVariableGroupConfig):
+            groups: List[ComponentGroup] = []
+            for index in range(variable.repeat_count if variable.repeat_count != 0 else 100):
+                visible = True if variable.repeat_count != 0 or index == 0 else False
+                with gr.Column(visible=visible) as group:
+                    components = [ self._build_output_component(v) for v in variable.variables ]
+                groups.append(ComponentGroup(group, components))
+            return groups
+
         label = variable.name or ""
         info = variable.description or ""
 
@@ -102,26 +111,55 @@ class GradioWebUIBuilder:
         if variable.type == "audio":
             return gr.Audio(label=label)
     
+        if variable.type == "video":
+            return gr.Video(label=label)
+
         return gr.Textbox(label=label, info=f"Unsupported type: {variable.type}")
 
+    def _flatten_output_components(self, components: List[Union[gr.Component, List[ComponentGroup]]]) -> List[gr.Component]:
+        flattened = []
+        for item in components:
+            if isinstance(item, list):
+                for group in item:
+                    flattened.extend(group.components)
+            else:
+                flattened.append(item)
+        return flattened
+    
+    async def _flatten_output(self, output: Any, variables: List[Union[WorkflowVariableConfig, WorkflowVariableGroupConfig]]) -> Any:
+        flattened = []
+        for variable in variables:
+            if isinstance(variable, WorkflowVariableGroupConfig):
+                group = output[variable.name] if variable.name else output
+                for value in group:
+                    flattened.extend(await self._flatten_output(value, variable.variables))
+            else:
+                value = output[variable.name] if variable.name else output
+                flattened.append(await self._convert_type(value, variable.type, variable.subtype, variable.format))
+        return flattened
+
     async def _convert_type(self, value: Any, type: Optional[str], subtype: Optional[str], format: Optional[str]) -> Any:
+        if type == "string":
+            if isinstance(value, (dict, list)):
+                return json.dumps(value)
+            return str(value)
+        
         if type == "image":
+            if format == "url" and isinstance(value, str):
+                return await load_image_from_stream(await HttpClient().request(value), subtype)
             if format == "base64" and isinstance(value, str):
                 return await load_image_from_stream(Base64StreamResource(value), subtype)
             if isinstance(value, HttpStreamResource):
                 return await load_image_from_stream(value, subtype)
             return None
 
-        if type == "audio":
+        if type in [ "audio", "video" ]:
+            if format == "url" and isinstance(value, str):
+                return await save_stream_to_temporary_file(await HttpClient().request(value), subtype)
             if format == "base64" and isinstance(value, str):
                 return await save_stream_to_temporary_file(Base64StreamResource(value), subtype)
             if isinstance(value, HttpStreamResource):
                 return await save_stream_to_temporary_file(value, subtype)
             return None
 
-        if type == "string":
-            if isinstance(value, (dict, list)):
-                return json.dumps(value)
-            return str(value)
-
         return value

model_compose-0.1.3/src/mindor/core/controller/webui/schema.py

@@ -0,0 +1,206 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel
+from mindor.dsl.schema.workflow import WorkflowConfig, WorkflowVariableConfig, WorkflowVariableGroupConfig
+from mindor.dsl.schema.component import ComponentConfig
+import re, json
+
+class WorkflowVariable:
+    def __init__(self, name: Optional[str], type: str, subtype: Optional[str], format: Optional[str], default: Optional[Any]):
+        self.name: Optional[str] = name
+        self.type: str = type
+        self.subtype: Optional[str] = subtype
+        self.format: Optional[str] = format
+        self.default: Optional[Any] = default
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "name": self.name,
+            "type": self.type,
+            "subtype": self.subtype,
+            "format": self.format,
+            "default": self.default
+        }
+
+    def __eq__(self, other):
+        if not isinstance(other, WorkflowVariable):
+            return False
+        if self.name is None or other.name is None:
+            return False
+        return self.name == other.name
+
+    def __hash__(self):
+        return hash(self.name) if self.name is not None else id(self)
+    
+class WorkflowVariableGroup:
+    def __init__(self, name: Optional[str], variables: List[WorkflowVariable], repeat_count: int):
+        self.name: Optional[str] = name
+        self.variables: List[WorkflowVariable] = variables
+        self.repeat_count: int = repeat_count
+
+class WorkflowVariableResolver:
+    def __init__(self):
+        self.patterns: Dict[str, re.Pattern] = {
+            "variable": re.compile(
+                r"""\$\{                                                             # ${ 
+                    ([a-zA-Z_][^.\s]*)                                               # key: input, env, etc.
+                    (?:\.([^\s\|\}]+))?                                              # path: key, key.path[0], etc.
+                    (?:\s*as\s*([^\s\|\}/;]+)(?:/([^\s\|\};]+))?(?:;([^\s\|\}]+))?)? # type/subtype;format
+                    (?:\s*\|\s*([^\}]+))?                                            # default value after `|`
+                \}""",                                                               # }
+                re.VERBOSE,
+            ),
+            "keypath": re.compile(r"[-_\w]+|\[\d+\]"),
+        }
+
+    def _enumerate_input_variables(self, value: Any, wanted_key: str) -> List[WorkflowVariable]:
+        if isinstance(value, str):
+            variables: List[WorkflowVariable] = []
+
+            for match in self.patterns["variable"].finditer(value):
+                key, path, type, subtype, format, default = match.group(1, 2, 3, 4, 5, 6)
+
+                if type and default:
+                    default = self._parse_as_type(default, type)
+
+                if key == wanted_key:
+                    variables.append(WorkflowVariable(path, type or "string", subtype, format, default))
+
+            return variables
+
+        if isinstance(value, BaseModel):
+            return self._enumerate_input_variables(value.model_dump(exclude_none=True), wanted_key)
+        
+        if isinstance(value, dict):
+            return sum([ self._enumerate_input_variables(v, wanted_key) for v in value.values() ], [])
+
+        if isinstance(value, list):
+            return sum([ self._enumerate_input_variables(v, wanted_key) for v in value ], [])
+        
+        return []
+
+    def _enumerate_output_variables(self, name: Optional[str], value: Any) -> List[WorkflowVariable]:
+        variables: List[WorkflowVariable] = []
+        
+        if isinstance(value, str):
+            for match in self.patterns["variable"].finditer(value):
+                key, path, type, subtype, format, default = match.group(1, 2, 3, 4, 5, 6)
+
+                if type and default:
+                    default = self._parse_as_type(default, type)
+
+                variables.append(WorkflowVariable(name, type or "string", subtype, format, default))
+            
+            return variables
+        
+        if isinstance(value, BaseModel):
+            return self._enumerate_output_variables(name, value.model_dump(exclude_none=True))
+        
+        if isinstance(value, dict):
+            return sum([ self._enumerate_output_variables(f"{name}.{k}" if name else f"{k}", v) for k, v in value.items() ], [])
+
+        if isinstance(value, list):
+            return sum([ self._enumerate_output_variables(f"{name}[{i}]" if name else f"[{i}]", v) for i, v in enumerate(value) ], [])
+        
+        return []
+
+    def _to_variable_config_list(self, variables: List[Union[WorkflowVariable, WorkflowVariableGroup]]) -> List[Union[WorkflowVariableConfig, WorkflowVariableGroupConfig]]:
+        configs: List[Union[WorkflowVariableConfig, WorkflowVariableGroupConfig]] = []
+        seen_single: Set[WorkflowVariable] = set()
+
+        for item in variables:
+            if isinstance(item, WorkflowVariableGroup):
+                group: List[WorkflowVariableConfig] = []
+                seen_in_group: Set[WorkflowVariable] = set()
+                for variable in item.variables:
+                    if variable not in seen_in_group:
+                        group.append(self._to_variable_config(variable))
+                        seen_in_group.add(variable)
+                configs.append(WorkflowVariableGroupConfig(name=item.name, variables=group, repeat_count=item.repeat_count))
+            else:
+                if item not in seen_single:
+                    configs.append(self._to_variable_config(item))
+                    seen_single.add(item)
+
+        return configs
+    
+    def _to_variable_config(self, variable: WorkflowVariable) -> WorkflowVariableConfig:
+        config_dict = variable.to_dict()
+
+        if variable.type == "select" and variable.subtype:
+            config_dict["options"] = variable.subtype.split(",")
+
+        return WorkflowVariableConfig(**config_dict)
+
+    def _parse_as_type(self, value: Any, type: str) -> Any:
+        if type == "number":
+            return float(value)
+
+        if type == "integer":
+            return int(value)
+        
+        if type == "boolean":
+            return str(value).lower() in [ "true", "1" ]
+        
+        if type == "json":
+            return json.loads(value)
+ 
+        return value
+
+class WorkflowInputVariableResolver(WorkflowVariableResolver):
+    def resolve(self, workflow: WorkflowConfig, components: Dict[str, ComponentConfig]) -> List[WorkflowVariableConfig]:
+        variables: List[WorkflowVariable] = []
+
+        for job in workflow.jobs.values():
+            if not job.input or job.input == "${input}":
+                action_id = job.action or "__default__"
+                if isinstance(job.component, str):
+                    component: Optional[ComponentConfig] = components[job.component] if job.component in components else None
+                    if component:
+                        variables.extend(self._enumerate_input_variables(component.actions[action_id], "input"))
+                else:
+                    variables.extend(self._enumerate_input_variables(job.component.actions[action_id], "input"))
+            else:
+                variables.extend(self._enumerate_input_variables(job.input, "input"))
+
+            for value in [ job.component, job.action, job.repeat_count ]:
+                variables.extend(self._enumerate_input_variables(value, "input"))
+
+        return self._to_variable_config_list(variables)
+
+class WorkflowOutputVariableResolver(WorkflowVariableResolver):
+    def resolve(self, workflow: WorkflowConfig, components: Dict[str, ComponentConfig]) -> List[Union[WorkflowVariableConfig, WorkflowVariableGroupConfig]]:
+        variables: List[Union[WorkflowVariable, WorkflowVariableGroup]] = []
+
+        for job_id, job in workflow.jobs.items():
+            if not self._is_terminal_job(workflow, job_id):
+                continue
+
+            job_variables: List[WorkflowVariable] = variables
+            repeat_count: int = job.repeat_count if isinstance(job.repeat_count, int) else 0
+
+            if repeat_count != 1:
+                variables.append(WorkflowVariableGroup(None, job_variables := [], repeat_count))
+
+            if not job.output or job.output == "${output}":
+                action_id = job.action or "__default__"
+                if isinstance(job.component, str):
+                    component: Optional[ComponentConfig] = components[job.component] if job.component in components else None
+                    if component:
+                        job_variables.extend(self._enumerate_output_variables(None, component.actions[action_id].output))
+                else:
+                    job_variables.extend(self._enumerate_output_variables(None, job.component.actions[action_id].output))
+            else:
+                job_variables.extend(self._enumerate_output_variables(None, job.output))
+
+        return self._to_variable_config_list(variables)
+
+    def _is_terminal_job(self, workflow: WorkflowConfig, job_id: str) -> bool:
+        return all(job_id not in job.depends_on for other_id, job in workflow.jobs.items() if other_id != job_id)
+
+class WorkflowSchema:
+    def __init__(self, name: str, title: str, description: Optional[str], input: List[WorkflowVariableConfig], output: List[Union[WorkflowVariableConfig, WorkflowVariableGroupConfig]]):
+        self.name: str = name
+        self.title: str = title
+        self.description: Optional[str] = description
+        self.input: List[WorkflowVariableConfig] = input
+        self.output: List[Union[WorkflowVariableConfig, WorkflowVariableGroupConfig]] = output

{model_compose-0.1.1 → model_compose-0.1.3}/src/mindor/core/controller/webui/webui.py

@@ -4,7 +4,7 @@ from mindor.dsl.schema.component import ComponentConfig
 from mindor.dsl.schema.workflow import WorkflowConfig
 from mindor.core.controller.runner import ControllerRunner
 from mindor.core.services import AsyncService
-from .schema import WorkflowSchema, WorkflowInputResolver, WorkflowOutputResolver
+from .schema import WorkflowSchema, WorkflowInputVariableResolver, WorkflowOutputVariableResolver
 from .gradio import GradioWebUIBuilder
 
 from fastapi import FastAPI, APIRouter, Body, HTTPException
@@ -68,8 +68,8 @@ class ControllerWebUI(AsyncService):
                 name=workflow.name,
                 title=workflow.title, 
                 description=workflow.description,
-                input=WorkflowInputResolver().resolve(workflow, self.components),
-                output=WorkflowOutputResolver().resolve(workflow, self.components)
+                input=WorkflowInputVariableResolver().resolve(workflow, self.components),
+                output=WorkflowOutputVariableResolver().resolve(workflow, self.components)
             )
 
         return schema

{model_compose-0.1.1 → model_compose-0.1.3}/src/mindor/core/listener/engine/http_callback.py

@@ -66,7 +66,7 @@ class HttpCallbackListener(ListenerEngine):
             )
 
     def _make_callback_handler(self, callback: HttpCallbackConfig) -> Callable:
-        async def handler(request: Request) -> Response:
+        async def _handler(request: Request) -> Response:
             content_type, _ = parse_options_header(request.headers, "Content-Type")
             body, query = await parse_request_body(request, content_type), request.query_params
             context: HttpCallbackContext = HttpCallbackContext(body, query, callback.bulk, callback.item)
@@ -85,7 +85,7 @@ class HttpCallbackListener(ListenerEngine):
 
             return Response()
 
-        return handler
+        return _handler
 
     async def _is_callback_succeeded(self, callback: HttpCallbackConfig, context: HttpCallbackContext) -> bool:
         status = (await context.render_template(callback.status)) if callback.status else None

{model_compose-0.1.1 → model_compose-0.1.3}/src/mindor/core/utils/http_client.py

@@ -1,9 +1,7 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, AsyncIterator, Any
 from .http_request import serialize_request_body, parse_options_header
 from .streaming import StreamResource
-
-from urllib.parse import urlencode
-import aiohttp, json
+import aiohttp
 
 class HttpStreamResource(StreamResource):
     def __init__(self, session: aiohttp.ClientSession, stream: aiohttp.StreamReader, content_type: Optional[str] = None, filename: Optional[str] = None):
@@ -28,7 +26,7 @@ class HttpStreamResource(StreamResource):
             yield chunk
 
 class HttpClient:
-    async def request(self, url: str, method: str, params: Optional[Dict[str, Any]], body: Optional[Any], headers: Optional[Dict[str, str]]) -> Any:
+    async def request(self, url: str, method: Optional[str] = "GET", params: Optional[Dict[str, Any]] = None, body: Optional[Any] = None, headers: Optional[Dict[str, str]] = None) -> Any:
         session = aiohttp.ClientSession()
         try:
             response = await session.request(
@@ -39,11 +37,11 @@ class HttpClient:
                 headers=headers
             )
 
-            if response.status >= 400:
-                raise ValueError(f"Request failed with status {response.status}")
-
             content = await self._parse_response_content(session, response)
 
+            if response.status >= 400:
+                raise ValueError(f"Request failed with status {response.status}: {content}")
+
             if not isinstance(content, HttpStreamResource):
                 await session.close()
 
@@ -57,7 +55,7 @@ class HttpClient:
 
         if content_type and body:
             return await serialize_request_body(body, content_type)
-        
+
         return body
 
     async def _parse_response_content(self, session: aiohttp.ClientSession, response: aiohttp.ClientResponse) -> Any:

{model_compose-0.1.1 → model_compose-0.1.3}/src/mindor/core/utils/template.py

@@ -48,7 +48,7 @@ class TemplateRenderer:
 
             value = default if value is None else value
 
-            if type and value:
+            if type and value is not None:
                 value = await self._convert_type(value, type, subtype, format)
 
             if variable == text:
@@ -85,7 +85,7 @@ class TemplateRenderer:
 
         if type == "integer":
             return int(value)
-        
+
         if type == "json":
             return json.loads(value)
         

{model_compose-0.1.1 → model_compose-0.1.3}/src/mindor/core/workflow/job.py

@@ -3,7 +3,7 @@ from mindor.dsl.schema.workflow import JobConfig
 from mindor.dsl.schema.component import ComponentConfig
 from mindor.core.component import ComponentEngine
 from .context import WorkflowContext
-import ulid
+import asyncio, ulid
 
 class Job:
     def __init__(self, id: str, config: JobConfig, component_provider: Callable[[str, Union[ComponentConfig, str]], ComponentEngine]):
@@ -12,7 +12,7 @@ class Job:
         self.component_provider: Callable[[str, Union[ComponentConfig, str]], ComponentEngine] = component_provider
 
     async def run(self, context: WorkflowContext) -> Any:
-        component: ComponentEngine = self.component_provider(self.id, self.config.component)
+        component: ComponentEngine = self.component_provider(self.id, await context.render_template(self.config.component))
 
         if not component.started:
             await component.start()
@@ -20,16 +20,18 @@ class Job:
         input = (await context.render_template(self.config.input)) if self.config.input else context.input
         outputs = []
 
-        for _ in range(self.config.repeats):
+        async def _run_once():
             call_id = ulid.ulid()
-            output = await component.run(self.config.action, call_id, input)
-            
-            if output:
-                outputs.append(output)
+            output = await component.run(await context.render_template(self.config.action), call_id, input)
+            context.register_source("output", output)
 
-        output = outputs[0] if len(outputs) == 1 else outputs or None
+            output = (await context.render_template(self.config.output)) if self.config.output else output
+            outputs.append(output)
 
-        if output:
-            context.register_source("output", output)
+        repeat_count = (await context.render_template(self.config.repeat_count)) if self.config.repeat_count else None
+        await asyncio.gather(*[ _run_once() for _ in range(int(repeat_count or 1)) ])
+
+        output = outputs[0] if len(outputs) == 1 else outputs or None
+        context.register_source("output", output)
 
-        return (await context.render_template(self.config.output)) if self.config.output else output
+        return output

{model_compose-0.1.1 → model_compose-0.1.3}/src/mindor/dsl/schema/workflow.py

@@ -1,17 +1,23 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from enum import Enum
 from pydantic import BaseModel, Field
-from pydantic import model_validator
+from pydantic import model_validator, field_validator
 from .component import ComponentConfig
 
 class JobConfig(BaseModel):
     component: Optional[Union[str, 'ComponentConfig']] = Field(default="__default__", description="The component to execute. Can be a string identifier or a ComponentConfig object.")
     action: Optional[str] = Field(default="__default__", description="The action to invoke within the component. Defaults to '__default__'.")
-    repeats: Optional[int] = Field(default=1, ge=1, description="Number of times to repeat the component execution. Must be at least 1.")
     input: Optional[Any] = Field(default=None, description="The input data passed to the component. Can be of any type.")
     output: Optional[Any] = Field(default=None, description="The expected output data from the component. Can be of any type.")
+    repeat_count: Optional[Union[int, str]] = Field(default=1, description="Number of times to repeat the component execution. Must be at least 1.")
     depends_on: Optional[List[str]] = Field(default_factory=list, description="List of job names that this job depends on. Ensures execution order.")
 
+    @field_validator("repeat_count")
+    def validate_repeat_count(cls, value):
+        if isinstance(value, int) and value < 1:
+            raise ValueError("'repeat_count' must be at least 1")
+        return value
+
 class WorkflowVariableType(str, Enum):
     # Primitive data types
     STRING  = "string"
@@ -25,6 +31,7 @@ class WorkflowVariableType(str, Enum):
     # Media and files
     IMAGE   = "image"
     AUDIO   = "audio"
+    VIDEO   = "video"
     FILE    = "file"
     # UI-related types
     SELECT  = "select"
@@ -33,16 +40,22 @@ class WorkflowVariableFormat(str, Enum):
     BASE64 = "base64"
     URL    = "url"
     PATH   = "path"
+    STREAM = "stream"
 
 class WorkflowVariableConfig(BaseModel):
     name: Optional[str] = Field(default=None, description="The name of the variable")
     type: WorkflowVariableType = Field(..., description="Type of the variable")
     subtype: Optional[str] = Field(default=None, description="Subtype of the variable")
     format: Optional[WorkflowVariableFormat] = Field(default=None, description="Format of the variable")
+    options: Optional[List[str]] = Field(default=None, description="List of valid options for select type")
     required: bool = Field(default=False, description="Whether this variable is required")
     default: Optional[Any] = Field(default=None, description="Default value if not provided")
     description: Optional[str] = Field(default=None, description="Description of the variable")
-    options: Optional[List[Any]] = Field(default=None, description="List of valid options for select type")
+
+class WorkflowVariableGroupConfig(BaseModel):
+    name: Optional[str] = Field(default=None, description="The name of the group of variables")
+    variables: List[WorkflowVariableConfig] = Field(default_factory=list, description="List of variables included in this group")
+    repeat_count: int = Field(default=1, description="The number of times this group of variables should be repeated")
 
 class WorkflowConfig(BaseModel):
     name: Optional[str] = None

{model_compose-0.1.1 → model_compose-0.1.3}/src/model_compose.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model-compose
-Version: 0.1.1
+Version: 0.1.3
 Summary: model-compose: Declarative AI Model and Workflow Orchestrator (part of the Mindor project)
 Author-email: Hanyeol Cho <hanyeol.cho@gmail.com>
 License-Expression: MIT

model_compose-0.1.1/src/mindor/core/controller/webui/schema.py

@@ -1,135 +0,0 @@
-from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
-from pydantic import BaseModel
-from mindor.dsl.schema.workflow import WorkflowConfig, WorkflowVariableConfig
-from mindor.dsl.schema.component import ComponentConfig
-import re, json, io
-
-class WorkflowVariableResolver:
-    def __init__(self):
-        self.patterns: Dict[str, re.Pattern] = {
-            "variable": re.compile(
-                r"""\$\{                                                             # ${ 
-                    ([a-zA-Z_][^.\s]*)                                               # key: input, env, etc.
-                    (?:\.([^\s\|\}]+))?                                              # path: key, key.path[0], etc.
-                    (?:\s*as\s*([^\s\|\}/;]+)(?:/([^\s\|\};]+))?(?:;([^\s\|\}]+))?)? # type/subtype;format
-                    (?:\s*\|\s*([^\}]+))?                                            # default value after `|`
-                \}""",                                                               # }
-                re.VERBOSE,
-            )
-        }
-
-    def _enumerate_input_variables(self, value: Any, wanted_key: str) -> List[Tuple[str, str, str, Optional[Any]]]:
-        if isinstance(value, str):
-            variables: List[Tuple[str, str, str, str, Optional[Any]]] = []
-
-            for match in self.patterns["variable"].finditer(value):
-                key, path, type, subtype, format, default = match.group(1, 2, 3, 4, 5, 6)
-
-                if type and default:
-                    default = self._parse_as_type(default, type)
-
-                if key == wanted_key:
-                    variables.append((path, type or "string", subtype, format, default))
-
-            return variables
-
-        if isinstance(value, BaseModel):
-            return self._enumerate_input_variables(value.model_dump(exclude_none=True), wanted_key)
-        
-        if isinstance(value, dict):
-            return sum([ self._enumerate_input_variables(v, wanted_key) for v in value.values() ], [])
-
-        if isinstance(value, list):
-            return sum([ self._enumerate_input_variables(v, wanted_key) for v in value ], [])
-        
-        return []
-
-    def _enumerate_output_variables(self, key: str, value: Any) -> List[Tuple[str, str, str, Optional[Any]]]:
-        variables: List[Tuple[str, str, str, str, Optional[Any]]] = []
-        
-        if isinstance(value, str):
-            for match in self.patterns["variable"].finditer(value):
-                type, subtype, format, default = match.group(3, 4, 5, 6)
-
-                if type and default:
-                    default = self._parse_as_type(default, type)
-
-                variables.append((key, type or "string", subtype, format, default))
-            
-            return variables
-        
-        if isinstance(value, BaseModel):
-            return self._enumerate_output_variables(key, value.model_dump(exclude_none=True))
-        
-        if isinstance(value, dict):
-            return sum([ self._enumerate_output_variables(f"{key}.{k}" if key else f"{k}", v) for k, v in value.items() ], [])
-
-        if isinstance(value, list):
-            return sum([ self._enumerate_output_variables(f"{key}[{i}]" if key else f"[{i}]", v) for i, v in enumerate(value) ], [])
-        
-        return []
-
-    def _parse_as_type(self, value: Any, type: str) -> Any:
-        if type == "number":
-            return float(value)
-
-        if type == "integer":
-            return int(value)
-        
-        if type == "boolean":
-            return str(value).lower() in [ "true", "1" ]
-        
-        if type == "json":
-            return json.loads(value)
- 
-        return value
-
-class WorkflowInputResolver(WorkflowVariableResolver):
-    def resolve(self, workflow: WorkflowConfig, components: Dict[str, ComponentConfig]) -> List[WorkflowVariableConfig]:
-        variables: List[Tuple[str, str, Optional[Any]]] = []
-
-        for job in workflow.jobs.values():
-            if not job.input or job.input == "${input}":
-                action_id = job.action or "__default__"
-                if isinstance(job.component, str):
-                    component: Optional[ComponentConfig] = components[job.component] if job.component in components else None
-                    if component:
-                        variables.extend(self._enumerate_input_variables(component.actions[action_id], "input"))
-                else:
-                    variables.extend(self._enumerate_input_variables(job.component.actions[action_id], "input"))
-            else:
-                variables.extend(self._enumerate_input_variables(job.input, "input"))
-
-        return [ WorkflowVariableConfig(name=name, type=type, subtype=subtype, format=format, default=default) for name, type, subtype, format, default in set(variables) ]
-
-class WorkflowOutputResolver(WorkflowVariableResolver):
-    def resolve(self, workflow: WorkflowConfig, components: Dict[str, ComponentConfig]) -> List[WorkflowVariableConfig]:
-        variables: List[Tuple[str, str, str, Optional[Any]]] = []
-        
-        for job_id, job in workflow.jobs.items():
-            if not self._is_terminal_job(workflow, job_id):
-                continue
-            
-            if not job.output or job.output == "${output}":
-                action_id = job.action or "__default__"
-                if isinstance(job.component, str):
-                    component: Optional[ComponentConfig] = components[job.component] if job.component in components else None
-                    if component:
-                        variables.extend(self._enumerate_output_variables(None, component.actions[action_id].output))
-                else:
-                    variables.extend(self._enumerate_output_variables(None, job.component.actions[action_id].output))
-            else:
-                variables.extend(self._enumerate_output_variables(None, job.output))
-
-        return [ WorkflowVariableConfig(name=name, type=type, subtype=subtype, format=format, default=default) for name, type, subtype, format, default in set(variables) ]
-
-    def _is_terminal_job(self, workflow: WorkflowConfig, job_id: str) -> bool:
-        return all(job_id not in job.depends_on for other_id, job in workflow.jobs.items() if other_id != job_id)
-
-class WorkflowSchema:
-    def __init__(self, name: str, title: str, description: Optional[str], input: List[WorkflowVariableConfig], output: List[WorkflowVariableConfig]):
-        self.name: str = name
-        self.title: str = title
-        self.description: Optional[str] = description
-        self.input: List[WorkflowVariableConfig] = input
-        self.output: List[WorkflowVariableConfig] = output