dashscope 1.15.0__py3-none-any.whl → 1.18.0__py3-none-any.whl

dashscope/common/base_type.py

@@ -0,0 +1,130 @@
+import dataclasses
+from dataclasses import dataclass
+from typing import Any, List
+
+import dashscope
+
+
+def get_object_type(name: str):
+    dashscope_objects = {
+        'assistant': dashscope.Assistant,
+        'assistant.deleted': dashscope.DeleteResponse,
+        'thread.message': dashscope.ThreadMessage,
+        'thread.run': dashscope.Run,
+        'thread.run.step': dashscope.RunStep,
+        'thread.message.file': dashscope.MessageFile,
+        'assistant.file': dashscope.AssistantFile,
+        'thread': dashscope.Thread,
+    }
+    return dashscope_objects.get(name, None)
+
+
+@dataclass(init=False)
+class BaseObjectMixin(object):
+    __slots__ = ()
+
+    def __init__(self, **kwargs):
+        field_type_map = self._get_fields_type()
+        for k, v in kwargs.items():
+            field = field_type_map.get(k, None)
+            if field:
+                if dataclasses.is_dataclass(field.type):  # process dataclasses
+                    self.__setattr__(k, field.type(**v))
+                    continue
+
+            if isinstance(v, dict):
+                object_name = v.get('object', None)
+                if object_name:
+                    object_type = get_object_type(object_name)
+                    if object_type:
+                        self.__setattr__(k, object_type(**v))
+                    else:
+                        self.__setattr__(k, v)
+                else:
+                    self.__setattr__(k, v)
+            elif isinstance(v, list):
+                obj_list = self._init_list_element_recursive(field, v)
+                self.__setattr__(k, obj_list)
+            else:
+                self.__setattr__(k, v)
+
+    def _init_list_element_recursive(self, field, items: list) -> List[Any]:
+        obj_list = []
+        for item in items:
+            if field:
+                # current only support List[cls_name],
+                # not support List[cls_nam1, cls_name2]
+                element_type = field.type.__args__[0]
+                if dataclasses.is_dataclass(element_type):
+                    obj_list.append(element_type(**item))
+                    continue
+
+            if isinstance(item, dict):
+                object_name = item.get('object', None)
+                if object_name:
+                    object_type = get_object_type(object_name)
+                    if object_type:
+                        obj_list.append(object_type(**item))
+                    else:
+                        obj_list.append(item)
+                else:
+                    obj_list.append(item)
+            elif isinstance(item, list):
+                obj_list.append(self._init_list_element_recursive(item))
+            else:
+                obj_list.append(item)
+        return obj_list
+
+    def _get_fields_type(self):
+        field_type_map = {}
+        if dataclasses.is_dataclass(self):
+            for field in dataclasses.fields(self):
+                field_type_map[field.name] = field
+        return field_type_map
+
+    def __setitem__(self, __key: Any, __value: Any) -> None:
+        return self.__setattr__(__key, __value)
+
+    def __getitem__(self, __key: Any) -> Any:
+        return self.__getattribute__(__key)
+
+    def __delitem__(self, key):
+        self.__delattr__(key)
+
+    def _recursive_to_str__(self, input_object) -> Any:
+        if isinstance(input_object, list):
+            output_object = []
+            for item in input_object:
+                output_object.append(self._recursive_to_str__(item))
+            return output_object
+        elif dataclasses.is_dataclass(input_object):
+            output_object = {}
+            for field in dataclasses.fields(input_object):
+                if hasattr(input_object, field.name):
+                    output_object[field.name] = self._recursive_to_str__(
+                        getattr(input_object, field.name))
+            return output_object
+        else:
+            return input_object
+
+    def __str__(self) -> str:
+        real_dict = self.__dict__
+        self_fields = dataclasses.fields(self)
+        for field in self_fields:
+            if hasattr(self, field.name):
+                real_dict[field.name] = getattr(self, field.name)
+        output_object = {}
+        for key, value in real_dict.items():
+            output_object[key] = self._recursive_to_str__(value)
+        return str(output_object)
+
+
+@dataclass(init=False)
+class BaseList(BaseObjectMixin):
+    status_code: int
+    has_more: bool
+    last_id: str
+    first_id: str
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)

dashscope/common/constants.py

