model-compose 0.1.7__tar.gz → 0.1.9__tar.gz

{model_compose-0.1.7/src/model_compose.egg-info → model_compose-0.1.9}/PKG-INFO

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

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

@@ -1,19 +1,30 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, AsyncIterator, Any
+from abc import ABC, abstractmethod
 from mindor.dsl.schema.component import HttpClientComponentConfig
 from mindor.dsl.schema.action import ActionConfig, HttpClientActionConfig, HttpClientCompletionConfig
 from mindor.core.listener import HttpCallbackListener
 from mindor.core.utils.http_client import HttpClient
+from mindor.core.utils.http_status import is_status_code_matched
 from mindor.core.utils.time import parse_duration
 from .base import ComponentEngine, ComponentType, ComponentEngineMap
 from .context import ComponentContext
 from datetime import datetime, timezone
 import asyncio
 
-class HttpClientPollingCompletion:
-    def __init__(self, base_url: Optional[str], headers: Optional[Dict[str, str]], config: HttpClientCompletionConfig):
+class HttpClientCompletion(ABC):
+    @abstractmethod
+    async def run(self, context: ComponentContext) -> Any:
+        pass
+
+    @abstractmethod
+    async def close(self) -> None:
+        pass
+
+class HttpClientPollingCompletion(HttpClientCompletion):
+    def __init__(self, config: HttpClientCompletionConfig, base_url: Optional[str], headers: Optional[Dict[str, str]]):
+        self.config: HttpClientCompletionConfig = config
         self.base_url: Optional[str] = base_url
         self.headers: Optional[Dict[str, str]] = headers
-        self.config: HttpClientCompletionConfig = config
         self.client: HttpClient = HttpClient()
 
     async def run(self, context: ComponentContext) -> Any:
@@ -30,33 +41,38 @@ class HttpClientPollingCompletion:
         await asyncio.sleep(interval.total_seconds())
 
         while datetime.now(timezone.utc) < deadline:
-            response = await self.client.request(url, method, params, body, headers)
+            response, status_code = await self.client.request(url, method, params, body, headers, raise_on_error=False)
             context.register_source("result", response)
 
-            status = (await context.render_template(self.config.status)) if self.config.status else response["status"]
-
-            if not status:
+            status = (await context.render_template(self.config.status)) if self.config.status else None
+            if self.config.status and 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 == await context.render_template(success_when):
+            if status:
+                if status in self.config.success_when or []:
                     return response
-
-            for fail_when in self.config.fail_when if self.config.fail_when else [ "failed" ]:
-                if status == await context.render_template(fail_when):
+                if status in self.config.fail_when or []:
                     raise RuntimeError(f"Polling failed: status '{status}' matched a failure condition.")
+            else: # use status code
+                if is_status_code_matched(status_code, self.config.success_when or []):
+                    return response
+                if is_status_code_matched(status_code, self.config.fail_when or []):
+                    raise RuntimeError(f"Polling failed: status code '{status_code}' matched a failure condition.")
 
             await asyncio.sleep(interval.total_seconds())
 
         raise TimeoutError(f"Polling timed out after {timeout}.")
 
+    async def close(self) -> None:
+        await self.client.close()
+
     async def _resolve_request_url(self, context: ComponentContext) -> str:
         if self.base_url and self.config.path:
             return await context.render_template(self.base_url) + await context.render_template(self.config.path)
 
         return await context.render_template(self.config.endpoint)
 
-class HttpClientCallbackCompletion:
+class HttpClientCallbackCompletion(HttpClientCompletion):
     def __init__(self, config: HttpClientCompletionConfig):
         self.config: HttpClientCompletionConfig = config
 
@@ -66,56 +82,71 @@ class HttpClientCallbackCompletion:
         HttpCallbackListener.register_pending_future(callback_id, future)
 
         return await future
+    
+    async def close(self) -> None:
+        pass
 
 class HttpClientAction:
-    def __init__(self, base_url: Optional[str], headers: Optional[Dict[str, str]], config: HttpClientActionConfig):
+    def __init__(self, config: HttpClientActionConfig, base_url: Optional[str], headers: Optional[Dict[str, str]]):
+        self.config: HttpClientActionConfig = config
         self.base_url: Optional[str] = base_url
         self.headers: Optional[Dict[str, str]] = headers
