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

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)

dashscope/finetune.py

@@ -18,6 +18,7 @@ class FineTune(CreateMixin, CancelMixin, DeleteMixin, ListMixin,
              mode: str = None,
              hyper_parameters: dict = {},
              api_key: str = None,
+             workspace: str = None,
              **kwargs) -> DashScopeAPIResponse:
         """Create fine-tune job
 
@@ -31,6 +32,7 @@ class FineTune(CreateMixin, CancelMixin, DeleteMixin, ListMixin,
             hyper_parameters (dict, optional): The fine-tune hyper parameters.
                 Defaults to empty.
             api_key (str, optional): The api key. Defaults to None.
+            workspace (str): The dashscope workspace id.
 
         Returns:
             DashScopeAPIResponse: The request result.
@@ -45,12 +47,16 @@ class FineTune(CreateMixin, CancelMixin, DeleteMixin, ListMixin,
             request['training_type'] = mode
         if 'finetuned_output' in kwargs:
             request['finetuned_output'] = kwargs['finetuned_output']
-        return super().call(request, api_key, **kwargs)
+        return super().call(request,
+                            api_key=api_key,
+                            workspace=workspace,
+                            **kwargs)
 
     @classmethod
     def cancel(cls,
                job_id: str,
                api_key: str = None,
+               workspace: str = None,
                **kwargs) -> DashScopeAPIResponse:
         """Cancel a running fine-tune job.
 
