dashscope 1.15.0__py3-none-any.whl → 1.17.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

@@ -8,6 +8,7 @@ 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.version import __version__
@@ -126,7 +127,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]
 
@@ -163,12 +164,16 @@ async def _handle_aiohttp_response(response: aiohttp.ClientResponse):
 
 
 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,20 +188,26 @@ 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):
     request_id = ''
-    if response.status_code == HTTPStatus.OK:
+    if response.status_code == HTTPStatus.OK or response.status_code == HTTPStatus.CREATED:
+        json_content = response.json()
+        if flattened_output:
+            json_content['status_code'] = response.status_code
+            return json_content
         output = None
         usage = None
         code = None
         msg = ''
-        json_content = response.json()
         if 'data' in json_content:
             output = json_content['data']
         if 'code' in json_content:
@@ -209,6 +220,11 @@ def _handle_http_response(response: requests.Response):
             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
+
         return DashScopeAPIResponse(request_id=request_id,
                                     status_code=response.status_code,
                                     code=code,
@@ -216,4 +232,4 @@ def _handle_http_response(response: requests.Response):
                                     usage=usage,
                                     message=msg)
     else:
-        return _handle_http_failed_response(response)
+        return _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

dashscope/embeddings/text_embedding.py

@@ -14,7 +14,11 @@ class TextEmbedding(BaseApi):
         text_embedding_v2 = 'text-embedding-v2'
 
     @classmethod
-    def call(cls, model: str, input: Union[str, List[str]],
+    def call(cls,
+             model: str,
+             input: Union[str, List[str]],
+             workspace: str = None,
+             api_key: str = None,
              **kwargs) -> DashScopeAPIResponse:
         """Get embedding of text input.
 
@@ -24,6 +28,7 @@ class TextEmbedding(BaseApi):
                 can be a text or list of text or opened file object,
                 if opened file object, will read all lines,
                 one embedding per line.
+            workspace (str): The dashscope workspace id.
             **kwargs:
                 text_type(str, `optional`): query or document.
 
@@ -42,4 +47,6 @@ class TextEmbedding(BaseApi):
                             task_group=task_group,
                             task=TextEmbedding.task,
                             function=function,
+                            api_key=api_key,
+                            workspace=workspace,
                             **kwargs)

dashscope/files.py

@@ -0,0 +1,107 @@
+import os
+
+from dashscope.api_entities.dashscope_response import DashScopeAPIResponse
+from dashscope.client.base_api import (DeleteMixin, FileUploadMixin, GetMixin,
+                                       ListMixin)
+from dashscope.common.constants import FilePurpose
+from dashscope.common.error import InvalidFileFormat
+from dashscope.common.utils import is_validate_fine_tune_file
+
+
+class Files(FileUploadMixin, ListMixin, DeleteMixin, GetMixin):
+    SUB_PATH = 'files'
+
+    @classmethod
+    def upload(cls,
+               file_path: str,
+               purpose: str = FilePurpose.fine_tune,
+               description: str = None,
+               api_key: str = None,
+               workspace: str = None,
+               **kwargs) -> DashScopeAPIResponse:
+        """Upload file for model fine-tune or other tasks.
+
+        Args:
+            file_path (str): The local file name to upload.
+            purpose (str): The purpose of the file[fine-tune|inference]
+            description (str, optional): The file description message.
+            api_key (str, optional): The api key. Defaults to None.
+            workspace (str): The dashscope workspace id.
+
+        Returns:
+            DashScopeAPIResponse: The upload information
+        """
+        if purpose == FilePurpose.fine_tune:
+            if not is_validate_fine_tune_file(file_path):
+                raise InvalidFileFormat(
+                    'The file %s is not in valid jsonl format' % file_path)
+        with open(file_path, 'rb') as f:
+            return super().upload(files=[('files', (os.path.basename(f.name),
+                                                    f, None))],
+                                  descriptions=[description]
+                                  if description is not None else None,
+                                  api_key=api_key,
+                                  workspace=workspace,
+                                  **kwargs)
+
+    @classmethod
+    def list(cls,
+             page=1,
+             page_size=10,
+             api_key: str = None,
+             workspace: str = None,
+             **kwargs) -> DashScopeAPIResponse:
+        """List uploaded files.
+
+        Args:
+            api_key (str, optional):
+            The api api_key, can be None,
+                if None, will get by default rule(TODO: api key doc).
+            page (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 fine-tune jobs in the result.
+        """
+        return super().list(page,
+                            page_size,
+                            api_key,
+                            workspace=workspace,
+                            **kwargs)
+
+    @classmethod
+    def get(cls,
+            file_id: str,
+            api_key: str = None,
+            workspace: str = None,
+            **kwargs) -> DashScopeAPIResponse:
+        """Get the file info.
+
+        Args:
+            file_id (str): The file id.
+            api_key (str, optional): The api key. Defaults to None.
+            workspace (str): The dashscope workspace id.
+
+        Returns:
+            DashScopeAPIResponse: The job info
+        """
+        return super().get(file_id, api_key, workspace=workspace, **kwargs)
+
+    @classmethod
+    def delete(cls,
+               file_id: str,
+               api_key: str = None,
+               workspace: str = None,
+               **kwargs) -> DashScopeAPIResponse:
+        """Delete uploaded file.
+
+        Args:
+            file_id (str): The file id want to delete.
+            api_key (str, optional): The api key. Defaults to None.
+            workspace (str): The dashscope workspace id.
+
+        Returns:
+            DashScopeAPIResponse: Delete result.
+        """
+        return super().delete(file_id, api_key, workspace=workspace, **kwargs)