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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "model-compose"
-version = "0.1.3"
+version = "0.1.5"
 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.3 → model_compose-0.1.5}/src/mindor/core/component/engine/context.py

@@ -14,8 +14,8 @@ class ComponentContext:
     def register_source(self, key: str, source: Any) -> None:
         self.sources[key] = source
 
-    async def render_template(self, data: Dict[str, Any]) -> Any:
-        return await self.renderer.render(data)
+    async def render_template(self, data: Dict[str, Any], ignore_files: bool = False) -> Any:
+        return await self.renderer.render(data, ignore_files)
 
     async def _resolve_source(self, key: str) -> Any:
         if key in self.sources:

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

@@ -88,7 +88,7 @@ class HttpClientAction:
             result = await self._handle_completion(self.config.completion, context)
             context.register_source("result", result)
 
-        return (await context.render_template(self.config.output)) if self.config.output else (result or response)
+        return (await context.render_template(self.config.output, ignore_files=True)) if self.config.output else (result or response)
 
     async def _resolve_request_url(self, context: ComponentContext) -> str:
         if self.base_url and self.config.path:

model_compose-0.1.5/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.5}/src/mindor/core/controller/webui/gradio.py

@@ -1,11 +1,14 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Callable, Awaitable, Any
 from mindor.dsl.schema.workflow import WorkflowVariableConfig, WorkflowVariableGroupConfig
-from mindor.core.utils.http_client import HttpClient, HttpStreamResource
+from mindor.core.utils.streaming import StreamResource, Base64StreamResource
+from mindor.core.utils.streaming import save_stream_to_temporary_file
+from mindor.core.utils.http_request import create_upload_file
+from mindor.core.utils.http_client import HttpClient
 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 +48,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 = await 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(
@@ -59,11 +62,11 @@ class GradioWebUIBuilder:
         return section
 
     def _build_input_component(self, variable: WorkflowVariableConfig) -> gr.Component:
-        label = variable.name + (" *" if variable.required else "") + (f" (default: {variable.default})" if variable.default else "")
+        label = (variable.name or "") + (" *" if variable.required else "") + (f" (default: {variable.default})" if variable.default else "")
         info = variable.description or ""
         default = variable.default
 
-        if variable.type == "string":
+        if variable.type == "string" or variable.format in [ "base64", "url" ]:
             return gr.Textbox(label=label, value="", info=info)
 
         if variable.type == "number":
@@ -78,8 +81,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 +94,25 @@ 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}")
+    
+    async 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] = await self._convert_input_value(value, variable.type, variable.subtype, variable.format, variable.internal)
+
+        return input
+
+    async def _convert_input_value(self, value: Any, type: Optional[str], subtype: Optional[str], format: Optional[str], internal: bool) -> Any:
+        if type in [ "image", "audio", "video", "file" ] and (not internal or not format):
+            if internal and format and format != "path":
+                value = await self._save_value_to_temporary_file(value, subtype, format)
+            return create_upload_file(value, type, subtype)
+
+        return value if value != "" else None
 
     def _build_output_component(self, variable: Union[WorkflowVariableConfig, WorkflowVariableGroupConfig]) -> Union[gr.Component, List[ComponentGroup]]:
         if isinstance(variable, WorkflowVariableGroupConfig):
@@ -102,15 +127,15 @@ class GradioWebUIBuilder:
         label = variable.name or ""
         info = variable.description or ""
 
-        if variable.type == "string":
+        if variable.type in [ "string", "base64" ]:
             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)
-    
+
         if variable.type == "video":
             return gr.Video(label=label)
 
@@ -126,40 +151,50 @@ 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))
+                flattened.append(await self._convert_output_value(value, variable.type, variable.subtype, variable.format, variable.internal))
         return flattened
 
-    async def _convert_type(self, value: Any, type: Optional[str], subtype: Optional[str], format: Optional[str]) -> Any:
+    async def _convert_output_value(self, value: Any, type: Optional[str], subtype: Optional[str], format: Optional[str], internal: bool) -> Any:
         if type == "string":
-            if isinstance(value, (dict, list)):
-                return json.dumps(value)
-            return str(value)
-        
+            return json.dumps(value) if isinstance(value, (dict, list)) else 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
+            return await self._load_image_from_value(value, subtype, format)
 
         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
+            return await self._save_value_to_temporary_file(value, subtype, format)
 
         return value