@@ -42,6 +42,7 @@ REPEATABLE_STATUS = [
 
 class FilePurpose:
     fine_tune = 'fine_tune'
+    assistants = 'assistants'
 
 
 class DeploymentStatus:

dashscope/common/error.py

@@ -106,3 +106,7 @@ class AsyncTaskCreateFailed(DashScopeException):
 
 class UploadFileException(DashScopeException):
     pass
+
+
+class TimeoutException(DashScopeException):
+    pass

dashscope/common/utils.py

@@ -2,14 +2,18 @@ import asyncio
 import json
 import os
 import platform
+from dataclasses import dataclass
 from http import HTTPStatus
 from typing import Dict
 from urllib.parse import urlparse
 
 import aiohttp
 import requests
+
 from dashscope.api_entities.dashscope_response import DashScopeAPIResponse
 from dashscope.common.api_key import get_default_api_key
+from dashscope.common.constants import SSE_CONTENT_TYPE
+from dashscope.common.logging import logger
 from dashscope.version import __version__
 
 
@@ -126,7 +130,7 @@ def join_url(base_url, *args):
         base_url = base_url + '/'
     url = base_url
     for arg in args:
-        if arg:
+        if arg is not None:
             url += arg + '/'
     return url[:-1]
 
@@ -162,13 +166,63 @@ async def _handle_aiohttp_response(response: aiohttp.ClientResponse):
                                         message=msg)
 
 
+@dataclass
+class SSEEvent:
+    id: str
+    eventType: str
+    data: str
+
+    def __init__(self, id: str, type: str, data: str):
+        self.id = id
+        self.eventType = type
+        self.data = data
+
+
+def _handle_stream(response: requests.Response):
+    # TODO define done message.
+    is_error = False
+    status_code = HTTPStatus.INTERNAL_SERVER_ERROR
+    event = SSEEvent(None, None, None)
+    eventType = None
+    for line in response.iter_lines():
+        if line:
+            line = line.decode('utf8')
+            line = line.rstrip('\n').rstrip('\r')
+            print(line)
+            if line.startswith('id:'):
+                id = line[len('id:'):]
+                event.id = id.strip()
+            elif line.startswith('event:'):
+                eventType = line[len('event:'):]
+                event.eventType = eventType.strip()
+                if eventType == 'error':
+                    is_error = True
+            elif line.startswith('status:'):
+                status_code = line[len('status:'):]
+                status_code = int(status_code.strip())
+            elif line.startswith('data:'):
+                line = line[len('data:'):]
+                event.data = line.strip()
+                if eventType is not None and eventType == 'done':
+                    continue
+                yield (is_error, status_code, event)
+                if is_error:
+                    break
+            else:
+                continue  # ignore heartbeat...
+
+
 def _handle_http_failed_response(
-        response: requests.Response) -> DashScopeAPIResponse:
+        response: requests.Response,
+        flattened_output: bool = False) -> DashScopeAPIResponse:
     msg = ''
     code = None
     request_id = ''
     if 'application/json' in response.headers.get('content-type', ''):
         error = response.json()
+        if flattened_output:
+            error['status_code'] = response.status_code
+            return error
         if 'message' in error:
             msg = error['message']
         if 'msg' in error:
@@ -183,37 +237,115 @@ def _handle_http_failed_response(
                                     message=msg)
     else:
         msg = response.content.decode('utf-8')
+        if flattened_output:
+            return {'status_code': response.status_code, 'message': msg}
         return DashScopeAPIResponse(request_id=request_id,
                                     status_code=response.status_code,
                                     code='Unknown',
                                     message=msg)
 
 
-def _handle_http_response(response: requests.Response):
+def _handle_http_response(response: requests.Response,
+                          flattened_output: bool = False):
+    response = _handle_http_stream_response(response, flattened_output)
+    _, output = next(response)
+    try:
+        next(response)
+    except StopIteration:
+        pass
+    return output
+
+
+def _handle_http_stream_response(response: requests.Response,
+                                 flattened_output: bool = False):
     request_id = ''
