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

{model_compose-0.1.2 → model_compose-0.1.4}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "model-compose"
-version = "0.1.2"
+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.2 → model_compose-0.1.4}/src/mindor/core/controller/engine/http_server.py

@@ -15,7 +15,7 @@ from fastapi import FastAPI, APIRouter, Request, Body, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import Response, JSONResponse, StreamingResponse
 from starlette.background import BackgroundTask
-import asyncio, uvicorn
+import uvicorn
 
 class WorkflowTaskRequestBody(BaseModel):
     workflow_id: Optional[str] = None
@@ -50,7 +50,7 @@ class HttpServerController(ControllerEngine):
         daemon: bool
     ):
         super().__init__(config, components, listeners, gateways, workflows, env, daemon)
-        
+
         self.server: Optional[uvicorn.Server] = None
         self.app: FastAPI = FastAPI(openapi_url=None, docs_url=None, redoc_url=None)
         self.router: APIRouter = APIRouter()

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

@@ -1,11 +1,12 @@
 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 HttpStreamResource
+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]):
@@ -29,8 +30,8 @@ class GradioWebUIBuilder:
 
     def _build_workflow_section(self, workflow: WorkflowSchema, runner: Callable[[Any], Awaitable[Any]]) -> gr.Column:
         with gr.Column() as section:
-            gr.Markdown(f"## **{workflow.title or 'Untitled Workflow'}**")  
-
+            gr.Markdown(f"## **{workflow.title or 'Untitled Workflow'}**")
+ 
             if workflow.description:
                 gr.Markdown(f"📝 {workflow.description}")
 
@@ -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(
@@ -74,14 +75,48 @@ class GradioWebUIBuilder:
         
         if variable.type == "boolean":
             return gr.Checkbox(label=label, value=default or False, info=info)
+        
+        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, type="filepath")
 
         if variable.type == "file":
-            return gr.File(label=label, file_types=["*"], info=info)
+            return gr.File(label=label)
 
         if variable.type == "select":
             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):
@@ -98,13 +133,16 @@ 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)
         
         if variable.type == "audio":
             return gr.Audio(label=label)
     
+        if variable.type == "video":
+            return gr.Video(label=label)
+
         return gr.Textbox(label=label, info=f"Unsupported type: {variable.type}")
 
     def _flatten_output_components(self, components: List[Union[gr.Component, List[ComponentGroup]]]) -> List[gr.Component]:
@@ -117,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))
@@ -134,15 +172,19 @@ 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)
             if format == "base64" and isinstance(value, str):
                 return await load_image_from_stream(Base64StreamResource(value), subtype)
             if isinstance(value, HttpStreamResource):
                 return await load_image_from_stream(value, subtype)
             return None
 
-        if type == "audio":
+        if 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):

{model_compose-0.1.2 → model_compose-0.1.4}/src/mindor/core/controller/webui/schema.py

@@ -111,17 +111,25 @@ class WorkflowVariableResolver:
             if isinstance(item, WorkflowVariableGroup):
                 group: List[WorkflowVariableConfig] = []
                 seen_in_group: Set[WorkflowVariable] = set()
-                for v in item.variables:
-                    if v not in seen_in_group:
-                        seen_in_group.add(v)
-                        group.append(WorkflowVariableConfig(**v.to_dict()))
+                for variable in item.variables:
+                    if variable not in seen_in_group:
+                        group.append(self._to_variable_config(variable))
+                        seen_in_group.add(variable)
                 configs.append(WorkflowVariableGroupConfig(name=item.name, variables=group, repeat_count=item.repeat_count))
             else:
                 if item not in seen_single:
+                    configs.append(self._to_variable_config(item))
                     seen_single.add(item)
-                    configs.append(WorkflowVariableConfig(**item.to_dict()))
 
         return configs
+    
+    def _to_variable_config(self, variable: WorkflowVariable) -> WorkflowVariableConfig:
+        config_dict = variable.to_dict()
+
+        if variable.type == "select" and variable.subtype:
+            config_dict["options"] = variable.subtype.split(",")
+
+        return WorkflowVariableConfig(**config_dict)
 
     def _parse_as_type(self, value: Any, type: str) -> Any:
         if type == "number":
@@ -138,7 +146,7 @@ class WorkflowVariableResolver:
  
         return value
 