-        self.config: HttpClientActionConfig = config
-        self.client: HttpClient = HttpClient()
+        self.completion: HttpClientCompletion = None
 
-    async def run(self, context: ComponentContext) -> Any:
+        if self.config.completion:
+            self._configure_completion()
+
+    def _configure_completion(self) -> None:
+        if self.config.completion.type == "polling":
+            self.completion = HttpClientPollingCompletion(self.config.completion, self.base_url, self.headers)
+            return
+        
+        if self.config.completion.type == "callback":
+            self.completion = HttpClientCallbackCompletion(self.config.completion)
+            return
+        
+        raise ValueError(f"Unsupported http completion type: {self.config.completion.type}")
+
+    async def run(self, context: ComponentContext, client: HttpClient) -> Any:
         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.headers, **self.config.headers })
 
-        response, result = await self.client.request(url, method, params, body, headers), None
+        response, result = await client.request(url, method, params, body, headers), None
         context.register_source("response", response)
 
-        if self.config.completion:
-            result = await self._handle_completion(self.config.completion, context)
+        if self.completion:
+            result = await self.completion.run(context)
             context.register_source("result", result)
 
         return (await context.render_template(self.config.output, ignore_files=True)) if self.config.output else (result or response)
 
+    async def close(self) -> None:
+        if self.completion:
+            await self.completion.close()
+
     async def _resolve_request_url(self, context: ComponentContext) -> str:
         if self.base_url and self.config.path:
             return await context.render_template(self.base_url) + await context.render_template(self.config.path)
 
         return await context.render_template(self.config.endpoint)
 
-    async def _handle_completion(self, completion: HttpClientCompletionConfig, context: ComponentContext) -> Any:
-        if completion.type == "polling":
-            return await HttpClientPollingCompletion(self.base_url, self.headers, completion).run(context)
-        
-        if completion.type == "callback":
-            return await HttpClientCallbackCompletion(completion).run(context)
-
-        return None
-
 class HttpClientComponent(ComponentEngine):
     def __init__(self, id: str, config: HttpClientComponentConfig, env: Dict[str, str], daemon: bool):
         super().__init__(id, config, env, daemon)
 
+        self.client: HttpClient = None
+
     async def _serve(self) -> None:
-        pass
+        self.client = HttpClient()
 
     async def _shutdown(self) -> None:
-        pass
+        await self.client.close()
+        self.client = None
 
     async def _run(self, action: ActionConfig, context: ComponentContext) -> Any:
-        return await HttpClientAction(self.config.base_url, self.config.headers, action).run(context)
+        return await HttpClientAction(action, self.config.base_url, self.config.headers).run(context, self.client)
 
 ComponentEngineMap[ComponentType.HTTP_CLIENT] = HttpClientComponent

{model_compose-0.1.7 → model_compose-0.1.9}/src/mindor/core/component/engine/shell.py

@@ -3,6 +3,7 @@ from mindor.dsl.schema.component import ShellComponentConfig
 from mindor.dsl.schema.action import ActionConfig, ShellActionConfig
 from .base import ComponentEngine, ComponentType, ComponentEngineMap, ActionConfig
 from .context import ComponentContext
+from asyncio.subprocess import Process
 import asyncio, os
 
 class ShellAction:
@@ -32,16 +33,26 @@ class ShellAction:
         try:
             stdout, stderr = await asyncio.wait_for(process.communicate(), timeout=timeout)
         except asyncio.TimeoutError:
-            process.kill()
-            await process.wait()
-            raise RuntimeError(f"Command timed out: {' '.join(command)}")
+            if await self._kill_process(process):
+                raise RuntimeError(f"Command timed out: {' '.join(command)}")
 
         return { 
-            "exit_code": process.returncode, 
             "stdout": stdout.decode().strip(), 
-            "stderr": stderr.decode().strip() 
+            "stderr": stderr.decode().strip(),
+            "exit_code": process.returncode
         }
 
+    async def _kill_process(self, process: Process) -> bool:
+        if process.returncode is None:
+            process.kill()
+            try:
+                await process.wait()
+            except Exception as e:
+                pass
+            return True
+        else:
+            return False
+
     def _resolve_working_directory(self) -> str:
         working_dir = self.config.working_dir
         if working_dir:

{model_compose-0.1.7 → model_compose-0.1.9}/src/mindor/core/controller/engine/http_server.py

