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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model-compose
-Version: 0.1.3
+Version: 0.1.4
 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.3 → model_compose-0.1.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "model-compose"
-version = "0.1.3"
+version = "0.1.4"
 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.4/src/mindor/core/controller/runner/http_client.py

@@ -0,0 +1,68 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from mindor.dsl.schema.controller import ControllerConfig
+from mindor.core.utils.http_client import HttpClient
+from .runner import ControllerClient
+from starlette.datastructures import UploadFile
+
+class HttpControllerClient(ControllerClient):
+    def __init__(self, config: ControllerConfig):
+        super().__init__(config)
+
+        self.client: HttpClient = HttpClient()
+
+    async def run_workflow(self, workflow_id: Optional[str], input: Any) -> Any:
+        base_path = self.config.base_path if self.config.base_path else ""
+        url = f"http://localhost:{self.config.port}{base_path}/workflows"
+        method = "POST"
+        body = {
+            "workflow_id": workflow_id,
+            "input": input,
+            "wait_for_completion": True,
+            "output_only": True
+        }
+        headers = {
+            "Content-Type": "application/json"
+        }
+
+        if self._contains_upload_file(input):
+            body = { key: value for key, value in self._flatten_for_multipart(body) }
+            headers = {
+                "Content-Type": "multipart/form-data"
+            }
+
+        return await self.client.request(url, method, None, body, headers)
+
+    def _flatten_for_multipart(self, body: Dict[str, Any], key: str = "") -> List[Tuple[str, Any]]:
+        flattened = []
+
+        for subkey, value in body.items():
+            full_key = f"{key}[{subkey}]" if key else subkey
+
+            if isinstance(value, dict):
+                flattened.extend(self._flatten_for_multipart(value, full_key))
+                continue
+
+            if isinstance(value, list):
+                for item in value:
+                    list_key = f"{full_key}[]"
+                    if isinstance(item, (dict, list)):
+                        flattened.extend(self._flatten_for_multipart({ list_key: item }))
+                    else:
+                        flattened.append((list_key, item))
+                continue
+
+            flattened.append((full_key, value))
+
+        return flattened
+
+    def _contains_upload_file(self, value: Any) -> bool:
+        if isinstance(value, UploadFile):
+            return True
+        
+        if isinstance(value, dict):
+            return any(self._contains_upload_file(v) for v in value.values())
+        
+        if isinstance(value, list):
+            return any(self._contains_upload_file(v) for v in value)
+        
+        return False

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

@@ -4,8 +4,9 @@ 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
+from starlette.datastructures import UploadFile
 import gradio as gr
-import json
+import json, os
 
 class ComponentGroup:
     def __init__(self, group: gr.Component, components: List[gr.Component]):
@@ -45,9 +46,9 @@ class GradioWebUIBuilder:
                 output_components = gr.Textbox(label="", lines=8, interactive=False, show_copy_button=True)
 
             async def _run_workflow(*args):
-                input = { variable.name: value if value != "" else None for variable, value in zip(workflow.input, args) }
+                input = self._build_input_values(args, workflow.input)
                 output = await runner(input)
-                output = await self._flatten_output(output, workflow.output)
+                output = await self._flatten_output_values(output, workflow.output)
                 return output[0] if len(output) == 1 else output
 
             run_button.click(
@@ -78,8 +79,11 @@ class GradioWebUIBuilder:
         if variable.type == "image":
             return gr.Image(label=label, type="filepath")
 
+        if variable.type == "audio":
+            return gr.Audio(label=label, type="filepath")
+
         if variable.type == "video":
-            return gr.Video(label=label)
+            return gr.Video(label=label, type="filepath")
 
         if variable.type == "file":
             return gr.File(label=label)
@@ -88,6 +92,31 @@ class GradioWebUIBuilder:
             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_input_values(self, arguments: List[Any], variables: List[WorkflowVariableConfig]) -> Any:
+        if len(variables) == 1 and not variables[0].name:
+            return arguments[0]
+
+        input: Dict[str, Any] = {}
+        
+        for value, variable in zip(arguments, variables):
+            input[variable.name] = self._convert_input_value(value, variable)
+
+        return input
+    
+    def _convert_input_value(self, value: Any, variable: WorkflowVariableConfig) -> Any:
+        if variable.type in [ "image", "audio", "video", "file" ]:
+            file, filename = open(value, "rb"), os.path.basename(value)
+            headers = { 
+                "Content-Type": self._guess_file_content_type(filename, variable),
+                "Content-Disposition": f'form-data; filename="{filename}"'
+            }
+            return UploadFile(file=file, filename=filename, headers=headers)
+
+        return value if value != "" else None
+    
+    def _guess_file_content_type(self, filename: str, variable: WorkflowVariableConfig) -> str:
+        return "application/octet-stream"
 
     def _build_output_component(self, variable: Union[WorkflowVariableConfig, WorkflowVariableGroupConfig]) -> Union[gr.Component, List[ComponentGroup]]:
         if isinstance(variable, WorkflowVariableGroupConfig):
@@ -104,7 +133,7 @@ class GradioWebUIBuilder:
 
         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)
         
