refactor: clean up explicit-parameters refactor

- Remove dead code _get_protocol_params and its unused import;
  UA-merge logic now exists in a single place (_build_api_request)
- Extract _merge_recognition_params helper to deduplicate repeated
  recognition-parameter merge blocks in Recognition (3 sites) and
  TranslationRecognizerRealtime/Chat (5 sites)
- Use Optional[...] annotations for explicit parameters introduced
  by the refactor (factory, Application.call, recognition,
  translation_recognizer, tokenization)

Behavior unchanged; all 460 unit tests pass.

Author: zhansheng.lzs

dashscope/api_entities/api_request_factory.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 # Copyright (c) Alibaba, Inc. and its affiliates.
-from typing import Any, Dict, Union
+from typing import Any, Dict, Optional, Union
 from urllib.parse import urlencode
 
 import aiohttp
@@ -12,7 +12,6 @@
 from dashscope.api_entities.http_request import HttpRequest
 from dashscope.api_entities.websocket_request import WebSocketRequest
 from dashscope.common.constants import (
-    REQUEST_TIMEOUT_KEYWORD,
     SERVICE_API_PATH,
     ApiProtocol,
     HTTPMethod,
@@ -22,57 +21,6 @@
 from dashscope.protocol.websocket import WebsocketStreamingMode
 
 
-def _get_protocol_params(kwargs):
-    api_protocol = kwargs.pop("api_protocol", ApiProtocol.HTTPS)
-    ws_stream_mode = kwargs.pop("ws_stream_mode", WebsocketStreamingMode.OUT)
-    is_binary_input = kwargs.pop("is_binary_input", False)
-    http_method = kwargs.pop("http_method", HTTPMethod.POST)
-    stream = kwargs.get("stream", False)
-    if not stream and ws_stream_mode == WebsocketStreamingMode.OUT:
-        ws_stream_mode = WebsocketStreamingMode.NONE
-
-    async_request = kwargs.pop("async_request", False)
-    query = kwargs.pop("query", False)
-    headers = kwargs.pop("headers", None)
-    request_timeout = kwargs.pop(REQUEST_TIMEOUT_KEYWORD, None)
-    form = kwargs.pop("form", None)
-    resources = kwargs.pop("resources", None)
-    base_address = kwargs.pop("base_address", None)
-    flattened_output = kwargs.pop("flattened_output", False)
-    extra_url_parameters = kwargs.pop("extra_url_parameters", None)
-    session = kwargs.pop("session", None)
-
-    # Extract user_agent from kwargs (preferred) or from headers["user-agent"]
-    user_agent = kwargs.pop("user_agent", "")
-    if headers and "user-agent" in headers:
-        header_ua = headers.pop("user-agent")
-        if user_agent:
-            user_agent = (
-                f"{header_ua}; {user_agent}" if header_ua else user_agent
-            )
-        else:
-            user_agent = header_ua
-
-    return (
-        api_protocol,
-        ws_stream_mode,
-        is_binary_input,
-        http_method,
-        stream,
-        async_request,
-        query,
-        headers,
-        request_timeout,
-        form,
-        resources,
-        base_address,
-        flattened_output,
-        extra_url_parameters,
-        user_agent,
-        session,
-    )
-
-
 def _build_api_request(  # pylint: disable=too-many-branches
     # pylint: disable=too-many-arguments,too-many-locals
     model: str,
@@ -87,23 +35,23 @@ def _build_api_request(  # pylint: disable=too-many-branches
     http_method: HTTPMethod = HTTPMethod.POST,
     stream: bool = False,
     async_request: bool = False,
-    request_timeout: int = None,
+    request_timeout: Optional[int] = None,
     # WebSocket specific
     ws_stream_mode: WebsocketStreamingMode = WebsocketStreamingMode.OUT,
     is_binary_input: bool = False,
     # HTTP specific
     query: bool = False,
-    headers: Dict[str, str] = None,
-    form: Dict = None,
-    resources: Dict = None,
-    base_address: str = None,
+    headers: Optional[Dict[str, str]] = None,
+    form: Optional[Dict] = None,
+    resources: Optional[Dict] = None,
+    base_address: Optional[str] = None,
     flattened_output: bool = False,
-    extra_url_parameters: Dict[str, Any] = None,
+    extra_url_parameters: Optional[Dict[str, Any]] = None,
     user_agent: str = "",
-    session: Union[requests.Session, aiohttp.ClientSession] = None,
-    task_id: str = None,
+    session: Optional[Union[requests.Session, aiohttp.ClientSession]] = None,
+    task_id: Optional[str] = None,
     enable_encryption: bool = False,
-    pre_task_id: str = None,
+    pre_task_id: Optional[str] = None,
     # Additional parameters for API request data
     **kwargs,
 ):

dashscope/app/application.py

@@ -6,7 +6,7 @@
 @Desc    :   Application calls for both http and http sse
 """
 import copy
-from typing import Any, Dict, Generator, List, Union
+from typing import Any, Dict, Generator, List, Optional, Union
 
 from dashscope.api_entities.api_request_factory import _build_api_request
 from dashscope.api_entities.dashscope_response import Message, Role
@@ -63,21 +63,21 @@ def call(  # type: ignore[override]
         workspace: str = None,
         api_key: str = None,
         messages: List[Message] = None,
-        stream: bool = None,
-        temperature: float = None,
-        top_p: float = None,
-        top_k: int = None,
-        seed: int = None,
-        session_id: str = None,
-        biz_params: Dict[str, Any] = None,
-        has_thoughts: bool = None,
-        doc_tag_codes: List[str] = None,
-        doc_reference_type: str = None,
-        memory_id: str = None,
-        image_list: List[str] = None,
-        file_list: List[str] = None,
-        rag_options: Dict[str, Any] = None,
-        incremental_output: bool = None,
+        stream: Optional[bool] = None,
+        temperature: Optional[float] = None,
+        top_p: Optional[float] = None,
+        top_k: Optional[int] = None,
+        seed: Optional[int] = None,
+        session_id: Optional[str] = None,
+        biz_params: Optional[Dict[str, Any]] = None,
+        has_thoughts: Optional[bool] = None,
+        doc_tag_codes: Optional[List[str]] = None,
+        doc_reference_type: Optional[str] = None,
+        memory_id: Optional[str] = None,
+        image_list: Optional[List[str]] = None,
+        file_list: Optional[List[str]] = None,
+        rag_options: Optional[Dict[str, Any]] = None,
+        incremental_output: Optional[bool] = None,
         **kwargs,
     ) -> Union[
         ApplicationResponse,

dashscope/audio/asr/recognition.py

@@ -10,7 +10,7 @@
 from http import HTTPStatus
 from queue import Queue
 from threading import Timer
-from typing import Any, Dict, List, Union
+from typing import Any, Dict, List, Optional, Union
 
 from dashscope.api_entities.dashscope_response import RecognitionResponse
 from dashscope.client.base_api import BaseApi
@@ -27,6 +27,36 @@
 from dashscope.protocol.websocket import WebsocketStreamingMode
 
 
+def _merge_recognition_params(
+    kwargs: Dict[str, Any],
+    disfluency_removal_enabled: Optional[bool],
+    diarization_enabled: Optional[bool],
+    speaker_count: Optional[int],
+    timestamp_alignment_enabled: Optional[bool],
+    special_word_filter: Optional[str],
+    audio_event_detection_enabled: Optional[bool],
+) -> Dict[str, Any]:
+    """Merge explicit recognition parameters into ``kwargs`` in place.
+
+    Only parameters that are not None are written, so callers can pass
+    through values that the user did not set.
+
+    Returns:
+        The merged ``kwargs`` dict (the same object).
+    """
+    for key, value in (
+        ("disfluency_removal_enabled", disfluency_removal_enabled),
+        ("diarization_enabled", diarization_enabled),
+        ("speaker_count", speaker_count),
+        ("timestamp_alignment_enabled", timestamp_alignment_enabled),
+        ("special_word_filter", special_word_filter),
+        ("audio_event_detection_enabled", audio_event_detection_enabled),
+    ):
+        if value is not None:
+            kwargs[key] = value
+    return kwargs
+
+
 class RecognitionResult(RecognitionResponse):
     """The result set of speech recognition, including the single-sentence
     recognition result returned by the callback mode, and all recognition
@@ -166,12 +196,12 @@ def __init__(
         sample_rate: int,
         workspace: str = None,
         # Recognition parameters
-        disfluency_removal_enabled: bool = None,
-        diarization_enabled: bool = None,
-        speaker_count: int = None,
-        timestamp_alignment_enabled: bool = None,
-        special_word_filter: str = None,
-        audio_event_detection_enabled: bool = None,
+        disfluency_removal_enabled: Optional[bool] = None,
+        diarization_enabled: Optional[bool] = None,
+        speaker_count: Optional[int] = None,
+        timestamp_alignment_enabled: Optional[bool] = None,
+        special_word_filter: Optional[str] = None,
+        audio_event_detection_enabled: Optional[bool] = None,
         **kwargs,
     ):
         if model is None:
@@ -193,24 +223,15 @@ def __init__(
         self._silence_timer = None
         self._kwargs = kwargs
         # Store recognition parameters
-        if disfluency_removal_enabled is not None:
-            self._kwargs[
-                "disfluency_removal_enabled"
-            ] = disfluency_removal_enabled
-        if diarization_enabled is not None:
-            self._kwargs["diarization_enabled"] = diarization_enabled
-        if speaker_count is not None:
-            self._kwargs["speaker_count"] = speaker_count
-        if timestamp_alignment_enabled is not None:
-            self._kwargs[
-                "timestamp_alignment_enabled"
-            ] = timestamp_alignment_enabled
-        if special_word_filter is not None:
-            self._kwargs["special_word_filter"] = special_word_filter
-        if audio_event_detection_enabled is not None:
-            self._kwargs[
-                "audio_event_detection_enabled"
-            ] = audio_event_detection_enabled
+        _merge_recognition_params(
+            self._kwargs,
+            disfluency_removal_enabled,
+            diarization_enabled,
+            speaker_count,
+            timestamp_alignment_enabled,
+            special_word_filter,
+            audio_event_detection_enabled,
+        )
         self._workspace = workspace
         self._start_stream_timestamp = -1
         self._first_package_timestamp = -1
@@ -348,12 +369,12 @@ def start(
         self,
         phrase_id: str = None,
         # Recognition parameters
-        disfluency_removal_enabled: bool = None,
-        diarization_enabled: bool = None,
-        speaker_count: int = None,
-        timestamp_alignment_enabled: bool = None,
-        special_word_filter: str = None,
-        audio_event_detection_enabled: bool = None,
+        disfluency_removal_enabled: Optional[bool] = None,
+        diarization_enabled: Optional[bool] = None,
+        speaker_count: Optional[int] = None,
+        timestamp_alignment_enabled: Optional[bool] = None,
+        special_word_filter: Optional[str] = None,
+        audio_event_detection_enabled: Optional[bool] = None,
         **kwargs,
     ):
         """Real-time speech recognition in asynchronous mode.
@@ -392,24 +413,15 @@ def start(
         self._on_complete_timestamp = -1
         self._phrase = phrase_id
         # Update recognition parameters
-        if disfluency_removal_enabled is not None:
-            self._kwargs[
-                "disfluency_removal_enabled"
-            ] = disfluency_removal_enabled
-        if diarization_enabled is not None:
-            self._kwargs["diarization_enabled"] = diarization_enabled
-        if speaker_count is not None:
-            self._kwargs["speaker_count"] = speaker_count
-        if timestamp_alignment_enabled is not None:
-            self._kwargs[
-                "timestamp_alignment_enabled"
-            ] = timestamp_alignment_enabled
-        if special_word_filter is not None:
-            self._kwargs["special_word_filter"] = special_word_filter
-        if audio_event_detection_enabled is not None:
-            self._kwargs[
-                "audio_event_detection_enabled"
-            ] = audio_event_detection_enabled
+        _merge_recognition_params(
+            self._kwargs,
+            disfluency_removal_enabled,
+            diarization_enabled,
+            speaker_count,
+            timestamp_alignment_enabled,
+            special_word_filter,
+            audio_event_detection_enabled,
+        )
         self._kwargs.update(**kwargs)
         self._recognition_once = False
         self._worker = threading.Thread(target=self.__receive_worker)
@@ -434,12 +446,12 @@ def call(  # type: ignore[override]  # noqa: E501
         file: str,
         phrase_id: str = None,
         # Recognition parameters
-        disfluency_removal_enabled: bool = None,
-        diarization_enabled: bool = None,
-        speaker_count: int = None,
-        timestamp_alignment_enabled: bool = None,
-        special_word_filter: str = None,
-        audio_event_detection_enabled: bool = None,
+        disfluency_removal_enabled: Optional[bool] = None,
+        diarization_enabled: Optional[bool] = None,
+        speaker_count: Optional[int] = None,
+        timestamp_alignment_enabled: Optional[bool] = None,
+        special_word_filter: Optional[str] = None,
+        audio_event_detection_enabled: Optional[bool] = None,
         **kwargs,
     ) -> RecognitionResult:
         """Real-time speech recognition in synchronous mode.
@@ -482,24 +494,15 @@ def call(  # type: ignore[override]  # noqa: E501
         self._stream_data = Queue()
         self._phrase = phrase_id
         # Update recognition parameters
-        if disfluency_removal_enabled is not None:
-            self._kwargs[
-                "disfluency_removal_enabled"
-            ] = disfluency_removal_enabled
-        if diarization_enabled is not None:
-            self._kwargs["diarization_enabled"] = diarization_enabled
-        if speaker_count is not None:
-            self._kwargs["speaker_count"] = speaker_count
-        if timestamp_alignment_enabled is not None:
-            self._kwargs[
-                "timestamp_alignment_enabled"
-            ] = timestamp_alignment_enabled
-        if special_word_filter is not None:
-            self._kwargs["special_word_filter"] = special_word_filter
-        if audio_event_detection_enabled is not None:
-            self._kwargs[
-                "audio_event_detection_enabled"
-            ] = audio_event_detection_enabled
+        _merge_recognition_params(
+            self._kwargs,
+            disfluency_removal_enabled,
+            diarization_enabled,
+            speaker_count,
+            timestamp_alignment_enabled,
+            special_word_filter,
+            audio_event_detection_enabled,
+        )
         self._kwargs.update(**kwargs)
         error_flag: bool = False
         sentences: List[Any] = []