@@ -59,7 +59,7 @@ class HttpServerController(ControllerEngine):
         self._configure_routes()
         self.app.include_router(self.router, prefix=self.config.base_path)
 
-    def _configure_server(self):
+    def _configure_server(self) -> None:
         self.app.add_middleware(
             CORSMiddleware, 
             allow_origins=[self.config.origins], 
@@ -68,7 +68,7 @@ class HttpServerController(ControllerEngine):
             allow_headers=["*"],
         )
 
-    def _configure_routes(self):
+    def _configure_routes(self) -> None:
         @self.router.post("/workflows")
         async def run_workflow(
             request: Request
@@ -107,6 +107,7 @@ class HttpServerController(ControllerEngine):
             log_level="info"
         ))
         await self.server.serve()
+        self.server = None
  
     async def _shutdown(self) -> None:
         if self.server:

model_compose-0.1.9/src/mindor/core/controller/engine/mcp_server.py

@@ -0,0 +1,159 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Callable, Awaitable, Any
+from mindor.dsl.schema.controller import McpServerControllerConfig
+from mindor.dsl.schema.component import ComponentConfig
+from mindor.dsl.schema.listener import ListenerConfig
+from mindor.dsl.schema.gateway import GatewayConfig
+from mindor.dsl.schema.workflow import WorkflowConfig, WorkflowVariableConfig
+from mindor.core.workflow.schema import WorkflowSchema, create_workflow_schema
+from mindor.core.utils.streaming import StreamResource
+from .base import ControllerEngine, ControllerType, ControllerEngineMap, TaskState
+from mcp.server.fastmcp.server import FastMCP
+from mcp.types import TextContent, ImageContent, AudioContent
+import uvicorn, re, json
+
+_invalid_function_chars_regex = re.compile(r"[^a-zA-Z0-9_]")
+
+class WorkflowToolGenerator():
+    def generate(self, workflow_id: str, workflow: WorkflowSchema, runner: Callable[[Optional[str], Any], Awaitable[Any]]) -> Tuple[Callable[[Any], Awaitable[Any]], str]:
+        async def _run_workflow(input: Any, workflow_id=workflow_id, variables=workflow.output) -> Any:
+            return await self._build_output_value(await runner(workflow_id, input), variables)
+
+        async def _build_input_value(arguments, variables=workflow.input) -> Any:
+            return await self._build_input_value(arguments, variables)
+
+        safe_workflow_id = re.sub(_invalid_function_chars_regex, "_", workflow_id)
+        arguments = ",".join([ variable.name or "input" for variable in workflow.input ])
+        code = f"async def _run_workflow_{safe_workflow_id}({arguments}): return await _run_workflow(await _build_input_value([{arguments}]))"
+        context = { "_run_workflow": _run_workflow, "_build_input_value": _build_input_value }
+        exec(compile(code, f"<string>", "exec"), context)
+
+        return (context[f"_run_workflow_{safe_workflow_id}"], self._generate_description(workflow))
+
+    async def _build_input_value(self, arguments: List[Any], variables: List[WorkflowVariableConfig]) -> Any:
+        input: Dict[str, Any] = {}
+
+        for value, variable in zip(arguments, variables):
+            type, subtype, format = variable.type.value, variable.subtype, variable.format.value if variable.format else None
+            input[variable.name or "input"] = await self._convert_input_value(value, type, subtype, format, variable.default)
+
+        return input
+
+    async def _convert_input_value(self, value: Any, type: str, subtype: Optional[str], format: Optional[str], default: Optional[Any]) -> Any:
+        if type in [ "image", "audio", "video", "file" ]:
+            if format and format != "path":
+                pass
+
+        return value if value != "" else None
+
+    async def _build_output_value(self, state: TaskState, variables: List[WorkflowVariableConfig]) -> List[Union[TextContent, ImageContent, AudioContent]]:
+        output: List[Union[TextContent, ImageContent]] = []
+
+        if state.output:
+            for variable in variables:
+                type, subtype, format = variable.type.value, variable.subtype, variable.format.value if variable.format else None
+                output.append(await self._convert_output_value(state.output, type, subtype, format))
+
+        return output
+
+    async def _convert_output_value(self, value: Any, type: str, subtype: Optional[str], format: Optional[str]) -> Union[TextContent, ImageContent, AudioContent]:
+        if type in [ "image", "audio", "video", "file" ]:
+            if format and format != "path":
+                pass
+
+        if isinstance(value, (dict, list)):
+            return TextContent(type="text", text=json.dumps(value))
+
+        return TextContent(type="text", text=str(value))
+
+    def _generate_description(self, workflow: WorkflowSchema) -> str:
+        lines = []
+
+        lines.append(workflow.description or workflow.title or "")
+        lines.append("")
+        lines.append("Args:")
+
+        for variable in workflow.input:
+            name, type = variable.name or "input", self._get_docstring_type(variable)
+            description = variable.get_annotation_value("description") or ""
+            lines.append(f"    {name} ({type}): {description}")
+
+        lines.append("Returns:")
+
+        if len(workflow.output) == 1 and not workflow.output[0].name:
+            variable = workflow.output[0]
+            name, type = variable.name or "", self._get_docstring_type(variable)
+            lines.append(f"    {type}: {description}")
+        else:
+            lines.append(f"    dict: results containing:")
+            for variable in workflow.output:
+                name, type = variable.name or "", self._get_docstring_type(variable)
+                description = variable.get_annotation_value("description") or ""
+                lines.append(f"        - {name} ({type}): {description}")
+
+        return "\n".join(lines)
+
+    def _get_docstring_type(self, variable: WorkflowVariableConfig) -> str:
+        type, subtype, format = variable.type.value, variable.subtype, variable.format.value if variable.format else None
+
+        if type == "object[]":
+            return "list[dict]"
+
+        if type == "number":
+            return "float"
+
+        if type == "integer":
+            return "int"
+
+        return "str"
+
+class McpServerController(ControllerEngine):
+    def __init__(
+        self,
+        config: McpServerControllerConfig,
+        components: Dict[str, ComponentConfig],
+        listeners: List[ListenerConfig],
+        gateways: List[GatewayConfig],
+        workflows: Dict[str, WorkflowConfig],
+        env: Dict[str, str],
+        daemon: bool
+    ):
+        super().__init__(config, components, listeners, gateways, workflows, env, daemon)
+
+        self.server: Optional[uvicorn.Server] = None
+        self.app: FastMCP = FastMCP(self.config.name, settings={
+            "streamable_http_path": self.config.base_path
+        })
+
+        self._configure_tools()
+
+    def _configure_tools(self) -> None:
+        schema = create_workflow_schema(self.workflows, self.components)
+
+        for workflow_id, workflow in schema.items():
+            fn, description = WorkflowToolGenerator().generate(workflow_id, workflow, self._run_workflow_as_tool)
+            self.app.add_tool(
+                fn=fn,
+                name=workflow.name or workflow_id,
+                title=workflow.title,
+                description=description,
+                annotations=None
+            )
+    
+    async def _run_workflow_as_tool(self, workflow_id: Optional[str], input: Any) -> TaskState:
+        return await self.run_workflow(workflow_id, input, wait_for_completion=True)
+
+    async def _serve(self) -> None:
+        self.server = uvicorn.Server(uvicorn.Config(
+            self.app.streamable_http_app(),
+            host=self.config.host,
+            port=self.config.port,
+            log_level="info"
+        ))
+        await self.server.serve()
+        self.server = None
+
+    async def _shutdown(self) -> None:
+        if self.server:
+            self.server.should_exit = True
+
+ControllerEngineMap[ControllerType.MCP_SERVER] = McpServerController

