dashscope 1.12.0__py3-none-any.whl → 1.13.1__py3-none-any.whl

dashscope/__init__.py

@@ -19,39 +19,20 @@ from dashscope.embeddings.multimodal_embedding import (
     MultiModalEmbedding, MultiModalEmbeddingItemAudio,
     MultiModalEmbeddingItemImage, MultiModalEmbeddingItemText)
 from dashscope.embeddings.text_embedding import TextEmbedding
+from dashscope.tokenizers import Tokenization
 from dashscope.file import File
 from dashscope.finetune import FineTune
 from dashscope.model import Model
 from dashscope.nlp.understanding import Understanding
-from dashscope.tokenizers import Tokenization
 
 __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,
+    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,
 ]
 

dashscope/aigc/code_generation.py

@@ -1,6 +1,7 @@
 from typing import Generator, List, Union
 
-from dashscope.api_entities.dashscope_response import DashScopeAPIResponse, DictMixin, Role
+from dashscope.api_entities.dashscope_response import (DashScopeAPIResponse,
+                                                       DictMixin, Role)
 from dashscope.client.base_api import BaseApi
 from dashscope.common.constants import MESSAGE, SCENE
 from dashscope.common.error import InputRequired, ModelRequired
@@ -47,7 +48,6 @@ class CodeGeneration(BaseApi):
     """API for AI-Generated Content(AIGC) models.
 
     """
-
     class Models:
         tongyi_lingma_v1 = 'tongyi-lingma-v1'
 
@@ -63,13 +63,14 @@ class CodeGeneration(BaseApi):
 
     @classmethod
     def call(
-            cls,
-            model: str,
-            scene: str = None,
-            api_key: str = None,
-            message: List[MessageParam] = None,
-            **kwargs
-    ) -> Union[DashScopeAPIResponse, Generator[DashScopeAPIResponse, None, None]]:
+        cls,
+        model: str,
+        scene: str = None,
+        api_key: str = None,
+        message: List[MessageParam] = None,
+        **kwargs
+    ) -> Union[DashScopeAPIResponse, Generator[DashScopeAPIResponse, None,
+                                               None]]:
         """Call generation model service.
 
         Args:
@@ -116,7 +117,8 @@ class CodeGeneration(BaseApi):
         if model is None or not model:
             raise ModelRequired('Model is required!')
         task_group, task = _get_task_group_and_task(__name__)
-        input, parameters = cls._build_input_parameters(model, scene, message, **kwargs)
+        input, parameters = cls._build_input_parameters(
+            model, scene, message, **kwargs)
         response = super().call(model=model,
                                 task_group=task_group,
                                 task=task,
@@ -133,11 +135,6 @@ class CodeGeneration(BaseApi):
 
     @classmethod
     def _build_input_parameters(cls, model, scene, message, **kwargs):
-        parameters = {
-            "n": kwargs.pop("n", 1)
-        }
-        input = {
-            SCENE: scene,
-            MESSAGE: message
-        }
+        parameters = {'n': kwargs.pop('n', 1)}
+        input = {SCENE: scene, MESSAGE: message}
         return input, {**parameters, **kwargs}

dashscope/aigc/conversation.py

@@ -1,12 +1,12 @@
+import json
 from copy import deepcopy
 from http import HTTPStatus
-from typing import Any, Generator, List, Union
+from typing import Any, Dict, Generator, List, Union
 
 from dashscope.api_entities.dashscope_response import (ConversationResponse,
                                                        Message, Role)
 from dashscope.client.base_api import BaseApi
-from dashscope.common.constants import (DEPRECATED_MESSAGE, HISTORY, MESSAGES,
-                                        PROMPT)
+from dashscope.common.constants import DEPRECATED_MESSAGE, HISTORY, PROMPT
 from dashscope.common.error import InputRequired, InvalidInput, ModelRequired
 from dashscope.common.logging import logger
 from dashscope.common.utils import _get_task_group_and_task
@@ -101,8 +101,7 @@ class Conversation(BaseApi):
         qwen_turbo = 'qwen-turbo'
         qwen_plus = 'qwen-plus'
 
-    def __init__(self,
-                 history: History = None) -> None:
+    def __init__(self, history: History = None) -> None:
         """Init a chat.
 
         Args:
