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

dashscope/__init__.py

@@ -19,11 +19,12 @@ 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, Tokenizer, get_tokenizer,
+                                  list_tokenizers)
 
 __all__ = [
     base_http_api_url, base_websocket_api_url, api_key, api_key_file_path,
@@ -32,8 +33,8 @@ __all__ = [
     TextEmbedding, MultiModalEmbedding, MultiModalEmbeddingItemAudio,
     MultiModalEmbeddingItemImage, MultiModalEmbeddingItemText,
     SpeechSynthesizer, MultiModalConversation, BatchTextEmbedding,
-    BatchTextEmbeddingResponse, Understanding, CodeGeneration,
-    Tokenization,
+    BatchTextEmbeddingResponse, Understanding, CodeGeneration, Tokenization,
+    Tokenizer, get_tokenizer, list_tokenizers
 ]
 
 logging.getLogger(__name__).addHandler(NullHandler())

dashscope/api_entities/aiohttp_request.py

@@ -2,12 +2,10 @@ 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,
-                                        SSE_CONTENT_TYPE, HTTPMethod,
-                                        StreamResultMode)
+                                        SSE_CONTENT_TYPE, HTTPMethod)
 from dashscope.common.error import UnsupportedHTTPMethod
 from dashscope.common.logging import logger
 from dashscope.common.utils import async_to_sync
@@ -21,7 +19,6 @@ class AioHttpRequest(AioBaseRequest):
                  stream: bool = True,
                  async_request: bool = False,
                  query: bool = False,
-                 stream_result_mode: str = StreamResultMode.ACCUMULATE,
                  timeout: int = DEFAULT_REQUEST_TIMEOUT_SECONDS,
                  task_id: str = None) -> None:
         """HttpSSERequest, processing http server sent event stream.

dashscope/api_entities/api_request_factory.py

@@ -4,7 +4,7 @@ from dashscope.api_entities.http_request import HttpRequest
 from dashscope.api_entities.websocket_request import WebSocketRequest
 from dashscope.common.constants import (REQUEST_TIMEOUT_KEYWORD,
                                         SERVICE_API_PATH, ApiProtocol,
-                                        HTTPMethod, StreamResultMode)
+                                        HTTPMethod)
 from dashscope.common.error import InputDataRequired, UnsupportedApiProtocol
 from dashscope.protocol.websocket import WebsocketStreamingMode
 
@@ -15,23 +15,23 @@ def _get_protocol_params(kwargs):
     is_binary_input = kwargs.pop('is_binary_input', False)
     http_method = kwargs.pop('http_method', HTTPMethod.POST)
     stream = kwargs.pop('stream', False)
+    if not stream and ws_stream_mode == WebsocketStreamingMode.OUT:
+        ws_stream_mode = WebsocketStreamingMode.NONE
+
     async_request = kwargs.pop('async_request', False)
     query = kwargs.pop('query', False)
     headers = kwargs.pop('headers', None)
     request_timeout = kwargs.pop(REQUEST_TIMEOUT_KEYWORD, None)
-    stream_result_mode = kwargs.pop('stream_result_mode',
-                                    StreamResultMode.ACCUMULATE)
     form = kwargs.pop('form', None)
     resources = kwargs.pop('resources', None)
     return (api_protocol, ws_stream_mode, is_binary_input, http_method, stream,
-            async_request, query, headers, request_timeout, stream_result_mode,
-            form, resources)
+            async_request, query, headers, request_timeout, form, resources)
 
 
 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,
+     async_request, query, headers, request_timeout, form,
      resources) = _get_protocol_params(kwargs)
     task_id = kwargs.pop('task_id', None)
     if api_protocol in [ApiProtocol.HTTP, ApiProtocol.HTTPS]:
@@ -55,7 +55,6 @@ def _build_api_request(model: str, input: object, task_group: str, task: str,
                               stream=stream,
                               async_request=async_request,
                               query=query,
-                              stream_result_mode=stream_result_mode,
                               timeout=request_timeout,
                               task_id=task_id)
     elif api_protocol == ApiProtocol.WEBSOCKET:
@@ -65,7 +64,6 @@ def _build_api_request(model: str, input: object, task_group: str, task: str,
                                    stream=stream,
                                    ws_stream_mode=ws_stream_mode,
                                    is_binary_input=is_binary_input,
-                                   stream_result_mode=stream_result_mode,
                                    timeout=request_timeout)
     else:
         raise UnsupportedApiProtocol(

dashscope/api_entities/http_request.py

@@ -2,12 +2,10 @@ import json
 from http import HTTPStatus
 
 import requests
-
 from dashscope.api_entities.base_request import BaseRequest
 from dashscope.api_entities.dashscope_response import DashScopeAPIResponse
 from dashscope.common.constants import (DEFAULT_REQUEST_TIMEOUT_SECONDS,
-                                        SSE_CONTENT_TYPE, HTTPMethod,
-                                        StreamResultMode)
+                                        SSE_CONTENT_TYPE, HTTPMethod)
 from dashscope.common.error import UnsupportedHTTPMethod
 from dashscope.common.logging import logger
 
@@ -20,7 +18,6 @@ class HttpRequest(BaseRequest):
                  stream: bool = True,
                  async_request: bool = False,
                  query: bool = False,
-                 stream_result_mode: str = StreamResultMode.ACCUMULATE,
                  timeout: int = DEFAULT_REQUEST_TIMEOUT_SECONDS,
                  task_id: str = None) -> None:
         """HttpSSERequest, processing http server sent event stream.