{model_compose-0.1.7 → model_compose-0.1.9}/src/mindor/core/controller/runner/http_client.py

@@ -32,6 +32,9 @@ class HttpControllerClient(ControllerClient):
 
         return await self.client.request(url, method, None, body, headers)
 
+    async def close(self) -> None:
+        await self.client.close()
+
     def _flatten_for_multipart(self, body: Dict[str, Any], key: str = "") -> List[Tuple[str, Any]]:
         flattened = []
 

{model_compose-0.1.7 → model_compose-0.1.9}/src/mindor/core/controller/runner/mcp_client.py

@@ -7,7 +7,8 @@ class McpControllerClient(ControllerClient):
     def __init__(self, config: ControllerConfig):
         super().__init__(config)
 
-        self.client: McpClient = McpClient()
-
     async def run_workflow(self, workflow_id: Optional[str], input: Any) -> Any:
         pass
+
+    async def close(self) -> None:
+        pass

{model_compose-0.1.7 → model_compose-0.1.9}/src/mindor/core/controller/runner/runner.py

@@ -13,6 +13,10 @@ class ControllerClient(ABC):
     async def run_workflow(self, workflow_id: Optional[str], input: Any) -> Any:
         pass
 
+    @abstractmethod
+    async def close(self) -> None:
+        pass
+
 class ControllerRunner:
     def __init__(self, config: ControllerConfig):
         self.config: ControllerConfig = config