@@ -126,13 +155,13 @@ class GradioWebUIBuilder:
                 flattened.append(item)
         return flattened
     
-    async def _flatten_output(self, output: Any, variables: List[Union[WorkflowVariableConfig, WorkflowVariableGroupConfig]]) -> Any:
+    async def _flatten_output_values(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))
+                    flattened.extend(await self._flatten_output_values(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))
@@ -143,7 +172,7 @@ class GradioWebUIBuilder:
             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)

model_compose-0.1.4/src/mindor/core/utils/http_client.py

@@ -0,0 +1,97 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, AsyncIterator, Any
+from .http_request import build_request_body, parse_options_header
+from .streaming import StreamResource
+from requests.structures import CaseInsensitiveDict
+import aiohttp
+
+class HttpStreamResource(StreamResource):
+    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
+
+    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()
+        chunk_size = buffer_size or 65536
+
+        while not self.stream.at_eof():
+            chunk = await self.stream.read(chunk_size)
+            if not chunk:
+                break
+            yield chunk
+
+class HttpClient:
+    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 self._request_with_session(session, url, method, params, body, headers)
+            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()
+
+            return content
+        except:
+            await session.close()
+            raise
+
+    async def _request_with_session(
+        self,
+        session: aiohttp.ClientSession,
+        url: str,
+        method: str,
+        params: Optional[Dict[str, Any]],
+        body: Optional[Any],
+        headers: Optional[Dict[str, str]]
+    ) -> aiohttp.ClientResponse:
+        data, content_type = self._build_request_body(body, headers)
+ 
+        if content_type == "multipart/form-data":
+            headers = CaseInsensitiveDict(headers)
+            headers.pop("Content-Type", None)
+
+        return await session.request(method, url, params=params, data=data, headers=headers)
+
+    def _build_request_body(self, body: Optional[Any], headers: Optional[Dict[str, str]]) -> Tuple[Any, str]:
+        content_type, _ = parse_options_header(headers, "Content-Type")
+
+        if content_type and body is not None:
+            return (build_request_body(body, content_type), content_type)
+
+        return (body, content_type)
+
+    async def _parse_response_content(self, session: aiohttp.ClientSession, response: aiohttp.ClientResponse) -> Tuple[Any, str]:
+        content_type, _ = parse_options_header(response.headers, "Content-Type")
+
+        if content_type == "application/json":
+            return (await response.json(), content_type)
+
+        if content_type.startswith("text/"):
+            return (await response.text(), content_type)
+
+        _, disposition = parse_options_header(response.headers, "Content-Disposition")
+        filename = disposition.get("filename")
+
+        return (HttpStreamResource(session, response.content, content_type, filename), content_type)

{model_compose-0.1.3 → model_compose-0.1.4}/src/mindor/core/utils/http_request.py

@@ -1,9 +1,9 @@
 from typing import Dict, List, Tuple, Optional, Any
 from requests.structures import CaseInsensitiveDict
-from starlette.datastructures import FormData
+from starlette.datastructures import FormData, UploadFile
 from urllib.parse import urlencode
 from fastapi import Request
-import re, json
+import aiohttp, re, json
 
 _token_pattern = r"([\w!#$%&'*+\-.^_`|~]+)"
 _quoted_pattern = r'"([^"]*)"'
