dashscope 1.14.1__py3-none-any.whl → 1.16.0__py3-none-any.whl

dashscope/__init__.py

@@ -6,6 +6,7 @@ from dashscope.aigc.conversation import Conversation, History, HistoryItem
 from dashscope.aigc.generation import Generation
 from dashscope.aigc.image_synthesis import ImageSynthesis
 from dashscope.aigc.multimodal_conversation import MultiModalConversation
+from dashscope.app.application import Application
 from dashscope.audio.asr.transcription import Transcription
 from dashscope.audio.tts.speech_synthesizer import SpeechSynthesizer
 from dashscope.common.api_key import save_api_key
@@ -23,18 +24,43 @@ from dashscope.file import File
 from dashscope.finetune import FineTune
 from dashscope.model import Model
 from dashscope.nlp.understanding import Understanding
+from dashscope.rerank.text_rerank import TextReRank
 from dashscope.tokenizers import (Tokenization, Tokenizer, get_tokenizer,
                                   list_tokenizers)
 
 __all__ = [
-    base_http_api_url, base_websocket_api_url, api_key, api_key_file_path,
-    save_api_key, Conversation, Generation, History, HistoryItem,
-    ImageSynthesis, Transcription, File, Deployment, FineTune, Model,
-    TextEmbedding, MultiModalEmbedding, MultiModalEmbeddingItemAudio,
-    MultiModalEmbeddingItemImage, MultiModalEmbeddingItemText,
-    SpeechSynthesizer, MultiModalConversation, BatchTextEmbedding,
-    BatchTextEmbeddingResponse, Understanding, CodeGeneration, Tokenization,
-    Tokenizer, get_tokenizer, list_tokenizers
+    base_http_api_url,
+    base_websocket_api_url,
+    api_key,
+    api_key_file_path,
+    save_api_key,
+    Conversation,
+    Generation,
+    History,
+    HistoryItem,
+    ImageSynthesis,
+    Transcription,
+    File,
+    Deployment,
+    FineTune,
+    Model,
+    TextEmbedding,
+    MultiModalEmbedding,
+    MultiModalEmbeddingItemAudio,
+    MultiModalEmbeddingItemImage,
+    MultiModalEmbeddingItemText,
+    SpeechSynthesizer,
+    MultiModalConversation,
+    BatchTextEmbedding,
+    BatchTextEmbeddingResponse,
+    Understanding,
+    CodeGeneration,
+    Tokenization,
+    Tokenizer,
+    get_tokenizer,
+    list_tokenizers,
+    Application,
+    TextReRank,
 ]
 
 logging.getLogger(__name__).addHandler(NullHandler())

dashscope/api_entities/dashscope_response.py

@@ -493,3 +493,66 @@ class ImageSynthesisResponse(DashScopeAPIResponse):
                                           request_id=api_response.request_id,
                                           code=api_response.code,
                                           message=api_response.message)
+
+
+@dataclass(init=False)
+class ReRankResult(DictMixin):
+    index: int
+    relevance_score: float
+    document: Dict = None
+
+    def __init__(self,
+                 index: int,
+                 relevance_score: float,
+                 document: Dict = None,
+                 **kwargs):
+        super().__init__(index=index,
+                         relevance_score=relevance_score,
+                         document=document,
+                         **kwargs)
+
+
+@dataclass(init=False)
+class ReRankOutput(DictMixin):
+    results: List[ReRankResult]
+
+    def __init__(self, results: List[ReRankResult] = None, **kwargs):
+        ress = None
+        if results is not None:
+            ress = []
+            for res in results:
+                ress.append(ReRankResult(**res))
+        super().__init__(results=ress, **kwargs)
+
+
+@dataclass(init=False)
+class ReRankUsage(DictMixin):
+    total_tokens: int
+
+    def __init__(self, total_tokens=None, **kwargs):
+        super().__init__(total_tokens=total_tokens, **kwargs)
+
+
+@dataclass(init=False)
+class ReRankResponse(DashScopeAPIResponse):
+    output: ReRankOutput
+    usage: GenerationUsage
+
+    @staticmethod
+    def from_api_response(api_response: DashScopeAPIResponse):
+        if api_response.status_code == HTTPStatus.OK:
+            usage = {}
+            if api_response.usage:
+                usage = api_response.usage
+
+            return ReRankResponse(status_code=api_response.status_code,
+                                  request_id=api_response.request_id,
+                                  code=api_response.code,
+                                  message=api_response.message,
+                                  output=ReRankOutput(**api_response.output),
+                                  usage=ReRankUsage(**usage))
+        else:
+            return ReRankResponse(status_code=api_response.status_code,
+                                  request_id=api_response.request_id,
+                                  code=api_response.code,
+                                  message=api_response.message)

