dashscope 1.8.0__py3-none-any.whl → 1.25.6__py3-none-any.whl

dashscope/app/application.py

@@ -0,0 +1,203 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+"""
+@File    :   application.py
+@Date    :   2024-02-24
+@Desc    :   Application calls for both http and http sse
+"""
+import copy
+from typing import Generator, List, Union
+
+from dashscope.api_entities.api_request_factory import _build_api_request
+from dashscope.api_entities.dashscope_response import Message, Role
+from dashscope.app.application_response import ApplicationResponse
+from dashscope.client.base_api import BaseApi
+from dashscope.common.api_key import get_default_api_key
+from dashscope.common.constants import (DEPRECATED_MESSAGE, HISTORY, MESSAGES,
+                                        PROMPT)
+from dashscope.common.error import InputRequired, InvalidInput
+from dashscope.common.logging import logger
+
+
+class Application(BaseApi):
+    task_group = 'apps'
+    function = 'completion'
+    """API for app completion calls.
+
+    """
+    class DocReferenceType:
+        """ doc reference type for rag completion """
+
+        simple = 'simple'
+
+        indexed = 'indexed'
+
+    @classmethod
+    def _validate_params(cls, api_key, app_id):
+        if api_key is None:
+            api_key = get_default_api_key()
+
+        if app_id is None or not app_id:
+            raise InputRequired('App id is required!')
+
+        return api_key, app_id
+
+    @classmethod
+    def call(
+        cls,
+        app_id: str,
+        prompt: str = None,
+        history: list = None,
+        workspace: str = None,
+        api_key: str = None,
+        messages: List[Message] = None,
+        **kwargs
+    ) -> Union[ApplicationResponse, Generator[ApplicationResponse, None,
+                                              None]]:
+        """Call app completion service.
+
+        Args:
+            app_id (str): Id of bailian application
+            prompt (str): The input prompt.
+            history (list):The user provided history
+                examples:
+                    [{'user':'The weather is fine today.',
+                    'bot': 'Suitable for outings'}].
+                Defaults to None.
+            workspace(str, `optional`): Workspace for app completion call
+            api_key (str, optional): The api api_key, can be None,
+                if None, will get by default rule(TODO: api key doc).
+            messages(list): The generation messages.
+
+            **kwargs:
+                stream(bool, `optional`): Enable server-sent events
+                    (ref: https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events)  # noqa E501
+                    the result will back partially[qwen-turbo,bailian-v1].
+                temperature(float, `optional`): Used to control the degree
+                    of randomness and diversity. Specifically, the temperature
+                    value controls the degree to which the probability distribution
+                    of each candidate word is smoothed when generating text.
+                    A higher temperature value will reduce the peak value of
+                    the probability, allowing more low-probability words to be
+                    selected, and the generated results will be more diverse;
+                    while a lower temperature value will enhance the peak value
+                    of the probability, making it easier for high-probability
+                    words to be selected, the generated results are more
+                    deterministic, range(0, 2) .[qwen-turbo,qwen-plus].
+                top_p(float, `optional`): A sampling strategy, called nucleus
+                    sampling, where the model considers the results of the
+                    tokens with top_p probability mass. So 0.1 means only
+                    the tokens comprising the top 10% probability mass are
+                    considered[qwen-turbo,bailian-v1].
+                top_k(int, `optional`): The size of the sample candidate set when generated.  # noqa E501
+                    For example, when the value is 50, only the 50 highest-scoring tokens  # noqa E501
+                    in a single generation form a randomly sampled candidate set. # noqa E501
+                    The larger the value, the higher the randomness generated;  # noqa E501
+                    the smaller the value, the higher the certainty generated. # noqa E501
+                    The default value is 0, which means the top_k policy is  # noqa E501
+                    not enabled. At this time, only the top_p policy takes effect. # noqa E501
+                seed(int, `optional`): When generating, the seed of the random number is used to control the
+                    randomness of the model generation. If you use the same seed, each run will generate the same results;
+                    you can use the same seed when you need to reproduce the model's generated results.
+                    The seed parameter supports unsigned 64-bit integer types. Default value 1234
+                session_id(str, `optional`): Session if for multiple rounds call.
+                biz_params(dict, `optional`): The extra parameters for flow or plugin.
+                has_thoughts(bool, `optional`): Flag to return rag or plugin process details. Default value false.
+                doc_tag_codes(list[str], `optional`): Tag code list for doc retrival.
+                doc_reference_type(str, `optional`): The type of doc reference.
+                    simple: simple format of doc retrival which not include index in response text but in doc reference list.
+                    indexed: include both index in response text and doc reference list
+                memory_id(str, `optional`): Used to store long term context summary between end users and assistant.
+                image_list(list, `optional`): Used to pass image url list.
+                rag_options(dict, `optional`): Rag options for retrieval augmented generation options.
+        Raises:
+            InvalidInput: The history and auto_history are mutually exclusive.
+
+        Returns:
+            Union[CompletionResponse,
+                  Generator[CompletionResponse, None, None]]: If
+            stream is True, return Generator, otherwise GenerationResponse.
+        """
+
+        api_key, app_id = Application._validate_params(api_key, app_id)
+
+        if (prompt is None or not prompt) and (messages is None
+                                               or len(messages) == 0):
+            raise InputRequired('prompt or messages 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, messages, **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)
+        # call request service.
+        response = request.call()
+        is_stream = kwargs.get('stream', False)
+
+        if is_stream:
+            return (ApplicationResponse.from_api_response(rsp)
+                    for rsp in response)
+        else:
+            return ApplicationResponse.from_api_response(response)
+
+    @classmethod
+    def _build_input_parameters(cls, prompt, history, messages, **kwargs):
+        parameters = {}
+
+        input_param = {}
+        if messages is not None:
+            msgs = copy.deepcopy(messages)
+            if prompt is not None and prompt:
+                msgs.append({'role': Role.USER, 'content': prompt})
+            input_param = {MESSAGES: msgs}
+        elif history is not None and history:
+            logger.warning(DEPRECATED_MESSAGE)
+            input_param[HISTORY] = history
+            if prompt is not None and prompt:
+                input_param[PROMPT] = prompt
+        else:
+            input_param[PROMPT] = prompt
+
+        session_id = kwargs.pop('session_id', None)
+        if session_id is not None and session_id:
+            input_param['session_id'] = session_id
+
+        doc_reference_type = kwargs.pop('doc_reference_type', None)
+        if doc_reference_type is not None and doc_reference_type:
+            input_param['doc_reference_type'] = doc_reference_type
+
+        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):
+                input_param['doc_tag_codes'] = doc_tag_codes
+            else:
+                raise InvalidInput('doc_tag_codes is not a List[str]')
+
+        memory_id = kwargs.pop('memory_id', None)
+        if memory_id is not None:
+            input_param['memory_id'] = memory_id
+
+        biz_params = kwargs.pop('biz_params', None)
+        if biz_params is not None and biz_params:
+            input_param['biz_params'] = biz_params
+
+        image_list = kwargs.pop('image_list', None)
+        if image_list is not None and image_list:
+            input_param['image_list'] = image_list
+
+        file_list = kwargs.pop('file_list', None)
+        if file_list is not None and file_list:
+            input_param['file_list'] = file_list
+
+        return input_param, {**parameters, **kwargs}

