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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "model-compose"
-version = "0.1.1"
+version = "0.1.2"
 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.2}/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.2}/src/mindor/core/controller/webui/gradio.py

@@ -1,5 +1,5 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Callable, Awaitable, Any
-from mindor.dsl.schema.workflow import WorkflowVariableConfig
+from mindor.dsl.schema.workflow import WorkflowVariableConfig, WorkflowVariableGroupConfig
 from mindor.core.utils.http_client import HttpStreamResource
 from mindor.core.utils.image import load_image_from_stream
 from mindor.core.utils.streaming import Base64StreamResource, save_stream_to_temporary_file
@@ -7,18 +7,23 @@ 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
 
@@ -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
@@ -89,7 +83,16 @@ class GradioWebUIBuilder:
         
         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 ""
 
@@ -104,7 +107,34 @@ class GradioWebUIBuilder:
     
         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 == "base64" and isinstance(value, str):
                 return await load_image_from_stream(Base64StreamResource(value), subtype)
@@ -119,9 +149,4 @@ class GradioWebUIBuilder:
                 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.1 → model_compose-0.1.2}/src/mindor/core/controller/webui/schema.py

@@ -1,8 +1,41 @@
 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.workflow import WorkflowConfig, WorkflowVariableConfig, WorkflowVariableGroupConfig
 from mindor.dsl.schema.component import ComponentConfig
-import re, json, io
+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):
@@ -15,12 +48,13 @@ class WorkflowVariableResolver:
                     (?:\s*\|\s*([^\}]+))?                                            # default value after `|`
                 \}""",                                                               # }
                 re.VERBOSE,
-            )
+            ),
+            "keypath": re.compile(r"[-_\w]+|\[\d+\]"),
         }
 
-    def _enumerate_input_variables(self, value: Any, wanted_key: str) -> List[Tuple[str, str, str, Optional[Any]]]:
+    def _enumerate_input_variables(self, value: Any, wanted_key: str) -> List[WorkflowVariable]:
         if isinstance(value, str):
-            variables: List[Tuple[str, str, str, str, Optional[Any]]] = []
+            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)
@@ -29,7 +63,7 @@ class WorkflowVariableResolver:
                     default = self._parse_as_type(default, type)
 
                 if key == wanted_key:
-                    variables.append((path, type or "string", subtype, format, default))
+                    variables.append(WorkflowVariable(path, type or "string", subtype, format, default))
 
             return variables
 
@@ -44,31 +78,51 @@ class WorkflowVariableResolver:
         
         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]]] = []
+    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):
-                type, subtype, format, default = match.group(3, 4, 5, 6)
+                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((key, type or "string", subtype, format, default))
+                variables.append(WorkflowVariable(name, type or "string", subtype, format, default))
             
             return variables
         
         if isinstance(value, BaseModel):
-            return self._enumerate_output_variables(key, value.model_dump(exclude_none=True))
+            return self._enumerate_output_variables(name, 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() ], [])
+            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"{key}[{i}]" if key else f"[{i}]", v) for i, v in enumerate(value) ], [])
+            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 v in item.variables:
+                    if v not in seen_in_group:
+                        seen_in_group.add(v)
+                        group.append(WorkflowVariableConfig(**v.to_dict()))
+                configs.append(WorkflowVariableGroupConfig(name=item.name, variables=group, repeat_count=item.repeat_count))
+            else:
+                if item not in seen_single:
+                    seen_single.add(item)
+                    configs.append(WorkflowVariableConfig(**item.to_dict()))
+
+        return configs
+
     def _parse_as_type(self, value: Any, type: str) -> Any:
         if type == "number":
             return float(value)
@@ -86,7 +140,7 @@ class WorkflowVariableResolver:
 
 class WorkflowInputResolver(WorkflowVariableResolver):
     def resolve(self, workflow: WorkflowConfig, components: Dict[str, ComponentConfig]) -> List[WorkflowVariableConfig]:
-        variables: List[Tuple[str, str, Optional[Any]]] = []
+        variables: List[WorkflowVariable] = []
 
         for job in workflow.jobs.values():
             if not job.input or job.input == "${input}":
@@ -100,36 +154,45 @@ class WorkflowInputResolver(WorkflowVariableResolver):
             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) ]
+            for value in [ job.repeat_count ]:
+                variables.extend(self._enumerate_input_variables(value, "input"))
+
+        return self._to_variable_config_list(variables)
 
 class WorkflowOutputResolver(WorkflowVariableResolver):
-    def resolve(self, workflow: WorkflowConfig, components: Dict[str, ComponentConfig]) -> List[WorkflowVariableConfig]:
-        variables: List[Tuple[str, str, str, Optional[Any]]] = []
-        
+    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:
-                        variables.extend(self._enumerate_output_variables(None, component.actions[action_id].output))
+                        job_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))
+                    job_variables.extend(self._enumerate_output_variables(None, job.component.actions[action_id].output))
             else:
-                variables.extend(self._enumerate_output_variables(None, job.output))
+                job_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) ]
+        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[WorkflowVariableConfig]):
+    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[WorkflowVariableConfig] = output
+        self.output: List[Union[WorkflowVariableConfig, WorkflowVariableGroupConfig]] = output

{model_compose-0.1.1 → model_compose-0.1.2}/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.2}/src/mindor/core/utils/http_client.py

@@ -39,11 +39,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()
 

{model_compose-0.1.1 → model_compose-0.1.2}/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.2}/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]):
@@ -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)
+            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.2}/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"
@@ -44,6 +50,11 @@ class WorkflowVariableConfig(BaseModel):
     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
     title: Optional[str] = None

{model_compose-0.1.1 → model_compose-0.1.2}/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.2
 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