-class WorkflowInputResolver(WorkflowVariableResolver):
+class WorkflowInputVariableResolver(WorkflowVariableResolver):
     def resolve(self, workflow: WorkflowConfig, components: Dict[str, ComponentConfig]) -> List[WorkflowVariableConfig]:
         variables: List[WorkflowVariable] = []
 
@@ -154,12 +162,12 @@ class WorkflowInputResolver(WorkflowVariableResolver):
             else:
                 variables.extend(self._enumerate_input_variables(job.input, "input"))
 
-            for value in [ job.repeat_count ]:
+            for value in [ job.component, job.action, job.repeat_count ]:
                 variables.extend(self._enumerate_input_variables(value, "input"))
 
         return self._to_variable_config_list(variables)
 
-class WorkflowOutputResolver(WorkflowVariableResolver):
+class WorkflowOutputVariableResolver(WorkflowVariableResolver):
     def resolve(self, workflow: WorkflowConfig, components: Dict[str, ComponentConfig]) -> List[Union[WorkflowVariableConfig, WorkflowVariableGroupConfig]]:
         variables: List[Union[WorkflowVariable, WorkflowVariableGroup]] = []
 

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

@@ -4,7 +4,7 @@ from mindor.dsl.schema.component import ComponentConfig
 from mindor.dsl.schema.workflow import WorkflowConfig
 from mindor.core.controller.runner import ControllerRunner
 from mindor.core.services import AsyncService
-from .schema import WorkflowSchema, WorkflowInputResolver, WorkflowOutputResolver
+from .schema import WorkflowSchema, WorkflowInputVariableResolver, WorkflowOutputVariableResolver
 from .gradio import GradioWebUIBuilder
 
 from fastapi import FastAPI, APIRouter, Body, HTTPException
@@ -68,8 +68,8 @@ class ControllerWebUI(AsyncService):
                 name=workflow.name,
                 title=workflow.title, 
                 description=workflow.description,
-                input=WorkflowInputResolver().resolve(workflow, self.components),
-                output=WorkflowOutputResolver().resolve(workflow, self.components)
+                input=WorkflowInputVariableResolver().resolve(workflow, self.components),
+                output=WorkflowOutputVariableResolver().resolve(workflow, self.components)
             )
 
         return schema

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.2 → 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.2 → model_compose-0.1.4}/src/mindor/core/workflow/job.py

@@ -12,7 +12,7 @@ class Job:
         self.component_provider: Callable[[str, Union[ComponentConfig, str]], ComponentEngine] = component_provider
 
     async def run(self, context: WorkflowContext) -> Any:
-        component: ComponentEngine = self.component_provider(self.id, self.config.component)
+        component: ComponentEngine = self.component_provider(self.id, await context.render_template(self.config.component))
 
         if not component.started:
             await component.start()
@@ -22,7 +22,7 @@ class Job:
 
         async def _run_once():
             call_id = ulid.ulid()
-            output = await component.run(self.config.action, call_id, input)
+            output = await component.run(await context.render_template(self.config.action), call_id, input)
             context.register_source("output", output)
 
             output = (await context.render_template(self.config.output)) if self.config.output else output

{model_compose-0.1.2 → model_compose-0.1.4}/src/mindor/dsl/schema/workflow.py

@@ -31,6 +31,7 @@ class WorkflowVariableType(str, Enum):
     # Media and files
     IMAGE   = "image"
     AUDIO   = "audio"
+    VIDEO   = "video"
     FILE    = "file"
     # UI-related types
     SELECT  = "select"
@@ -39,16 +40,17 @@ class WorkflowVariableFormat(str, Enum):
     BASE64 = "base64"
     URL    = "url"
     PATH   = "path"
+    STREAM = "stream"
 
 class WorkflowVariableConfig(BaseModel):
     name: Optional[str] = Field(default=None, description="The name 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")
+    options: Optional[List[str]] = Field(default=None, description="List of valid options for select type")
     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")
-    options: Optional[List[Any]] = Field(default=None, description="List of valid options for select type")
 
 class WorkflowVariableGroupConfig(BaseModel):
     name: Optional[str] = Field(default=None, description="The name of the group of variables")

{model_compose-0.1.2 → 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.2
+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.2/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.2/src/mindor/core/utils/http_client.py

@@ -1,75 +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
-
-from urllib.parse import urlencode
-import aiohttp, json
-
-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: str, params: Optional[Dict[str, Any]], body: Optional[Any], headers: Optional[Dict[str, str]]) -> 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)