dashscope 1.18.1__py3-none-any.whl → 1.19.1__py3-none-any.whl

dashscope/__init__.py

@@ -1,12 +1,12 @@
 import logging
 from logging import NullHandler
 
-from dashscope.app.application import Application
 from dashscope.aigc.code_generation import CodeGeneration
 from dashscope.aigc.conversation import Conversation, History, HistoryItem
-from dashscope.aigc.generation import Generation
+from dashscope.aigc.generation import AioGeneration, Generation
 from dashscope.aigc.image_synthesis import ImageSynthesis
 from dashscope.aigc.multimodal_conversation import MultiModalConversation
+from dashscope.app.application import Application
 from dashscope.assistants import Assistant, AssistantList, Assistants
 from dashscope.assistants.assistant_types import AssistantFile, DeleteResponse
 from dashscope.audio.asr.transcription import Transcription
@@ -14,7 +14,8 @@ from dashscope.audio.tts.speech_synthesizer import SpeechSynthesizer
 from dashscope.common.api_key import save_api_key
 from dashscope.common.env import (api_key, api_key_file_path,
                                   base_http_api_url, base_websocket_api_url)
-from dashscope.deployment import Deployment
+from dashscope.customize.deployments import Deployments
+from dashscope.customize.finetunes import FineTunes
 from dashscope.embeddings.batch_text_embedding import BatchTextEmbedding
 from dashscope.embeddings.batch_text_embedding_response import \
     BatchTextEmbeddingResponse
@@ -23,8 +24,7 @@ from dashscope.embeddings.multimodal_embedding import (
     MultiModalEmbeddingItemImage, MultiModalEmbeddingItemText)
 from dashscope.embeddings.text_embedding import TextEmbedding
 from dashscope.files import Files
