dashscope 1.21.0__py3-none-any.whl → 1.22.1__py3-none-any.whl

dashscope/aigc/chat_completion.py

@@ -0,0 +1,271 @@
+import json
+from typing import Any, Dict, Generator, List, Union
+
+import dashscope
+from dashscope.api_entities.dashscope_response import (GenerationResponse,
+                                                       Message)
+from dashscope.client.base_api import BaseAioApi, CreateMixin
+from dashscope.common import constants
+from dashscope.common.error import InputRequired, ModelRequired
+from dashscope.common.utils import _get_task_group_and_task
+from dashscope.api_entities.chat_completion_types import ChatCompletion, ChatCompletionChunk
+
+
+class Completions(CreateMixin):
+    """Support openai compatible chat completion interface.
+
+    """
+    SUB_PATH = ''
+    @classmethod
+    def create(
+        cls,
+        *,
+        model: str,
+        messages: List[Message],
+        stream: bool = False,
+        temperature: float = None,
+        top_p: float = None,
+        top_k: int = None,
+        stop: Union[List[str], List[List[int]]] = None,
+        max_tokens: int = None,
+        repetition_penalty: float = None,
+        api_key: str = None,
+        workspace: str = None,
+        extra_headers: Dict = None,
+        extra_body: Dict = None,
+        **kwargs
+    ) -> Union[ChatCompletion, Generator[ChatCompletionChunk, None, None]]:
+        """Call openai compatible chat completion model service.
+
+        Args:
+            model (str): The requested model, such as qwen-long
+            messages (list): The generation messages.
+                examples:
+                    [{'role': 'user',
+                      'content': 'The weather is fine today.'},
+                      {'role': 'assistant', 'content': 'Suitable for outings'}]
+            stream(bool, `optional`): Enable server-sent events
+                (ref: https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events)  # noqa E501
+                the result will back partially[qwen-turbo,bailian-v1].
+            temperature(float, `optional`): Used to control the degree
+                of randomness and diversity. Specifically, the temperature
+                value controls the degree to which the probability distribution
+                of each candidate word is smoothed when generating text.
+                A higher temperature value will reduce the peak value of
+                the probability, allowing more low-probability words to be
+                selected, and the generated results will be more diverse;
+                while a lower temperature value will enhance the peak value
+                of the probability, making it easier for high-probability
+                words to be selected, the generated results are more
+                deterministic.
+            top_p(float, `optional`): A sampling strategy, called nucleus
+                sampling, where the model considers the results of the
+                tokens with top_p probability mass. So 0.1 means only
+                the tokens comprising the top 10% probability mass are
+                considered.
+            top_k(int, `optional`): The size of the sample candidate set when generated.  # noqa E501
+                For example, when the value is 50, only the 50 highest-scoring tokens  # noqa E501
+                in a single generation form a randomly sampled candidate set. # noqa E501
+                The larger the value, the higher the randomness generated;  # noqa E501
+                the smaller the value, the higher the certainty generated. # noqa E501
+                The default value is 0, which means the top_k policy is  # noqa E501
+                not enabled. At this time, only the top_p policy takes effect. # noqa E501
+            stop(list[str] or list[list[int]], `optional`): Used to control the generation to stop  # noqa E501
+                when encountering setting str or token ids, the result will not include # noqa E501
+                stop words or tokens.
+            max_tokens(int, `optional`): The maximum token num expected to be output. It should be # noqa E501
+                noted that the length generated by the model will only be less than max_tokens,  # noqa E501
+                not necessarily equal to it. If max_tokens is set too large, the service will # noqa E501
+                directly prompt that the length exceeds the limit. It is generally # noqa E501
+                not recommended to set this value.
+            repetition_penalty(float, `optional`): Used to control the repeatability when generating models.  # noqa E501
+                Increasing repetition_penalty can reduce the duplication of model generation.  # noqa E501
+                1.0 means no punishment.
+            api_key (str, optional): The api api_key, can be None,
+                if None, will get by default rule.
+            workspace (str, optional): The bailian workspace id.
+            **kwargs:
+                timeout: set request timeout.
+        Raises:
+            InvalidInput: The history and auto_history are mutually exclusive.
+
+        Returns:
+            Union[ChatCompletion,
+                  Generator[ChatCompletionChunk, None, None]]: If
+            stream is True, return Generator, otherwise ChatCompletion.
+        """
+        if messages is None or not messages:
+            raise InputRequired('Messages is required!')
+        if model is None or not model:
+            raise ModelRequired('Model is required!')
+        data = {}
+        data['model'] = model
+        data['messages'] = messages
+        if temperature is not None:
+            data['temperature'] = temperature
+        if top_p is not None:
+            data['top_p'] = top_p
+        if top_k is not None:
+            data['top_k'] = top_k
+        if stop is not None:
+            data['stop'] = stop
+        if max_tokens is not None:
+            data[max_tokens] = max_tokens
+        if repetition_penalty is not None:
+            data['repetition_penalty'] = repetition_penalty
+        if extra_body is not None and extra_body:
+            data = {**data, **extra_body}
+        
+        if extra_headers is not None and extra_headers:
+            kwargs = {'headers': extra_headers} if kwargs else {**kwargs, **{'headers': extra_headers}}
+
+        response = super().call(data=data,
+                                path='chat/completions',
+                                base_address=dashscope.base_compatible_api_url,
+                                api_key=api_key,
+                                flattened_output=True,
+                                stream=stream,
+                                workspace=workspace,
+                                **kwargs)
+        if stream:
+            return (ChatCompletionChunk(**item) for _, item in response)
+        else:
+            return ChatCompletion(**response)
+
+
+class AioGeneration(BaseAioApi):
+    task = 'text-generation'
+    """API for AI-Generated Content(AIGC) models.
+
+    """
+    class Models:
+        """@deprecated, use qwen_turbo instead"""
+        qwen_v1 = 'qwen-v1'
+        """@deprecated, use qwen_plus instead"""
+        qwen_plus_v1 = 'qwen-plus-v1'
+
+        bailian_v1 = 'bailian-v1'
+        dolly_12b_v2 = 'dolly-12b-v2'
+        qwen_turbo = 'qwen-turbo'
+        qwen_plus = 'qwen-plus'
+        qwen_max = 'qwen-max'
+
+    @classmethod
+    async def call(
+        cls,
+        model: str,
+        prompt: Any = None,
+        history: list = None,
+        api_key: str = None,
+        messages: List[Message] = None,
+        plugins: Union[str, Dict[str, Any]] = None,
+        workspace: str = None,
+        **kwargs
+    ) -> Union[GenerationResponse, Generator[GenerationResponse, None, None]]:
+        """Call generation model service.
+
+        Args:
+            model (str): The requested model, such as qwen-turbo
+            prompt (Any): The input prompt.
+            history (list):The user provided history, deprecated
+                examples:
+                    [{'user':'The weather is fine today.',
+                    'bot': 'Suitable for outings'}].
+                Defaults to None.
+            api_key (str, optional): The api api_key, can be None,
+                if None, will get by default rule(TODO: api key doc).
+            messages (list): The generation messages.
+                examples:
+                    [{'role': 'user',
+                      'content': 'The weather is fine today.'},
+                      {'role': 'assistant', 'content': 'Suitable for outings'}]
+            plugins (Any): The plugin config. Can be plugins config str, or dict.
+            **kwargs:
+                stream(bool, `optional`): Enable server-sent events
+                    (ref: https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events)  # noqa E501
+                    the result will back partially[qwen-turbo,bailian-v1].
+                temperature(float, `optional`): Used to control the degree
+                    of randomness and diversity. Specifically, the temperature
+                    value controls the degree to which the probability distribution
+                    of each candidate word is smoothed when generating text.
+                    A higher temperature value will reduce the peak value of
+                    the probability, allowing more low-probability words to be
+                    selected, and the generated results will be more diverse;
+                    while a lower temperature value will enhance the peak value
+                    of the probability, making it easier for high-probability
+                    words to be selected, the generated results are more
+                    deterministic, range(0, 2) .[qwen-turbo,qwen-plus].
+                top_p(float, `optional`): A sampling strategy, called nucleus
+                    sampling, where the model considers the results of the
+                    tokens with top_p probability mass. So 0.1 means only
+                    the tokens comprising the top 10% probability mass are
+                    considered[qwen-turbo,bailian-v1].
+                top_k(int, `optional`): The size of the sample candidate set when generated.  # noqa E501
+                    For example, when the value is 50, only the 50 highest-scoring tokens  # noqa E501
+                    in a single generation form a randomly sampled candidate set. # noqa E501
+                    The larger the value, the higher the randomness generated;  # noqa E501
+                    the smaller the value, the higher the certainty generated. # noqa E501
+                    The default value is 0, which means the top_k policy is  # noqa E501
+                    not enabled. At this time, only the top_p policy takes effect. # noqa E501
+                enable_search(bool, `optional`): Whether to enable web search(quark).  # noqa E501
+                    Currently works best only on the first round of conversation.
+                    Default to False, support model: [qwen-turbo].
+                customized_model_id(str, required) The enterprise-specific
+                    large model id, which needs to be generated from the
+                    operation background of the enterprise-specific
+                    large model product, support model: [bailian-v1].
+                result_format(str, `optional`): [message|text] Set result result format. # noqa E501
+                    Default result is text
+                incremental_output(bool, `optional`): Used to control the streaming output mode. # noqa E501
+                    If true, the subsequent output will include the previously input content. # noqa E501
+                    Otherwise, the subsequent output will not include the previously output # noqa E501
+                    content. Default false.
+                stop(list[str] or list[list[int]], `optional`): Used to control the generation to stop  # noqa E501
+                    when encountering setting str or token ids, the result will not include # noqa E501
+                    stop words or tokens.
+                max_tokens(int, `optional`): The maximum token num expected to be output. It should be # noqa E501
+                    noted that the length generated by the model will only be less than max_tokens,  # noqa E501
+                    not necessarily equal to it. If max_tokens is set too large, the service will # noqa E501
+                    directly prompt that the length exceeds the limit. It is generally # noqa E501
+                    not recommended to set this value.
+                repetition_penalty(float, `optional`): Used to control the repeatability when generating models.  # noqa E501
+                    Increasing repetition_penalty can reduce the duplication of model generation.  # noqa E501
+                    1.0 means no punishment.
+            workspace (str): The dashscope workspace id.
+        Raises:
+            InvalidInput: The history and auto_history are mutually exclusive.
+
+        Returns:
+            Union[GenerationResponse,
+                  Generator[GenerationResponse, None, None]]: If
+            stream is True, return Generator, otherwise GenerationResponse.
+        """
+        if (prompt is None or not prompt) and (messages is None
+                                               or not messages):
+            raise InputRequired('prompt or messages is required!')
+        if model is None or not model:
+            raise ModelRequired('Model is required!')
+        task_group, function = _get_task_group_and_task(__name__)
+        if plugins is not None:
+            headers = kwargs.pop('headers', {})
+            if isinstance(plugins, str):
+                headers['X-DashScope-Plugin'] = plugins
+            else:
+                headers['X-DashScope-Plugin'] = json.dumps(plugins)
+            kwargs['headers'] = headers
+        input, parameters = Generation._build_input_parameters(
+            model, prompt, history, messages, **kwargs)
+        response = await super().call(model=model,
+                                      task_group=task_group,
+                                      task=Generation.task,
+                                      function=function,
+                                      api_key=api_key,
+                                      input=input,
+                                      workspace=workspace,
+                                      **parameters)
+        is_stream = kwargs.get('stream', False)
+        if is_stream:
+            return (GenerationResponse.from_api_response(rsp)
+                    async for rsp in response)
+        else:
+            return GenerationResponse.from_api_response(response)

