apt: fix dict, list

Author: zhansheng.lzs

dashscope/finetune/reinforcement/common/cli.py

@@ -44,14 +44,14 @@ def format_output(data: Any, fmt: str = "table") -> None:
         console.print(
             yaml.dump(data, default_flow_style=False, allow_unicode=True))
     else:
-        if isinstance(data, dict):
+        if isinstance(data, Dict):
             table = Table(title="Result", show_header=True,
                           header_style="bold cyan")
             table.add_column("Key", style="cyan")
             table.add_column("Value", style="green")
             for k, v in data.items():
                 val = str(v) if not isinstance(v,
-                                               (dict, list)) else json.dumps(v,
+                                               (Dict, list)) else json.dumps(v,
                                                                              ensure_ascii=False,
                                                                              indent=2)
                 table.add_row(str(k), val)
@@ -180,12 +180,12 @@ async def _test_fc_async(
         func_type: str,
         input_data: Dict[str, Any],
         api_key: Optional[str]
-) -> dict:
+) -> Dict:
     """Core asynchronous testing logic."""
     try:
         result = await AgenticRL.test_functions(
             instance_id=instance_id,
-            type=func_type,
+            function_type=func_type,
             input_data=input_data,
             api_key=api_key,
         )

dashscope/finetune/reinforcement/common/errors.py

@@ -3,7 +3,7 @@
 """
 
 from datetime import datetime
-from typing import Optional
+from typing import Optional, Dict
 
 
 class AgenticRLError(Exception):
@@ -67,7 +67,7 @@ class OutputError(AgenticRLError):
     """Raised when service response fails output validation checks"""
 
     def __init__(self, message: str, error_code: int = 1200,
-                 response: Optional[dict] = None):
+                 response: Optional[Dict] = None):
         super().__init__(message, error_code)
         self.response = response
 
@@ -177,8 +177,8 @@ class ValidationError(AgenticRLError):
     """Base class for data validation failures"""
 
     def __init__(self, message: str, error_code: int = 1500,
-                 invalid_data: Optional[dict] = None,
-                 validation_rules: Optional[dict] = None):
+                 invalid_data: Optional[Dict] = None,
+                 validation_rules: Optional[Dict] = None):
         super().__init__(f"Validation failed: {message}", error_code)
         self.invalid_data = invalid_data
         self.validation_rules = validation_rules

dashscope/finetune/reinforcement/common/model.py

@@ -842,7 +842,7 @@ async def verify_function(
             instance_id: Optional[str] = None,
             instance_url: Optional[str] = None,
             instance_token: Optional[str] = None
-    ) -> dict:
+    ) -> Dict:
         """Validate deployed function functionality."""
         try:
             # Get instance metadata
@@ -884,6 +884,17 @@ async def verify_function(
                 raise ValidationError("Unsupported input type",
                                       error_code=2402)
 
+        except Exception as e:
+            logger.error(
+                f"Validation failed | Instance: {instance_id}, "
+                f"Error: {str(e)}",
+                exc_info=True
+            )
+            raise ValidationError(
+                f"Function verification failed: {str(e)}", error_code=2403
+            ) from e
+
+        try:
             validated = validator.model_validate(response)
 
             logger.info(
@@ -901,7 +912,8 @@ async def verify_function(
                 exc_info=True
             )
             raise ValidationError(
-                f"Function verification failed: {str(e)}", error_code=2403
+                f"Function verification failed: "
+                f"{str(e)}, response: {response}", error_code=2404
             ) from e
 
 
@@ -1188,7 +1200,7 @@ def combine_ids_runtimes(
             if function_runtimes and i <= len(function_runtimes) - 1:
                 runtime_config = function_runtimes[i].copy()
                 if 'env' in runtime_config and isinstance(
-                        runtime_config['env'], dict):
+                        runtime_config['env'], Dict):
                     for key, value in runtime_config['env'].items():
                         if isinstance(value, bool):
                             runtime_config['env'][key] = str(value).lower()

dashscope/finetune/reinforcement/common/utils.py

@@ -100,10 +100,10 @@ async def _handle_response(response) -> Dict[str, Any]:
 async def client_fc(
         api_key: str,
         url: str,
-        input: dict,
+        input: Dict,
         method: str = 'POST',
         content_type: str = 'application/json'
-) -> dict:
+) -> Dict:
     """Client function for Function Compute API requests."""
     return await async_http_request(
         method=method,
@@ -581,9 +581,9 @@ def deep_mask(data: Any) -> Any:
         try:
             data = data.model_dump(mode='json')
         except AttributeError:
-            data = data.dict()
+            data = data.Dict()
 
-    if isinstance(data, dict):
+    if isinstance(data, Dict):
         return {
             key: secret_part_str(
                 val) if key.lower() in LOGGER_FILTER_FIELDS else deep_mask(val)
@@ -686,8 +686,8 @@ def get_func_type_id(func_type: FunctionType):
 
 def deep_remove_none(obj):
     """Recursively remove items with value None from dicts and lists (including nested structures)"""
-    if isinstance(obj, dict):
-        # Process dict: filter keys with non-None values and recursively process values
+    if isinstance(obj, Dict):
+        # Process Dict: filter keys with non-None values and recursively process values
         return {
             k: deep_remove_none(v)
             for k, v in obj.items()
@@ -843,7 +843,7 @@ def serialize_for_output(data: Any) -> Any:
     This function recursively processes data to ensure it can be serialized to formats like JSON.
     It handles:
     - Pydantic V2 models using model_dump()
-    - Pydantic V1 models using dict()
+    - Pydantic V1 models using Dict()
     - Regular objects via their __dict__ attribute
     - Lists, tuples, and dictionaries recursively
     - Other basic types as-is
@@ -852,20 +852,20 @@ def serialize_for_output(data: Any) -> Any:
         data: Input data to serialize (any type)
 
     Returns:
-        Serialized data in a format suitable for output (dict, list, or primitive)
+        Serialized data in a format suitable for output (Dict, list, or primitive)
     """
     # Handle Pydantic models (version detection)
     if hasattr(data, "model_dump"):  # Pydantic V2
         return data.model_dump()
     elif hasattr(data, "dict"):  # Pydantic V1