-    if response.status_code == HTTPStatus.OK:
-        output = None
-        usage = None
-        code = None
-        msg = ''
+    if (response.status_code == HTTPStatus.OK
+            and SSE_CONTENT_TYPE in response.headers.get('content-type', '')):
+        for is_error, status_code, event in _handle_stream(response):
+            if not is_error:
+                try:
+                    output = None
+                    usage = None
+                    msg = json.loads(event.data)
+                    if flattened_output:
+                        msg['status_code'] = response.status_code
+                        yield event.eventType, msg
+                    else:
+                        logger.debug('Stream message: %s' % msg)
+                        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']
+                        yield event.eventType, DashScopeAPIResponse(
+                            request_id=request_id,
+                            status_code=HTTPStatus.OK,
+                            output=output,
+                            usage=usage)
+                except json.JSONDecodeError as e:
+                    if flattened_output:
+                        yield event.eventType, {
+                            'status_code': response.status_code,
+                            'message': e.message
+                        }
+                    else:
+                        yield event.eventType, DashScopeAPIResponse(
+                            request_id=request_id,
+                            status_code=HTTPStatus.BAD_REQUEST,
+                            output=None,
+                            code='Unknown',
+                            message=event.data)
+                    continue
+            else:
+                if flattened_output:
+                    yield event.eventType, {
+                        'status_code': status_code,
+                        'message': event.data
+                    }
+                else:
+                    msg = json.loads(event.eventType)
+                    yield event.eventType, DashScopeAPIResponse(
+                        request_id=request_id,
+                        status_code=status_code,
+                        output=None,
+                        code=msg['code']
+                        if 'code' in msg else None,  # noqa E501
+                        message=msg['message']
+                        if 'message' in msg else None)  # noqa E501
+    elif response.status_code == HTTPStatus.OK or response.status_code == HTTPStatus.CREATED:
         json_content = response.json()
-        if 'data' in json_content:
-            output = json_content['data']
-        if 'code' in json_content:
-            code = json_content['code']
-        if 'message' in json_content:
-            msg = json_content['message']
-        if 'output' in json_content:
-            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']
-        return DashScopeAPIResponse(request_id=request_id,
-                                    status_code=response.status_code,
-                                    code=code,
-                                    output=output,
-                                    usage=usage,
-                                    message=msg)
+        if flattened_output:
+            json_content['status_code'] = response.status_code
+            yield None, json_content
+        else:
+            output = None
+            usage = None
+            code = None
+            msg = ''
+            if 'data' in json_content:
+                output = json_content['data']
+            if 'code' in json_content:
+                code = json_content['code']
+            if 'message' in json_content:
+                msg = json_content['message']
+            if 'output' in json_content:
+                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']
+                json_content.pop('request_id', None)
+
+            if 'data' not in json_content and 'output' not in json_content:
+                output = json_content
+
+            yield None, DashScopeAPIResponse(request_id=request_id,
+                                             status_code=response.status_code,
+                                             code=code,
+                                             output=output,
+                                             usage=usage,
+                                             message=msg)
     else:
-        return _handle_http_failed_response(response)
+        yield None, _handle_http_failed_response(response, flattened_output)

dashscope/deployment.py

@@ -15,6 +15,7 @@ class Deployment(CreateMixin, DeleteMixin, ListMixin, GetMixin,
              version: str = None,
              suffix: str = None,
              api_key: str = None,
+             workspace: str = None,
              **kwargs) -> DashScopeAPIResponse:
         """Call to deployment a model service.
 
@@ -27,6 +28,7 @@ class Deployment(CreateMixin, DeleteMixin, ListMixin, GetMixin,
                 Defaults to None.
             capacity (int, optional): The model service capacity.
             api_key (str, optional): The api-key. Defaults to None.
+            workspace (str): The dashscope workspace id.
 
         Returns:
             DashScopeAPIResponse: _description_
@@ -37,13 +39,17 @@ class Deployment(CreateMixin, DeleteMixin, ListMixin, GetMixin,
             req['model_version'] = version
         if suffix is not None:
             req['suffix'] = suffix
-        return super().call(req, api_key, **kwargs)
+        return super().call(req,
+                            api_key=api_key,
+                            workspace=workspace,
+                            **kwargs)
 
     @classmethod
     def list(cls,
              page_no=1,
              page_size=10,
              api_key: str = None,
+             workspace: str = None,
              **kwargs) -> DashScopeAPIResponse:
         """List deployments.
 