dashscope/api_entities/aiohttp_request.py

@@ -2,7 +2,6 @@ import json
 from http import HTTPStatus
 
 import aiohttp
-
 from dashscope.api_entities.base_request import AioBaseRequest
 from dashscope.api_entities.dashscope_response import DashScopeAPIResponse
 from dashscope.common.constants import (DEFAULT_REQUEST_TIMEOUT_SECONDS,

dashscope/api_entities/api_request_data.py

@@ -2,7 +2,6 @@ import json
 from urllib.parse import urlencode
 
 import aiohttp
-
 from dashscope.common.constants import ApiProtocol
 from dashscope.io.input_output import InputResolver
 

dashscope/api_entities/api_request_factory.py

@@ -81,13 +81,15 @@ def _build_api_request(model: str,
             websocket_url = base_address
         else:
             websocket_url = dashscope.base_websocket_api_url
+        pre_task_id = kwargs.pop('pre_task_id', None)
         request = WebSocketRequest(url=websocket_url,
                                    api_key=api_key,
                                    stream=stream,
                                    ws_stream_mode=ws_stream_mode,
                                    is_binary_input=is_binary_input,
                                    timeout=request_timeout,
-                                   flattened_output=flattened_output)
+                                   flattened_output=flattened_output,
+                                   pre_task_id=pre_task_id)
     else:
         raise UnsupportedApiProtocol(
             'Unsupported protocol: %s, support [http, https, websocket]' %

dashscope/api_entities/chat_completion_types.py

@@ -0,0 +1,349 @@
+# adapter from openai sdk
+from dataclasses import dataclass
+from typing import Dict, List, Literal, Optional
+
+from dashscope.common.base_type import BaseObjectMixin
+"""
+{
+    "choices": [
+        {
+            "message": {
+                "role": "assistant",
+                "content": "很抱歉，由于您提供的信息不完整，我无法直接比较两篇文章的内容。但是，一般而言，大型语言模型的训练通常确实涉及两个主要阶段：\n\n1. **预训练阶段 (Pre-Training Phase)**：在这个阶段，模型在大规模无标注文本数据集（如互联网上的网页、书籍、新闻等）上进行训练。目的是让模型学习语言的通用模式和结构。常见的预训练技术包括自回归（Autoregressive）模型如GPT系列，以及transformer架构下的编码器-解码器模型如BERT系列。\n\n2. **微调阶段 (Fine-Tuning Phase)**：预训练模型在特定任务的数据集上进行进一步训练，以适应下游任务，如问答、文本分类、机器翻译等。这个阶段允许模型根据具体任务的需求调整权重，从而提高性能。\n\n如果您能提供更详细的信息或两篇文章的具体内容，我可以给出更准确的比较分析。"
+            },
+            "finish_reason": "stop",
+            "index": 0,
+            "logprobs": null
+        }
+    ],
+    "object": "chat.completion",
+    "usage": {
+        "prompt_tokens": 66,
+        "completion_tokens": 195,
+        "total_tokens": 261
+    },
+    "created": 1716539630,
+    "system_fingerprint": null,
+    "model": "qwen-long",
+    "id": "chatcmpl-a737071790e091c6be016ea27a891392",
+    "status_code": 200
+}
+"""
+
+@dataclass(init=False)
+class CompletionUsage(BaseObjectMixin):
+    completion_tokens: int
+    """Number of tokens in the generated completion."""
+
+    prompt_tokens: int
+    """Number of tokens in the prompt."""
+
+    total_tokens: int
+    """Total number of tokens used in the request (prompt + completion)."""
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+@dataclass(init=False)
+class TopLogprob(BaseObjectMixin):
+    token: str
+    """The token."""
+
+    bytes: Optional[List[int]] = None
+    """A list of integers representing the UTF-8 bytes representation of the token.
+
+    Useful in instances where characters are represented by multiple tokens and
+    their byte representations must be combined to generate the correct text
+    representation. Can be `null` if there is no bytes representation for the token.
+    """
+
+    logprob: float
+    """The log probability of this token, if it is within the top 20 most likely
+    tokens.
+
+    Otherwise, the value `-9999.0` is used to signify that the token is very
+    unlikely.
+    """
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+@dataclass(init=False)
+class ChatCompletionTokenLogprob(BaseObjectMixin):
+    token: str
+    """The token."""
+
+    bytes: Optional[List[int]] = None
+    """A list of integers representing the UTF-8 bytes representation of the token.
+
+    Useful in instances where characters are represented by multiple tokens and
+    their byte representations must be combined to generate the correct text
+    representation. Can be `null` if there is no bytes representation for the token.
+    """
+
+    logprob: float
+    """The log probability of this token, if it is within the top 20 most likely
+    tokens.
+
+    Otherwise, the value `-9999.0` is used to signify that the token is very
+    unlikely.
+    """
+
+    top_logprobs: List[TopLogprob]
+    """List of the most likely tokens and their log probability, at this token
+    position.
+
+    In rare cases, there may be fewer than the number of requested `top_logprobs`
+    returned.
+    """
+    def __init__(self, **kwargs):
+        if 'top_logprobs' in kwargs and kwargs['top_logprobs'] is not None and kwargs['top_logprobs']:
+            top_logprobs = []
+            for logprob in kwargs['top_logprobs']:
+                top_logprobs.append(ChatCompletionTokenLogprob(**logprob))
+            self.top_logprobs = top_logprobs
+        else:
+            self.top_logprobs = None
+                
+        super().__init__(**kwargs)
+        
+   
+@dataclass(init=False)
+class ChoiceLogprobs(BaseObjectMixin):
+    content: Optional[List[ChatCompletionTokenLogprob]] = None
+    """A list of message content tokens with log probability information."""
+    def __init__(self, **kwargs):
+        if 'content' in kwargs and kwargs['content'] is not None and kwargs['content']:
+            logprobs = []
+            for logprob in kwargs['content']:
+                logprobs.append(ChatCompletionTokenLogprob(**logprob))
+            self.content = logprobs
+        else:
+            self.content = None
+                
+        super().__init__(**kwargs)
+
+@dataclass(init=False)
+class FunctionCall(BaseObjectMixin):
+    arguments: str
+    """
+    The arguments to call the function with, as generated by the model in JSON
+    format. Note that the model does not always generate valid JSON, and may
+    hallucinate parameters not defined by your function schema. Validate the
+    arguments in your code before calling your function.
+    """
+
+    name: str
+    """The name of the function to call."""
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+@dataclass(init=False)
+class Function(BaseObjectMixin):
+    arguments: str
+    """
+    The arguments to call the function with, as generated by the model in JSON
+    format. Note that the model does not always generate valid JSON, and may
+    hallucinate parameters not defined by your function schema. Validate the
+    arguments in your code before calling your function.
+    """
+
+    name: str
+    """The name of the function to call."""
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+@dataclass(init=False)
+class ChatCompletionMessageToolCall(BaseObjectMixin):
+    id: str
+    """The ID of the tool call."""
+
+    function: Function
+    """The function that the model called."""
+
+    type: Literal["function"]
+    """The type of the tool. Currently, only `function` is supported."""
+    def __init__(self, **kwargs):
+        if 'function' in kwargs and kwargs['function'] is not None and kwargs['function']:
+            self.function = Function(**kwargs.pop('function', {}))
+        else:
+            function = None
+                
+        super().__init__(**kwargs)
+    
+@dataclass(init=False)
+class ChatCompletionMessage(BaseObjectMixin):
+    content: Optional[str] = None
+    """The contents of the message."""
+
+    role: Literal["assistant"]
+    """The role of the author of this message."""
+
+    function_call: Optional[FunctionCall] = None
+    """Deprecated and replaced by `tool_calls`.
+
+    The name and arguments of a function that should be called, as generated by the
+    model.
+    """
+
+    tool_calls: Optional[List[ChatCompletionMessageToolCall]] = None
+    
+    """The tool calls generated by the model, such as function calls."""
+    def __init__(self, **kwargs):
+        if 'function_call' in kwargs and kwargs['function_call'] is not None and kwargs['function_call']:
+            self.function_call = FunctionCall(**kwargs.pop('function_call', {}))
+        
+        if 'tool_calls' in kwargs and kwargs['tool_calls'] is not None and kwargs['tool_calls']:
+            tool_calls = []
+            for tool_call in kwargs['tool_calls']:
+                tool_calls.append(ChatCompletionMessageToolCall(**tool_call))
+            self.tool_calls = tool_calls
+                
+        super().__init__(**kwargs)
+    
+@dataclass(init=False)
+class Choice(BaseObjectMixin):
+    finish_reason: Literal["stop", "length", "tool_calls", "content_filter", "function_call"]
+    """The reason the model stopped generating tokens.
+
+    This will be `stop` if the model hit a natural stop point or a provided stop
+    sequence, `length` if the maximum number of tokens specified in the request was
+    reached, `content_filter` if content was omitted due to a flag from our content
+    filters, `tool_calls` if the model called a tool, or `function_call`
+    (deprecated) if the model called a function.
+    """
+
+    index: int
+    """The index of the choice in the list of choices."""
+
+    logprobs: Optional[ChoiceLogprobs] = None
+    """Log probability information for the choice."""
+
+    message: ChatCompletionMessage
+    """A chat completion message generated by the model."""
+    
+    def __init__(self, **kwargs):
+        if 'message' in kwargs and kwargs['message'] is not None and kwargs['message']:
+            self.message = ChatCompletionMessage(**kwargs.pop('message', {}))
+        else:
+            self.message = None
+        
+        if 'logprobs' in kwargs and kwargs['logprobs'] is not None and kwargs['logprobs']:
+            self.logprobs = ChoiceLogprobs(**kwargs.pop('logprobs', {}))
+
+        super().__init__(**kwargs)
+    
+@dataclass(init=False)
+class ChatCompletion(BaseObjectMixin):
+    status_code: int
+    """The call response status_code, 200 indicate create success.
+    """
+    code: str
+    """The request failed, this is the error code.
+    """
+    message: str
+    """The request failed, this is the error message.
+    """
+    id: str
+    """A unique identifier for the chat completion.
+    """
+    choices: List[Choice]
+    """A list of chat completion choices.
+
+    Can be more than one if `n` is greater than 1.
+    """
+
+    created: int
+    """The Unix timestamp (in seconds) of when the chat completion was created."""
+
+    model: str
+    """The model used for the chat completion."""
+
+    object: Literal["chat.completion"]
+    """The object type, which is always `chat.completion`."""
+
+    system_fingerprint: Optional[str] = None
+    """This fingerprint represents the backend configuration that the model runs with.
+
+    Can be used in conjunction with the `seed` request parameter to understand when
+    backend changes have been made that might impact determinism.
+    """
+
+    usage: Optional[CompletionUsage] = None
+    """Usage statistics for the completion request."""
+    
+    def __init__(self, **kwargs):
+        if 'usage' in kwargs and kwargs['usage'] is not None and kwargs['usage']:
+            self.usage = CompletionUsage(**kwargs.pop('usage', {}))
+        else:
+            self.usage = None
+        
+        if 'choices' in kwargs and kwargs['choices'] is not None and kwargs['choices']:
+            choices = []
+            for choice in kwargs.pop('choices', []):
+                choices.append(Choice(**choice))
+            self.choices = choices
+        else:
+            self.choices = None
+        super().__init__(**kwargs)
+        
+@dataclass(init=False)
+class ChatCompletionChunk(BaseObjectMixin):
+    status_code: int
+    """The call response status_code, 200 indicate create success.
+    """
+    code: str
+    """The request failed, this is the error code.
+    """
+    message: str
+    """The request failed, this is the error message.
+    """
+    id: str
+    """A unique identifier for the chat completion. Each chunk has the same ID."""
+
+    choices: List[Choice]
+    """A list of chat completion choices.
+
+    Can contain more than one elements if `n` is greater than 1. Can also be empty
+    for the last chunk if you set `stream_options: {"include_usage": true}`.
+    """
+
+    created: int
+    """The Unix timestamp (in seconds) of when the chat completion was created.
+
+    Each chunk has the same timestamp.
+    """
+
+    model: str
+    """The model to generate the completion."""
+
+    object: Literal["chat.completion.chunk"]
+    """The object type, which is always `chat.completion.chunk`."""
+
+    system_fingerprint: Optional[str] = None
+    """
+    This fingerprint represents the backend configuration that the model runs with.
+    Can be used in conjunction with the `seed` request parameter to understand when
+    backend changes have been made that might impact determinism.
+    """
+
+    usage: Optional[CompletionUsage] = None
+    """
+    An optional field that will only be present when you set
+    `stream_options: {"include_usage": true}` in your request. When present, it
+    contains a null value except for the last chunk which contains the token usage
+    statistics for the entire request.
+    """
+    def __init__(self, **kwargs):
+        if 'usage' in kwargs and kwargs['usage'] is not None and kwargs['usage']:
+            self.usage = CompletionUsage(**kwargs.pop('usage', {}))
+        else:
+            self.usage = None
+        
+        if 'choices' in kwargs and kwargs['choices'] is not None and kwargs['choices']:
+            choices = []
+            for choice in kwargs.pop('choices', []):
+                choices.append(Choice(**choice))
+            self.choices = choices
+        else:
+            self.choices = None
+        super().__init__(**kwargs)
+    

dashscope/api_entities/dashscope_response.py

@@ -480,7 +480,7 @@ class VideoSynthesisOutput(DictMixin):
 class ImageSynthesisUsage(DictMixin):
     image_count: int
 
-    def __init__(self, image_count: int, **kwargs):
+    def __init__(self, image_count: int = None, **kwargs):
         super().__init__(image_count=image_count, **kwargs)
 
 

dashscope/api_entities/http_request.py

@@ -3,7 +3,6 @@ from http import HTTPStatus
 
 import aiohttp
 import requests
-
 from dashscope.api_entities.base_request import AioBaseRequest
 from dashscope.api_entities.dashscope_response import DashScopeAPIResponse
 from dashscope.common.constants import (DEFAULT_REQUEST_TIMEOUT_SECONDS,