@@ -24,10 +28,15 @@ class ControllerRunner:
         if self.config.type == "http-server":
             self.client = HttpControllerClient(self.config)
             return
-        
+
         if self.config.type == "mcp-server":
             self.client = McpControllerClient(self.config)
             return
+
+        raise ValueError(f"Unsupported controller type: {self.config.type}")
     
     async def run_workflow(self, workflow_id: Optional[str], input: Any) -> Any:
         return await self.client.run_workflow(workflow_id, input)
+
+    async def close(self) -> None:
+        await self.client.close()

{model_compose-0.1.7 → model_compose-0.1.9}/src/mindor/core/controller/webui/gradio.py

@@ -62,18 +62,15 @@ class GradioWebUIBuilder:
 
     def _build_input_component(self, variable: WorkflowVariableConfig) -> gr.Component:
         label = (variable.name or "") + (" *" if variable.required else "") + (f" (default: {variable.default})" if variable.default else "")
-        info = variable.description or ""
+        info = variable.get_annotation_value("description") or ""
         default = variable.default
 
         if variable.type == "string" or variable.format in [ "base64", "url" ]:
             return gr.Textbox(label=label, value="", info=info)
 
-        if variable.type == "number":
-            return gr.Number(label=label, value="", precision=None, info=info)
-        
-        if variable.type == "integer":
-            return gr.Number(label=label, value="", precision=0, info=info)
-        
+        if variable.type in [ "integer", "number" ]:
+            return gr.Number(label=label, value="", info=info)
+
         if variable.type == "boolean":
             return gr.Checkbox(label=label, value=default or False, info=info)
         
@@ -96,14 +93,14 @@ class GradioWebUIBuilder:
     
     async def _build_input_value(self, arguments: List[Any], variables: List[WorkflowVariableConfig]) -> Any:
         if len(variables) == 1 and not variables[0].name:
-            return arguments[0]
+            value, variable = arguments[0], variables[0]
+            type, subtype, format = variable.type.value, variable.subtype, variable.format.value if variable.format else None
+            return await self._convert_input_value(value, type, subtype, format, variable.internal)
 
         input: Dict[str, Any] = {}
-        
         for value, variable in zip(arguments, variables):
             type, subtype, format = variable.type.value, variable.subtype, variable.format.value if variable.format else None
             input[variable.name] = await self._convert_input_value(value, type, subtype, format, variable.internal)
-
         return input
 
     async def _convert_input_value(self, value: Any, type: str, subtype: Optional[str], format: Optional[str], internal: bool) -> Any:
@@ -125,13 +122,16 @@ class GradioWebUIBuilder:
             return groups
 
         label = variable.name or ""
-        info = variable.description or ""
+        info = variable.get_annotation_value("description") or ""
 
         if variable.type in [ "string", "base64" ]:
             return gr.Textbox(label=label, interactive=False, show_copy_button=True, info=info)
 
         if variable.type == "markdown":
             return gr.Markdown(label=label)
+        
+        if variable.type in [ "json", "object[]" ]:
+            return gr.JSON(label=label)
 
         if variable.type == "image":
             return gr.Image(label=label, interactive=False)
@@ -184,7 +184,7 @@ class GradioWebUIBuilder:
             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)
+            return await load_image_from_stream(await HttpClient.request_once(value), subtype)
 
         if isinstance(value, StreamResource):
             return await load_image_from_stream(value, subtype)
@@ -196,7 +196,7 @@ class GradioWebUIBuilder:
             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)
+            return await save_stream_to_temporary_file(await HttpClient.request_once(value), subtype)
 
         if isinstance(value, StreamResource):
             return await save_stream_to_temporary_file(value, subtype)

{model_compose-0.1.7 → model_compose-0.1.9}/src/mindor/core/controller/webui/webui.py

