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

dashscope/app/application.py

@@ -1,6 +1,4 @@
 #!/usr/bin/env python3
-# -*-coding:utf-8 -*-
-
 """
 @File    :   application.py
 @Date    :   2024-02-24
@@ -18,12 +16,10 @@ from dashscope.common.error import InputRequired, InvalidInput
 
 class Application(BaseApi):
     task_group = 'apps'
-    function = "completion"
-
+    function = 'completion'
     """API for app completion calls.
 
     """
-
     class DocReferenceType:
         """ doc reference type for rag completion """
 
@@ -41,14 +37,15 @@ class Application(BaseApi):
 
     @classmethod
     def call(
-            cls,
-            app_id: str,
-            prompt: str,
-            history: list = None,
-            workspace: str = None,
-            api_key: str = None,
-            **kwargs
-    ) -> Union[ApplicationResponse, Generator[ApplicationResponse, None, None]]:
+        cls,
+        app_id: str,
+        prompt: str,
+        history: list = None,
+        workspace: str = None,
+        api_key: str = None,
+        **kwargs
+    ) -> Union[ApplicationResponse, Generator[ApplicationResponse, None,
+                                              None]]:
         """Call app completion service.
 
         Args:
@@ -115,17 +112,14 @@ class Application(BaseApi):
         if prompt is None or not prompt:
             raise InputRequired('prompt is required!')
 
-        if workspace is not None and workspace:
-            headers = kwargs.pop('headers', {})
-            headers['X-DashScope-WorkSpace'] = workspace
-            kwargs['headers'] = headers
-
-        input, parameters = cls._build_input_parameters(prompt, history, **kwargs)
+        input, parameters = cls._build_input_parameters(
+            prompt, history, **kwargs)
         request = _build_api_request(model='',
                                      input=input,
                                      task_group=Application.task_group,
                                      task=app_id,
                                      function=Application.function,
+                                     workspace=workspace,
                                      api_key=api_key,
                                      is_service=False,
                                      **parameters)
@@ -143,9 +137,7 @@ class Application(BaseApi):
     def _build_input_parameters(cls, prompt, history, **kwargs):
         parameters = {}
 
-        input_param = {HISTORY: history,
-                       PROMPT: prompt
-                       }
+        input_param = {HISTORY: history, PROMPT: prompt}
 
         session_id = kwargs.pop('session_id', None)
         if session_id is not None and session_id:
@@ -157,7 +149,8 @@ class Application(BaseApi):
 
         doc_tag_codes = kwargs.pop('doc_tag_codes', None)
         if doc_tag_codes is not None:
-            if isinstance(doc_tag_codes, list) and all(isinstance(item, str) for item in doc_tag_codes):
+            if isinstance(doc_tag_codes, list) and all(
+                    isinstance(item, str) for item in doc_tag_codes):
                 input_param['doc_tag_codes'] = doc_tag_codes
             else:
                 raise InvalidInput('doc_tag_codes is not a List[str]')

dashscope/assistants/__init__.py

@@ -0,0 +1,14 @@
+# yapf: disable
+
+from dashscope.assistants.assistant_types import (Assistant, AssistantFile,
+                                                  AssistantList,
+                                                  DeleteResponse)
+from dashscope.assistants.assistants import Assistants
+
+__all__ = [
+    Assistant,
+    Assistants,
+    AssistantList,
+    AssistantFile,
+    DeleteResponse,
+]

dashscope/assistants/assistant_types.py

