style: satisfy pre-commit and fix a Python 3.9 test failure

The pre-commit workflow failed on `add-trailing-comma`, `black` and `pylint`,
and the 3.9 unit-test job failed on one new test.

pylint:
- `_handle_response` was at 52/50 statements. The SSE parse-failure branch it
  gained was a near-copy of the one in `call()`, so both now share
  `_sse_parse_failure_response`, which brings it back under the limit instead
  of widening it.
- Four test modules drive private request handlers on purpose; they now carry
  the module-level `protected-access` disable the other 18 test modules use.
- `test_error_detail_preserved` had a bare `yield` after `raise` purely to make
  the closure an async generator, which reads as unreachable code. It now
  yields first and raises after, matching the neighbouring test.
- `test_agentstudio_protocol` used `import dashscope.agentstudio as ...`.

Python 3.9:
- `test_record_is_attributed_to_the_caller` read `caplog.records`, which was
  empty because the SDK logger does not propagate and caplog attaches at the
  root. It now attaches a collecting handler to the module's own logger, so the
  stacklevel attribution is verified on every supported version.

Tests: 1174 passed, 6 skipped. All pre-commit hooks pass.

Author: zhansheng.lzs

dashscope/api_entities/http_request.py

@@ -166,6 +166,36 @@ def _send_with_retry(
         return send()
 
 
+def _sse_parse_failure_response(
+    status: int,
+    data: str,
+    request_id: str,
+    headers: dict,
+) -> DashScopeAPIResponse:
+    """Build the 500 for an SSE body the SDK cannot parse.
+
+    An unparsable body is a server-side defect rather than a bad request, and
+    the payload is the only evidence of it, so it is kept in ``message``.
+
+    ``status`` feeds the log line only: the sync and async callers read it from
+    different attributes.
+    """
+    error_message = data or INTERNAL_ERROR.format_msg()
+    logger.error(
+        "Request failed: status=%s, code=%s, message=%s",
+        status,
+        INTERNAL_ERROR.error_code,
+        truncate_error_message(error_message),
+    )
+    return DashScopeAPIResponse(
+        request_id=request_id,
+        status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
+        code=INTERNAL_ERROR.error_code,
+        message=error_message,
+        headers=headers,
+    )
+
+
 class HttpRequest(AioBaseRequest):
     def __init__(
         self,
@@ -434,20 +464,11 @@ async def _handle_aio_response(  # pylint: disable=too-many-branches, too-many-s
                     if "request_id" in msg:
                         request_id = msg["request_id"]
                 except json.JSONDecodeError:
-                    error_code = INTERNAL_ERROR.error_code
-                    error_message = data or INTERNAL_ERROR.format_msg()
-                    logger.error(
-                        "Request failed: status=%s, code=%s, message=%s",
+                    yield _sse_parse_failure_response(
                         response.status,
-                        error_code,
-                        truncate_error_message(error_message),
-                    )
-                    yield DashScopeAPIResponse(
-                        request_id=request_id,
-                        status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
-                        code=error_code,
-                        message=error_message,
-                        headers=headers,
+                        data,
+                        request_id,
+                        headers,
                     )
                     continue
                 if is_error:
@@ -555,21 +576,11 @@ def _handle_response(  # pylint: disable=too-many-branches
                     if "request_id" in msg:
                         request_id = msg["request_id"]
                 except json.JSONDecodeError:
-                    error_code = INTERNAL_ERROR.error_code
-                    error_message = data or INTERNAL_ERROR.format_msg()
-                    logger.error(
-                        "Request failed: status=%s, code=%s, message=%s",
+                    yield _sse_parse_failure_response(
                         response.status_code,
-                        error_code,
-                        truncate_error_message(error_message),
-                    )
-                    yield DashScopeAPIResponse(
-                        request_id=request_id,
-                        status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
-                        output=None,
-                        code=error_code,
-                        message=error_message,
-                        headers=headers,
+                        data,
+                        request_id,
+                        headers,
                     )
                     continue
                 if is_error:

dashscope/finetune/agentic_rl.py

@@ -156,11 +156,11 @@ def _public_exception(public_error, cause: Exception) -> DashScopeException:
     ``error_code`` instead of the internal one.
     """
     summary = f"{type(cause).__name__}: {_exc_message(cause)}"
-    exc_cls = (
-        InvalidParameter if public_error == INVALID_REQUEST
-        else DashScopeException
-    )
-    exc = exc_cls(f"{public_error.format_msg()} | Caused by: {summary}")
+    message = f"{public_error.format_msg()} | Caused by: {summary}"
+    if public_error == INVALID_REQUEST:
+        exc = InvalidParameter(message)
+    else:
+        exc = DashScopeException(message)
     exc.status_code = public_error.status_code
     exc.error_code = public_error.error_code
     return exc
@@ -192,13 +192,19 @@ def init(self, config_path: Optional[str] = None, **kwargs) -> Self:
         Initialize an AgenticRL instance from a YAML configuration file.
         """
         try:
-            self.tuning = TuningModel.load_from_yaml(config_path or "", **kwargs)
+            self.tuning = TuningModel.load_from_yaml(
+                config_path or "",
+                **kwargs,
+            )
         except Exception as e:
             _log_internal_error(SDK_AGENTIC_RL_CONFIGURATION_ERROR, e)
             # ``load_from_yaml`` reports a missing file and a malformed one
             # through the same IOErrorWithCode, and both are the caller's to
             # fix. An I/O failure deeper in a request stays a 500.
-            public_error = _get_public_error(e, input_errors=(IOErrorWithCode,))
+            public_error = _get_public_error(
+                e,
+                input_errors=(IOErrorWithCode,),
+            )
             raise _public_exception(public_error, e) from e
 
         return self

tests/unit/test_agentic_rl_init_errors.py

@@ -18,6 +18,7 @@
     PERMISSION_DENIED,
     REQUEST_TIMEOUT,
 )
+from dashscope.finetune import agentic_rl
 from dashscope.finetune.agentic_rl import (
     AgenticRL,
     _log_internal_error,
@@ -125,6 +126,21 @@ def test_log_message_has_no_unfilled_placeholder(self, mock_logger):
         assert rendered == "Invalid system configuration detected."
 
 
+class _Collect(logging.Handler):
+    """Collects records straight off the SDK logger.
+
+    ``caplog`` attaches at the root, and the SDK logger does not propagate, so
+    it sees nothing here.
+    """
+
+    def __init__(self, sink):
+        super().__init__(level=logging.ERROR)
+        self._sink = sink
+
+    def emit(self, record):
+        self._sink.append(record)
+
+
 class TestLogInternalError:
     def test_keeps_the_positional_log_shape(self):
         error_def = MagicMock()
@@ -168,17 +184,22 @@ def test_cause_is_logged_with_a_traceback(self):
         assert mock_logger.error.call_args[0][4] is cause
         assert mock_logger.error.call_args.kwargs["exc_info"] is True
 
-    def test_record_is_attributed_to_the_caller(self, caplog):
+    def test_record_is_attributed_to_the_caller(self):
         """Every handler logs through this helper, so without the stacklevel
         the record's location would be the same line for all five."""
         error_def = MagicMock()
         error_def.name = "sdk.agentic_rl.SomeFailure"
         error_def.format_message.return_value = "rendered"
+        records = []
+        handler = _Collect(records)
 
-        with caplog.at_level(logging.ERROR, logger="dashscope"):
+        agentic_rl.logger.addHandler(handler)
+        try:
             _log_internal_error(error_def, RuntimeErrorWithCode("boom"))
+        finally:
+            agentic_rl.logger.removeHandler(handler)
 
-        assert caplog.records[-1].funcName == (
+        assert records[-1].funcName == (
             "test_record_is_attributed_to_the_caller"
         )
 

tests/unit/test_agentstudio_protocol.py

@@ -352,7 +352,10 @@ def test_sdk_originated_codes_use_registry_namespace():
         "sdk.agentstudio.StreamClosedError"
     )
     # Timeout is a specialization of connection failure.
-    assert issubclass(exceptions.APITimeoutError, exceptions.APIConnectionError)
+    assert issubclass(
+        exceptions.APITimeoutError,
+        exceptions.APIConnectionError,
+    )
 
 
 def test_prerelease_error_code_shape_is_accepted():
@@ -367,16 +370,25 @@ def test_prerelease_error_code_shape_is_accepted():
 def test_camel_case_request_id_is_accepted():
     """unwrap() already translates requestId on the success path, so the
     error path must accept the same spelling."""
-    body = {"error": {"code": "api_error", "message": "boom"},
-            "requestId": "req_camel"}
+    body = {
+        "error": {"code": "api_error", "message": "boom"},
+        "requestId": "req_camel",
+    }
     err = exceptions.from_response(status_code=500, body=body)
     assert err.request_id == "req_camel"
     # snake_case still wins when both are present.
-    both = {"error": {"code": "api_error"},
-            "request_id": "req_snake", "requestId": "req_camel"}
-    assert exceptions.from_response(
-        status_code=500, body=both,
-    ).request_id == "req_snake"
+    both = {
+        "error": {"code": "api_error"},
+        "request_id": "req_snake",
+        "requestId": "req_camel",
+    }
+    assert (
+        exceptions.from_response(
+            status_code=500,
+            body=both,
+        ).request_id
+        == "req_snake"
+    )
 
 
 def test_recognized_code_outranks_status():
@@ -662,7 +674,7 @@ def test_exception_classes_are_reexported_from_package_root():
     other tests here import from the ``exceptions`` submodule, so only this one
     catches a repeat.
     """
-    import dashscope.agentstudio as agentstudio
+    from dashscope import agentstudio
 
     names = [
         "AgentStudioError",

tests/unit/test_error_detail_preserved.py

@@ -127,8 +127,8 @@ async def failing():
 
     def test_registry_text_is_still_present(self):
         async def failing():
+            yield 1
             raise ValueError("bad")
-            yield  # pragma: no cover
 
         response = list(iter_over_async(failing()))[-1]
 

tests/unit/test_error_registry_p0_regressions.py

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+# pylint: disable=protected-access
 """Regression tests for the two P0 defects fixed on dev/errors.
 
 P0-1: ``AioHttpRequest._handle_response`` yielded the result of the
@@ -129,9 +130,7 @@ def test_no_unawaited_coroutine_warning(self):
             asyncio.run(_collect(_make_request(), response))
 
         assert not [
-            w
-            for w in caught
-            if "never awaited" in str(w.message)
+            w for w in caught if "never awaited" in str(w.message)
         ], "error response coroutine was not awaited"
 
     def test_registry_has_no_external_field(self):

tests/unit/test_error_status_classification.py

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+# pylint: disable=protected-access
 """Failures must be reported with the status they actually mean.
 
 Three classification defects: a 403 WebSocket handshake was reported as a 401

tests/unit/test_sse_parse_error_consistency.py

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+# pylint: disable=protected-access
 """All four SSE parse-failure paths must report the same error.
 
 A body the SDK cannot parse is a server-side defect, not a bad request, so
@@ -51,9 +52,9 @@ def __init__(self):
 
 
 def _assert_unified(rsp):
-    assert rsp.status_code == HTTPStatus.INTERNAL_SERVER_ERROR, (
-        "an unparsable server body must not be reported as a client error"
-    )
+    assert (
+        rsp.status_code == HTTPStatus.INTERNAL_SERVER_ERROR
+    ), "an unparsable server body must not be reported as a client error"
     assert rsp.code == INTERNAL_ERROR.error_code
     assert MALFORMED in rsp.message, "the raw payload must reach the caller"
     assert "response data" not in rsp.message