dashscope/app/__init__.py

@@ -0,0 +1,5 @@
+from .application import Application
+
+__all__ = [
+    Application
+]

dashscope/app/application.py

@@ -0,0 +1,169 @@
+#!/usr/bin/env python3
+# -*-coding:utf-8 -*-
+
+"""
+@File    :   application.py
+@Date    :   2024-02-24
+@Desc    :   Application calls for both http and http sse
+"""
+from typing import Generator, Union
+
+from dashscope.api_entities.api_request_factory import _build_api_request
+from dashscope.app.application_response import ApplicationResponse
+from dashscope.client.base_api import BaseApi
+from dashscope.common.api_key import get_default_api_key
+from dashscope.common.constants import HISTORY, PROMPT
+from dashscope.common.error import InputRequired, InvalidInput
+
+
+class Application(BaseApi):
+    task_group = 'apps'
+    function = "completion"
+
+    """API for app completion calls.
+
+    """
+
+    class DocReferenceType:
+        """ doc reference type for rag completion """
+
+        simple = 'simple'
+
+        indexed = 'indexed'
+
+    @classmethod
+    def _validate_params(cls, api_key, app_id):
+        if api_key is None:
+            api_key = get_default_api_key()
+        if app_id is None or not app_id:
+            raise InputRequired('App id is required!')
+        return api_key, app_id
+
+    @classmethod
+    def call(
+            cls,
+            app_id: str,
+            prompt: str,
+            history: list = None,
+            workspace: str = None,
+            api_key: str = None,
+            **kwargs
+    ) -> Union[ApplicationResponse, Generator[ApplicationResponse, None, None]]:
+        """Call app completion service.
+
+        Args:
+            app_id (str): Id of bailian application
+            prompt (str): The input prompt.
+            history (list):The user provided history
+                examples:
+                    [{'user':'The weather is fine today.',
+                    'bot': 'Suitable for outings'}].
+                Defaults to None.
+            workspace(str, `optional`): Workspace for app completion call
+            api_key (str, optional): The api api_key, can be None,
+                if None, will get by default rule(TODO: api key doc).
+
+            **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
+                seed(int, `optional`): When generating, the seed of the random number is used to control the
+                    randomness of the model generation. If you use the same seed, each run will generate the same results;
+                    you can use the same seed when you need to reproduce the model's generated results.
+                    The seed parameter supports unsigned 64-bit integer types. Default value 1234
+                session_id(str, `optional`): Session if for multiple rounds call.
+                biz_params(dict, `optional`): The extra parameters for flow or plugin.
+                has_thoughts(bool, `optional`): Flag to return rag or plugin process details. Default value false.
+                doc_tag_codes(list[str], `optional`): Tag code list for doc retrival.
+                doc_reference_type(str, `optional`): The type of doc reference.
+                    simple: simple format of doc retrival which not include index in response text but in doc reference list.
+                    indexed: include both index in response text and doc reference list
+        Raises:
+            InvalidInput: The history and auto_history are mutually exclusive.
+
+        Returns:
+            Union[CompletionResponse,
+                  Generator[CompletionResponse, None, None]]: If
+            stream is True, return Generator, otherwise GenerationResponse.
+        """
+
+        api_key, app_id = Application._validate_params(api_key, app_id)
+
+        if prompt is None or not prompt:
+            raise InputRequired('prompt is required!')
+
+        if workspace is not None and workspace:
+            headers = kwargs.pop('headers', {})
+            headers['X-DashScope-WorkSpace'] = workspace
+            kwargs['headers'] = headers
+
+        input, parameters = cls._build_input_parameters(prompt, history, **kwargs)
+        request = _build_api_request(model='',
+                                     input=input,
+                                     task_group=Application.task_group,
+                                     task=app_id,
+                                     function=Application.function,
+                                     api_key=api_key,
+                                     is_service=False,
+                                     **parameters)
+        # call request service.
+        response = request.call()
+        is_stream = kwargs.get('stream', False)
+
+        if is_stream:
+            return (ApplicationResponse.from_api_response(rsp)
+                    for rsp in response)
+        else:
+            return ApplicationResponse.from_api_response(response)
+
+    @classmethod
+    def _build_input_parameters(cls, prompt, history, **kwargs):
+        parameters = {}
+
+        input_param = {HISTORY: history,
+                       PROMPT: prompt
+                       }
+
+        session_id = kwargs.pop('session_id', None)
+        if session_id is not None and session_id:
+            input_param['session_id'] = session_id
+
+        doc_reference_type = kwargs.pop('doc_reference_type', None)
+        if doc_reference_type is not None and doc_reference_type:
+            input_param['doc_reference_type'] = doc_reference_type
+
+        doc_tag_codes = kwargs.pop('doc_tag_codes', None)
+        if doc_tag_codes is not None:
+            if isinstance(doc_tag_codes, list) and all(isinstance(item, str) for item in doc_tag_codes):
+                input_param['doc_tag_codes'] = doc_tag_codes
+            else:
+                raise InvalidInput('doc_tag_codes is not a List[str]')
+
+        biz_params = kwargs.pop('biz_params', None)
+        if biz_params is not None and biz_params:
+            input_param['biz_params'] = biz_params
+
+        return input_param, {**parameters, **kwargs}