@@ -0,0 +1,164 @@
+# adapter from openai sdk
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Union
+
+from dashscope.common.base_type import BaseList, BaseObjectMixin
+
+__all__ = [
+    'Assistant', 'AssistantFile', 'ToolCodeInterpreter', 'ToolSearch',
+    'ToolWanX', 'FunctionDefinition', 'ToolFunction', 'AssistantFileList',
+    'AssistantList', 'DeleteResponse'
+]
+
+
+@dataclass(init=False)
+class AssistantFile(BaseObjectMixin):
+    id: str
+    assistant_id: str
+    created_at: int
+    object: str
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+
+@dataclass(init=False)
+class ToolCodeInterpreter(BaseObjectMixin):
+    type: str = 'code_interpreter'
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+
+@dataclass(init=False)
+class ToolSearch(BaseObjectMixin):
+    type: str = 'search'
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+
+@dataclass(init=False)
+class ToolWanX(BaseObjectMixin):
+    type: str = 'wanx'
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+
+@dataclass(init=False)
+class FunctionDefinition(BaseObjectMixin):
+    name: str
+    description: Optional[str] = None
+    parameters: Optional[Dict[str, object]] = None
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+
+@dataclass(init=False)
+class ToolFunction(BaseObjectMixin):
+    function: FunctionDefinition
+    type: str = 'function'
+
+    def __init__(self, **kwargs):
+        self.function = FunctionDefinition(**kwargs.pop('function', {}))
+        super().__init__(**kwargs)
+
+
+Tool = Union[ToolCodeInterpreter, ToolSearch, ToolFunction, ToolWanX]
+ASSISTANT_SUPPORT_TOOL = {
+    'code_interpreter': ToolCodeInterpreter,
+    'search': ToolSearch,
+    'wanx': ToolWanX,
+    'function': ToolFunction
+}
+
+
+def convert_tools_dict_to_objects(tools):
+    tools_object = []
+    for tool in tools:
+        if 'type' in tool:
+            tool_type = ASSISTANT_SUPPORT_TOOL.get(tool['type'], None)
+            if tool_type:
+                tools_object.append(tool_type(**tool))
+            else:
+                tools_object.append(tool)
+        else:
+            tools_object.append(tool)
+    return tools_object
+
+
+@dataclass(init=False)
+class Assistant(BaseObjectMixin):
+    status_code: int
+    """The call response status_code, 200 indicate create success.
+    """
+    code: str
+    """The request failed, this is the error code.
+    """
+    message: str
+    """The request failed, this is the error message.
+    """
+    id: str
+    """ID of the assistant.
+    """
+    model: str
+    name: Optional[str] = None
+    created_at: int
+    """The Unix timestamp (in seconds) for when the assistant was created.
+    """
+    description: Optional[str] = None
+
+    file_ids: List[str]
+
+    instructions: Optional[str] = None
+    metadata: Optional[object] = None
+    tools: List[Tool]
+
+    def __init__(self, **kwargs):
+        self.tools = convert_tools_dict_to_objects(kwargs.pop('tools', []))
+        super().__init__(**kwargs)
+
+
+@dataclass(init=False)
+class AssistantList(BaseList):
+    data: List[Assistant]
+
+    def __init__(self,
+                 has_more: bool = None,
+                 last_id: Optional[str] = None,
+                 first_id: Optional[str] = None,
+                 data: List[Assistant] = [],
+                 **kwargs):
+        super().__init__(has_more=has_more,
+                         last_id=last_id,
+                         first_id=first_id,
+                         data=data,
+                         **kwargs)
+
+
+@dataclass(init=False)
+class AssistantFileList(BaseList):
+    data: List[AssistantFile]
+
+    def __init__(self,
+                 has_more: bool = None,
+                 last_id: Optional[str] = None,
+                 first_id: Optional[str] = None,
+                 data: List[AssistantFile] = [],
+                 **kwargs):
+        super().__init__(has_more=has_more,
+                         last_id=last_id,
+                         first_id=first_id,
+                         data=data,
+                         **kwargs)
+
+
+@dataclass(init=False)
+class DeleteResponse(BaseObjectMixin):
+    id: str
+    deleted: bool
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)

dashscope/assistants/assistants.py

