model-compose 0.0.16__tar.gz → 0.1.0__tar.gz

{model_compose-0.0.16 → model_compose-0.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model-compose
-Version: 0.0.16
+Version: 0.1.0
 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
@@ -18,6 +18,7 @@ Requires-Dist: uvicorn
 Requires-Dist: pyngrok
 Requires-Dist: ulid
 Requires-Dist: gradio
+Requires-Dist: Pillow
 Dynamic: license-file
 
 # model-compose: Declarative AI Model and Workflow Orchestrator (_part of the Mindor project_)

{model_compose-0.0.16 → model_compose-0.1.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "model-compose"
-version = "0.0.16"
+version = "0.1.0"
 description = "model-compose: Declarative AI Model and Workflow Orchestrator (part of the Mindor project)"
 authors = [
     { name = "Hanyeol Cho", email = "hanyeol.cho@gmail.com" }
@@ -18,7 +18,8 @@ dependencies = [
     "uvicorn",
     "pyngrok", 
     "ulid", 
-    "gradio"
+    "gradio",
+    "Pillow"
 ]
 
 [project.scripts]

{model_compose-0.0.16 → model_compose-0.1.0}/src/mindor/core/component/engine/context.py

@@ -14,10 +14,10 @@ class ComponentContext:
     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)
+    async def render_template(self, data: Dict[str, Any]) -> Any:
+        return await self.renderer.render(data)
 
-    def _resolve_source(self, key: str) -> Any:
+    async def _resolve_source(self, key: str) -> Any:
         if key in self.sources:
             return self.sources[key]
         if key == "input":

{model_compose-0.0.16 → model_compose-0.1.0}/src/mindor/core/component/engine/http_client.py

@@ -16,11 +16,11 @@ class HttpClientPollingCompletion:
         self.client: HttpClient = HttpClient()
 
     async def run(self, context: ComponentContext) -> 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)
+        url     = await self._resolve_request_url(context)
+        method  = await context.render_template(self.config.method)
+        params  = await context.render_template(self.config.params)
+        body    = await context.render_template(self.config.body)
+        headers = await context.render_template(self.config.headers)
 
         interval = parse_duration(self.config.interval) if self.config.interval else 5.0
         timeout  = parse_duration(self.config.timeout) if self.config.timeout else 300
@@ -32,35 +32,35 @@ class HttpClientPollingCompletion:
             response = await self.client.request(url, method, params, body, headers)
 
             context.register_source("result", response)
-            status = context.render_template(self.config.status) if self.config.status else response["status"]
+            status = (await context.render_template(self.config.status)) if self.config.status else response["status"]
 
             if not status:
                 raise RuntimeError(f"Polling failed: no status found in response.")
 
             for success_when in self.config.success_when if self.config.success_when else [ "completed" ]:
-                if status == context.render_template(success_when):
+                if status == await context.render_template(success_when):
                     return response
 
             for fail_when in self.config.fail_when if self.config.fail_when else [ "failed" ]:
-                if status == context.render_template(fail_when):
+                if status == await context.render_template(fail_when):
                     raise RuntimeError(f"Polling failed: status '{status}' matched a failure condition.")
 
             await asyncio.sleep(interval.total_seconds())
 
         raise TimeoutError(f"Polling timed out after {timeout}.")
 
-    def _resolve_request_url(self, context: ComponentContext) -> str:
+    async def _resolve_request_url(self, context: ComponentContext) -> str:
         if self.base_url and self.config.path:
-            return context.render_template(self.base_url) + context.render_template(self.config.path)
+            return await context.render_template(self.base_url) + await context.render_template(self.config.path)
 
-        return context.render_template(self.config.endpoint)
+        return await context.render_template(self.config.endpoint)
 
 class HttpClientCallbackCompletion:
     def __init__(self, config: HttpClientCompletionConfig):
         self.config: HttpClientCompletionConfig = config
 
     async def run(self, context: ComponentContext) -> Any:
-        callback_id = context.render_template(self.config.wait_for)
+        callback_id = await context.render_template(self.config.wait_for)
         future: asyncio.Future = asyncio.get_event_loop().create_future()
         HttpCallbackListener.register_pending_future(callback_id, future)
 
@@ -73,11 +73,11 @@ class HttpClientAction:
         self.client: HttpClient = HttpClient()
 
     async def run(self, context: ComponentContext) -> 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)
