PyPI - model-compose - Versions diffs - 0.0.9__tar.gz → 0.0.11__tar.gz - Mend

@@ -68,20 +68,36 @@ class HttpCallbackListener(BaseListener):
     def _make_callback_handler(self, callback: HttpCallbackConfig) -> Callable:
         async def handler(request: Request) -> Response:
             body, query = await self._parse_request_content(request), request.query_params
-            context = HttpCallbackContext(body, query, callback.bulk, callback.item)
+            context: HttpCallbackContext = HttpCallbackContext(body, query, callback.bulk, callback.item)
+            succeeded: bool = self._is_callback_succeeded(callback, context)
             for item in context.items():
                 callback_id = item.render_template(callback.identify_by)
                 future: asyncio.Future = self._get_pending_future(callback_id)
                 if future:
-                    future.set_result(item.render_template(callback.result) if callback.result else item.body)
+                    if succeeded:
+                        future.set_result(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)
             return Response()
         return handler
+    def _is_callback_succeeded(self, callback: HttpCallbackConfig, context: HttpCallbackContext) -> bool:
+        status = context.render_template(callback.status) if callback.status else None
+        if status:
+            if callback.success_when and status == context.render_template(callback.success_when):
+                return True
+            if callback.fail_when and status == context.render_template(callback.fail_when):
+                return False
+        return True
     async def _parse_request_content(self, request: Request) -> Any:
         content_type, _ = parse_options_header(request.headers.get("Content-Type", ""))

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

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

@@ -31,20 +31,23 @@ class HttpClientPollingCompletion:
         while datetime.now(timezone.utc) < deadline:
             response = await self.client.request(url, method, params, body, headers)
-            context.register_source("response", response)
+            context.register_source("result", response)
             status = context.render_template(self.config.status) if self.config.status else response["status"]
-            success_when = context.render_template(self.config.success_when) if self.config.success_when else "completed"
-            if success_when and status == success_when:
-                return response
+            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):
+                    return response
-            fail_when = context.render_template(self.config.fail_when) if self.config.fail_when else "failed"
-            if fail_when and status == fail_when:
-                raise RuntimeError(f"Polling failed: status='{status}'.")
+            for fail_when in self.config.fail_when if self.config.fail_when else [ "failed" ]:
+                if status == 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}")
+        raise TimeoutError(f"Polling timed out after {timeout}.")
     def _resolve_request_url(self, context: ComponentContext) -> str:
         if self.base_url and self.config.path:

@@ -15,8 +15,8 @@ class PollingCompletionConfig(CommonCompletionConfig):
     body: Optional[Dict[str, Any]] = Field(default_factory=dict)
     params: Optional[Dict[str, str]] = Field(default_factory=dict)
     status: Optional[str] = None
-    success_when: Optional[str] = None
-    fail_when: Optional[str] = None
+    success_when: Optional[List[str]] = None
+    fail_when: Optional[List[str]] = None
     interval: Optional[str] = None
     timeout: Optional[str] = None
@@ -26,6 +26,13 @@ class PollingCompletionConfig(CommonCompletionConfig):
             raise ValueError("Either 'endpoint' or 'path' must be set, but not both.")
         return values
+    @model_validator(mode="before")
+    def normalize_status_fields(cls, values: Dict[str, Any]):
+        for key in ("success_when", "fail_when"):
+            if isinstance(values.get(key), str):
+                values[key] = [ values[key] ]
+        return values
 class CallbackCompletionConfig(CommonCompletionConfig):
     type: Literal["callback"]
     wait_for: str

@@ -9,8 +9,18 @@ class HttpCallbackConfig(BaseModel):
     bulk: bool = False
     item: Optional[str] = None
     identify_by: str
+    status: Optional[str] = None
+    success_when: Optional[List[str]] = None
+    fail_when: Optional[List[str]] = None
     result: Optional[Any] = None
+    @model_validator(mode="before")
+    def normalize_status_fields(cls, values: Dict[str, Any]):
+        for key in [ "success_when", "fail_when" ]:
+            if isinstance(values.get(key), str):
+                values[key] = [ values[key] ]
+        return values
 class HttpCallbackListenerConfig(CommonListenerConfig):
     type: Literal[ListenerType.HTTP_CALLBACK]
     host: Optional[str] = "0.0.0.0"

model-compose 0.0.9__tar.gz → 0.0.11__tar.gz

model-compose 0.0.9tar.gz → 0.0.11tar.gz