dashscope/app/application_response.py

@@ -0,0 +1,196 @@
+#!/usr/bin/env python3
+# -*-coding:utf-8 -*-
+
+"""
+@File    :   application_response.py
+@Date    :   2024-02-24
+@Desc    :   application call response
+"""
+from dataclasses import dataclass
+from http import HTTPStatus
+from typing import List, Dict
+
+from dashscope.api_entities.dashscope_response import DashScopeAPIResponse, DictMixin
+
+
+@dataclass(init=False)
+class ApplicationThought(DictMixin):
+    thought: str
+    action_type: str
+    response: str
+    action_name: str
+    action: str
+    action_input_stream: str
+    action_input: Dict
+    observation: str
+
+    def __init__(self,
+                 thought: str = None,
+                 action_type: str = None,
+                 response: str = None,
+                 action_name: str = None,
+                 action: str = None,
+                 action_input_stream: str = None,
+                 action_input: Dict = None,
+                 observation: str = None,
+                 **kwargs):
+        """ Thought of app completion call result which describe model planning and doc retrieval
+            or plugin calls details.
+
+        Args:
+            thought (str, optional): Model's inference thought for doc retrieval or plugin process.
+            action_type (str, optional): Action type. response : final response; api: to run api calls.
+            response (str, optional): Model's results.
+            action_name (str, optional): Action name, e.g. searchDocument、api.
+            action (str, optional): Code of action, means which plugin or action to be run.
+            action_input_stream (str, optional): Input param with stream.
+            action_input (dict, optional): Api or plugin input parameters.
+            observation (str, optional): Result of api call or doc retrieval.
+        """
+
+        super().__init__(thought=thought,
+                         action_type=action_type,
+                         response=response,
+                         action_name=action_name,
+                         action=action,
+                         action_input_stream=action_input_stream,
+                         action_input=action_input,
+                         observation=observation,
+                         **kwargs)
+
+
+@dataclass(init=False)
+class ApplicationDocReference(DictMixin):
+    index_id: str
+    title: str
+    doc_id: str
+    doc_name: str
+    doc_url: str
+    text: str
+    biz_id: str
+
+    def __init__(self,
+                 index_id: str = None,
+                 title: str = None,
+                 doc_id: str = None,
+                 doc_name: str = None,
+                 doc_url: str = None,
+                 text: str = None,
+                 biz_id: str = None,
+                 **kwargs):
+        """ Doc references for retrieval result.
+
+        Args:
+            index_id (str, optional): Index id of doc retrival result reference.
+            title (str, optional): Title of original doc that retrieved.
+            doc_id (str, optional): Id of original doc that retrieved.
+            doc_name (str, optional): Name of original doc that retrieved.
+            doc_url (str, optional): Url of original doc that retrieved.
+            text (str, optional): Text in original doc that retrieved.
+            biz_id (str, optional): Biz id that caller is able to associated for biz logic.
+        """
+
+        super().__init__(index_id=index_id,
+                         title=title,
+                         doc_id=doc_id,
+                         doc_name=doc_name,
+                         doc_url=doc_url,
+                         text=text,
+                         biz_id=biz_id,
+                         **kwargs)
+
+
+@dataclass(init=False)
+class ApplicationOutput(DictMixin):
+    text: str
+    finish_reason: str
+    session_id: str
+    thoughts: List[ApplicationThought]
+    doc_references: List[ApplicationDocReference]
+
+    def __init__(self,
+                 text: str = None,
+                 finish_reason: str = None,
+                 session_id: str = None,
+                 thoughts: List[ApplicationThought] = None,
+                 doc_references: List[ApplicationDocReference] = None,
+                 **kwargs):
+
+        ths = None
+        if thoughts is not None:
+            ths = []
+            for thought in thoughts:
+                ths.append(ApplicationThought(**thought))
+
+        refs = None
+        if doc_references is not None:
+            refs = []
+            for ref in doc_references:
+                refs.append(ApplicationDocReference(**ref))
+
+        super().__init__(text=text,
+                         finish_reason=finish_reason,
+                         session_id=session_id,
+                         thoughts=ths,
+                         doc_references=refs,
+                         **kwargs)
+
+
+@dataclass(init=False)
+class ApplicationModelUsage(DictMixin):
+    model_id: str
+    input_tokens: int
+    output_tokens: int
+
+    def __init__(self,
+                 model_id: str = None,
+                 input_tokens: int = 0,
+                 output_tokens: int = 0,
+                 **kwargs):
+        super().__init__(model_id=model_id,
+                         input_tokens=input_tokens,
+                         output_tokens=output_tokens,
+                         **kwargs)
+
+
+@dataclass(init=False)
+class ApplicationUsage(DictMixin):
+    models: List[ApplicationModelUsage]
+
+    def __init__(self,
+                 models: List[ApplicationModelUsage] = None,
+                 **kwargs):
+        model_usages = None
+        if models is not None:
+            model_usages = []
+            for model_usage in models:
+                model_usages.append(ApplicationModelUsage(**model_usage))
+
+        super().__init__(models=model_usages,
+                         **kwargs)
+
+
+@dataclass(init=False)
+class ApplicationResponse(DashScopeAPIResponse):
+    output: ApplicationOutput
+    usage: ApplicationUsage
+
+    @staticmethod
+    def from_api_response(api_response: DashScopeAPIResponse):
+        if api_response.status_code == HTTPStatus.OK:
+            usage = {}
+            if api_response.usage:
+                usage = api_response.usage
+
+            return ApplicationResponse(
+                status_code=api_response.status_code,
+                request_id=api_response.request_id,
+                code=api_response.code,
+                message=api_response.message,
+                output=ApplicationOutput(**api_response.output),
+                usage=ApplicationUsage(**usage))
+        else:
+            return ApplicationResponse(status_code=api_response.status_code,
+                                       request_id=api_response.request_id,
+                                       code=api_response.code,
+                                       message=api_response.message)

