licos-dev-sdk 0.2.10__tar.gz → 0.2.11__tar.gz

{licos_dev_sdk-0.2.10 → licos_dev_sdk-0.2.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: licos-dev-sdk
-Version: 0.2.10
+Version: 0.2.11
 Summary: LICOS Dev SDK - file generation and model capability clients
 Requires-Python: >=3.10
 Requires-Dist: docxtpl>=0.16

{licos_dev_sdk-0.2.10 → licos_dev_sdk-0.2.11}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "licos-dev-sdk"
-version = "0.2.10"
+version = "0.2.11"
 description = "LICOS Dev SDK - file generation and model capability clients"
 requires-python = ">=3.10"
 dependencies = [

{licos_dev_sdk-0.2.10 → licos_dev_sdk-0.2.11}/src/licos_dev_sdk/model.py

@@ -23,6 +23,8 @@ MODEL_DETAIL_PATH = "/api/v1/admin/workspaces/models/detail"
 DEFAULT_REQUEST_TIMEOUT_SECS = 120
 DEFAULT_ASYNC_TIMEOUT_SECS = 600
 DEFAULT_ASYNC_POLL_INTERVAL_SECS = 2.0
+ASYNC_MODEL_TASK_HEADER_NAME = "X-DashScope-Async"
+ASYNC_MODEL_TASK_HEADER_VALUE = "enable"
 DEFAULT_CATALOG_CACHE_TTL_SECS = 300
 
 _CATALOG_CACHE: dict[tuple[str, str, str, str, str, str], tuple[float, list[dict[str, Any]]]] = {}
@@ -416,21 +418,21 @@ class ImageGenerationClient:
     ) -> ModelResult:
         endpoint = _resolve_endpoint_with_detail(self.runtime, "imageGeneration", requested_model=model)
         selected_model = endpoint.model
-        if raw_request:
-            body = dict(raw_request)
-            body.setdefault("model", selected_model)
-        else:
-            params = dict(parameters or {})
-            params["n"] = _image_count(count, params)
-            if size:
-                params["size"] = size
-            input_payload = {"prompt": prompt}
-            if negative_prompt:
-                input_payload["negative_prompt"] = negative_prompt
-            body = {"model": selected_model, "input": input_payload, "parameters": params}
-        return _submit_model_task(
-            endpoint,
-            self.runtime,
+        if raw_request:
+            body = dict(raw_request)
+            body.setdefault("model", selected_model)
+        else:
+            body = _image_generation_body(
+                prompt,
+                selected_model,
+                count=count,
+                negative_prompt=negative_prompt,
+                size=size,
+                parameters=parameters,
+            )
+        return _submit_model_task(
+            endpoint,
+            self.runtime,
             body,
             wait=wait,
             timeout=timeout,
@@ -819,6 +821,38 @@ def _request_headers(endpoint: ModelEndpoint) -> dict[str, str]:
     return endpoint.required_headers
 
 
+def _task_submit_headers(endpoint: ModelEndpoint) -> dict[str, str]:
+    headers = dict(_request_headers(endpoint))
+    if _is_async_model_task(endpoint) and not any(
+        key.lower() == ASYNC_MODEL_TASK_HEADER_NAME.lower() for key in headers
+    ):
+        headers[ASYNC_MODEL_TASK_HEADER_NAME] = ASYNC_MODEL_TASK_HEADER_VALUE
+    return headers
+
+
+def _is_async_model_task(endpoint: ModelEndpoint) -> bool:
+    if endpoint.capability.strip().lower() in {"imagegeneration", "image_generation"}:
+        return False
+    return (
+        endpoint.async_task
+        or bool(endpoint.task_query_url)
+        or any(key.lower() == ASYNC_MODEL_TASK_HEADER_NAME.lower() for key in endpoint.request_headers)
+        or _is_async_model_task_capability(endpoint.capability)
+    )
+
+
+def _is_async_model_task_capability(capability: str) -> bool:
+    return capability.strip().lower() in {
+        "imagegeneration",
+        "image_generation",
+        "videogeneration",
+        "video_generation",
+        "speechrecognition",
+        "speech_recognition",
+        "speech",
+    }
+
+
 def _normalize_input_capabilities(value: str | None = None) -> str | None:
     if value is None:
         return None
@@ -849,7 +883,53 @@ def _video_input_capabilities(
             value = input_payload.get(key)
             if value is not None and str(value).strip():
                 return "image"
-    return "text"
+    return "text"
+
+
+def _image_generation_body(
+    prompt: str,
+    model: str,
+    *,
+    count: int | None = None,
+    negative_prompt: str | None = None,
+    size: str | None = None,
+    parameters: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    params = dict(parameters or {})
+    image_count = _image_count(count, params)
+    params.pop("count", None)
+    if image_count is not None:
+        params["n"] = image_count
+    else:
+        params.pop("n", None)
+    if negative_prompt:
+        params.setdefault("negative_prompt", negative_prompt)
+    if size:
+        params.setdefault("size", size)
+    return {
+        "model": model,
+        "input": {
+            "messages": [
+                {
+                    "role": "user",
+                    "content": [{"text": prompt}],
+                }
+            ]
+        },
+        "parameters": params,
+    }
+
+
+def _image_count(count: int | None, parameters: dict[str, Any]) -> int | None:
+    values = [count, parameters.get("n"), parameters.get("count")]
+    for value in values:
+        try:
+            parsed = int(value)
+        except (TypeError, ValueError):
+            continue
+        if parsed > 0:
+            return max(1, min(4, parsed))
+    return None
 
 
 def _fetch_model_detail(
@@ -1336,7 +1416,7 @@ def _post_model_json(
             endpoint.base_url,
             token=runtime.token,
             body=body,
-            headers=_request_headers(endpoint),
+            headers=_task_submit_headers(endpoint),
             timeout=request_timeout,
         )
     except ApiError as exc:
@@ -1347,7 +1427,7 @@ def _post_model_json(
                 endpoint.base_url,
                 token=refreshed.token,
                 body=body,
-                headers=_request_headers(endpoint),
+                headers=_task_submit_headers(endpoint),
                 timeout=request_timeout,
             )
         raise
@@ -1364,7 +1444,7 @@ def _submit_model_task(
 ) -> ModelResult:
     submit_response = _post_model_json(endpoint, runtime, body, timeout=timeout)
     response = submit_response
-    if endpoint.async_task and wait:
+    if _is_async_model_task(endpoint) and wait:
         response = _await_async_model_result(
             endpoint,
             runtime,
@@ -1379,7 +1459,7 @@ def _submit_model_task(
         response=response,
         urls=_collect_urls(response),
         texts=_collect_texts(response),
-        submit_response=submit_response if endpoint.async_task else None,
+        submit_response=submit_response if _is_async_model_task(endpoint) else None,
     )
 
 
@@ -1677,19 +1757,7 @@ def _selected_model(model: str | None, default: str) -> str:
     return selected
 
 
-def _image_count(count: int | None, parameters: dict[str, Any]) -> int:
-    values = [count, parameters.get("n"), parameters.get("count")]
-    for value in values:
-        try:
-            parsed = int(value)
-        except (TypeError, ValueError):
-            continue
-        if parsed > 0:
-            return max(1, min(4, parsed))
-    return 1
-
-
-def _non_empty_list(values: Sequence[str | None]) -> list[str]:
+def _non_empty_list(values: Sequence[str | None]) -> list[str]:
     return [value.strip() for value in values if isinstance(value, str) and value.strip()]
 
 

{licos_dev_sdk-0.2.10 → licos_dev_sdk-0.2.11}/tests/test_model.py

@@ -59,14 +59,14 @@ def _available_models_payload(category_code: str = "llm", input_capabilities: st
                 "baseUrl": "http://gateway.example/v1/chat/completions",
             }
         ],
-        "image_generation": [
-            {
-                "providerCode": "test-provider",
-                "categoryCode": "image_generation",
-                "modelCode": "image-model",
-                "baseUrl": "http://gateway.example/image",
-            }
-        ],
+        "image_generation": [
+            {
+                "providerCode": "test-provider",
+                "categoryCode": "image_generation",
+                "modelCode": "image-model",
+                "baseUrl": "http://gateway.example/image",
+            }
+        ],
         "video_generation": [
             {
                 "providerCode": "test-provider",
@@ -75,6 +75,8 @@ def _available_models_payload(category_code: str = "llm", input_capabilities: st
                 "baseUrl": "http://gateway.example/video-image"
                 if input_capabilities == "image"
                 else "http://gateway.example/video-text",
+                "async": True,
+                "taskQueryUrl": "http://gateway.example/tasks/{taskId}",
             }
         ],
         "speech": [
@@ -83,6 +85,7 @@ def _available_models_payload(category_code: str = "llm", input_capabilities: st
                 "categoryCode": "speech",
                 "modelCode": "asr-model",
                 "baseUrl": "http://gateway.example/asr",
+                "taskQueryUrl": "http://gateway.example/tasks/{taskId}",
             }
         ],
     }.get(category_code, [])
@@ -105,10 +108,14 @@ def _model_detail_payload(model_code: str = "chat-text") -> dict[str, Any]:
         }
     if model_code == "image-model":
         return {
-            "code": 0,
-            "success": True,
-            "data": {"code": model_code, "baseUrl": "http://gateway.example/image"},
-        }
+            "code": 0,
+            "success": True,
+            "data": {
+                "code": model_code,
+                "baseUrl": "http://gateway.example/image",
+                "requiredHeaders": [],
+            },
+        }
     if model_code in ("video-text-model", "video-image-model"):
         suffix = "image" if model_code == "video-image-model" else "text"
         return {
@@ -116,6 +123,12 @@ def _model_detail_payload(model_code: str = "chat-text") -> dict[str, Any]:
             "success": True,
             "data": {"code": model_code, "baseUrl": f"http://gateway.example/video-{suffix}"},
         }
+    if model_code == "asr-model":
+        return {
+            "code": 0,
+            "success": True,
+            "data": {"code": model_code, "baseUrl": "http://gateway.example/asr"},
+        }
     return {
         "code": 0,
         "success": True,
@@ -398,7 +411,7 @@ class ModelSdkTests(unittest.TestCase):
         self.assertEqual(kwargs["timeout"], 30)
         self.assertTrue(kwargs["streaming"])
 
-    def test_image_generation_defaults_to_one_image(self) -> None:
+    def test_image_generation_uses_sync_multimodal_body(self) -> None:
         captured: dict[str, Any] = {}
 
         def fake_urlopen(req: Any, timeout: int = 0) -> _FakeResponse:
@@ -409,6 +422,7 @@ class ModelSdkTests(unittest.TestCase):
             if req.full_url.startswith("http://platform.example/api/v1/admin/workspaces/models/detail?"):
                 return _FakeResponse(_model_detail_payload("image-model"))
             if req.full_url == "http://gateway.example/image":
+                captured["headers"] = dict(req.header_items())
                 captured["body"] = json.loads(req.data.decode("utf-8"))
                 return _FakeResponse({"output": {"url": "https://cdn.example/image.png"}})
             raise AssertionError(req.full_url)
@@ -416,9 +430,13 @@ class ModelSdkTests(unittest.TestCase):
         with mock.patch.object(model.request, "urlopen", fake_urlopen):
             result = model.ImageGenerationClient().generate("blue sky")
 
-        self.assertEqual(captured["body"]["model"], "image-model")
-        self.assertEqual(captured["body"]["parameters"]["n"], 1)
-        self.assertEqual(result.urls, ["https://cdn.example/image.png"])
+        self.assertEqual(captured["body"]["model"], "image-model")
+        self.assertEqual(captured["body"]["input"]["messages"][0]["role"], "user")
+        self.assertEqual(captured["body"]["input"]["messages"][0]["content"][0]["text"], "blue sky")
+        self.assertNotIn("n", captured["body"]["parameters"])
+        headers = {key.lower(): value for key, value in captured["headers"].items()}
+        self.assertNotIn("x-dashscope-async", headers)
+        self.assertEqual(result.urls, ["https://cdn.example/image.png"])
 
     def test_video_generation_uses_text_input_capability_without_image(self) -> None:
         captured: dict[str, Any] = {}
@@ -432,6 +450,7 @@ class ModelSdkTests(unittest.TestCase):
             if req.full_url.startswith("http://platform.example/api/v1/admin/workspaces/models/detail?"):
                 return _FakeResponse(_model_detail_payload("video-text-model"))
             if req.full_url == "http://gateway.example/video-text":
+                captured["headers"] = dict(req.header_items())
                 captured["body"] = json.loads(req.data.decode("utf-8"))
                 return _FakeResponse({"output": {"video_url": "https://cdn.example/text.mp4"}})
             raise AssertionError(req.full_url)
@@ -441,8 +460,38 @@ class ModelSdkTests(unittest.TestCase):
 
         self.assertEqual(captured["catalog_query"]["inputCapabilities"], ["text"])
         self.assertEqual(captured["body"]["model"], "video-text-model")
+        headers = {key.lower(): value for key, value in captured["headers"].items()}
+        self.assertEqual(headers["x-dashscope-async"], "enable")
         self.assertEqual(result.urls, ["https://cdn.example/text.mp4"])
 
+    def test_speech_recognition_submits_with_async_header(self) -> None:
+        captured: dict[str, Any] = {}
+
+        def fake_urlopen(req: Any, timeout: int = 0) -> _FakeResponse:
+            if req.full_url == "http://platform.example/api/v1/internal/auth/ai-user-token":
+                return _FakeResponse({"code": 0, "success": True, "data": {"accessToken": "user-token"}})
+            if _is_available_models_request(req):
+                return _available_models_response(req)
+            if req.full_url.startswith("http://platform.example/api/v1/admin/workspaces/models/detail?"):
+                return _FakeResponse(_model_detail_payload("asr-model"))
+            if req.full_url == "http://gateway.example/asr":
+                captured["headers"] = dict(req.header_items())
+                captured["body"] = json.loads(req.data.decode("utf-8"))
+                return _FakeResponse({"output": {"task_id": "asr-task-1", "task_status": "PENDING"}})
+            raise AssertionError(req.full_url)
+
+        with mock.patch.object(model.request, "urlopen", fake_urlopen):
+            result = model.SpeechRecognitionClient().recognize(
+                audio_url="https://cdn.example/a.wav",
+                wait=False,
+            )
+
+        headers = {key.lower(): value for key, value in captured["headers"].items()}
+        self.assertEqual(headers["x-dashscope-async"], "enable")
+        self.assertEqual(captured["body"]["model"], "asr-model")
+        self.assertEqual(captured["body"]["input"]["file_urls"], ["https://cdn.example/a.wav"])
+        self.assertEqual(result.submit_response["output"]["task_id"], "asr-task-1")
+
     def test_video_generation_uses_image_input_capability_with_image(self) -> None:
         captured: dict[str, Any] = {}