+
+    async def _load_image_from_value(self, value: Any, subtype: Optional[str], format: Optional[str]) -> Optional[str]:
+        if format == "base64" and isinstance(value, str):
+            return await load_image_from_stream(Base64StreamResource(value), subtype)
+
+        if format == "url" and isinstance(value, str):
+            return await load_image_from_stream(await HttpClient().request(value), subtype)
+
+        if isinstance(value, StreamResource):
+            return await load_image_from_stream(value, subtype)
+
+        return None
+
+    async def _save_value_to_temporary_file(self, value: Any, subtype: Optional[str], format: Optional[str]) -> Optional[str]:
+        if format == "base64" and isinstance(value, str):
+            return await save_stream_to_temporary_file(Base64StreamResource(value), subtype)
+
+        if format == "url" and isinstance(value, str):
+            return await save_stream_to_temporary_file(await HttpClient().request(value), subtype)
+
+        if isinstance(value, StreamResource):
+            return await save_stream_to_temporary_file(value, subtype)
+
+        return None

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

@@ -5,12 +5,13 @@ 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]):
+    def __init__(self, name: Optional[str], type: str, subtype: Optional[str], format: Optional[str], default: Optional[Any], internal: bool = False):
         self.name: Optional[str] = name
         self.type: str = type
         self.subtype: Optional[str] = subtype
         self.format: Optional[str] = format
         self.default: Optional[Any] = default
+        self.internal: bool = internal
 
     def to_dict(self) -> Dict[str, Any]:
         return {
@@ -18,7 +19,8 @@ class WorkflowVariable:
             "type": self.type,
             "subtype": self.subtype,
             "format": self.format,
-            "default": self.default
+            "default": self.default,
+            "internal": self.internal
         }
 
     def __eq__(self, other):
@@ -52,7 +54,7 @@ class WorkflowVariableResolver:
             "keypath": re.compile(r"[-_\w]+|\[\d+\]"),
         }
 
-    def _enumerate_input_variables(self, value: Any, wanted_key: str) -> List[WorkflowVariable]:
+    def _enumerate_input_variables(self, value: Any, wanted_key: str, internal: bool = False) -> List[WorkflowVariable]:
         if isinstance(value, str):
             variables: List[WorkflowVariable] = []
 
@@ -63,22 +65,22 @@ class WorkflowVariableResolver:
                     default = self._parse_as_type(default, type)
 
                 if key == wanted_key:
-                    variables.append(WorkflowVariable(path, type or "string", subtype, format, default))
+                    variables.append(WorkflowVariable(path, type or "string", subtype, format, default, internal))
 
             return variables
 
         if isinstance(value, BaseModel):
-            return self._enumerate_input_variables(value.model_dump(exclude_none=True), wanted_key)
+            return self._enumerate_input_variables(value.model_dump(exclude_none=True), wanted_key, internal)
         
         if isinstance(value, dict):
-            return sum([ self._enumerate_input_variables(v, wanted_key) for v in value.values() ], [])
+            return sum([ self._enumerate_input_variables(v, wanted_key, internal) for v in value.values() ], [])
 
         if isinstance(value, list):
-            return sum([ self._enumerate_input_variables(v, wanted_key) for v in value ], [])
+            return sum([ self._enumerate_input_variables(v, wanted_key, internal) for v in value ], [])
         
         return []
 
-    def _enumerate_output_variables(self, name: Optional[str], value: Any) -> List[WorkflowVariable]:
+    def _enumerate_output_variables(self, name: Optional[str], value: Any, internal: bool = False) -> List[WorkflowVariable]:
         variables: List[WorkflowVariable] = []
         
         if isinstance(value, str):
@@ -88,18 +90,18 @@ class WorkflowVariableResolver:
                 if type and default:
                     default = self._parse_as_type(default, type)
 
-                variables.append(WorkflowVariable(name, type or "string", subtype, format, default))
+                variables.append(WorkflowVariable(name, type or "string", subtype, format, default, internal))
             
             return variables
         
         if isinstance(value, BaseModel):
-            return self._enumerate_output_variables(name, value.model_dump(exclude_none=True))
+            return self._enumerate_output_variables(name, value.model_dump(exclude_none=True), internal)
         
         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() ], [])
+            return sum([ self._enumerate_output_variables(f"{name}.{k}" if name else f"{k}", v, internal) 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 sum([ self._enumerate_output_variables(f"{name}[{i}]" if name else f"[{i}]", v, internal) for i, v in enumerate(value) ], [])
         
         return []
 
@@ -126,7 +128,7 @@ class WorkflowVariableResolver:
     def _to_variable_config(self, variable: WorkflowVariable) -> WorkflowVariableConfig:
         config_dict = variable.to_dict()
 
-        if variable.type == "select" and variable.subtype:
+        if variable.type in [ "image", "audio", "video", "file", "select" ] and variable.subtype:
             config_dict["options"] = variable.subtype.split(",")
 
         return WorkflowVariableConfig(**config_dict)
@@ -156,9 +158,13 @@ class WorkflowInputVariableResolver(WorkflowVariableResolver):
                 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"))
+                        action = component.actions[action_id] if action_id in component.actions else None
+                        if action:
+                            variables.extend(self._enumerate_input_variables(action, "input", internal=True))
                 else:
-                    variables.extend(self._enumerate_input_variables(job.component.actions[action_id], "input"))
+                    action = job.component.actions[action_id] if action_id in job.component.actions else None
+                    if action:
+                        variables.extend(self._enumerate_input_variables(action, "input", internal=True))
             else:
                 variables.extend(self._enumerate_input_variables(job.input, "input"))
 
@@ -186,9 +192,13 @@ class WorkflowOutputVariableResolver(WorkflowVariableResolver):
                 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))
+                        action = component.actions[action_id] if action_id in component.actions else None
+                        if action:
+                            job_variables.extend(self._enumerate_output_variables(None, action.output, internal=True))
                 else:
-                    job_variables.extend(self._enumerate_output_variables(None, job.component.actions[action_id].output))
+                    action = job.component.actions[action_id] if action_id in job.component.actions else None
+                    if action:
+                        job_variables.extend(self._enumerate_output_variables(None, action.output, internal=True))
             else:
                 job_variables.extend(self._enumerate_output_variables(None, job.output))
 

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

@@ -25,8 +25,8 @@ class HttpCallbackContext:
         async for item in self._items():
             yield HttpCallbackContext(item, self.query, False, None)
 
-    async def render_template(self, template: str) -> Any:
-        return await self.renderer.render(template)
+    async def render_template(self, template: str, ignore_files: bool = True) -> Any:
+        return await self.renderer.render(template, ignore_files)
 
     async def _items(self) -> List[Any]:
         item = await self.renderer.render(self.item) if self.item else self.body
@@ -78,7 +78,7 @@ class HttpCallbackListener(ListenerEngine):
 
                 if future:
                     if succeeded:
-                        future.set_result((await item.render_template(callback.result)) if callback.result else item.body)
+                        future.set_result((await item.render_template(callback.result, ignore_files=True)) if callback.result else item.body)
                     else:
                         future.set_exception(RuntimeError(f"Task failed for '{callback_id}'"))
                     self._remove_pending_future(callback_id)

model_compose-0.1.5/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.5}/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, os
 
 _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:])
@@ -84,3 +101,21 @@ def parse_options_header(headers: Dict[str, str], header_name: str) -> Tuple[str
         options = {}
 
     return value.strip().lower(), options
+
+def create_upload_file(path: str, type: Optional[str], subtype: Optional[str]) -> UploadFile:
+    file, filename = open(path, "rb"), os.path.basename(path)
+    content_type = guess_file_content_type(filename, type, subtype)
+    headers = { 
+        "Content-Type": content_type,
+        "Content-Disposition": f'form-data; filename="{filename}"'
+    }
+
+    return UploadFile(file=file, filename=filename, headers=headers)
+
+def guess_file_content_type(filename: str, type: Optional[str], subtype: Optional[str]) -> str:
+    subtype = filename.split(".")[-1] if not subtype else subtype
+    
+    if type in [ "image", "audio", "video" ] and subtype:
+        return f"{type}/{subtype}"
+
+    return "application/octet-stream"

{model_compose-0.1.3 → model_compose-0.1.5}/src/mindor/core/utils/streaming.py

@@ -1,7 +1,8 @@
 from typing import Optional, AsyncIterator
 from abc import ABC, abstractmethod
 from tempfile import NamedTemporaryFile
-import io, base64
+from aiofiles.threadpool.binary import AsyncBufferedReader
+import aiofiles, io, base64
 
 class StreamResource(ABC):
     def __init__(self, content_type: Optional[str], filename: Optional[str]):
@@ -29,7 +30,12 @@ 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))
+        self.encoded: str = encoded
+        self.stream: Optional[io.BytesIO] = None
+
+    async def __aenter__(self):
+        self.stream = io.BytesIO(base64.b64decode(self.encoded))
+        return self
 
     async def close(self):
         self.stream.close()