@@ -126,6 +125,7 @@ class Conversation(BaseApi):
         n_history: int = -1,
         api_key: str = None,
         messages: List[Message] = None,
+        plugins: Union[str, Dict[str, Any]] = None,
         **kwargs
     ) -> Union[ConversationResponse, Generator[ConversationResponse, None,
                                                None]]:
@@ -150,6 +150,7 @@ class Conversation(BaseApi):
                     [{'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(qwen-turbo, qwen-plus):
                 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
@@ -157,13 +158,13 @@ class Conversation(BaseApi):
                 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 
+                    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
@@ -195,6 +196,13 @@ class Conversation(BaseApi):
         if model is None or not model:
             raise ModelRequired('Model is required!')
         task_group, _ = _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 = self._build_input_parameters(
             model, prompt, history, auto_history, n_history, messages,
             **kwargs)
@@ -236,15 +244,13 @@ class Conversation(BaseApi):
     def _build_input_parameters(self, model, prompt, history, auto_history,
                                 n_history, messages, **kwargs):
         if model == Conversation.Models.qwen_v1:
-            logger.warning("Model %s is deprecated, use %s instead!" % (
-                Conversation.Models.qwen_v1,
-                Conversation.Models.qwen_turbo
-            ))
+            logger.warning(
+                'Model %s is deprecated, use %s instead!' %
+                (Conversation.Models.qwen_v1, Conversation.Models.qwen_turbo))
         if model == Conversation.Models.qwen_plus_v1:
-            logger.warning("Model %s is deprecated, use %s instead!" % (
-                Conversation.Models.qwen_plus_v1,
-                Conversation.Models.qwen_plus
-            ))            
+            logger.warning('Model %s is deprecated, use %s instead!' %
+                           (Conversation.Models.qwen_plus_v1,
+                            Conversation.Models.qwen_plus))
         parameters = {}
         if history is not None and auto_history:
             raise InvalidInput('auto_history is True, history must None')

dashscope/aigc/generation.py

@@ -1,5 +1,6 @@
 import copy
-from typing import Any, Generator, List, Union
+import json
+from typing import Any, Dict, Generator, List, Union
 
 from dashscope.api_entities.dashscope_response import (GenerationResponse,
                                                        Message, Role)
@@ -36,6 +37,7 @@ class Generation(BaseApi):
         history: list = None,
         api_key: str = None,
         messages: List[Message] = None,
+        plugins: Union[str, Dict[str, Any]] = None,
         **kwargs
     ) -> Union[GenerationResponse, Generator[GenerationResponse, None, None]]:
         """Call generation model service.
@@ -55,6 +57,7 @@ class Generation(BaseApi):
                     [{'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
@@ -102,6 +105,13 @@ class Generation(BaseApi):
         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 = cls._build_input_parameters(
             model, prompt, history, messages, **kwargs)
         response = super().call(model=model,

dashscope/aigc/multimodal_conversation.py

@@ -1,9 +1,13 @@
+import copy
 from typing import Generator, List, Union
 
-from dashscope.api_entities.dashscope_response import (MultiModalConversationResponse)
+from dashscope.api_entities.dashscope_response import \
+    MultiModalConversationResponse
 from dashscope.client.base_api import BaseApi
 from dashscope.common.error import InputRequired, ModelRequired
 from dashscope.common.utils import _get_task_group_and_task
+from dashscope.utils.oss_utils import preprocess_message_element
+
 
 class MultiModalConversation(BaseApi):
     """MultiModal conversational robot interface.
@@ -21,7 +25,8 @@ class MultiModalConversation(BaseApi):
         messages: List,
         api_key: str = None,
         **kwargs
-    ) -> Union[MultiModalConversationResponse, Generator[MultiModalConversationResponse, None, None]]:
+    ) -> Union[MultiModalConversationResponse, Generator[
+            MultiModalConversationResponse, None, None]]:
         """Call the conversation model service.
 
         Args:
@@ -59,7 +64,7 @@ class MultiModalConversation(BaseApi):
                     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(float, `optional`): 
+                top_k(float, `optional`):
 
         Raises:
             InvalidInput: The history and auto_history are mutually exclusive.
@@ -74,7 +79,13 @@ class MultiModalConversation(BaseApi):
         if model is None or not model:
             raise ModelRequired('Model is required!')
         task_group, _ = _get_task_group_and_task(__name__)
-        input = {'messages': messages}
+        msg_copy = copy.deepcopy(messages)
+        has_upload = cls._preprocess_messages(model, msg_copy, api_key)
+        if has_upload:
+            headers = kwargs.pop('headers', {})
+            headers['X-DashScope-OssResourceResolve'] = 'enable'
+            kwargs['headers'] = headers
+        input = {'messages': msg_copy}
         response = super().call(model=model,
                                 task_group=task_group,
                                 task=MultiModalConversation.task,
@@ -88,3 +99,27 @@ class MultiModalConversation(BaseApi):
                     for rsp in response)
         else:
             return MultiModalConversationResponse.from_api_response(response)
+
+    @classmethod
+    def _preprocess_messages(cls, model: str, messages: List[dict],
+                             api_key: str):
+        """
+            messages = [
+                {
+                    "role": "user",
+                    "content": [
+                        {"image": ""},
+                        {"text": ""},
+                    ]
+                }
+            ]
+        """
+        has_upload = False
+        for message in messages:
+            content = message['content']
+            for elem in content:
+                is_upload = preprocess_message_element(model, elem, api_key)
+                if is_upload and not has_upload:
+                    has_upload = True
+
+        return has_upload

dashscope/api_entities/api_request_data.py

@@ -41,10 +41,10 @@ class ApiRequestData():
     def add_parameters(self, **params):
         for key, value in params.items():
             self.parameters[key] = value
-    
+
     def add_resources(self, resources):
         self.resources = resources
-    
+
     def to_request_object(self) -> str:
         """Convert data to json, called from http request.
         Returns:

dashscope/api_entities/api_request_factory.py

@@ -28,14 +28,8 @@ def _get_protocol_params(kwargs):
             form, resources)
 
 
-def _build_api_request(model: str,
-                       input: object,
-                       task_group: str,
-                       task: str,
-                       function: str,
-                       api_key: str,
-                       is_service=True,
-                       **kwargs):
+def _build_api_request(model: str, input: object, task_group: str, task: str,
+                       function: str, api_key: str, is_service=True, **kwargs):
     (api_protocol, ws_stream_mode, is_binary_input, http_method, stream,
      async_request, query, headers, request_timeout, stream_result_mode, form,
      resources) = _get_protocol_params(kwargs)
@@ -44,8 +38,8 @@ def _build_api_request(model: str,
         if not dashscope.base_http_api_url.endswith('/'):
             http_url = dashscope.base_http_api_url + '/'
         else:
-            http_url = dashscope.base_http_api_url
-
+            http_url = dashscope.base_http_api_url    
+   
         if is_service:
             http_url = http_url + SERVICE_API_PATH + '/'
 

dashscope/api_entities/dashscope_response.py

@@ -137,12 +137,17 @@ class Message(DictMixin):
 class Choice(DictMixin):
     finish_reason: str
     message: Message
-    def __init__(self, finish_reason: str = None, message: Message = None, **kwargs):
+
+    def __init__(self,
+                 finish_reason: str = None,
+                 message: Message = None,
+                 **kwargs):
         msgObject = None
         if message is not None:
             msgObject = Message(**message)
-        super().__init__(finish_reason=finish_reason, 
-                         message=msgObject, **kwargs)
+        super().__init__(finish_reason=finish_reason,
+                         message=msgObject,
+                         **kwargs)
 
 
 @dataclass(init=False)
@@ -160,7 +165,7 @@ class GenerationOutput(DictMixin):
         if choices is not None:
             chs = []
             for choice in choices:
-                chs.append(Choice(**choice))             
+                chs.append(Choice(**choice))
         super().__init__(text=text,
                          finish_reason=finish_reason,
                          choices=chs,
@@ -206,6 +211,7 @@ class GenerationResponse(DashScopeAPIResponse):
                                       code=api_response.code,
                                       message=api_response.message)
 
+
 @dataclass(init=False)
 class MultiModalConversationOutput(DictMixin):
     choices: List[Choice]
@@ -219,7 +225,7 @@ class MultiModalConversationOutput(DictMixin):
         if choices is not None:
             chs = []
             for choice in choices:
-                chs.append(Choice(**choice)) 
+                chs.append(Choice(**choice))
         super().__init__(text=text,
                          finish_reason=finish_reason,
                          choices=chs,
@@ -230,6 +236,7 @@ class MultiModalConversationOutput(DictMixin):
 class MultiModalConversationUsage(DictMixin):
     input_tokens: int
     output_tokens: int
+
     # TODO add image usage info.
 
     def __init__(self,
@@ -261,10 +268,12 @@ class MultiModalConversationResponse(DashScopeAPIResponse):
                 output=MultiModalConversationOutput(**api_response.output),
                 usage=MultiModalConversationUsage(**usage))
         else:
-            return MultiModalConversationResponse(status_code=api_response.status_code,
-                                      request_id=api_response.request_id,
-                                      code=api_response.code,
-                                      message=api_response.message)
+            return MultiModalConversationResponse(
+                status_code=api_response.status_code,
+                request_id=api_response.request_id,
+                code=api_response.code,
+                message=api_response.message)
+
 
 @dataclass(init=False)
 class ConversationResponse(GenerationResponse):

dashscope/audio/asr/__init__.py

@@ -1,4 +1,8 @@
+from .asr_phrase_manager import AsrPhraseManager
 from .recognition import Recognition, RecognitionCallback, RecognitionResult
 from .transcription import Transcription
 
-__all__ = [Transcription, Recognition, RecognitionCallback, RecognitionResult]
+__all__ = [
+    Transcription, Recognition, RecognitionCallback, RecognitionResult,
+    AsrPhraseManager
+]

dashscope/audio/asr/asr_phrase_manager.py

@@ -0,0 +1,179 @@
+from http import HTTPStatus
+from typing import Any, Dict
+
+from dashscope.api_entities.dashscope_response import DashScopeAPIResponse
+from dashscope.client.base_api import BaseAsyncApi
+from dashscope.common.error import InvalidParameter
+from dashscope.common.logging import logger
+from dashscope.finetune import FineTune
+
+
+class AsrPhraseManager(BaseAsyncApi):
+    """Hot word management for speech recognition.
+    """
+    @classmethod
+    def create_phrases(cls,
+                       model: str,
+                       phrases: Dict[str, Any],
+                       training_type: str = 'compile_asr_phrase',
+                       **kwargs) -> DashScopeAPIResponse:
+        """Create hot words.
+
+        Args:
+            model (str): The requested model.
+            phrases (Dict[str, Any]): A dictionary that contains phrases,
+                such as {'下一首':90,'上一首':90}.
+            training_type (str, `optional`): The training type,
+                'compile_asr_phrase' is default.
+
+        Raises:
+            InvalidParameter: Parameter input is None or empty!
+
+        Returns:
+            DashScopeAPIResponse: The results of creating hot words.
+        """
+        if phrases is None or len(phrases) == 0:
+            raise InvalidParameter('phrases is empty!')
+        if training_type is None or len(training_type) == 0:
+            raise InvalidParameter('training_type is empty!')
+
+        original_ft_sub_path = FineTune.SUB_PATH
+        FineTune.SUB_PATH = 'fine-tunes'
+        response = FineTune.call(model=model,
+                                 training_file_ids=[],
+                                 validation_file_ids=[],
+                                 mode=training_type,
+                                 hyper_parameters={'phrase_list': phrases},
+                                 **kwargs)
+        FineTune.SUB_PATH = original_ft_sub_path
+
+        if response.status_code != HTTPStatus.OK:
+            logger.error('Create phrase failed, ' + str(response))
+
+        return response
+
+    @classmethod
+    def update_phrases(cls,
+                       model: str,
+                       phrase_id: str,
+                       phrases: Dict[str, Any],
+                       training_type: str = 'compile_asr_phrase',
+                       **kwargs) -> DashScopeAPIResponse:
+        """Update the hot words marked phrase_id.
+
+        Args:
+            model (str): The requested model.
+            phrase_id (str): The ID of phrases,
+                which created by create_phrases().
+            phrases (Dict[str, Any]): A dictionary that contains phrases,
+                such as {'暂停':90}.
+            training_type (str, `optional`):
+                The training type, 'compile_asr_phrase' is default.
+
+        Raises:
+            InvalidParameter: Parameter input is None or empty!
+
+        Returns:
+            DashScopeAPIResponse: The results of updating hot words.
+        """
+        if phrase_id is None or len(phrase_id) == 0:
+            raise InvalidParameter('phrase_id is empty!')
+        if phrases is None or len(phrases) == 0:
+            raise InvalidParameter('phrases is empty!')
+        if training_type is None or len(training_type) == 0:
+            raise InvalidParameter('training_type is empty!')
+
+        original_ft_sub_path = FineTune.SUB_PATH
+        FineTune.SUB_PATH = 'fine-tunes'
+        response = FineTune.call(model=model,
+                                 training_file_ids=[],
+                                 validation_file_ids=[],
+                                 mode=training_type,
+                                 hyper_parameters={'phrase_list': phrases},
+                                 finetuned_output=phrase_id,
+                                 **kwargs)
+        FineTune.SUB_PATH = original_ft_sub_path
+
+        if response.status_code != HTTPStatus.OK:
+            logger.error('Update phrase failed, ' + str(response))
+
+        return response
+
+    @classmethod
+    def query_phrases(cls, phrase_id: str, **kwargs) -> DashScopeAPIResponse:
+        """Query the hot words by phrase_id.
+
+        Args:
+            phrase_id (str): The ID of phrases,
+                which created by create_phrases().
+
+        Raises:
+            InvalidParameter: phrase_id input is None or empty!
+
+        Returns:
+            AsrPhraseManagerResult: The results of querying hot words.
+        """
+        if phrase_id is None or len(phrase_id) == 0:
+            raise InvalidParameter('phrase_id is empty!')
+
+        original_ft_sub_path = FineTune.SUB_PATH
+        FineTune.SUB_PATH = 'fine-tunes/outputs'
+        response = FineTune.get(job_id=phrase_id, **kwargs)
+        FineTune.SUB_PATH = original_ft_sub_path
+
+        if response.status_code != HTTPStatus.OK:
+            logger.error('Query phrase failed, ' + str(response))
+
+        return response
+
+    @classmethod
+    def list_phrases(cls,
+                     page: int = 1,
+                     page_size: int = 10,
+                     **kwargs) -> DashScopeAPIResponse:
+        """List all information of phrases.
+
+        Args:
+            page (int): Page number, greater than 0, default value 1.
+            page_size (int): The paging size, greater than 0
+                and less than or equal to 100, default value 10.
+
+        Returns:
+            DashScopeAPIResponse: The results of listing hot words.
+        """
+        original_ft_sub_path = FineTune.SUB_PATH
+        FineTune.SUB_PATH = 'fine-tunes/outputs'
+        response = FineTune.list(page=page, page_size=page_size, **kwargs)
+        FineTune.SUB_PATH = original_ft_sub_path
+
+        if response.status_code != HTTPStatus.OK:
+            logger.error('List phrase failed, ' + str(response))
+
+        return response
+
+    @classmethod
+    def delete_phrases(cls, phrase_id: str, **kwargs) -> DashScopeAPIResponse:
+        """Delete the hot words by phrase_id.
+
+        Args:
+            phrase_id (str): The ID of phrases,
+                which created by create_phrases().
+
+        Raises:
+            InvalidParameter: phrase_id input is None or empty!
+
+        Returns:
+            DashScopeAPIResponse: The results of deleting hot words.
+        """
+        if phrase_id is None or len(phrase_id) == 0:
+            raise InvalidParameter('phrase_id is empty!')
+
+        original_ft_sub_path = FineTune.SUB_PATH
+        FineTune.SUB_PATH = 'fine-tunes/outputs'
+        response = FineTune.delete(job_id=phrase_id, **kwargs)
+        FineTune.SUB_PATH = original_ft_sub_path
+
+        if response.status_code != HTTPStatus.OK:
+            logger.error('Delete phrase failed, ' + str(response))
+
+        return response