dashscope/rerank/text_rerank.py

@@ -0,0 +1,67 @@
+from typing import List
+
+from dashscope.api_entities.dashscope_response import ReRankResponse
+from dashscope.client.base_api import BaseApi
+from dashscope.common.error import InputRequired, ModelRequired
+from dashscope.common.utils import _get_task_group_and_task
+
+
+class TextReRank(BaseApi):
+    task = 'text-rerank'
+    """API for rerank models.
+
+    """
+    class Models:
+        gte_rerank = 'gte-rerank'
+
+    @classmethod
+    def call(cls,
+             model: str,
+             query: str,
+             documents: List[str],
+             return_documents: bool = None,
+             top_n: int = None,
+             api_key: str = None,
+             **kwargs) -> ReRankResponse:
+        """Calling rerank service.
+
+        Args:
+            model (str): The model to use.
+            query (str): The query string.
+            documents (List[str]): The documents to rank.
+            return_documents(bool, `optional`): enable return origin documents,
+                system default is false.
+            top_n(int, `optional`): how many documents to return, default return
+                all the documents.
+            api_key (str, optional): The DashScope api key. Defaults to None.
+
+        Raises:
+            InputRequired: The query and documents are required.
+            ModelRequired: The model is required.
+
+        Returns:
+            RerankResponse: The rerank result.
+        """
+
+        if query is None or documents is None or not documents:
+            raise InputRequired('query and documents are required!')
+        if model is None or not model:
+            raise ModelRequired('Model is required!')
+        task_group, function = _get_task_group_and_task(__name__)
+        input = {'query': query, 'documents': documents}
+        parameters = {}
+        if return_documents is not None:
+            parameters['return_documents'] = return_documents
+        if top_n is not None:
+            parameters['top_n'] = top_n
+        parameters = {**parameters, **kwargs}
+
+        response = super().call(model=model,
+                                task_group=task_group,
+                                task=TextReRank.task,
+                                function=function,
+                                api_key=api_key,
+                                input=input,
+                                **parameters)
+
+        return ReRankResponse.from_api_response(response)