@@ -37,12 +37,12 @@ class NestedFormParser:
         
         return parts
 
-async def serialize_request_body(body: Any, content_type: Optional[str]) -> Any:
+def build_request_body(body: Any, content_type: Optional[str]) -> Any:
     if content_type == "application/json":
         return json.dumps(body)
     
     if content_type == "multipart/form-data":
-        return urlencode(body)
+        return build_request_form(body)
 
     if content_type == "application/x-www-form-urlencoded":
         return urlencode(body)
@@ -52,6 +52,22 @@ async def serialize_request_body(body: Any, content_type: Optional[str]) -> Any:
 
     return body
 
+def build_request_form(body: Any) -> aiohttp.FormData:
+    form = aiohttp.FormData()
+
+    for key, value in body.items() if isinstance(body, dict) else {}:
+        if isinstance(value, UploadFile):
+            form.add_field(
+                name=key,
+                value=value.file,
+                filename=value.filename,
+                content_type=value.content_type or "application/octet-stream"
+            )
+        else:
+            form.add_field(name=key, value=str(value))
+
+    return form
+
 async def parse_request_body(request: Request, content_type: str, nested: bool = False) -> Any:
     if content_type in [ "multipart/form-data", "application/x-www-form-urlencoded" ]:
         return await parse_request_form(request, nested)
@@ -75,6 +91,7 @@ async def parse_request_form(request: Request, nested: bool = False) -> Any:
 def parse_options_header(headers: Dict[str, str], header_name: str) -> Tuple[str, Dict[str, str]]:
     value = CaseInsensitiveDict(headers or {}).get(header_name, "")
     pos = _firefox_escape_fix_regex.sub("%22", value).find(";")
+    
     if pos >= 0:
         options = { 
             m.group(1).lower(): m.group(2) or m.group(3).replace("%22", "") for m in _option_regex.finditer(value[pos:])

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model-compose
-Version: 0.1.3
+Version: 0.1.4
 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.3/src/mindor/core/controller/runner/http_client.py

@@ -1,26 +0,0 @@
-from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
-from mindor.dsl.schema.controller import ControllerConfig
-from mindor.core.utils.http_client import HttpClient
-from .runner import ControllerClient
-
-class HttpControllerClient(ControllerClient):
-    def __init__(self, config: ControllerConfig):
-        super().__init__(config)
-
-        self.client: HttpClient = HttpClient()
-
-    async def run_workflow(self, workflow_id: Optional[str], input: Any) -> Any:
-        base_path = self.config.base_path if self.config.base_path else ""
-        url = f"http://localhost:{self.config.port}{base_path}/workflows"
-        method = "POST"
-        body = {
-            "workflow_id": workflow_id,
-            "input": input,
-            "wait_for_completion": True,
-            "output_only": True
-        }
-        headers = {
-            "Content-Type": "application/json"
-        }
-
-        return await self.client.request(url, method, None, body, headers)

model_compose-0.1.3/src/mindor/core/utils/http_client.py

@@ -1,73 +0,0 @@
-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
-import aiohttp
-
-class HttpStreamResource(StreamResource):
-    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
-
-    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()
-        chunk_size = buffer_size or 65536
-
-        while not self.stream.at_eof():
-            chunk = await self.stream.read(chunk_size)
-            if not chunk:
-                break
-            yield chunk
-
-class HttpClient:
-    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(
-                method,
-                url,
-                params=params,
-                data=await self._serialize_request_body(body, headers),
-                headers=headers
-            )
-
-            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()
-
-            return content
-        except:
-            await session.close()
-            raise
-
-    async def _serialize_request_body(self, body: Optional[Any], headers: Optional[Dict[str, str]]) -> Any:
-        content_type, _ = parse_options_header(headers, "Content-Type")
-
-        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:
-        content_type, _ = parse_options_header(response.headers, "Content-Type")
-
-        if content_type == "application/json":
-            return await response.json()
-
-        if content_type.startswith("text/"):
-            return await response.text()
-
-        _, disposition = parse_options_header(response.headers, "Content-Disposition")
-        filename = disposition.get("filename")
-
-        return HttpStreamResource(session, response.content, content_type, filename)