dashscope/api_entities/websocket_request.py

@@ -5,12 +5,11 @@ from http import HTTPStatus
 from typing import Tuple, Union
 
 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,
                                         SERVICE_503_MESSAGE,
-                                        WEBSOCKET_ERROR_CODE, StreamResultMode)
+                                        WEBSOCKET_ERROR_CODE)
 from dashscope.common.error import (RequestFailure, UnexpectedMessageReceived,
                                     UnknownMessageReceived)
 from dashscope.common.logging import logger
@@ -29,7 +28,6 @@ class WebSocketRequest(AioBaseRequest):
         stream: bool = True,
         ws_stream_mode: str = WebsocketStreamingMode.OUT,
         is_binary_input: bool = False,
-        stream_result_mode: str = StreamResultMode.ACCUMULATE,
         timeout: int = DEFAULT_REQUEST_TIMEOUT_SECONDS,
     ) -> None:
         super().__init__()
@@ -50,7 +48,6 @@ class WebSocketRequest(AioBaseRequest):
         else:
             self.timeout = timeout
         self.ws_stream_mode = ws_stream_mode
-        self.stream_result_mode = stream_result_mode
         self.is_binary_input = is_binary_input
 
         self.headers = {
@@ -177,7 +174,6 @@ class WebSocketRequest(AioBaseRequest):
         # check if request stream data, re return an iterator,
         # otherwise we collect data and return user.
         # no matter what, the response is streaming
-        final_payload = None
         is_binary_output = False
         while True:
             msg = await ws.receive()
@@ -186,36 +182,21 @@ class WebSocketRequest(AioBaseRequest):
                 msg_json = msg.json()
                 logger.debug('Receive %s event' % msg_json[HEADER][EVENT_KEY])
                 if msg_json[HEADER][EVENT_KEY] == EventType.GENERATED:
-                    if final_payload is None:
-                        final_payload = []
                     payload = msg_json['payload']
-                    if self.stream:
-                        yield False, payload
-                    elif self.stream_result_mode == StreamResultMode.ACCUMULATE:  # noqa E501
-                        final_payload = payload
-                    else:
-                        final_payload.append(payload)
+                    yield False, payload
                 elif msg_json[HEADER][EVENT_KEY] == EventType.FINISHED:
-                    if final_payload is None:
-                        final_payload = []
                     payload = None
                     if 'payload' in msg_json:
                         payload = msg_json['payload']
                     logger.debug(payload)
                     if payload:
-                        if self.stream:
-                            yield False, payload
-                        elif self.stream_result_mode == StreamResultMode.ACCUMULATE:  # noqa E501
-                            yield False, payload
-                        else:
-                            final_payload.extend(payload)
-                            yield False, final_payload
+                        yield False, payload
                     else:
                         if not self.stream:
                             if is_binary_output:
-                                yield True, final_payload
+                                yield True, payload
                             else:
-                                yield False, final_payload
+                                yield False, payload
                     break
                 elif msg_json[HEADER][EVENT_KEY] == EventType.FAILED:
                     self._on_failed(msg_json)
@@ -225,14 +206,7 @@ class WebSocketRequest(AioBaseRequest):
                     raise UnknownMessageReceived(error)
             elif msg.type == aiohttp.WSMsgType.BINARY:
                 is_binary_output = True
-                if final_payload is None:
-                    final_payload = b''
-                if self.stream:
-                    yield True, msg.data
-                elif self.stream_result_mode == StreamResultMode.ACCUMULATE:
-                    final_payload = msg.data
-                else:
-                    final_payload += msg.data
+                yield True, msg.data
 
     def _on_failed(self, details):
         error = RequestFailure(request_id=details[HEADER][TASK_ID],

dashscope/common/constants.py

@@ -44,22 +44,6 @@ class FilePurpose:
     fine_tune = 'fine_tune'
 
 
-class StreamResultMode:
-    """Stream result mode.
-        examples(I like apple)
-            accumulate: will output
-                I
-                I like
-                I like apple
-            divide: will output
-                I
-                like
-                apple
-    """
-    ACCUMULATE = 'accumulate'
-    DIVIDE = 'divide'
-
-
 class DeploymentStatus:
     DEPLOYING = 'DEPLOYING'
     SERVING = 'RUNNING'

dashscope/common/error.py

@@ -1,61 +1,65 @@
-class AuthenticationError(Exception):
+class DashScopeException(Exception):
     pass
 
 
-class InvalidParameter(Exception):
+class AuthenticationError(DashScopeException):
     pass
 
 
-class InvalidTask(Exception):
+class InvalidParameter(DashScopeException):
     pass
 
 
-class UnsupportedModel(Exception):
+class InvalidTask(DashScopeException):
     pass
 
 
-class UnsupportedTask(Exception):
+class UnsupportedModel(DashScopeException):
     pass
 
 
-class ModelRequired(Exception):
+class UnsupportedTask(DashScopeException):
     pass
 
 
-class InvalidModel(Exception):
+class ModelRequired(DashScopeException):
     pass
 
 
-class InvalidInput(Exception):
+class InvalidModel(DashScopeException):
     pass
 
 
-class InvalidFileFormat(Exception):
+class InvalidInput(DashScopeException):
     pass
 
 
-class UnsupportedApiProtocol(Exception):
+class InvalidFileFormat(DashScopeException):
     pass
 
 
-class NotImplemented(Exception):
+class UnsupportedApiProtocol(DashScopeException):
     pass
 
 
-class MultiInputsWithBinaryNotSupported(Exception):
+class NotImplemented(DashScopeException):
     pass
 
 
-class UnexpectedMessageReceived(Exception):
+class MultiInputsWithBinaryNotSupported(DashScopeException):
     pass
 
 
-class UnsupportedData(Exception):
+class UnexpectedMessageReceived(DashScopeException):
+    pass
+
+
+class UnsupportedData(DashScopeException):
     pass
 
 
 # for server send generation or inference error.
-class RequestFailure(Exception):
+class RequestFailure(DashScopeException):
     def __init__(self,
                  request_id=None,
                  message=None,
@@ -72,33 +76,33 @@ class RequestFailure(Exception):
         return msg
 
 
-class UnknownMessageReceived(Exception):
+class UnknownMessageReceived(DashScopeException):
     pass
 
 
-class InputDataRequired(Exception):
+class InputDataRequired(DashScopeException):
     pass
 
 
-class InputRequired(Exception):
+class InputRequired(DashScopeException):
     pass
 
 
-class UnsupportedDataType(Exception):
+class UnsupportedDataType(DashScopeException):
     pass
 
 
-class ServiceUnavailableError(Exception):
+class ServiceUnavailableError(DashScopeException):
     pass
 
 
-class UnsupportedHTTPMethod(Exception):
+class UnsupportedHTTPMethod(DashScopeException):
     pass
 
 
-class AsyncTaskCreateFailed(Exception):
+class AsyncTaskCreateFailed(DashScopeException):
     pass
 
 
-class UploadFileException(Exception):
+class UploadFileException(DashScopeException):
     pass

dashscope/common/utils.py

@@ -14,7 +14,7 @@ from dashscope.version import __version__
 
 
 def is_validate_fine_tune_file(file_path):
-    with open(file_path) as f:
+    with open(file_path, encoding='utf-8') as f:
         for line in f:
             try:
                 json.loads(line)

dashscope/embeddings/multimodal_embedding.py

@@ -88,6 +88,7 @@ class MultiModalEmbedding(BaseApi):
                             task_group=task_group,
                             task=MultiModalEmbedding.task,
                             function=function,
+                            api_key=api_key,
                             **kwargs)
 
     @classmethod