model-compose 0.0.6__tar.gz → 0.0.7__tar.gz

{model_compose-0.0.6/src/model_compose.egg-info → model_compose-0.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model-compose
-Version: 0.0.6
+Version: 0.0.7
 Summary: model-compose: Declarative AI Model and Workflow Orchestrator (from Mindor)
 Author-email: Hanyeol Cho <hanyeol.cho@gmail.com>
 License-Expression: MIT

{model_compose-0.0.6 → model_compose-0.0.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "model-compose"
-version = "0.0.6"
+version = "0.0.7"
 description = "model-compose: Declarative AI Model and Workflow Orchestrator (from Mindor)"
 authors = [
     { name = "Hanyeol Cho", email = "hanyeol.cho@gmail.com" }

{model_compose-0.0.6 → model_compose-0.0.7}/src/mindor/core/component/engine/http_client.py

@@ -9,7 +9,7 @@ from urllib.parse import urlencode
 import aiohttp, json
 
 class HttpStreamResource(StreamResource):
-    def __init__(self, session: aiohttp.ClientSession, stream: aiohttp.StreamReader, filename: Optional[str], content_type: Optional[str]):
+    def __init__(self, session: aiohttp.ClientSession, stream: aiohttp.StreamReader, content_type: Optional[str], filename: Optional[str]):
         super().__init__(content_type, filename)
 
         self.session: aiohttp.ClientSession = session
@@ -105,7 +105,7 @@ class HttpClientAction:
         _, disposition = parse_options_header(response.headers.get("Content-Disposition", ""))
         filename = disposition.get("filename")
 
-        return HttpStreamResource(session, response.content, filename, content_type)
+        return HttpStreamResource(session, response.content, content_type, filename)
 
 class HttpClientComponent(BaseComponent):
     def __init__(self, id: str, config: HttpClientComponentConfig, env: Dict[str, str], daemon: bool):

{model_compose-0.0.6 → model_compose-0.0.7}/src/mindor/core/controller/engine/http_server.py

@@ -9,13 +9,13 @@ from mindor.core.utils.resources import StreamResource
 from .base import BaseController, ControllerType, ControllerEngineMap, TaskState
 
 from fastapi import FastAPI, APIRouter, Body, HTTPException
-from fastapi.responses import JSONResponse, StreamingResponse
+from fastapi.responses import Response, JSONResponse, StreamingResponse
 from starlette.background import BackgroundTask
 import asyncio, uvicorn
 
 class WorkflowTaskRequestBody(BaseModel):
     workflow_id: Optional[str] = None
-    input: Optional[Dict[str, Any]] = None
+    input: Optional[Any] = None
     wait_for_completion: bool = True
     output_only: bool = False
 
@@ -53,22 +53,9 @@ class HttpServerController(BaseController):
             state = await self.run_workflow(body.workflow_id, body.input, body.wait_for_completion)
 
             if body.output_only and body.wait_for_completion:
-                if state.status == "failed":
-                    raise HTTPException(status_code=500, detail=str(state.error))
-                
-                if isinstance(state.output, StreamResource):
-                    return StreamingResponse(
-                        state.output,
-                        media_type=state.output.content_type,
-                        headers = {
-                            "Content-Disposition": f"attachment; filename={state.output.filename}"
-                        } if state.output.filename else {},
-                        #background=BackgroundTask(lambda: asyncio.create_task(state.output.close()))
-                    )
-
-                return state.output
+                return self._render_task_output(state)
             
-            return JSONResponse(content=TaskResult.from_instance(state).model_dump(exclude_none=True))
+            return self._render_task_state(state)
 
         @self.router.get("/tasks/{task_id}")
         async def get_task_state(
@@ -81,25 +68,9 @@ class HttpServerController(BaseController):
                 raise HTTPException(status_code=404, detail="Task not found.")
             
             if output_only:
-                if state.status in [ "pending", "processing" ]:
-                    raise HTTPException(status_code=202, detail="Task is still in progress.")
-                
-                if state.status == "failed":
-                    raise HTTPException(status_code=500, detail=str(state.error))
-
-                if isinstance(state.output, StreamResource):
-                    return StreamingResponse(
-                        state.output,
-                        media_type=state.output.content_type,
-                        headers = {
-                            "Content-Disposition": f"attachment; filename={state.output.filename}"
-                        } if state.output.filename else {},
-                        # background=BackgroundTask(lambda: asyncio.create_task(state.output.close()))
-                    )
-
-                return state.output
-
-            return JSONResponse(content=TaskResult.from_instance(state).model_dump(exclude_none=True))
+                return self._render_task_output(state)
+
+            return self._render_task_state(state)
 
     async def _serve(self) -> None:
         self.server = uvicorn.Server(uvicorn.Config(
@@ -113,4 +84,39 @@ class HttpServerController(BaseController):
     async def _shutdown(self) -> None:
         self.server.should_exit = True
 
+    def _render_task_output(self, state: TaskState) -> Response:
+        if state.status in [ "pending", "processing" ]:
+            raise HTTPException(status_code=202, detail="Task is still in progress.")
+
+        if state.status == "failed":
+            raise HTTPException(status_code=500, detail=str(state.error))
+
+        if isinstance(state.output, StreamResource):
+            return self._render_stream_resource(state.output)
+        
+        return JSONResponse(content=state.output)
+
+    def _render_task_state(self, state: TaskState) -> Response:
+        return JSONResponse(content=TaskResult.from_instance(state).model_dump(exclude_none=True))
+    
+    def _render_stream_resource(self, resource: StreamResource) -> Response:
+        def _close_stream():
+            asyncio.run(resource.close()) 
+
+        return StreamingResponse(
+            resource,
+            media_type=resource.content_type, 
+            headers=self._build_stream_resource_headers(resource), 
+            background=BackgroundTask(_close_stream)
+        )
+    
+    def _build_stream_resource_headers(self, resource: StreamResource) -> Dict[str, str]:
+        headers: Dict[str, str] = { "Cache-Control": "no-cache" }
+
+        if resource.filename:
+            filename = resource.filename.replace('"', '\\"')
+            headers["Content-Disposition"] = f'attachment; filename="{filename}"'
+
+        return headers
+
 ControllerEngineMap[ControllerType.HTTP_SERVER] = HttpServerController

{model_compose-0.0.6 → model_compose-0.0.7}/src/mindor/core/workflow/job.py

@@ -12,13 +12,13 @@ class Job:
         self.component_provider: Callable[[Union[ComponentConfig, str]], BaseComponent] = component_provider
 
     async def run(self, context: WorkflowContext) -> Any:
-        component = self.component_provider(self.config.component)
+        component = self.component_provider(self.id, self.config.component)
 
         if not component.started:
             await component.start()
 
         call_id = ulid.ulid()
-        input = context.render_template(self.config.input) if self.config.output else context.input
+        input = 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:

{model_compose-0.0.6 → model_compose-0.0.7}/src/mindor/core/workflow/workflow.py

@@ -76,9 +76,9 @@ class WorkflowResolver:
         return default_ids[0] if default_ids else "__default__"
 
 class WorkflowRunner:
-    def __init__(self, jobs: Dict[str, JobConfig], component_provider: Callable[[Union[ComponentConfig, str]], BaseComponent]):
+    def __init__(self, jobs: Dict[str, JobConfig], component_provider: Callable[[Union[str, ComponentConfig, str]], BaseComponent]):
         self.jobs: Dict[str, JobConfig] = jobs
-        self.component_provider: Callable[[Union[ComponentConfig, str]], BaseComponent] = component_provider
+        self.component_provider: Callable[[Union[str, ComponentConfig, str]], BaseComponent] = component_provider
 
     async def run(self, context: WorkflowContext) -> Any:
         pending_jobs: Dict[str, Job] = { job_id: Job(job_id, job, self.component_provider) for job_id, job in self.jobs.items() }
@@ -144,14 +144,14 @@ class Workflow:
     def validate(self) -> None:
         JobGraphValidator(self.config.jobs).validate()
 
-    def _create_component(self, component: Union[ComponentConfig, str]) -> BaseComponent:
-        return create_component(*self._resolve_component(component), env=self.env, daemon=False)
+    def _create_component(self, id: str, component: Union[ComponentConfig, str]) -> BaseComponent:
+        return create_component(*self._resolve_component(id, component), env=self.env, daemon=False)
 
-    def _resolve_component(self, component: Union[ComponentConfig, str]) -> Tuple[str, ComponentConfig]:
+    def _resolve_component(self, id: str, component: Union[ComponentConfig, str]) -> Tuple[str, ComponentConfig]:
         if isinstance(component, str):
             return ComponentResolver(self.components).resolve(component)
     
-        return self.id, component
+        return id, component
 
 def create_workflow(id: str, config: WorkflowConfig, components: Dict[str, ComponentConfig], env: Dict[str, str]) -> Workflow:
     return Workflow(id, config, components, env)

{model_compose-0.0.6 → model_compose-0.0.7/src/model_compose.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model-compose
-Version: 0.0.6
+Version: 0.0.7
 Summary: model-compose: Declarative AI Model and Workflow Orchestrator (from Mindor)
 Author-email: Hanyeol Cho <hanyeol.cho@gmail.com>
 License-Expression: MIT