@@ -58,17 +64,19 @@ class FineTune(CreateMixin, CancelMixin, DeleteMixin, ListMixin,
             job_id (str): The fine-tune job id.
             api_key (str, optional): The api api_key, can be None,
                 if None, will get by default rule(TODO: api key doc).
+            workspace (str): The dashscope workspace id.
 
         Returns:
             DashScopeAPIResponse: The request result.
         """
-        return super().cancel(job_id, api_key, **kwargs)
+        return super().cancel(job_id, api_key, workspace=workspace, **kwargs)
 
     @classmethod
     def list(cls,
              page=1,
              page_size=10,
              api_key: str = None,
+             workspace: str = None,
              **kwargs) -> DashScopeAPIResponse:
         """List fine-tune job.
 
@@ -76,59 +84,73 @@ class FineTune(CreateMixin, CancelMixin, DeleteMixin, ListMixin,
             api_key (str, optional): The api key
             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, **kwargs)
+        return super().list(page,
+                            page_size,
+                            api_key,
+                            workspace=workspace,
+                            **kwargs)
 
     @classmethod
     def get(cls,
             job_id: str,
             api_key: str = None,
+            workspace: str = None,
             **kwargs) -> DashScopeAPIResponse:
         """Get fine-tune job information.
 
         Args:
             job_id (str): The fine-tune job 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(job_id, api_key, **kwargs)
+        return super().get(job_id, api_key, workspace=workspace, **kwargs)
 
     @classmethod
     def delete(cls,
                job_id: str,
                api_key: str = None,
+               workspace: str = None,
                **kwargs) -> DashScopeAPIResponse:
         """Delete a fine-tune job.
 
         Args:
             job_id (str): The fine-tune job 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(job_id, api_key, **kwargs)
+        return super().delete(job_id, api_key, workspace=workspace, **kwargs)
 
     @classmethod
     def stream_events(cls,
                       job_id: str,
                       api_key: str = None,
+                      workspace: str = None,
                       **kwargs) -> DashScopeAPIResponse:
         """Get fine-tune job events.
 
         Args:
             job_id (str): The fine-tune job id
             api_key (str, optional): the api key. Defaults to None.
+            workspace (str): The dashscope workspace id.
 
         Returns:
             DashScopeAPIResponse: The job log events.
         """
-        return super().stream_events(job_id, api_key, **kwargs)
+        return super().stream_events(job_id,
+                                     api_key,
+                                     workspace=workspace,
+                                     **kwargs)
 
     @classmethod
     def logs(cls,
@@ -136,6 +158,7 @@ class FineTune(CreateMixin, CancelMixin, DeleteMixin, ListMixin,
              offset=1,
              line=1000,
              api_key: str = None,
+             workspace: str = None,
              **kwargs) -> DashScopeAPIResponse:
         """Get log of the job.
 
@@ -144,8 +167,9 @@ class FineTune(CreateMixin, CancelMixin, DeleteMixin, ListMixin,
             offset (int, optional): start log line. Defaults to 1.
             line (int, optional): total line return. Defaults to 1000.
             api_key (str, optional): The api key. Defaults to None.
+            workspace (str): The dashscope workspace id.
 
         Returns:
             DashScopeAPIResponse: The response
         """
-        return super().logs(job_id, offset, line)
+        return super().logs(job_id, offset, line, workspace=workspace)

dashscope/model.py

@@ -9,23 +9,26 @@ class Model(ListMixin, GetMixin):
     def get(cls,
             name: str,
             api_key: str = None,
+            workspace: str = None,
             **kwargs) -> DashScopeAPIResponse:
         """Get the model information.
 
         Args:
             name (str): The model name.
             api_key (str, optional): The api key. Defaults to None.
+            workspace (str): The dashscope workspace id.
 
         Returns:
             DashScopeAPIResponse: The model information.
         """
-        return super().get(name, api_key, **kwargs)
+        return super().get(name, api_key, workspace=workspace, **kwargs)
 
     @classmethod
     def list(cls,
              page=1,
              page_size=10,
              api_key: str = None,
+             workspace: str = None,
              **kwargs) -> DashScopeAPIResponse:
         """List models.
 
@@ -37,4 +40,8 @@ class Model(ListMixin, GetMixin):
         Returns:
             DashScopeAPIResponse: The models.
         """
-        return super().list(api_key, page, page_size, **kwargs)
+        return super().list(api_key,
+                            page,
+                            page_size,
+                            workspace=workspace,
+                            **kwargs)

dashscope/models.py

@@ -0,0 +1,47 @@
+from dashscope.api_entities.dashscope_response import DashScopeAPIResponse
+from dashscope.client.base_api import GetMixin, ListMixin
+
+
+class Model(ListMixin, GetMixin):
+    SUB_PATH = 'models'
+
+    @classmethod
+    def get(cls,
+            name: str,
+            api_key: str = None,
+            workspace: str = None,
+            **kwargs) -> DashScopeAPIResponse:
+        """Get the model information.
+
+        Args:
+            name (str): The model name.
+            api_key (str, optional): The api key. Defaults to None.
+            workspace (str): The dashscope workspace id.
+
+        Returns:
+            DashScopeAPIResponse: The model information.
+        """
+        return super().get(name, api_key, workspace=workspace, **kwargs)
+
+    @classmethod
+    def list(cls,
+             page=1,
+             page_size=10,
+             api_key: str = None,
+             workspace: str = None,
+             **kwargs) -> DashScopeAPIResponse:
+        """List models.
+
+        Args:
+            api_key (str, optional): The api key
+            page (int, optional): Page number. Defaults to 1.
+            page_size (int, optional): Items per page. Defaults to 10.
+
+        Returns:
+            DashScopeAPIResponse: The models.
+        """
+        return super().list(api_key,
+                            page,
+                            page_size,
+                            workspace=workspace,
+                            **kwargs)

dashscope/nlp/understanding.py

@@ -25,8 +25,8 @@ class Understanding(BaseApi):
 
         Args:
             model (str): The requested model, such as opennlu-v1
-            sentence (str): The text content entered by the user that needs to be processed supports both Chinese and English. (The maximum limit for input is 1024 tokens, which is the sum of all input fields).
-            labels (list): For the extraction task, label is the name of the type that needs to be extracted. For classification tasks, label is the classification system. Separate different labels with Chinese commas..
+            sentence (str): The text content entered by the user that needs to be processed supports both Chinese and English. (The maximum limit for input is 1024 tokens, which is the sum of all input fields).  # noqa E501
+            labels (list): For the extraction task, label is the name of the type that needs to be extracted. For classification tasks, label is the classification system. Separate different labels with Chinese commas..  # noqa E501
             task (str): Task type, optional as extraction or classification, default as extraction.
             api_key (str, optional): The api api_key, can be None,
                 if None, will get by default rule(TODO: api key doc).

dashscope/rerank/text_rerank.py

@@ -0,0 +1,67 @@
+from typing import List
+
+from dashscope.api_entities.dashscope_response import ReRankResponse
+from dashscope.client.base_api import BaseApi
+from dashscope.common.error import InputRequired, ModelRequired
+from dashscope.common.utils import _get_task_group_and_task
+
+
+class TextReRank(BaseApi):
+    task = 'text-rerank'
+    """API for rerank models.
+
+    """
+    class Models:
+        gte_rerank = 'gte-rerank'
+
+    @classmethod
+    def call(cls,
+             model: str,
+             query: str,
+             documents: List[str],
+             return_documents: bool = None,
+             top_n: int = None,
+             api_key: str = None,
+             **kwargs) -> ReRankResponse:
+        """Calling rerank service.
+
+        Args:
+            model (str): The model to use.
+            query (str): The query string.
+            documents (List[str]): The documents to rank.
+            return_documents(bool, `optional`): enable return origin documents,
+                system default is false.
+            top_n(int, `optional`): how many documents to return, default return
+                all the documents.
+            api_key (str, optional): The DashScope api key. Defaults to None.
+
+        Raises:
+            InputRequired: The query and documents are required.
+            ModelRequired: The model is required.
+
+        Returns:
+            RerankResponse: The rerank result.
+        """
+
+        if query is None or documents is None or not documents:
+            raise InputRequired('query and documents are required!')
+        if model is None or not model:
+            raise ModelRequired('Model is required!')
+        task_group, function = _get_task_group_and_task(__name__)
+        input = {'query': query, 'documents': documents}
+        parameters = {}
+        if return_documents is not None:
+            parameters['return_documents'] = return_documents
+        if top_n is not None:
+            parameters['top_n'] = top_n
+        parameters = {**parameters, **kwargs}
+
+        response = super().call(model=model,
+                                task_group=task_group,
+                                task=TextReRank.task,
+                                function=function,
+                                api_key=api_key,
+                                input=input,
+                                **parameters)
+
+        return ReRankResponse.from_api_response(response)

dashscope/threads/__init__.py

@@ -0,0 +1,24 @@
+# yapf: disable
+
+from dashscope.threads.messages.messages import Messages
+from dashscope.threads.runs.runs import Runs
+from dashscope.threads.runs.steps import Steps
+from dashscope.threads.thread_types import (MessageFile, Run, RunList, RunStep,
+                                            RunStepList, Thread, ThreadMessage,
+                                            ThreadMessageList)
+from dashscope.threads.threads import Threads
+
+__all__ = [
+    MessageFile,
+    Messages,
+    Run,
+    Runs,
+    RunList,
+    Steps,
+    RunStep,
+    RunStepList,
+    Threads,
+    Thread,
+    ThreadMessage,
+    ThreadMessageList,
+]

dashscope/threads/messages/files.py

@@ -0,0 +1,111 @@
+from dashscope.client.base_api import GetStatusMixin, ListObjectMixin
+from dashscope.common.error import InputRequired
+from dashscope.threads.thread_types import MessageFile, MessageFileList
+
+__all__ = ['Files']
+
+
+class Files(ListObjectMixin, GetStatusMixin):
+    SUB_PATH = 'messages'  # useless
+
+    @classmethod
+    def retrieve(cls,
+                 file_id: str,
+                 *,
+                 thread_id: str,
+                 message_id: str,
+                 workspace: str = None,
+                 api_key: str = None,
+                 **kwargs) -> MessageFile:
+        """Retrieve the `MessageFile`.
+
+        Args:
+            thread_id (str): The thread id.
+            message_id (str): The message id.
+            file_id (str): The file id.
+            workspace (str): The dashscope workspace id.
+            api_key (str, optional): The api key. Defaults to None.
+
+        Returns:
+            MessageFile: The `MessageFile` object.
+        """
+        return cls.get(file_id,
+                       thread_id=thread_id,
+                       message_id=message_id,
+                       workspace=workspace,
+                       api_key=api_key,
+                       **kwargs)
+
+    @classmethod
+    def get(cls,
+            file_id: str,
+            *,
+            message_id: str,
+            thread_id: str,
+            workspace: str = None,
+            api_key: str = None,
+            **kwargs) -> MessageFile:
+        """Retrieve the `MessageFile`.
+
+        Args:
+            assistant_id (str): The assistant id.
+            message_id (str): The message id.
+            file_id (str): The file id.
+            workspace (str): The dashscope workspace id.
+            api_key (str, optional): The api key. Defaults to None.
+
+        Returns:
+            MessageFile: The `MessageFile` object.
+        """
+        if not thread_id or not message_id or not file_id:
+            raise InputRequired(
+                'thread id, message id and file id are required!')
+        response = super().get(
+            message_id,
+            path=f'threads/{thread_id}/messages/{message_id}/files/{file_id}',
+            workspace=workspace,
+            api_key=api_key,
+            flattened_output=True,
+            **kwargs)
+        return MessageFile(**response)
+
+    @classmethod
+    def list(cls,
+             message_id: str,
+             *,
+             thread_id: str,
+             limit: int = None,
+             order: str = None,
+             after: str = None,
+             before: str = None,
+             workspace: str = None,
+             api_key: str = None,
+             **kwargs) -> MessageFileList:
+        """List message files.
+
+        Args:
+            thread_id (str): The thread id.
+            message_id (str): The message_id.
+            limit (int, optional): How many assistant to retrieve. Defaults to None.
+            order (str, optional): Sort order by created_at. Defaults to None.
+            after (str, optional): Assistant id after. Defaults to None.
+            before (str, optional): Assistant id before. Defaults to None.
+            workspace (str, optional): The DashScope workspace id. Defaults to None.
+            api_key (str, optional): Your DashScope api key. Defaults to None.
+
+        Returns:
+            MessageFileList: The `MessageFileList`.
+        """
+        if not thread_id or not message_id:
+            raise InputRequired('thread id, message id are required!')
+        response = super().list(
+            limit=limit,
+            order=order,
+            after=after,
+            before=before,
+            path=f'threads/{thread_id}/messages/{message_id}/files',
+            workspace=workspace,
+            api_key=api_key,
+            flattened_output=True,
+            **kwargs)
+        return MessageFileList(**response)