-from dashscope.finetune import FineTune
-from dashscope.model import Model
+from dashscope.models import Models
 from dashscope.nlp.understanding import Understanding
 from dashscope.rerank.text_rerank import TextReRank
 from dashscope.threads import (MessageFile, Messages, Run, RunList, Runs,
@@ -39,6 +39,7 @@ __all__ = [
     api_key,
     api_key_file_path,
     save_api_key,
+    AioGeneration,
     Conversation,
     Generation,
     History,
@@ -46,9 +47,9 @@ __all__ = [
     ImageSynthesis,
     Transcription,
     Files,
-    Deployment,
-    FineTune,
-    Model,
+    Deployments,
+    FineTunes,
+    Models,
     TextEmbedding,
     MultiModalEmbedding,
     MultiModalEmbeddingItemAudio,

dashscope/aigc/generation.py

@@ -4,7 +4,7 @@ from typing import Any, Dict, Generator, List, Union
 
 from dashscope.api_entities.dashscope_response import (GenerationResponse,
                                                        Message, Role)
-from dashscope.client.base_api import BaseApi
+from dashscope.client.base_api import BaseAioApi, BaseApi
 from dashscope.common.constants import (CUSTOMIZED_MODEL_ID,
                                         DEPRECATED_MESSAGE, HISTORY, MESSAGES,
                                         PROMPT)
@@ -188,3 +188,141 @@ class Generation(BaseApi):
             input[CUSTOMIZED_MODEL_ID] = customized_model_id
 
         return input, {**parameters, **kwargs}
+
+
+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/http_request.py

@@ -1,18 +1,22 @@
 import json
 from http import HTTPStatus
 
+import aiohttp
 import requests
 
-from dashscope.api_entities.base_request import BaseRequest
+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,
                                         SSE_CONTENT_TYPE, HTTPMethod)
 from dashscope.common.error import UnsupportedHTTPMethod
 from dashscope.common.logging import logger
-from dashscope.common.utils import _handle_stream
+from dashscope.common.utils import (_handle_aio_stream,
+                                    _handle_aiohttp_failed_response,
+                                    _handle_http_failed_response,
+                                    _handle_stream)
 
 
-class HttpRequest(BaseRequest):
+class HttpRequest(AioBaseRequest):
     def __init__(self,
                  url: str,
                  api_key: str,
@@ -84,6 +88,127 @@ class HttpRequest(BaseRequest):
                 pass
             return output
 
+    async def aio_call(self):
+        response = self._handle_aio_request()
+        if self.stream:
+            return (item async for item in response)
+        else:
+            result = await response.__anext__()
+            try:
+                await response.__anext__()
+            except StopAsyncIteration:
+                pass
+            return result
+
+    async def _handle_aio_request(self):
+        try:
+            async with aiohttp.ClientSession(
+                    timeout=aiohttp.ClientTimeout(total=self.timeout),
+                    headers=self.headers) as session:
+                logger.debug('Starting request: %s' % self.url)
+                if self.method == HTTPMethod.POST:
+                    is_form, obj = self.data.get_aiohttp_payload()
+                    if is_form:
+                        headers = {**self.headers, **obj.headers}
+                        response = await session.post(url=self.url,
+                                                      data=obj,
+                                                      headers=headers)
+                    else:
+                        response = await session.request('POST',
+                                                         url=self.url,
+                                                         json=obj,
+                                                         headers=self.headers)
+                elif self.method == HTTPMethod.GET:
+                    response = await session.get(url=self.url,
+                                                 params=self.data.parameters,
+                                                 headers=self.headers)
+                else:
+                    raise UnsupportedHTTPMethod('Unsupported http method: %s' %
+                                                self.method)
+                logger.debug('Response returned: %s' % self.url)
+                async with response:
+                    async for rsp in self._handle_aio_response(response):
+                        yield rsp
+        except aiohttp.ClientConnectorError as e:
+            logger.exception(e)
+            yield DashScopeAPIResponse(-1,
+                                       '',
+                                       'Unknown',
+                                       message='Error type: %s, message: %s' %
+                                       (type(e), e))
+        except BaseException as e:
+            logger.exception(e)
+            yield DashScopeAPIResponse(-1,
+                                       '',
+                                       'Unknown',
+                                       message='Error type: %s, message: %s' %
+                                       (type(e), e))
+
+    async def _handle_aio_response(self, response: aiohttp.ClientResponse):
+        request_id = ''
+        if (response.status == HTTPStatus.OK and self.stream
+                and SSE_CONTENT_TYPE in response.content_type):
+            async for is_error, status_code, data in _handle_aio_stream(
+                    response):
+                try:
+                    output = None
+                    usage = None
+                    msg = json.loads(data)
+                    if not is_error:
+                        if 'output' in msg:
+                            output = msg['output']
+                        if 'usage' in msg:
+                            usage = msg['usage']
+                    if 'request_id' in msg:
+                        request_id = msg['request_id']
+                except json.JSONDecodeError:
+                    yield DashScopeAPIResponse(
+                        request_id=request_id,
+                        status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
+                        code='Unknown',
+                        message=data)
+                    continue
+                if is_error:
+                    yield DashScopeAPIResponse(request_id=request_id,
+                                               status_code=status_code,
+                                               code=msg['code'],
+                                               message=msg['message'])
+                else:
+                    yield DashScopeAPIResponse(request_id=request_id,
+                                               status_code=HTTPStatus.OK,
+                                               output=output,
+                                               usage=usage)
+        elif (response.status == HTTPStatus.OK
+              and 'multipart' in response.content_type):
+            reader = aiohttp.MultipartReader.from_response(response)
+            output = {}
+            while True:
+                part = await reader.next()
+                if part is None:
+                    break
+                output[part.name] = await part.read()
+            if 'request_id' in output:
+                request_id = output['request_id']
+            yield DashScopeAPIResponse(request_id=request_id,
+                                       status_code=HTTPStatus.OK,
+                                       output=output)
+        elif response.status == HTTPStatus.OK:
+            json_content = await response.json()
+            output = None
+            usage = None
+            if 'output' in json_content and json_content['output'] is not None:
+                output = json_content['output']
+            if 'usage' in json_content:
+                usage = json_content['usage']
+            if 'request_id' in json_content:
+                request_id = json_content['request_id']
+            yield DashScopeAPIResponse(request_id=request_id,
+                                       status_code=HTTPStatus.OK,
+                                       output=output,
+                                       usage=usage)
+        else:
+            yield await _handle_aiohttp_failed_response(response)
+
     def _handle_response(self, response: requests.Response):
         request_id = ''
         if (response.status_code == HTTPStatus.OK and self.stream
@@ -149,33 +274,7 @@ class HttpRequest(BaseRequest):
                                            output=output,
                                            usage=usage)
         else:
-            if 'application/json' in response.headers.get('content-type', ''):
-                error = response.json()
-                if 'request_id' in error:
-                    request_id = error['request_id']
-                if 'message' not in error:
-                    message = ''
-                    logger.error('Request: %s failed, status: %s' %
-                                 (self.url, response.status_code))
-                else:
-                    message = error['message']
-                    logger.error(
-                        'Request: %s failed, status: %s, message: %s' %
-                        (self.url, response.status_code, error['message']))
-                yield DashScopeAPIResponse(
-                    request_id=request_id,
-                    status_code=response.status_code,
-                    output=None,
-                    code=error['code']
-                    if 'code' in error else None,  # noqa E501
-                    message=message)
-            else:
-                msg = response.content
-                yield DashScopeAPIResponse(request_id=request_id,
-                                           status_code=response.status_code,
-                                           output=None,
-                                           code='Unknown',
-                                           message=msg.decode('utf-8'))
+            yield _handle_http_failed_response(response)
 
     def _handle_request(self):
         try:
@@ -207,6 +306,10 @@ class HttpRequest(BaseRequest):
                                                 self.method)
                 for rsp in self._handle_response(response):
                     yield rsp
-        except Exception as e:
+        except BaseException as e:
             logger.error(e)
-            raise e
+            yield DashScopeAPIResponse(-1,
+                                       '',
+                                       'Unknown',
+                                       message='Error type: %s, message: %s' %
+                                       (type(e), e))

dashscope/api_entities/websocket_request.py

@@ -154,6 +154,13 @@ class WebSocketRequest(AioBaseRequest):
                                        status_code=code,
                                        code=code,
                                        message=msg)
+        except BaseException as e:
+            logger.exception(e)
+            yield DashScopeAPIResponse(request_id='',
+                                       status_code=-1,
+                                       code='Unknown',
+                                       message='Error type: %s, message: %s' %
+                                       (type(e), e))
 
     def _to_DashScopeAPIResponse(self, task_id, is_binary, result):
         if is_binary:

dashscope/app/__init__.py

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

dashscope/app/application_response.py

@@ -1,6 +1,4 @@
 #!/usr/bin/env python3
-# -*-coding:utf-8 -*-
-
 """
 @File    :   application_response.py
 @Date    :   2024-02-24
@@ -8,9 +6,10 @@
 """
 from dataclasses import dataclass
 from http import HTTPStatus
-from typing import List, Dict
+from typing import Dict, List
 
-from dashscope.api_entities.dashscope_response import DashScopeAPIResponse, DictMixin
+from dashscope.api_entities.dashscope_response import (DashScopeAPIResponse,
+                                                       DictMixin)
 
 
 @dataclass(init=False)
@@ -157,17 +156,14 @@ class ApplicationModelUsage(DictMixin):
 class ApplicationUsage(DictMixin):
     models: List[ApplicationModelUsage]
 
-    def __init__(self,
-                 models: List[ApplicationModelUsage] = None,
-                 **kwargs):
+    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)
+        super().__init__(models=model_usages, **kwargs)
 
 
 @dataclass(init=False)