dashscope/app/application_response.py

@@ -0,0 +1,246 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+"""
+@File    :   application_response.py
+@Date    :   2024-02-24
+@Desc    :   application call response
+"""
+from dataclasses import dataclass
+from http import HTTPStatus
+from typing import Dict, List, Optional
+
+from dashscope.api_entities.dashscope_response import (DashScopeAPIResponse,
+                                                       DictMixin)
+
+
+@dataclass(init=False)
+class ApplicationThought(DictMixin):
+    thought: str
+    action_type: str
+    response: str
+    action_name: str
+    action: str
+    action_input_stream: str
+    action_input: Dict
+    observation: str
+
+    def __init__(self,
+                 thought: str = None,
+                 action_type: str = None,
+                 response: str = None,
+                 action_name: str = None,
+                 action: str = None,
+                 action_input_stream: str = None,
+                 action_input: Dict = None,
+                 observation: str = None,
+                 **kwargs):
+        """ Thought of app completion call result which describe model planning and doc retrieval
+            or plugin calls details.
+
+        Args:
+            thought (str, optional): Model's inference thought for doc retrieval or plugin process.
+            action_type (str, optional): Action type. response : final response; api: to run api calls.
+            response (str, optional): Model's results.
+            action_name (str, optional): Action name, e.g. searchDocument、api.
+            action (str, optional): Code of action, means which plugin or action to be run.
+            action_input_stream (str, optional): Input param with stream.
+            action_input (dict, optional): Api or plugin input parameters.
+            observation (str, optional): Result of api call or doc retrieval.
+        """
+
+        super().__init__(thought=thought,
+                         action_type=action_type,
+                         response=response,
+                         action_name=action_name,
+                         action=action,
+                         action_input_stream=action_input_stream,
+                         action_input=action_input,
+                         observation=observation,
+                         **kwargs)
+
+
+@dataclass(init=False)
+class ApplicationDocReference(DictMixin):
+    index_id: str
+    title: str
+    doc_id: str
+    doc_name: str
+    doc_url: str
+    text: str
+    biz_id: str
+    images: List[str]
+    page_number: List[int]
+
+    def __init__(self,
+                 index_id: str = None,
+                 title: str = None,
+                 doc_id: str = None,
+                 doc_name: str = None,
+                 doc_url: str = None,
+                 text: str = None,
+                 biz_id: str = None,
+                 images: List[str] = None,
+                 page_number: List[int] = None,
+                 **kwargs):
+        """ Doc references for retrieval result.
+
+        Args:
+            index_id (str, optional): Index id of doc retrival result reference.
+            title (str, optional): Title of original doc that retrieved.
+            doc_id (str, optional): Id of original doc that retrieved.
+            doc_name (str, optional): Name of original doc that retrieved.
+            doc_url (str, optional): Url of original doc that retrieved.
+            text (str, optional): Text in original doc that retrieved.
+            biz_id (str, optional): Biz id that caller is able to associated for biz logic.
+            images (list, optional): List of referenced image URLs
+        """
+
+        super().__init__(index_id=index_id,
+                         title=title,
+                         doc_id=doc_id,
+                         doc_name=doc_name,
+                         doc_url=doc_url,
+                         text=text,
+                         biz_id=biz_id,
+                         images=images,
+                         page_number=page_number,
+                         **kwargs)
+
+@dataclass(init=False)
+class WorkflowMessage(DictMixin):
+    node_id: str
+    node_name: str
+    node_type: str
+    node_status: str
+    node_is_completed: str
+    node_msg_seq_id: int
+    message: str
+
+    class Message(DictMixin):
+        role: str
+        content: str
+
+    def __init__(self,
+                 node_id: str = None,
+                 node_name: str = None,
+                 node_type: str = None,
+                 node_status: str = None,
+                 node_is_completed: str = None,
+                 node_msg_seq_id: int = None,
+                 message: Message = None,
+                 **kwargs):
+        """ Workflow message.
+
+        Args:
+            node_id (str, optional): .
+            node_name (str, optional): .
+            node_type (str, optional): .
+            node_status (str, optional): .
+            node_is_completed (str, optional): .
+            node_msg_seq_id (int, optional): .
+            message (Message, optional): .
+        """
+
+        super().__init__(node_id=node_id,
+                         node_name=node_name,
+                         node_type=node_type,
+                         node_status=node_status,
+                         node_is_completed=node_is_completed,
+                         node_msg_seq_id=node_msg_seq_id,
+                         message=message,
+                         **kwargs)
+
+
+@dataclass(init=False)
+class ApplicationOutput(DictMixin):
+    text: str
+    finish_reason: str
+    session_id: str
+    thoughts: List[ApplicationThought]
+    doc_references: List[ApplicationDocReference]
+    workflow_message: WorkflowMessage
+
+    def __init__(self,
+                 text: str = None,
+                 finish_reason: str = None,
+                 session_id: str = None,
+                 thoughts: List[ApplicationThought] = None,
+                 doc_references: List[ApplicationDocReference] = None,
+                 workflow_message: WorkflowMessage = None,
+                 **kwargs):
+
+        ths = None
+        if thoughts is not None:
+            ths = []
+            for thought in thoughts:
+                ths.append(ApplicationThought(**thought))
+
+        refs = None
+        if doc_references is not None:
+            refs = []
+            for ref in doc_references:
+                refs.append(ApplicationDocReference(**ref))
+
+        super().__init__(text=text,
+                         finish_reason=finish_reason,
+                         session_id=session_id,
+                         thoughts=ths,
+                         doc_references=refs,
+                         workflow_message=workflow_message,
+                         **kwargs)
+
+
+@dataclass(init=False)
+class ApplicationModelUsage(DictMixin):
+    model_id: str
+    input_tokens: int
+    output_tokens: int
+
+    def __init__(self,
+                 model_id: str = None,
+                 input_tokens: int = 0,
+                 output_tokens: int = 0,
+                 **kwargs):
+        super().__init__(model_id=model_id,
+                         input_tokens=input_tokens,
+                         output_tokens=output_tokens,
+                         **kwargs)
+
+
+@dataclass(init=False)
+class ApplicationUsage(DictMixin):
+    models: List[ApplicationModelUsage]
+
+    def __init__(self, models: List[ApplicationModelUsage] = None, **kwargs):
+        model_usages = None
+        if models is not None:
+            model_usages = []
+            for model_usage in models:
+                model_usages.append(ApplicationModelUsage(**model_usage))
+
+        super().__init__(models=model_usages, **kwargs)
+
+
+@dataclass(init=False)
+class ApplicationResponse(DashScopeAPIResponse):
+    output: ApplicationOutput
+    usage: ApplicationUsage
+
+    @staticmethod
+    def from_api_response(api_response: DashScopeAPIResponse):
+        if api_response.status_code == HTTPStatus.OK:
+            usage = {}
+            if api_response.usage:
+                usage = api_response.usage
+
+            return ApplicationResponse(
+                status_code=api_response.status_code,
+                request_id=api_response.request_id,
+                code=api_response.code,
+                message=api_response.message,
+                output=ApplicationOutput(**api_response.output),
+                usage=ApplicationUsage(**usage))
+        else:
+            return ApplicationResponse(status_code=api_response.status_code,
+                                       request_id=api_response.request_id,
+                                       code=api_response.code,
+                                       message=api_response.message)

dashscope/assistants/__init__.py

@@ -0,0 +1,16 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+
+# 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,175 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+
+# 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]
+
+    object: Optional[str] = None
+
+    top_p: Optional[float] = None
+    top_k: Optional[int] = None
+    temperature: Optional[float] = None
+    max_tokens: Optional[int] = None
+
+    request_id: Optional[str] = None
+
+    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)