-        return data.dict()
+        return data.Dict()
 
     # Handle regular objects via their attribute dictionary
     if hasattr(data, "__dict__"):
         data = data.__dict__
 
     # Recursively process container types
-    if isinstance(data, dict):
+    if isinstance(data, Dict):
         return {k: serialize_for_output(v) for k, v in data.items()}
     elif isinstance(data, (list, tuple, set)):
         return [serialize_for_output(item) for item in data]

dashscope/finetune/reinforcement/component/func_decorator.py

@@ -82,7 +82,7 @@ def decorator(cls: Type) -> Type:
 
         async def process(self, input_data: RewardInput) -> RewardOutput:
             """Processes input by executing all sub-reward functions and aggregating results"""
-            sub_rewards: dict[str, RewardOutput] = {}
+            sub_rewards: Dict[str, RewardOutput] = {}
 
             tasks = []
             for name, sub_func in self._reward_meta.sub_functions.items():

dashscope/finetune/reinforcement/component/observability/genai/_core.py

@@ -120,10 +120,10 @@ def _inner(x: Any, depth: int) -> Any:
                     pass
         if hasattr(x, "dict") and callable(getattr(x, "dict", None)):
             try:
-                return _inner(x.dict(), depth + 1)  # type: ignore[call-arg]
+                return _inner(x.Dict(), depth + 1)  # type: ignore[call-arg]
             except Exception:
                 pass
-        if isinstance(x, dict):
+        if isinstance(x, Dict):
             out: Dict[str, Any] = {}
             for i, (k, v) in enumerate(x.items()):
                 if i >= limits.max_items:

dashscope/finetune/reinforcement/component/observability/genai/messages.py

@@ -125,7 +125,7 @@ def unwrap_openai_completion(completion: Any) -> Any:
     try:
         if completion is None:
             return None
-        if isinstance(completion, dict):
+        if isinstance(completion, Dict):
             return completion
         if getattr(completion, "choices", None) is not None:
             return completion
@@ -146,15 +146,15 @@ def _shape_args_for_debug(arguments: Any) -> Dict[str, Any]:
         return {"args_type": "None", "args_str_len": 0}
     if isinstance(arguments, str):
         return {"args_type": "str", "args_str_len": len(arguments)}
-    if isinstance(arguments, (dict, list)):
+    if isinstance(arguments, (Dict, list)):
         return {"args_type": type(arguments).__name__,
                 "args_json_len": len(json.dumps(arguments, default=str))}
     return {"args_type": type(arguments).__name__,
             "args_repr_len": len(repr(arguments))}
 
 
 def _first_tool_call_keys(tc: Any) -> Any:
-    if isinstance(tc, dict):
+    if isinstance(tc, Dict):
         return sorted(tc.keys())
     out = []
     for k in ("function", "name", "args", "id", "type", "arguments"):
@@ -180,7 +180,7 @@ def tool_calls_to_parts(tool_calls: Any) -> List[Any]:
     parts: List[Any] = []
     for i, tc in enumerate(tool_calls):
         fn = getattr(tc, "function", None)
-        if fn is None and isinstance(tc, dict):
+        if fn is None and isinstance(tc, Dict):
             fn = tc.get("function")
         name = ""
         args: Any = "{}"