dashscope/audio/asr/asr_phrase_manager.py

@@ -5,7 +5,7 @@ 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
+from dashscope.customize.finetunes import FineTunes
 
 
 class AsrPhraseManager(BaseAsyncApi):
@@ -39,16 +39,16 @@ class AsrPhraseManager(BaseAsyncApi):
         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},
-                                 workspace=workspace,
-                                 **kwargs)
-        FineTune.SUB_PATH = original_ft_sub_path
+        original_ft_sub_path = FineTunes.SUB_PATH
+        FineTunes.SUB_PATH = 'fine-tunes'
+        response = FineTunes.call(model=model,
+                                  training_file_ids=[],
+                                  validation_file_ids=[],
+                                  mode=training_type,
+                                  hyper_parameters={'phrase_list': phrases},
+                                  workspace=workspace,
+                                  **kwargs)
+        FineTunes.SUB_PATH = original_ft_sub_path
 
         if response.status_code != HTTPStatus.OK:
             logger.error('Create phrase failed, ' + str(response))
@@ -88,17 +88,17 @@ class AsrPhraseManager(BaseAsyncApi):
         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,
-                                 workspace=workspace,
-                                 **kwargs)
-        FineTune.SUB_PATH = original_ft_sub_path
+        original_ft_sub_path = FineTunes.SUB_PATH
+        FineTunes.SUB_PATH = 'fine-tunes'
+        response = FineTunes.call(model=model,
+                                  training_file_ids=[],
+                                  validation_file_ids=[],
+                                  mode=training_type,
+                                  hyper_parameters={'phrase_list': phrases},
+                                  finetuned_output=phrase_id,
+                                  workspace=workspace,
+                                  **kwargs)
+        FineTunes.SUB_PATH = original_ft_sub_path
 
         if response.status_code != HTTPStatus.OK:
             logger.error('Update phrase failed, ' + str(response))
