Alicloud Ai Multimodal Qwen Vl Test

#!/usr/bin/env python3
"""Executable smoke test for alicloud-ai-multimodal-qwen-vl."""

from __future__ import annotations

import argparse
import importlib.util
import json
from pathlib import Path


def load_analyze_module(repo_root: Path):
    module_path = (
        repo_root
        / "skills/ai/multimodal/alicloud-ai-multimodal-qwen-vl/scripts/analyze_image.py"
    )
    spec = importlib.util.spec_from_file_location("analyze_image", module_path)
    if spec is None or spec.loader is None:
        raise RuntimeError(f"Cannot load module: {module_path}")
    module = importlib.util.module_from_spec(spec)
    spec.loader.exec_module(module)
    return module


def main() -> None:
    parser = argparse.ArgumentParser(description="Smoke test for Qwen VL image understanding skill")
    parser.add_argument(
        "--image",
        required=True,
        help="Image URL or local path for validation",
    )
    parser.add_argument(
        "--prompt",
        default="Describe the image and list 3 visible details.",
        help="Prompt for the model",
    )
    parser.add_argument(
        "--model",
        default="qwen3-vl-plus",
        help="Model name to test",
    )
    parser.add_argument(
        "--output",
        default="output/ai-multimodal-qwen-vl/smoke-test/result.json",
        help="Where to save smoke-test output JSON",
    )
    args = parser.parse_args()

    repo_root = Path(__file__).resolve().parents[5]
    mod = load_analyze_module(repo_root)
    mod._load_env()
    mod._load_dashscope_api_key_from_credentials()

    req = {
        "prompt": args.prompt,
        "image": args.image,
        "model": args.model,
        "max_tokens": 512,
        "temperature": 0.2,
    }
    result = mod.call_analyze(req)

    text = result.get("text")
    if not isinstance(text, str) or not text.strip():
        raise RuntimeError("Smoke test failed: empty text in response")
    if result.get("model") != args.model and not str(result.get("model", "")).startswith(args.model):
        raise RuntimeError(
            f"Smoke test failed: unexpected model. expected={args.model} actual={result.get('model')}"
        )

    output_path = Path(args.output)
    output_path.parent.mkdir(parents=True, exist_ok=True)
    output_path.write_text(json.dumps(result, ensure_ascii=True, indent=2), encoding="utf-8")

    print(json.dumps({"status": "pass", "output": str(output_path)}, ensure_ascii=True))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Unit tests for Qwen VL analyze_image helper behaviors."""

from __future__ import annotations

import importlib.util
import json
import unittest
from pathlib import Path


def _load_module():
    root = Path(__file__).resolve().parents[4]
    module_path = root / "skills/ai/multimodal/alicloud-ai-multimodal-qwen-vl/scripts/analyze_image.py"
    spec = importlib.util.spec_from_file_location("analyze_image", module_path)
    if spec is None or spec.loader is None:
        raise RuntimeError("Cannot load analyze_image module")
    module = importlib.util.module_from_spec(spec)
    spec.loader.exec_module(module)
    return module


class AnalyzeImageTests(unittest.TestCase):
    def setUp(self) -> None:
        self.mod = _load_module()

    def test_build_payload_with_json_mode(self) -> None:
        payload = self.mod.build_payload(
            req={"prompt": "extract", "max_tokens": 100, "temperature": 0.0},
            model="qwen3-vl-plus",
            image_url="https://example.com/img.jpg",
            detail="auto",
            json_mode=True,
            schema_obj=None,
        )
        self.assertEqual(payload["response_format"]["type"], "json_object")

    def test_build_payload_with_schema(self) -> None:
        schema = {
            "type": "object",
            "properties": {"name": {"type": "string"}},
            "required": ["name"],
        }
        payload = self.mod.build_payload(
            req={"prompt": "extract", "max_tokens": 100, "temperature": 0.0},
            model="qwen3-vl-plus",
            image_url="https://example.com/img.jpg",
            detail="high",
            json_mode=False,
            schema_obj=schema,
        )
        self.assertEqual(payload["response_format"]["type"], "json_schema")
        self.assertEqual(payload["response_format"]["json_schema"]["schema"], schema)

    def test_extract_text_content_from_list(self) -> None:
        text = self.mod.extract_text_content(
            [
                {"type": "text", "text": "hello"},
                {"type": "reasoning", "text": "ignore"},
            ]
        )
        self.assertEqual(text, "hello")

    def test_parse_json_text(self) -> None:
        parsed = self.mod.try_parse_json_text('{"a":1}')
        self.assertEqual(parsed, {"a": 1})
        self.assertIsNone(self.mod.try_parse_json_text("not json"))

    def test_extract_error_message(self) -> None:
        message = self.mod.extract_error_message({"error": {"message": "bad request"}})
        self.assertEqual(message, "bad request")


if __name__ == "__main__":
    unittest.main()