dashscope 1.16.0__py3-none-any.whl → 1.17.1__py3-none-any.whl

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/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)

dashscope/threads/messages/messages.py

@@ -0,0 +1,218 @@
+from typing import Dict, List, Optional
+
+from dashscope.client.base_api import (CreateMixin, GetStatusMixin,
+                                       ListObjectMixin, UpdateMixin)
+from dashscope.common.error import InputRequired
+from dashscope.threads.thread_types import ThreadMessage, ThreadMessageList
+
+__all__ = ['Messages']
+
+
+class Messages(CreateMixin, ListObjectMixin, GetStatusMixin, UpdateMixin):
+    SUB_PATH = 'messages'  # useless
+
+    @classmethod
+    def call(cls,
+             thread_id: str,
+             *,
+             content: str,
+             role: str = 'user',
+             file_ids: List[str] = [],
+             metadata: Optional[object] = None,
+             workspace: str = None,
+             api_key: str = None,
+             **kwargs) -> ThreadMessage:
+        """Create message of thread.
+
+        Args:
+            thread_id (str): The thread id.
+            content (str): The message content.
+            role (str, optional): The message role. Defaults to 'user'.
+            file_ids (List[str], optional): The file_ids include in message. Defaults to [].
+            metadata (Optional[object], optional): The custom key/value pairs. Defaults to None.
+            workspace (str, optional): The DashScope workspace id. Defaults to None.
+            api_key (str, optional): The DashScope api key. Defaults to None.
+
+        Returns:
+            ThreadMessage: The `ThreadMessage` object.
+        """
+        return cls.create(thread_id,
+                          content=content,
+                          role=role,
+                          file_ids=file_ids,
+                          metadata=metadata,
+                          workspace=workspace,
+                          **kwargs)
+
+    @classmethod
+    def create(cls,
+               thread_id: str,
+               *,
+               content: str,
+               role: str = 'user',
+               file_ids: List[str] = [],
+               metadata: Optional[object] = None,
+               workspace: str = None,
+               api_key: str = None,
+               **kwargs) -> ThreadMessage:
+        """Create message of thread.
+
+        Args:
+            thread_id (str): The thread id.
+            content (str): The message content.
+            role (str, optional): The message role. Defaults to 'user'.
+            file_ids (List[str], optional): The file_ids include in message. Defaults to [].
+            metadata (Optional[object], optional): The custom key/value pairs. Defaults to None.
+            workspace (str, optional): The DashScope workspace id. Defaults to None.
+            api_key (str, optional): The DashScope api key. Defaults to None.
+
+        Returns:
+            ThreadMessage: The `ThreadMessage` object.
+        """
+        cls.SUB_PATH = '%s/messages' % thread_id
+        data = {}
+        if not thread_id or not content:
+            raise InputRequired('thread_id and content are required!')
+        data['content'] = content
+        data['role'] = role
+        if metadata:
+            data['metadata'] = metadata
+        if file_ids:
+            data['file_ids'] = file_ids
+        response = super().call(data=data,
+                                path=f'threads/{thread_id}/messages',
+                                api_key=api_key,
+                                flattened_output=True,
+                                workspace=workspace,
+                                **kwargs)
+        return ThreadMessage(**response)
+
+    @classmethod
+    def retrieve(cls,
+                 message_id: str,
+                 *,
+                 thread_id: str,
+                 workspace: str = None,
+                 api_key: str = None,
+                 **kwargs) -> ThreadMessage:
+        """Get the `ThreadMessage`.
+
+        Args:
+            thread_id (str): The thread id.
+            message_id (str): The message id.
+            workspace (str): The dashscope workspace id.
+            api_key (str, optional): The api key. Defaults to None.
+
+        Returns:
+            ThreadMessage: The `ThreadMessage` object.
+        """
+        return cls.get(message_id,
+                       thread_id=thread_id,
+                       workspace=workspace,
+                       api_key=api_key,
+                       **kwargs)
+
+    @classmethod
+    def get(cls,
+            message_id: str,
+            *,
+            thread_id: str,
+            workspace: str = None,
+            api_key: str = None,
+            **kwargs) -> ThreadMessage:
+        """Get the `ThreadMessage`.
+
+        Args:
+            thread_id (str): The thread id.
+            message_id (str): The message id.
+            workspace (str): The dashscope workspace id.
+            api_key (str, optional): The api key. Defaults to None.
+
+        Returns:
+            ThreadMessage: The `ThreadMessage` object.
+        """
+        if not message_id or not thread_id:
+            raise InputRequired('thread id, message id are required!')
+        response = super().get(
+            message_id,
+            path=f'threads/{thread_id}/messages/{message_id}',
+            workspace=workspace,
+            api_key=api_key,
+            flattened_output=True,
+            **kwargs)
+        return ThreadMessage(**response)
+
+    @classmethod
+    def list(cls,
+             thread_id: str,
+             *,
+             limit: int = None,
+             order: str = None,
+             after: str = None,
+             before: str = None,
+             workspace: str = None,
+             api_key: str = None,
+             **kwargs) -> ThreadMessageList:
+        """List message of the thread.
+
+        Args:
+            thread_id (str): The thread 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:
+            ThreadMessageList: The `ThreadMessageList` object.
+        """
+        if not thread_id:
+            raise InputRequired('thread id is required!')
+        response = super().list(limit=limit,
+                                order=order,
+                                after=after,
+                                before=before,
+                                path=f'threads/{thread_id}/messages',
+                                workspace=workspace,
+                                api_key=api_key,
+                                flattened_output=True,
+                                **kwargs)
+        return ThreadMessageList(**response)
+
+    @classmethod
+    def update(cls,
+               message_id: str,
+               *,
+               thread_id: str,
+               metadata: Dict = None,
+               workspace: str = None,
+               api_key: str = None,
+               **kwargs) -> ThreadMessage:
+        """Update an message of the thread.
+
+        Args:
+            thread_id (str): The thread id.
+            message_id (str): The message id.
+            content (str): The message content.
+            role (str, optional): The message role. Defaults to 'user'.
+            file_ids (List[str], optional): The file_ids include in message. Defaults to [].
+            metadata (Optional[object], optional): The custom key/value pairs. Defaults to None.
+            workspace (str, optional): The DashScope workspace id. Defaults to None.
+            api_key (str, optional): The DashScope api key. Defaults to None.
+
+        Returns:
+            ThreadMessage: The `ThreadMessage` object.
+        """
+        if not thread_id or not message_id:
+            raise InputRequired('thread id and message id are required!')
+        response = super().update(target=message_id,
+                                  json={'metadata': metadata},
+                                  path='threads/%s/messages/%s' %
+                                  (thread_id, message_id),
+                                  api_key=api_key,
+                                  workspace=workspace,
+                                  flattened_output=True,
+                                  method='post',
+                                  **kwargs)
+        return ThreadMessage(**response)