@@ -30,7 +30,7 @@ class ControllerWebUI(AsyncService):
         self.env: Dict[str, str] = env
         self.server: Optional[uvicorn.Server] = None
         self.app: FastAPI = FastAPI(openapi_url=None, docs_url=None, redoc_url=None)
-        self.runner: ControllerRunner = ControllerRunner(controller)
+        self.runner: ControllerRunner = None
 
         self._configure_driver()
 
@@ -44,6 +44,7 @@ class ControllerWebUI(AsyncService):
             return
 
     async def _serve(self) -> None:
+        self.runner = ControllerRunner(self.controller)
         self.server = uvicorn.Server(uvicorn.Config(
             self.app,
             host=self.config.host,
@@ -51,10 +52,15 @@ class ControllerWebUI(AsyncService):
             log_level="info"
         ))
         await self.server.serve()
+        await self.runner.close()
+        self.server = None
+        self.runner = None
     
     async def _shutdown(self) -> None:
         if self.server:
             self.server.should_exit = True
-    
+
     async def _run_workflow(self, workflow_id: Optional[str], input: Any) -> Any:
-        return await self.runner.run_workflow(workflow_id, input)
+        if self.runner:
+            return await self.runner.run_workflow(workflow_id, input)
+        return None

model_compose-0.1.9/src/mindor/core/gateway/engine/ssh_tunnel.py

@@ -0,0 +1,25 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Callable, Iterator, Any
+from mindor.dsl.schema.gateway import SshTunnelGatewayConfig
+from .base import GatewayEngine, GatewayType, GatewayEngineMap
+from pyngrok import ngrok
+
+class SshTunnelGateway(GatewayEngine):
+    def __init__(self, id: str, config: SshTunnelGatewayConfig, env: Dict[str, str], daemon: bool):
+        super().__init__(id, config, env, daemon)
+
+        self.tunnel: Optional[Any] = None
+        self.public_url: Optional[str] = None
+
+    def get_context(self) -> Dict[str, Any]:
+        return {
+            "public_url": self.public_url,
+            "port": self.config.port
+        }
+
+    async def _serve(self) -> None:
+        pass
+
+    async def _shutdown(self) -> None:
+        pass
+  
+GatewayEngineMap[GatewayType.SSH_TUNNEL] = SshTunnelGateway

{model_compose-0.1.7 → model_compose-0.1.9}/src/mindor/core/listener/engine/http_callback.py

@@ -22,7 +22,7 @@ class HttpCallbackContext:
         self.renderer: TemplateRenderer = TemplateRenderer(self._resolve_source)
 
     async def items(self) -> AsyncIterator["HttpCallbackContext"]:
-        async for item in self._items():
+        for item in await self._items():
             yield HttpCallbackContext(item, self.query, False, None)
 
     async def render_template(self, template: str, ignore_files: bool = True) -> Any:
@@ -56,7 +56,7 @@ class HttpCallbackListener(ListenerEngine):
         self._configure_routes()
         self.app.include_router(self.router, prefix=self.config.base_path)
 
-    def _configure_routes(self):
+    def _configure_routes(self) -> None:
         for callback in self.config.callbacks:
             self.router.add_api_route(
                 path=callback.path,
@@ -69,8 +69,8 @@ class HttpCallbackListener(ListenerEngine):
         async def _handler(request: Request) -> Response:
             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 = await self._is_callback_succeeded(callback, context)
+            context = HttpCallbackContext(body, query, callback.bulk, callback.item)
+            succeeded = await self._is_callback_succeeded(callback, context)
 
             async for item in context.items():
                 callback_id = await item.render_template(callback.identify_by)
@@ -91,13 +91,12 @@ class HttpCallbackListener(ListenerEngine):
         status = (await context.render_template(callback.status)) if callback.status else None
 
         if status:
-            if callback.success_when and status == await context.render_template(callback.success_when):
+            if status in callback.success_when or []:
                 return True
-
-            if callback.fail_when and status == await context.render_template(callback.fail_when):
+            if status in callback.fail_when or []:
                 return False
 
-        return True       
+        return True
 
     async def _serve(self) -> None:
         self.server = uvicorn.Server(uvicorn.Config(
@@ -107,6 +106,7 @@ class HttpCallbackListener(ListenerEngine):
             log_level="info"
         ))
         await self.server.serve()
+        self.server = None
  
     async def _shutdown(self) -> None:
         if self.server: