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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model-compose
-Version: 0.0.17
+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

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

@@ -1,6 +1,6 @@
 [project]
 name = "model-compose"
-version = "0.0.17"
+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" }

{model_compose-0.0.17 → 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.17 → 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.17 → model_compose-0.1.0}/src/mindor/core/controller/engine/http_server.py

@@ -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.17 → model_compose-0.1.0}/src/mindor/core/controller/webui/gradio.py

@@ -1,6 +1,8 @@
 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.image import load_image_from_base64
+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
 
@@ -42,11 +44,11 @@ class GradioWebUIBuilder:
 
                 if workflow.output:
                     if isinstance(output, dict):
-                        output = [ self._convert_type(output[variable.name], variable.type, variable.format) for variable in workflow.output ]
+                        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 = self._convert_type(output, variable.type, variable.format)
+                        output = await self._convert_type(output, variable.type, variable.subtype, variable.format)
 
                 return output
 
@@ -84,21 +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}")
 
-    def _convert_type(self, value: Any, type: str, format: Optional[str]) -> Any:
+    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 load_image_from_base64(value)
+                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.0.17 → model_compose-0.1.0}/src/mindor/core/controller/webui/schema.py

@@ -8,28 +8,28 @@ 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\|\}]+)))? # type/format
-                    (?:\s*\|\s*([^\}]+))?                       # default value after `|`
-                \}""",                                          # }
+                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, Optional[Any]]] = []
+            variables: List[Tuple[str, str, str, str, Optional[Any]]] = []
 
             for match in self.patterns["variable"].finditer(value):
-                key, path, type, format, default = match.group(1, 2, 3, 4, 5)
+                key, path, type, subtype, format, default = match.group(1, 2, 3, 4, 5, 6)
 
                 if type and default:
-                    default = self._convert_type(default, type, format)
+                    default = self._convert_type(default, type, subtype, format)
 
                 if key == wanted_key:
-                    variables.append((path, type or "string", format, default))
+                    variables.append((path, type or "string", subtype, format, default))
 
             return variables
 
@@ -45,16 +45,16 @@ 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, Optional[Any]]] = []
+        variables: List[Tuple[str, str, str, str, Optional[Any]]] = []
         
         if isinstance(value, str):
             for match in self.patterns["variable"].finditer(value):
-                type, format, default = match.group(3, 4, 5)
+                type, subtype, format, default = match.group(3, 4, 5, 6)
 
                 if type and default:
-                    default = self._convert_type(default, type, format)
+                    default = self._convert_type(default, type, subtype, format)
 
-                variables.append((key, type or "string", format, default))
+                variables.append((key, type or "string", subtype, format, default))
             
             return variables
         
@@ -69,18 +69,18 @@ class WorkflowVariableResolver:
         
         return []        
 
-    def _convert_type(self, value: Any, type: str, format: Optional[str]) -> Any:
+    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 == "json":
-            return json.loads(value)
-        
         if type == "boolean":
             return str(value).lower() in [ "true", "1" ]
+        
+        if type == "json":
+            return json.loads(value)
  
         return value
 
@@ -100,11 +100,11 @@ class WorkflowInputResolver(WorkflowVariableResolver):
             else:
                 variables.extend(self._enumerate_input_variables(job.input, "input"))
 
-        return [ WorkflowVariableConfig(name=name, type=type, format=format, default=default) for name, type, format, default in set(variables) ]
+        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, Optional[Any]]] = []
+        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):
@@ -121,7 +121,7 @@ class WorkflowOutputResolver(WorkflowVariableResolver):
             else:
                 variables.extend(self._enumerate_output_variables(None, job.output))
 
-        return [ WorkflowVariableConfig(name=name, type=type, format=format, default=default) for name, type, format, default in set(variables) ]
+        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)

{model_compose-0.0.17 → 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.17 → 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.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")

{model_compose-0.0.17 → model_compose-0.1.0}/src/mindor/core/utils/template.py

@@ -1,54 +1,55 @@
-from typing import Callable, Dict, List, Optional, Any
-import re, json
+from typing import Callable, Dict, List, Optional, Awaitable, Any
+from .streaming import StreamResource, encode_stream_to_base64
+import re, json, base64
 
 class TemplateRenderer:
-    def __init__(self, source_resolver: Callable[[str], Any]):
-        self.source_resolver: Callable[[str], Any] = source_resolver
+    def __init__(self, source_resolver: Callable[[str], Awaitable[Any]]):
+        self.source_resolver: Callable[[str], Awaitable[Any]] = source_resolver
         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\|\}]+)))? # type/format
-                    (?:\s*\|\s*([^\}]+))?                       # default value after `|`
-                \}""",                                          # }
+                r"""\$\{                                                             # ${ 
+                    ([a-zA-Z_][^.\s]*)                                               # key: input, env, etc.
+                    (?:\.([^\s\|\}]+))?                                              # path: key, key.path[0], etc.
+                    (?:\s*as\s*([^\s\|\}/;]+)(?:/([^\s\|\};]+))?(?:;([^\s\|\}]+))?)? # type/subtype;format
+                    (?:\s*\|\s*([^\}]+))?                                            # default value after `|`
+                \}""",                                                               # }
                 re.VERBOSE,
             ),
             "keypath": re.compile(r"[-_\w]+|\[\d+\]"),
         }
 
-    def render(self, data: Any) -> Any:
-        return self._render_element(data)
+    async def render(self, data: Any) -> Any:
+        return await self._render_element(data)
 
-    def _render_element(self, element: Any) -> Any:
+    async def _render_element(self, element: Any) -> Any:
         if isinstance(element, str):
-            return self._render_text(element)
+            return await self._render_text(element)
         
         if isinstance(element, dict):
-            return { key: self._render_element(value) for key, value in element.items() }
+            return { key: await self._render_element(value) for key, value in element.items() }
         
         if isinstance(element, list):
-            return [ self._render_element(item) for item in element ]
+            return [ await self._render_element(item) for item in element ]
         
         return element
 
-    def _render_text(self, text: str) -> Any:
+    async def _render_text(self, text: str) -> Any:
         while True:
             match = self.patterns["variable"].search(text)
             
             if not match:
                 break
 
-            key, path, type, format, default, variable = (*match.group(1, 2, 3, 4, 5), match.group(0))
+            key, path, type, subtype, format, default, variable = (*match.group(1, 2, 3, 4, 5, 6), match.group(0))
             try:
-                value = self._resolve_by_path(self.source_resolver(key), path)
+                value = self._resolve_by_path(await self.source_resolver(key), path)
             except Exception:
                 value = None
 
             value = default if not value else value
 
-            if format and value:
-                value = self._convert_type(value, type, format)
+            if type and value:
+                value = await self._convert_type(value, type, subtype, format)
 
             if variable == text:
                 return value
@@ -78,7 +79,7 @@ class TemplateRenderer:
         
         return current
 
-    def _convert_type(self, value: Any, type: str, format: Optional[str]) -> Any:
+    async def _convert_type(self, value: Any, type: str, subtype: str, format: Optional[str]) -> Any:
         if type == "number":
             return float(value)
 
@@ -91,4 +92,9 @@ class TemplateRenderer:
         if type == "boolean":
             return str(value).lower() in [ "true", "1" ]
         
+        if type == "base64":
+            if isinstance(value, StreamResource):
+                return await encode_stream_to_base64(value)
+            return base64.b64encode(value)
+
         return value

{model_compose-0.0.17 → model_compose-0.1.0}/src/mindor/core/workflow/context.py

@@ -16,10 +16,10 @@ class WorkflowContext:
     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.17 → model_compose-0.1.0}/src/mindor/core/workflow/job.py

@@ -18,10 +18,10 @@ class Job:
             await component.start()
 
         call_id = ulid.ulid()
-        input = context.render_template(self.config.input) if self.config.input else context.input
+        input = (await context.render_template(self.config.input)) if self.config.input else context.input
         output = await component.run(self.config.action, call_id, input)
 
         if output:
             context.register_source("output", output)
 
-        return context.render_template(self.config.output) if self.config.output else output
+        return (await context.render_template(self.config.output)) if self.config.output else output

{model_compose-0.0.17 → model_compose-0.1.0}/src/mindor/dsl/schema/workflow.py

@@ -1,4 +1,5 @@
 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 .component import ComponentConfig
@@ -10,10 +11,33 @@ class JobConfig(BaseModel):
     output: Optional[Any] = None
     depends_on: Optional[List[str]] = Field(default_factory=list)
 
+class WorkflowVariableType(str, Enum):
+    # Primitive data types
+    STRING  = "string"
+    TEXT    = "text"
+    INTEGER = "integer"
+    NUMBER  = "number"
+    BOOLEAN = "boolean"
+    JSON    = "json"
+    # Encoded data
+    BASE64  = "base64"
+    # Media and files
+    IMAGE   = "image"
+    AUDIO   = "audio"
+    FILE    = "file"
+    # UI-related types
+    SELECT  = "select"
+
+class WorkflowVariableFormat(str, Enum):
+    BASE64 = "base64"
+    URL    = "url"
+    PATH   = "path"
+
 class WorkflowVariableConfig(BaseModel):
     name: Optional[str] = Field(default=None, description="The name of the variable")
-    type: Literal[ "string", "base64", "integer", "number", "json", "boolean", "image", "file", "select" ] = Field(..., description="Type of the variable")
-    format: Optional[Literal[ "base64" ]] = Field(default=None, description="Format of the variable")
+    type: WorkflowVariableType = Field(..., description="Type of the variable")
+    subtype: Optional[str] = Field(default=None, description="Subtype of the variable")
+    format: Optional[WorkflowVariableFormat] = Field(default=None, description="Format of the variable")
     required: bool = Field(default=False, description="Whether this variable is required")
     default: Optional[Any] = Field(default=None, description="Default value if not provided")
     description: Optional[str] = Field(default=None, description="Description of the variable")

{model_compose-0.0.17 → model_compose-0.1.0}/src/model_compose.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model-compose
-Version: 0.0.17
+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

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

@@ -1,9 +0,0 @@
-from typing import Optional
-from PIL import Image as PILImage
-import io, base64
-
-def load_image_from_base64(value: str) -> Optional[PILImage.Image]:
-    try:
-        return PILImage.open(io.BytesIO(base64.b64decode(value)))
-    except:
-        return None

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

@@ -1,28 +0,0 @@
-from typing import Optional, AsyncIterator
-from abc import ABC, abstractmethod
-
-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
-    def get_stream(self):
-        pass
-    
-    @abstractmethod
-    async def close(self):
-        pass
-
-    @abstractmethod
-    async def _iterate_stream(self) -> AsyncIterator[bytes]:
-        pass