@@ -126,12 +126,12 @@ class AsrPhraseManager(BaseAsyncApi):
         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,
-                                workspace=workspace,
-                                **kwargs)
-        FineTune.SUB_PATH = original_ft_sub_path
+        original_ft_sub_path = FineTunes.SUB_PATH
+        FineTunes.SUB_PATH = 'fine-tunes/outputs'
+        response = FineTunes.get(job_id=phrase_id,
+                                 workspace=workspace,
+                                 **kwargs)
+        FineTunes.SUB_PATH = original_ft_sub_path
 
         if response.status_code != HTTPStatus.OK:
             logger.error('Query phrase failed, ' + str(response))
@@ -155,13 +155,13 @@ class AsrPhraseManager(BaseAsyncApi):
         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,
-                                 workspace=workspace,
-                                 **kwargs)
-        FineTune.SUB_PATH = original_ft_sub_path
+        original_ft_sub_path = FineTunes.SUB_PATH
+        FineTunes.SUB_PATH = 'fine-tunes/outputs'
+        response = FineTunes.list(page=page,
+                                  page_size=page_size,
+                                  workspace=workspace,
+                                  **kwargs)
+        FineTunes.SUB_PATH = original_ft_sub_path
 
         if response.status_code != HTTPStatus.OK:
             logger.error('List phrase failed, ' + str(response))
@@ -188,12 +188,12 @@ class AsrPhraseManager(BaseAsyncApi):
         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,
-                                   workspace=workspace,
-                                   **kwargs)
-        FineTune.SUB_PATH = original_ft_sub_path
+        original_ft_sub_path = FineTunes.SUB_PATH
+        FineTunes.SUB_PATH = 'fine-tunes/outputs'
+        response = FineTunes.delete(job_id=phrase_id,
+                                    workspace=workspace,
+                                    **kwargs)
+        FineTunes.SUB_PATH = original_ft_sub_path
 
         if response.status_code != HTTPStatus.OK:
             logger.error('Delete phrase failed, ' + str(response))