+        url     = await self._resolve_request_url(context)
+        method  = await context.render_template(self.config.method)
+        params  = await context.render_template(self.config.params)
+        body    = await context.render_template(self.config.body)
+        headers = await context.render_template(self.config.headers)
 
         response, result = await self.client.request(url, method, params, body, headers), None
 
@@ -90,13 +90,13 @@ class HttpClientAction:
             if result:
                 context.register_source("result", result)
 
-        return context.render_template(self.config.output) if self.config.output else (result or response)
+        return (await context.render_template(self.config.output)) if self.config.output else (result or response)
 
-    def _resolve_request_url(self, context: ComponentContext) -> str:
+    async def _resolve_request_url(self, context: ComponentContext) -> str:
         if self.base_url and self.config.path:
-            return context.render_template(self.base_url) + context.render_template(self.config.path)
+            return await context.render_template(self.base_url) + await context.render_template(self.config.path)
 
-        return context.render_template(self.config.endpoint)
+        return await context.render_template(self.config.endpoint)
 
     async def _handle_completion(self, completion: HttpClientCompletionConfig, context: ComponentContext) -> Any:
         if completion.type == "polling":

{model_compose-0.0.16 → model_compose-0.1.0}/src/mindor/core/controller/engine/http_server.py

@@ -61,10 +61,10 @@ class HttpServerController(ControllerEngine):
 
     def _configure_server(self):
         self.app.add_middleware(
-            CORSMiddleware,
-            allow_origins=["*"],
-            allow_credentials=True,
-            allow_methods=["*"],
+            CORSMiddleware, 
+            allow_origins=[self.config.origins], 
+            allow_credentials=True, 
+            allow_methods=["*"], 
             allow_headers=["*"],
         )
 
@@ -148,7 +148,7 @@ class HttpServerController(ControllerEngine):
             resource,
             media_type=resource.content_type, 
             headers=self._build_stream_resource_headers(resource), 
-            background=BackgroundTask(_close_stream())
+            background=BackgroundTask(_close_stream)
         )
     
     def _build_stream_resource_headers(self, resource: StreamResource) -> Dict[str, str]:

{model_compose-0.0.16 → model_compose-0.1.0}/src/mindor/core/controller/webui/gradio.py

@@ -1,20 +1,11 @@
 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.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
 
-mermaid_code = """
-```mermaid  
-graph LR
-    A[Start] --> B[Process];
-    B --> C{Decision};
-    C -->|Yes| D[Do something];
-    C -->|No| E[Do something else];
-    D --> F[End];
-    E --> F;
-``` 
-"""
-
 class GradioWebUIBuilder:
     def build(self, schema: Dict[str, WorkflowSchema], runner: Callable[[Optional[str], Any], Awaitable[Any]]) -> gr.Blocks:
         with gr.Blocks() as blocks:
@@ -37,8 +28,6 @@ class GradioWebUIBuilder:
             if workflow.description:
                 gr.Markdown(f"📝 {workflow.description}")
 
-            gr.Markdown(mermaid_code)
-            
             gr.Markdown("#### 📥 Input Parameters")
             input_components = [ self._build_input_component(variable) for variable in workflow.input ]
             run_button = gr.Button("🚀 Run Workflow", variant="primary")
@@ -53,9 +42,13 @@ class GradioWebUIBuilder:
                 input = { variable.name: value for variable, value in zip(workflow.input, args) }
                 output = await runner(input)
 
-                if workflow.output and isinstance(output, dict):
-                    output = [ output[variable.name] for variable in workflow.output ]
-                    output = output[0] if len(output) == 1 else output
+                if workflow.output:
+                    if isinstance(output, dict):
+                        output = [ await self._convert_type(output[variable.name], variable.type, variable.subtype, variable.format) for variable in workflow.output ]
+                        output = output[0] if len(output) == 1 else output
+                    else:
+                        variable = workflow.output[0]
+                        output = await self._convert_type(output, variable.type, variable.subtype, variable.format)
 
                 return output
 