dashscope/version.py

@@ -1 +1 @@
-__version__ = '1.14.1'
+__version__ = '1.16.0'

{dashscope-1.14.1.dist-info → dashscope-1.16.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dashscope
-Version: 1.14.1
+Version: 1.16.0
 Summary: dashscope client sdk library
 Home-page: https://dashscope.aliyun.com/
 Author: Alibaba Cloud

{dashscope-1.14.1.dist-info → dashscope-1.16.0.dist-info}/RECORD

@@ -1,10 +1,10 @@
-dashscope/__init__.py,sha256=UExSJnogmqVAzRL6R4HhTp-yTz9GwoDIh5xAf7E_BEI,2018
+dashscope/__init__.py,sha256=d8I_67Tz2SZ2QQl5ApZQce86c3EM3obx9bQPtlvR_c8,2242
 dashscope/cli.py,sha256=7CnUZqaaUc0FxbmXHMiqOALl9YzZmSrFS23A7hbR0w0,23917
 dashscope/deployment.py,sha256=uhlQYOiu1baMQxQnFmRwI6ces0I-_DKp8uej_L0v1eY,4400
 dashscope/file.py,sha256=Dv2Fz3DLbcye2uuQxyQwRM7ky27OthouLXIpSQagQy4,3324
 dashscope/finetune.py,sha256=5QlIcnFCfSjN3gn9A2FO0kLUDa9Rx_jSc44ezT3aBEo,5118
 dashscope/model.py,sha256=iuIfal-vOo0yav0HXPdA7f93vd5JNTGIAdCG_WIYkW8,1158
-dashscope/version.py,sha256=eyARjsqZfiB7blnKzG-sgKU2HEsI143aQSUAfhkeA8U,23
+dashscope/version.py,sha256=VqyRgjiBsROG0SjVyQSaBPufjG1-xO7kqvhm7iGUJGA,23
 dashscope/aigc/__init__.py,sha256=s-MCA87KYiVumYtKtJi5IMN7xelSF6TqEU3s3_7RF-Y,327
 dashscope/aigc/code_generation.py,sha256=bizJb3zGZx3pB74FKMIcnOi_6jkxpKgx__6urzqhQ_E,10627
 dashscope/aigc/conversation.py,sha256=_sAWhQjLgJENqRAXh-i2dw8bt_i69fJv9KZYVIi4CEg,14090
@@ -16,9 +16,12 @@ dashscope/api_entities/aiohttp_request.py,sha256=ZFbdpJh7SwHnBzbYLhqr_FdcDVRgLVM
 dashscope/api_entities/api_request_data.py,sha256=JUMcfpJjKXEZLCBSFIDpgoaeQYk5uK9-CwhM4OHIHFQ,5463
 dashscope/api_entities/api_request_factory.py,sha256=MCJOGgUzaWTaLZ5d8m8dck7QdSUNX7XLbKYyB3pT23E,4067
 dashscope/api_entities/base_request.py,sha256=cXUL7xqSV8wBr5d-1kx65AO3IsRR9A_ps6Lok-v-MKM,926
-dashscope/api_entities/dashscope_response.py,sha256=1KdBib5xOftcKXLzTETe5LElGy2mB8IG8E3JZrGOaAY,15814
+dashscope/api_entities/dashscope_response.py,sha256=Bp1T7HwVlkOvpMNg-AEjz-BScxhLUXMXlE8ApXTtfhQ,17872
 dashscope/api_entities/http_request.py,sha256=MzaTznVJUbyA8u6cLegxVSEM3JWlAhPHbSh4uDCX0-A,9506
 dashscope/api_entities/websocket_request.py,sha256=zU7OskAHaNlKcR9s_6Hlnhr5N3oam4w0sUD5E9N-4BQ,14586
+dashscope/app/__init__.py,sha256=OOV2rFy0QlA9Gu3XVPtWJoBwK1J11BdGhkEdX_sdYGU,68
+dashscope/app/application.py,sha256=nr27hXX8Es_6IWAPKO-Yzj7GF-sxC6JbL2P9U6UhqcE,7911
+dashscope/app/application_response.py,sha256=pIuDSu_SAcX1Y_gK6ZYaadaMXV52XBZoM1uN4tTZ3FA,6739
 dashscope/audio/__init__.py,sha256=vlw0TFVRdeRWfzmJxhzarVUqkMs-DZNf4GiMtm3C8XE,45
 dashscope/audio/asr/__init__.py,sha256=-s180qWn_JPSpCo1q0aDJJ5HQ3zTzD4z5yUwsRqH4aU,275
 dashscope/audio/asr/asr_phrase_manager.py,sha256=BNrRBGGoAW_rcxoi_euh6bRktJO6asTiGroE8PMh1Xg,6641
@@ -47,6 +50,8 @@ dashscope/nlp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dashscope/nlp/understanding.py,sha256=uVkf_4iULnlnuGmEX3taKiHgzxu173vvgVwY5EO2C2Y,2803
 dashscope/protocol/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dashscope/protocol/websocket.py,sha256=z-v6PGx3L4zYBANuC48s7SWSQSwRCDoh0zcfhv9Bf8U,561
+dashscope/rerank/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dashscope/rerank/text_rerank.py,sha256=1L-RLUxMCvNhbMud1FUG6YFWT7ZV979fzhMEuVjJ1oI,2398
 dashscope/resources/qwen.tiktoken,sha256=srG437XMXwJLr8NzEhxquj9m-aWgJp4kNHCh3hajMYY,2561218
 dashscope/tokenizers/__init__.py,sha256=Oy5FMT37Non6e1YxdHQ89U93Dy3CG1Ez0gBa771KZo0,200
 dashscope/tokenizers/qwen_tokenizer.py,sha256=dCnT9-9NrqPS85bEhjlPULUfDADVRhlleYwM_ILgCeI,4111
@@ -55,9 +60,9 @@ dashscope/tokenizers/tokenizer.py,sha256=y6P91qTCYo__pEx_0VHAcj9YECfbUdRqZU1fdGT
 dashscope/tokenizers/tokenizer_base.py,sha256=REDhzRyDT13iequ61-a6_KcTy0GFKlihQve5HkyoyRs,656
 dashscope/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dashscope/utils/oss_utils.py,sha256=iCF5fLqIXDCS2zkE96t2DEUxCI76ArnQH2DiY2hgHu0,6522
-dashscope-1.14.1.dist-info/LICENSE,sha256=Izp5L1DF1Mbza6qojkqNNWlE_mYLnr4rmzx2EBF8YFw,11413
-dashscope-1.14.1.dist-info/METADATA,sha256=Hlg9nly8P6C_7fj2RwM8HEDuP8dt5unBCUmwGEy-FoY,6659
-dashscope-1.14.1.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
-dashscope-1.14.1.dist-info/entry_points.txt,sha256=raEp5dOuj8whJ7yqZlDM8WQ5p2RfnGrGNo0QLQEnatY,50
-dashscope-1.14.1.dist-info/top_level.txt,sha256=woqavFJK9zas5xTqynmALqOtlafghjsk63Xk86powTU,10
-dashscope-1.14.1.dist-info/RECORD,,
+dashscope-1.16.0.dist-info/LICENSE,sha256=Izp5L1DF1Mbza6qojkqNNWlE_mYLnr4rmzx2EBF8YFw,11413
+dashscope-1.16.0.dist-info/METADATA,sha256=3cCTPzfYufBwbOtgXaSRwzo7mv6uEOHTjTuMAv9yPD4,6659
+dashscope-1.16.0.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+dashscope-1.16.0.dist-info/entry_points.txt,sha256=raEp5dOuj8whJ7yqZlDM8WQ5p2RfnGrGNo0QLQEnatY,50
+dashscope-1.16.0.dist-info/top_level.txt,sha256=woqavFJK9zas5xTqynmALqOtlafghjsk63Xk86powTU,10
+dashscope-1.16.0.dist-info/RECORD,,