@@ -0,0 +1,280 @@
+from typing import Dict, List, Optional
+
+from dashscope.assistants.assistant_types import (Assistant, AssistantList,
+                                                  DeleteResponse)
+from dashscope.client.base_api import (CancelMixin, CreateMixin, DeleteMixin,
+                                       GetStatusMixin, ListObjectMixin,
+                                       UpdateMixin)
+from dashscope.common.error import ModelRequired
+
+__all__ = ['Assistants']
+
+
+class Assistants(CreateMixin, CancelMixin, DeleteMixin, ListObjectMixin,
+                 GetStatusMixin, UpdateMixin):
+    SUB_PATH = 'assistants'
+
+    @classmethod
+    def _create_assistant_object(
+        cls,
+        model: str = None,
+        name: str = None,
+        description: str = None,
+        instructions: str = None,
+        tools: Optional[str] = [],
+        file_ids: Optional[str] = [],
+        metadata: Dict = {},
+    ):
+        obj = {}
+        if model:
+            obj['model'] = model
+        if name:
+            obj['name'] = name
+        if description:
+            obj['description'] = description
+        if instructions:
+            obj['instructions'] = instructions
+        if tools:
+            obj['tools'] = tools
+        obj['file_ids'] = file_ids
+        obj['metadata'] = metadata
+
+        return obj
+
+    @classmethod
+    def call(cls,
+             *,
+             model: str,
+             name: str = None,
+             description: str = None,
+             instructions: str = None,
+             tools: Optional[List[Dict]] = [],
+             file_ids: Optional[List[str]] = [],
+             metadata: Dict = None,
+             workspace: str = None,
+             api_key: str = None,
+             **kwargs) -> Assistant:
+        """Create Assistant.
+
+        Args:
+            model (str): The model to use.
+            name (str, optional): The assistant name. Defaults to None.
+            description (str, optional): The assistant description. Defaults to None.
+            instructions (str, optional): The system instructions this assistant uses. Defaults to None.
+            tools (Optional[List[Dict]], optional): List of tools to use. Defaults to [].
+            file_ids (Optional[List[str]], optional): : The files to use. Defaults to [].
+            metadata (Dict, optional): Custom key-value pairs associate with assistant. Defaults to None.
+            workspace (str, optional): The DashScope workspace id. Defaults to None.
+            api_key (str, optional): The DashScope api key. Defaults to None.
+
+        Raises:
+            ModelRequired: The model is required.
+
+        Returns:
+            Assistant: The `Assistant` object.
+        """
+        return cls.create(model=model,
+                          name=name,
+                          description=description,
+                          instructions=instructions,
+                          tools=tools,
+                          file_ids=file_ids,
+                          metadata=metadata,
+                          workspace=workspace,
+                          api_key=api_key,
+                          **kwargs)
+
+    @classmethod
+    def create(cls,
+               *,
+               model: str,
+               name: str = None,
+               description: str = None,
+               instructions: str = None,
+               tools: Optional[List[Dict]] = [],
+               file_ids: Optional[List[str]] = [],
+               metadata: Dict = None,
+               workspace: str = None,
+               api_key: str = None,
+               **kwargs) -> Assistant:
+        """Create Assistant.
+
+        Args:
+            model (str): The model to use.
+            name (str, optional): The assistant name. Defaults to None.
+            description (str, optional): The assistant description. Defaults to None.
+            instructions (str, optional): The system instructions this assistant uses. Defaults to None.
+            tools (Optional[List[Dict]], optional): List of tools to use. Defaults to [].
+            file_ids (Optional[List[str]], optional): : The files to use. Defaults to [].
+            metadata (Dict, optional): Custom key-value pairs associate with assistant. Defaults to None.
+            workspace (str, optional): The DashScope workspace id. Defaults to None.
+            api_key (str, optional): The DashScope api key. Defaults to None.
+
+        Raises:
+            ModelRequired: The model is required.
+
+        Returns:
+            Assistant: The `Assistant` object.
+        """
+        if not model:
+            raise ModelRequired('Model is required!')
+        data = cls._create_assistant_object(model, name, description,
+                                            instructions, tools, file_ids,
+                                            metadata)
+        response = super().call(data=data,
+                                api_key=api_key,
+                                flattened_output=True,
+                                workspace=workspace,
+                                **kwargs)
+        return Assistant(**response)
+
+    @classmethod
+    def retrieve(cls,
+                 assistant_id: str,
+                 *,
+                 workspace: str = None,
+                 api_key: str = None,
+                 **kwargs) -> Assistant:
+        """Get the `Assistant`.
+
+        Args:
+            assistant_id (str): The assistant id.
+            workspace (str): The dashscope workspace id.
+            api_key (str, optional): The api key. Defaults to None.
+
+        Returns:
+            Assistant: The `Assistant` object.
+        """
+        return cls.get(assistant_id,
+                       workspace=workspace,
+                       api_key=api_key,
+                       **kwargs)
+
+    @classmethod
+    def get(cls,
+            assistant_id: str,
+            *,
+            workspace: str = None,
+            api_key: str = None,
+            **kwargs) -> Assistant:
+        """Get the `Assistant`.
+
+        Args:
+            assistant_id (str): The assistant id.
+            workspace (str): The dashscope workspace id.
+            api_key (str, optional): The api key. Defaults to None.
+
+        Returns:
+            Assistant: The `Assistant` object.
+        """
+        if not assistant_id:
+            raise ModelRequired('assistant_id is required!')
+        response = super().get(assistant_id,
+                               workspace=workspace,
+                               api_key=api_key,
+                               flattened_output=True,
+                               **kwargs)
+        return Assistant(**response)
+
+    @classmethod
+    def list(cls,
+             *,
+             limit: int = None,
+             order: str = None,
+             after: str = None,
+             before: str = None,
+             workspace: str = None,
+             api_key: str = None,
+             **kwargs) -> AssistantList:
+        """List assistants
+
+        Args:
+            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:
+            AssistantList: The list of assistants.
+        """
+        response = super().list(limit=limit,
+                                order=order,
+                                after=after,
+                                before=before,
+                                workspace=workspace,
+                                api_key=api_key,
+                                flattened_output=True,
+                                **kwargs)
+        return AssistantList(**response)
+
+    @classmethod
+    def update(cls,
+               assistant_id: str,
+               *,
+               model: str = None,
+               name: str = None,
+               description: str = None,
+               instructions: str = None,
+               tools: Optional[str] = [],
+               file_ids: Optional[str] = [],
+               metadata: Dict = None,
+               workspace: str = None,
+               api_key: str = None,
+               **kwargs) -> Assistant:
+        """Update an exist assistants
+
+        Args:
+            assistant_id (str): The target assistant id.
+            model (str): The model to use.
+            name (str, optional): The assistant name. Defaults to None.
+            description (str, optional): The assistant description . Defaults to None.
+            instructions (str, optional): The system instructions this assistant uses.. Defaults to None.
+            tools (Optional[str], optional): List of tools to use.. Defaults to [].
+            file_ids (Optional[str], optional): The files to use in assistants.. Defaults to [].
+            metadata (Dict, optional): Custom key-value pairs associate with assistant. Defaults to None.
+            workspace (str): The DashScope workspace id.
+            api_key (str, optional): The DashScope workspace id. Defaults to None.
+
+        Returns:
+            Assistant: The updated assistant.
+        """
+        if not assistant_id:
+            raise ModelRequired('assistant_id is required!')
+        response = super().update(assistant_id,
+                                  cls._create_assistant_object(
+                                      model, name, description, instructions,
+                                      tools, file_ids, metadata),
+                                  api_key=api_key,
+                                  workspace=workspace,
+                                  flattened_output=True,
+                                  method='post',
+                                  **kwargs)
+        return Assistant(**response)
+
+    @classmethod
+    def delete(cls,
+               assistant_id: str,
+               *,
+               workspace: str = None,
+               api_key: str = None,
+               **kwargs) -> DeleteResponse:
+        """Delete uploaded file.
+
+        Args:
+            assistant_id (str): The assistant id want to delete.
+            workspace (str): The DashScope workspace id.
+            api_key (str, optional): The api key. Defaults to None.
+
+        Returns:
+            AssistantsDeleteResponse: Delete result.
+        """
+        if not assistant_id:
+            raise ModelRequired('assistant_id is required!')
+        response = super().delete(assistant_id,
+                                  api_key=api_key,
+                                  workspace=workspace,
+                                  flattened_output=True,
+                                  **kwargs)
+        return DeleteResponse(**response)