@@ -93,10 +86,33 @@ class GradioWebUIBuilder:
         return gr.Textbox(label=label, value=default, info=f"Unsupported type: {variable.type}")
 
     def _build_output_component(self, variable: WorkflowVariableConfig) -> gr.Component:
-        label = variable.name
+        label = variable.name or ""
         info = variable.description or ""
-        
+
         if variable.type == "string":
             return gr.Textbox(label=label, interactive=False, show_copy_button=True, info=info)
         
+        if variable.type == "image":
+            return gr.Image(label=label, interactive=False)
+        
+        if variable.type == "audio":
+            return gr.Audio(label=label)
+    
         return gr.Textbox(label=label, info=f"Unsupported type: {variable.type}")
+
+    async def _convert_type(self, value: Any, type: Optional[str], subtype: Optional[str], format: Optional[str]) -> Any:
+        if type == "image":
+            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 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
+
+        return value

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

@@ -0,0 +1,135 @@
+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._convert_type(default, type, subtype, format)
+
+                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._convert_type(default, type, subtype, format)
+
+                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 _convert_type(self, value: Any, type: str, subtype: str, format: Optional[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

{model_compose-0.0.16 → model_compose-0.1.0}/src/mindor/core/listener/engine/http_callback.py

@@ -1,4 +1,4 @@
-from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Callable, Iterator, Any
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Callable, AsyncIterator, Any
 
 from mindor.dsl.schema.listener import HttpCallbackListenerConfig, HttpCallbackConfig
 from mindor.core.utils.http_request import parse_request_body, parse_options_header
@@ -21,15 +21,15 @@ class HttpCallbackContext:
         self.item: Optional[str] = item
         self.renderer: TemplateRenderer = TemplateRenderer(self._resolve_source)
 
-    def items(self) -> Iterator["HttpCallbackContext"]:
-        for item in self._items():
+    async def items(self) -> AsyncIterator["HttpCallbackContext"]:
+        async for item in self._items():
             yield HttpCallbackContext(item, self.query, False, None)
 
-    def render_template(self, template: str) -> Any:
-        return self.renderer.render(template)
+    async def render_template(self, template: str) -> Any:
+        return await self.renderer.render(template)
 
-    def _items(self) -> List[Any]:
-        item = self.renderer.render(self.item) if self.item else self.body
+    async def _items(self) -> List[Any]:
+        item = await self.renderer.render(self.item) if self.item else self.body
 
         if self.bulk:
             if not isinstance(item, list):
@@ -38,7 +38,7 @@ class HttpCallbackContext:
 
         return [ item ]
 
-    def _resolve_source(self, key: str) -> Any:
+    async def _resolve_source(self, key: str) -> Any:
         if key == "body" or key == "item":
             return self.body
         if key == "query":
@@ -70,15 +70,15 @@ class HttpCallbackListener(ListenerEngine):
             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)
-            succeeded: bool = self._is_callback_succeeded(callback, context)
+            succeeded: bool = await self._is_callback_succeeded(callback, context)
 
-            for item in context.items():
-                callback_id = item.render_template(callback.identify_by)
+            async for item in context.items():
+                callback_id = await item.render_template(callback.identify_by)
                 future: asyncio.Future = self._get_pending_future(callback_id)
 
                 if future:
                     if succeeded:
-                        future.set_result(item.render_template(callback.result) if callback.result else item.body)
+                        future.set_result((await item.render_template(callback.result)) if callback.result else item.body)
                     else:
                         future.set_exception(RuntimeError(f"Task failed for '{callback_id}'"))
                     self._remove_pending_future(callback_id)
@@ -87,14 +87,14 @@ class HttpCallbackListener(ListenerEngine):
 
         return handler
 
-    def _is_callback_succeeded(self, callback: HttpCallbackConfig, context: HttpCallbackContext) -> bool:
-        status = context.render_template(callback.status) if callback.status else None
+    async def _is_callback_succeeded(self, callback: HttpCallbackConfig, context: HttpCallbackContext) -> bool:
+        status = (await context.render_template(callback.status)) if callback.status else None
 
         if status:
-            if callback.success_when and status == context.render_template(callback.success_when):
+            if callback.success_when and status == await context.render_template(callback.success_when):
                 return True
 
-            if callback.fail_when and status == context.render_template(callback.fail_when):
+            if callback.fail_when and status == await context.render_template(callback.fail_when):
                 return False
 
         return True       

{model_compose-0.0.16 → model_compose-0.1.0}/src/mindor/core/utils/http_client.py

@@ -6,17 +6,16 @@ from urllib.parse import urlencode
 import aiohttp, json
 
 class HttpStreamResource(StreamResource):
-    def __init__(self, session: aiohttp.ClientSession, stream: aiohttp.StreamReader, content_type: Optional[str], filename: Optional[str]):
+    def __init__(self, session: aiohttp.ClientSession, stream: aiohttp.StreamReader, content_type: Optional[str] = None, filename: Optional[str] = None):
         super().__init__(content_type, filename)
 
         self.session: aiohttp.ClientSession = session
         self.stream: aiohttp.StreamReader = stream
 
-    def get_stream(self):
-        return self.stream
-    
     async def close(self):
         await self.session.close()
+        self.session = None
+        self.stream  = None
 
     async def _iterate_stream(self) -> AsyncIterator[bytes]:
         _, buffer_size = self.stream.get_read_buffer_limits()

{model_compose-0.0.16 → model_compose-0.1.0}/src/mindor/core/utils/http_request.py

@@ -16,8 +16,7 @@ class NestedFormParser:
         data = {}
 
         for form_key, value in form.items():
-            keys = self._parse_key_path(form_key)
-            current = data
+            keys, current = self._parse_key_path(form_key), data
             for index, key in enumerate(keys):
                 if index == len(keys) - 1:
                     if key.endswith("[]"):

model_compose-0.1.0/src/mindor/core/utils/image.py

@@ -0,0 +1,14 @@
+from typing import Optional
+from .streaming import StreamResource
+from PIL import Image as PILImage
+import io, base64
+
+async def load_image_from_stream(stream: StreamResource, extension: Optional[str]) -> Optional[PILImage.Image]:
+    try:
+        data = bytearray()
+        async with stream:
+            async for chunk in stream:
+                data.extend(chunk)
+            return PILImage.open(io.BytesIO(data))
+    except Exception:
+        return None

model_compose-0.1.0/src/mindor/core/utils/streaming.py

@@ -0,0 +1,63 @@
+from typing import Optional, AsyncIterator
+from abc import ABC, abstractmethod
+from tempfile import NamedTemporaryFile
+import io, base64
+
+class StreamResource(ABC):
+    def __init__(self, content_type: Optional[str], filename: Optional[str]):
+        self.content_type = content_type or "application/octet-stream"
+        self.filename = filename
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.close()
+
+    def __aiter__(self):
+        return self._iterate_stream()
+
+    @abstractmethod
+    async def close(self):
+        pass
+
+    @abstractmethod
+    async def _iterate_stream(self) -> AsyncIterator[bytes]:
+        pass
+
+class Base64StreamResource(StreamResource):
+    def __init__(self, encoded: str, content_type: Optional[str] = None, filename: Optional[str] = None):
+        super().__init__(content_type, filename)
+
+        self.stream: Optional[io.BytesIO] = io.BytesIO(base64.b64decode(encoded))
+
+    async def close(self):
+        self.stream.close()
+        self.stream = None
+        
+    async def _iterate_stream(self) -> AsyncIterator[bytes]:
+        while True:
+            chunk = self.stream.read(8192)
+            if not chunk:
+                break
+            yield chunk
+
+async def save_stream_to_temporary_file(stream: StreamResource, extension: Optional[str]) -> Optional[str]:
+    try:
+        file = NamedTemporaryFile(suffix=f".{extension}" if extension else None, delete=False)
+        async with stream:
+            async for chunk in stream:
+                file.write(chunk)
+        file.flush()
+        file.close()
+        return file.name
+    except Exception:
+        return None
+
+async def encode_stream_to_base64(stream: StreamResource) -> str:
+    buffer = io.BytesIO()
+    async with stream:
+        async for chunk in stream:
+            buffer.write(chunk)
+    buffer.seek(0)
+    return base64.b64encode(buffer.read()).decode("utf-8")