@@ -52,49 +58,65 @@ class Deployment(CreateMixin, DeleteMixin, ListMixin, GetMixin,
                 will get by default rule(TODO: api key doc). Defaults to None.
             page_no (int, optional): Page number. Defaults to 1.
             page_size (int, optional): Items per page. Defaults to 10.
+            workspace (str): The dashscope workspace id.
 
         Returns:
             DashScopeAPIResponse: The deployment list.
         """
-        return super().list(page_no, page_size, api_key, **kwargs)
+        return super().list(page_no,
+                            page_size,
+                            api_key,
+                            workspace=workspace,
+                            **kwargs)
 
     @classmethod
     def get(cls,
             deployed_model: str,
             api_key: str = None,
+            workspace: str = None,
             **kwargs) -> DashScopeAPIResponse:
         """Get model deployment information.
 
         Args:
             deployed_model (str): The deployment_id.
             api_key (str, optional): The api key. Defaults to None.
+            workspace (str): The dashscope workspace id.
 
         Returns:
             DashScopeAPIResponse: The deployment information.
         """
-        return super().get(deployed_model, api_key, **kwargs)
+        return super().get(deployed_model,
+                           api_key,
+                           workspace=workspace,
+                           **kwargs)
 
     @classmethod
     def delete(cls,
                deployment_id: str,
                api_key: str = None,
+               workspace: str = None,
                **kwargs) -> DashScopeAPIResponse:
         """Delete model deployment.
 
         Args:
             deployment_id (str): The deployment id.
             api_key (str, optional): The api key. Defaults to None.
+            workspace (str): The dashscope workspace id.
 
         Returns:
             DashScopeAPIResponse: The delete result.
         """
-        return super().delete(deployment_id, api_key, **kwargs)
+        return super().delete(deployment_id,
+                              api_key,
+                              workspace=workspace,
+                              **kwargs)
 
     @classmethod
     def update(cls,
                deployment_id: str,
                version: str,
                api_key: str = None,
+               workspace: str = None,
                **kwargs) -> DashScopeAPIResponse:
         """Update model deployment.
 
@@ -102,18 +124,24 @@ class Deployment(CreateMixin, DeleteMixin, ListMixin, GetMixin,
             deployment_id (str): The deployment id.
             version (str): The target model version.
             api_key (str, optional): The api key. Defaults to None.
+            workspace (str): The dashscope workspace id.
 
         Returns:
             DashScopeAPIResponse: The delete result.
         """
         req = {'deployment_model': deployment_id, 'model_version': version}
-        return super().put(deployment_id, req, api_key, **kwargs)
+        return super().put(deployment_id,
+                           req,
+                           api_key,
+                           workspace=workspace,
+                           **kwargs)
 
     @classmethod
     def scale(cls,
               deployment_id: str,
               capacity: int,
               api_key: str = None,
+              workspace: str = None,
               **kwargs) -> DashScopeAPIResponse:
         """Scaling model deployment.
 
@@ -126,4 +154,10 @@ class Deployment(CreateMixin, DeleteMixin, ListMixin, GetMixin,
             DashScopeAPIResponse: The delete result.
         """
         req = {'deployed_model': deployment_id, 'capacity': capacity}
-        return super().put(deployment_id, req, 'scale', api_key, **kwargs)
+        path = '%s/%s/scale' % (cls.SUB_PATH.lower(), deployment_id)
+        return super().put(deployment_id,
+                           req,
+                           path=path,
+                           api_key=api_key,
+                           workspace=workspace,
+                           **kwargs)

dashscope/embeddings/batch_text_embedding.py

@@ -22,6 +22,7 @@ class BatchTextEmbedding(BaseAsyncApi):
              model: str,
              url: str,
              api_key: str = None,
+             workspace: str = None,
              **kwargs) -> BatchTextEmbeddingResponse:
         """Call async text embedding service and get result.
 
@@ -30,6 +31,7 @@ class BatchTextEmbedding(BaseAsyncApi):
             url (Any): The async request file url, which contains text
                 to embedding line by line.
             api_key (str, optional): The api api_key. Defaults to None.
+            workspace (str): The dashscope workspace id.
             **kwargs:
                 text_type(str, `optional`): [query|document], After the
                 text is converted into a vector, it can be applied to
@@ -47,13 +49,18 @@ class BatchTextEmbedding(BaseAsyncApi):
         Returns:
             AsyncTextEmbeddingResponse: The async text embedding task result.
         """
-        return super().call(model, url, api_key=api_key, **kwargs)
+        return super().call(model,
+                            url,
+                            api_key=api_key,
+                            workspace=workspace,
+                            **kwargs)
 
     @classmethod
     def async_call(cls,
                    model: str,
                    url: str,
                    api_key: str = None,
+                   workspace: str = None,
                    **kwargs) -> BatchTextEmbeddingResponse:
         """Create a async text embedding task, and return task information.
 
@@ -62,6 +69,7 @@ class BatchTextEmbedding(BaseAsyncApi):
             url (Any): The async request file url, which contains text
                 to embedding line by line.
             api_key (str, optional): The api api_key. Defaults to None.
+            workspace (str): The dashscope workspace id.
             **kwargs:
                 text_type(str, `optional`): [query|document], After the
                 text is converted into a vector, it can be applied to
@@ -91,47 +99,53 @@ class BatchTextEmbedding(BaseAsyncApi):
                                       function=BatchTextEmbedding.function,
                                       api_key=api_key,
                                       input=input,
+                                      workspace=workspace,
                                       **kwargs)
         return BatchTextEmbeddingResponse.from_api_response(response)
 
     @classmethod
     def fetch(cls,
               task: Union[str, BatchTextEmbeddingResponse],
-              api_key: str = None) -> BatchTextEmbeddingResponse:
+              api_key: str = None,
+              workspace: str = None) -> BatchTextEmbeddingResponse:
         """Fetch async text embedding task status or result.
 
         Args:
             task (Union[str, AsyncTextEmbeddingResponse]): The task_id or
                 AsyncTextEmbeddingResponse return by async_call().
             api_key (str, optional): The api api_key. Defaults to None.
+            workspace (str): The dashscope workspace id.
 
         Returns:
             AsyncTextEmbeddingResponse: The task status or result.
         """
-        response = super().fetch(task, api_key)
+        response = super().fetch(task, api_key, workspace=workspace)
         return BatchTextEmbeddingResponse.from_api_response(response)
 
     @classmethod
     def wait(cls,
              task: Union[str, BatchTextEmbeddingResponse],
-             api_key: str = None) -> BatchTextEmbeddingResponse:
+             api_key: str = None,
+             workspace: str = None) -> BatchTextEmbeddingResponse:
         """Wait for async text embedding task to complete, and return the result.
 
         Args:
             task (Union[str, AsyncTextEmbeddingResponse]): The task_id or
                 AsyncTextEmbeddingResponse return by async_call().
             api_key (str, optional): The api api_key. Defaults to None.
+            workspace (str): The dashscope workspace id.
 
         Returns:
             AsyncTextEmbeddingResponse: The task result.
         """