@@ -191,7 +191,7 @@ def tool_calls_to_parts(tool_calls: Any) -> List[Any]:
             # ``messages`` history).  Never use ``getattr(fn, "arguments", "{}")`` for dicts:
             # ``getattr`` returns the default literal ``"{}"``, which is truthy and prevents
             # the ``or fn.get("arguments", ...)`` fallback from running — real arguments are lost.
-            if isinstance(fn, dict):
+            if isinstance(fn, Dict):
                 name = fn.get("name") or ""
                 raw_args = fn.get("arguments")
             else:
@@ -201,17 +201,17 @@ def tool_calls_to_parts(tool_calls: Any) -> List[Any]:
         else:
             branch = "top_level_lc"
             name = getattr(tc, "name", "") or (
-                tc.get("name") if isinstance(tc, dict) else "")
+                tc.get("name") if isinstance(tc, Dict) else "")
             # LangChain ``ToolCall`` / LC-like dicts: payload lives in top-level ``args``, not
             # OpenAI's nested ``function.arguments`` string.
-            if isinstance(tc, dict):
+            if isinstance(tc, Dict):
                 if tc.get("args") is not None:
                     args = tc["args"]
             else:
                 lc_args = getattr(tc, "args", None)
                 if lc_args is not None:
                     args = lc_args
-        tid = getattr(tc, "id", None) if not isinstance(tc, dict) else tc.get(
+        tid = getattr(tc, "id", None) if not isinstance(tc, Dict) else tc.get(
             "id")
         args_str = _sanitize_tool_call_arguments(args)
         if _debug_llm_tool_calls():
@@ -220,7 +220,7 @@ def tool_calls_to_parts(tool_calls: Any) -> List[Any]:
                 if fn is not None:
                     raw_a = (
                         fn.get("arguments", "__sentinel__")
-                        if isinstance(fn, dict)
+                        if isinstance(fn, Dict)
                         else getattr(fn, "arguments", "__sentinel__")
                     )
                     nested_fn_diag = {
@@ -262,7 +262,7 @@ def _extract_tool_calls_from_message_obj(m: Any) -> Any:
     if tc is not None:
         return tc
     ak = getattr(m, "additional_kwargs", None)
-    if isinstance(ak, dict):
+    if isinstance(ak, Dict):
         return ak.get("tool_calls")
     return None
 
@@ -307,7 +307,7 @@ def openai_chat_messages_to_input_messages(messages: Any) -> List[Any]:
             _debug_llm_tool_calls_log_exc()
     out: List[Any] = []
     for idx, m in enumerate(messages):
-        if isinstance(m, dict):
+        if isinstance(m, Dict):
             raw_role = m.get("role")
             content = m.get("content")
             tool_calls = m.get("tool_calls")
@@ -392,29 +392,29 @@ def openai_completion_to_output_messages(completion: Any) -> List[Any]:
 
     # OpenAI-compatible SDKs sometimes return plain dicts (e.g. http clients or
     # wrappers). Handle both object- and dict-shaped responses.
-    if isinstance(completion, dict):
+    if isinstance(completion, Dict):
         choices = completion.get("choices") or []
     else:
         choices = getattr(completion, "choices", None) or []
     if not choices:
         return []
     result: List[Any] = []
     for ch in choices:
-        if isinstance(ch, dict):
+        if isinstance(ch, Dict):
             msg = ch.get("message")
             finish = ch.get("finish_reason") or "stop"
         else:
             msg = getattr(ch, "message", None)
             finish = getattr(ch, "finish_reason", None) or "stop"
 
-        if isinstance(msg, dict):
+        if isinstance(msg, Dict):
             role = msg.get("role") or "assistant"
         else:
             role = getattr(msg, "role",
                            "assistant") if msg is not None else "assistant"
         parts: List[Any] = []
         if msg is not None:
-            if isinstance(msg, dict):
+            if isinstance(msg, Dict):
                 content = msg.get("content")
             else:
                 content = getattr(msg, "content", None)
@@ -423,7 +423,7 @@ def openai_completion_to_output_messages(completion: Any) -> List[Any]:
                     Text(content=content if isinstance(content, str) else str(
                         content))
                 )
-            if isinstance(msg, dict):
+            if isinstance(msg, Dict):
                 tool_calls = msg.get("tool_calls")
             else:
                 tool_calls = getattr(msg, "tool_calls", None)
@@ -452,7 +452,7 @@ def dashscope_response_to_output_messages(response: Any) -> List[Any]:
             role = "assistant"
             parts: List[Any] = []
             if msg is not None:
-                if isinstance(msg, dict):
+                if isinstance(msg, Dict):
                     role = msg.get("role") or "assistant"
                     content = msg.get("content")
                     tool_calls = msg.get("tool_calls")