-        response = super().wait(task, api_key)
+        response = super().wait(task, api_key, workspace=workspace)
         return BatchTextEmbeddingResponse.from_api_response(response)
 
     @classmethod
     def cancel(cls,
                task: Union[str, BatchTextEmbeddingResponse],
-               api_key: str = None) -> DashScopeAPIResponse:
+               api_key: str = None,
+               workspace: str = None) -> DashScopeAPIResponse:
         """Cancel async text embedding task.
         Only tasks whose status is PENDING can be canceled.
 
@@ -139,11 +153,12 @@ class BatchTextEmbedding(BaseAsyncApi):
             task (Union[str, AsyncTextEmbeddingResponse]): The task_id or
                 AsyncTextEmbeddingResponse return by async_call().
             api_key (str, optional): The api api_key. Defaults to None.
+            workspace (str): The dashscope workspace id.
 
         Returns:
             DashScopeAPIResponse: The response data.
         """
-        return super().cancel(task, api_key)
+        return super().cancel(task, api_key, workspace=workspace)
 
     @classmethod
     def list(cls,
@@ -156,6 +171,7 @@ class BatchTextEmbedding(BaseAsyncApi):
              page_no: int = 1,
              page_size: int = 10,
              api_key: str = None,
+             workspace: str = None,
              **kwargs) -> DashScopeAPIResponse:
         """List async tasks.
 
@@ -186,4 +202,5 @@ class BatchTextEmbedding(BaseAsyncApi):
                             page_no=page_no,
                             page_size=page_size,
                             api_key=api_key,
+                            workspace=workspace,
                             **kwargs)

dashscope/embeddings/multimodal_embedding.py

@@ -55,6 +55,7 @@ class MultiModalEmbedding(BaseApi):
              model: str,
              input: List[MultiModalEmbeddingItemBase],
              api_key: str = None,
+             workspace: str = None,
              **kwargs) -> DashScopeAPIResponse:
         """Get embedding multimodal contents..
 
@@ -62,6 +63,7 @@ class MultiModalEmbedding(BaseApi):
             model (str): The embedding model name.
             input (List[MultiModalEmbeddingElement]): The embedding elements,
                 every element include data, modal, factor field.
+            workspace (str): The dashscope workspace id.
             **kwargs:
                 auto_truncation(bool, `optional`): Automatically truncate
                 audio longer than 15 seconds or text longer than 70 words.
@@ -89,6 +91,7 @@ class MultiModalEmbedding(BaseApi):
                             task=MultiModalEmbedding.task,
                             function=function,
                             api_key=api_key,
+                            workspace=workspace,
                             **kwargs)
 
     @classmethod