File size: 50,808 Bytes

cbc00ce

# -*- coding: utf-8 -*-
# Copyright (c) Alibaba, Inc. and its affiliates.
import asyncio
import collections
import time
from http import HTTPStatus
from typing import Any, Dict, Iterator, List, Union

import requests

import dashscope
from dashscope.api_entities.api_request_factory import _build_api_request
from dashscope.api_entities.dashscope_response import DashScopeAPIResponse
from dashscope.common.api_key import get_default_api_key
from dashscope.common.constants import (
    DEFAULT_REQUEST_TIMEOUT_SECONDS,
    REPEATABLE_STATUS,
    REQUEST_TIMEOUT_KEYWORD,
    SSE_CONTENT_TYPE,
    TaskStatus,
    HTTPMethod,
)
from dashscope.common.error import InvalidParameter, InvalidTask, ModelRequired
from dashscope.common.logging import logger
from dashscope.common.utils import (
    _handle_http_failed_response,
    _handle_http_response,
    _handle_http_stream_response,
    default_headers,
    join_url,
)


class AsyncAioTaskGetMixin:
    @classmethod
    async def _get(
        cls,
        task_id: str,
        api_key: str = None,
        workspace: str = None,
        **kwargs,
    ) -> DashScopeAPIResponse:
        base_url = kwargs.pop("base_address", None)
        url = _normalization_url(base_url, "tasks", task_id)
        kwargs = cls._handle_kwargs(api_key, workspace, **kwargs)
        kwargs["base_address"] = url
        if not api_key:
            api_key = get_default_api_key()
        request = _build_api_request(
            "",
            "",
            "",
            "",
            "",
            api_key=api_key,
            is_service=False,
            **kwargs,
        )
        return await cls._handle_request(request)

    @classmethod
    def _handle_kwargs(
        cls,
        api_key: str = None,
        workspace: str = None,
        **kwargs,
    ):
        custom_headers = kwargs.pop("headers", None)
        headers = {
            **_workspace_header(workspace),
            **default_headers(api_key),
        }
        if custom_headers:
            headers = {
                **custom_headers,
                **headers,
            }
        if workspace is not None:
            headers = {
                "X-DashScope-WorkSpace": workspace,
                **kwargs.pop("headers", {}),
            }
        kwargs["headers"] = headers
        kwargs["http_method"] = HTTPMethod.GET
        return kwargs

    @classmethod
    async def _handle_request(cls, request):
        # 如果 aio_call 返回的是异步生成器，则需要从中获取响应
        response = await request.aio_call()
        # 处理异步生成器的情况
        if isinstance(response, collections.abc.AsyncGenerator):
            result = None
            async for item in response:
                result = item
            return result
        else:
            return response


class BaseAsyncAioApi(AsyncAioTaskGetMixin):
    """BaseApi, internal use only."""

    @classmethod
    def _validate_params(cls, api_key, model):
        if api_key is None:
            api_key = get_default_api_key()
        if model is None or not model:
            raise ModelRequired("Model is required!")
        return api_key, model

    @classmethod
    async def async_call(
        cls,
        model: str,
        input: object,  # pylint: disable=redefined-builtin
        task_group: str,
        task: str = None,
        function: str = None,
        api_key: str = None,
        workspace: str = None,
        **kwargs,
    ) -> DashScopeAPIResponse:
        api_key, model = cls._validate_params(api_key, model)
        if workspace is not None:
            headers = {
                "X-DashScope-WorkSpace": workspace,
                **kwargs.pop("headers", {}),
            }
            kwargs["headers"] = headers
        kwargs["async_request"] = True
        request = _build_api_request(
            model=model,
            input=input,
            task_group=task_group,
            task=task,
            function=function,
            api_key=api_key,
            **kwargs,
        )
        # call request service.
        return await request.aio_call()

    @classmethod
    async def call(
        cls,
        model: str,
        input: object,  # pylint: disable=redefined-builtin
        task_group: str,
        task: str = None,
        function: str = None,
        api_key: str = None,
        workspace: str = None,
        **kwargs,
    ) -> DashScopeAPIResponse:
        # call request service.
        response = await BaseAsyncAioApi.async_call(
            model,
            input,
            task_group,
            task,
            function,
            api_key,
            workspace,
            **kwargs,
        )
        response = await BaseAsyncAioApi.wait(
            response,
            api_key=api_key,
            workspace=workspace,
            **kwargs,
        )
        return response

    @classmethod
    def _get_task_id(cls, task):
        if isinstance(task, str):
            task_id = task
        elif isinstance(task, DashScopeAPIResponse):
            if task.status_code == HTTPStatus.OK:
                task_id = task.output["task_id"]
            else:
                raise InvalidTask(
                    f"Invalid task, task create failed: {task}",
                )
        else:
            raise InvalidParameter("Task invalid!")
        if task_id is None or task_id == "":
            raise InvalidParameter("Task id required!")
        return task_id

    @classmethod
    async def wait(
        cls,
        task: Union[str, DashScopeAPIResponse],
        api_key: str = None,
        workspace: str = None,
        **kwargs,
    ) -> DashScopeAPIResponse:
        """Wait for async task completion and return task result.

        Args:
            task (Union[str, DashScopeAPIResponse]): The task_id, or
                async_call response.
            api_key (str, optional): The api_key. Defaults to None.

        Returns:
            DashScopeAPIResponse: The async task information.
        """
        task_id = cls._get_task_id(task)
        wait_seconds = 1
        max_wait_seconds = 5
        increment_steps = 3
        step = 0
        while True:
            step += 1
            # we start by querying once every second, and double
            # the query interval after every 3(increment_steps)
            # intervals, until we hit the max waiting interval
            # of 5(seconds）
            # (server side return immediately when ready)
            if wait_seconds < max_wait_seconds and step % increment_steps == 0:
                wait_seconds = min(wait_seconds * 2, max_wait_seconds)
            rsp = await cls._get(
                task_id,
                api_key,
                workspace=workspace,
                **kwargs,
            )
            if rsp.status_code == HTTPStatus.OK:
                if rsp.output is None:
                    return rsp

                task_status = rsp.output["task_status"]
                if task_status in [
                    TaskStatus.FAILED,
                    TaskStatus.CANCELED,
                    TaskStatus.SUCCEEDED,
                    TaskStatus.UNKNOWN,
                ]:
                    return rsp
                else:
                    logger.info("The task %s is  %s", task_id, task_status)
                    await asyncio.sleep(wait_seconds)  # 异步等待
            elif rsp.status_code in REPEATABLE_STATUS:
                logger.warning(
                    "Get task: %s temporary failure, "
                    "status_code: %s, code: %s message: %s, will try again.",
                    task_id,
                    rsp.status_code,
                    rsp.code,
                    rsp.message,
                )
                await asyncio.sleep(wait_seconds)  # 异步等待
            else:
                return rsp

    @classmethod
    async def cancel(
        cls,
        task: Union[str, DashScopeAPIResponse],
        api_key: str = None,
        workspace: str = None,
        **kwargs,
    ) -> DashScopeAPIResponse:
        """Cancel PENDING task.

        Args:
            task (Union[str, DashScopeAPIResponse]): The task_id, or
                async_call response.
            api_key (str, optional): The api-key. Defaults to None.

        Returns:
            DashScopeAPIResponse: The cancel result.
        """
        task_id = cls._get_task_id(task)
        base_url = kwargs.pop("base_address", None)
        url = _normalization_url(base_url, "tasks", task_id, "cancel")
        kwargs = cls._handle_kwargs(api_key, workspace, **kwargs)
        kwargs["base_address"] = url
        if not api_key:
            api_key = get_default_api_key()
        request = _build_api_request(
            "",
            "",
            "",
            "",
            "",
            api_key=api_key,
            is_service=False,
            **kwargs,
        )
        return await cls._handle_request(request)

    @classmethod
    async def list(
        cls,
        start_time: str = None,
        end_time: str = None,
        model_name: str = None,
        api_key_id: str = None,
        region: str = None,
        status: str = None,
        page_no: int = 1,
        page_size: int = 10,
        api_key: str = None,
        workspace: str = None,
        **kwargs,
    ) -> DashScopeAPIResponse:
        """List async tasks.

        Args:
            start_time (str, optional): The tasks start time,
                for example: 20230420000000. Defaults to None.
            end_time (str, optional): The tasks end time,
                for example: 20230420000000. Defaults to None.
            model_name (str, optional): The tasks model name.
                Defaults to None.
            api_key_id (str, optional): The tasks api-key-id.
                Defaults to None.
            region (str, optional): The service region,
                for example: cn-beijing. Defaults to None.
            status (str, optional): The status of tasks[PENDING,
                RUNNING, SUCCEEDED, FAILED, CANCELED]. Defaults to None.
            page_no (int, optional): The page number. Defaults to 1.
            page_size (int, optional): The page size. Defaults to 10.
            api_key (str, optional): The user api-key. Defaults to None.

        Returns:
            DashScopeAPIResponse: The response data.
        """
        base_url = kwargs.pop("base_address", None)
        url = _normalization_url(base_url, "tasks")
        params = {"page_no": page_no, "page_size": page_size}
        if start_time is not None:
            params["start_time"] = start_time
        if end_time is not None:
            params["end_time"] = end_time
        if model_name is not None:
            params["model_name"] = model_name
        if api_key_id is not None:
            params["api_key_id"] = api_key_id
        if region is not None:
            params["region"] = region
        if status is not None:
            params["status"] = status
        kwargs = cls._handle_kwargs(api_key, workspace, **kwargs)
        kwargs["base_address"] = url
        if not api_key:
            api_key = get_default_api_key()
        request = _build_api_request(
            model_name,
            "",
            "",
            "",
            "",
            api_key=api_key,
            is_service=False,
            extra_url_parameters=params,
            **kwargs,
        )
        return await cls._handle_request(request)

    @classmethod
    async def fetch(
        cls,
        task: Union[str, DashScopeAPIResponse],
        api_key: str = None,
        workspace: str = None,
        **kwargs,
    ) -> DashScopeAPIResponse:
        """Query async task status.

        Args:
            task (Union[str, DashScopeAPIResponse]): The task_id, or
                async_call response.
            api_key (str, optional): The api_key. Defaults to None.

        Returns:
            DashScopeAPIResponse: The async task information.
        """
        task_id = cls._get_task_id(task)
        return await cls._get(task_id, api_key, workspace, **kwargs)


class BaseAioApi:
    """BaseApi, internal use only."""

    @classmethod
    def _validate_params(cls, api_key, model):
        if api_key is None:
            api_key = get_default_api_key()
        if model is None or not model:
            raise ModelRequired("Model is required!")
        return api_key, model

    @classmethod
    async def call(
        cls,
        model: str,
        input: object,  # pylint: disable=redefined-builtin
        task_group: str,
        task: str = None,
        function: str = None,
        api_key: str = None,
        workspace: str = None,
        **kwargs,
    ) -> DashScopeAPIResponse:
        """Call service and get result.

        Args:
            model (str): The requested model, such as gpt3-v2
            input (object): The api input data, cannot be None.
            task_group (str, optional): The api task group.
            task (str, optional): The task name. Defaults to None.
            function (str, optional): The function of the task.
                Defaults to None.
            api_key (str, optional): The api api_key, if not present,
                will get by default rule(TODO: api key doc). Defaults to None.
            api_protocol (str, optional): Api protocol websocket or http.
                Defaults to None.
            ws_stream_mode (str, optional): websocket stream mode,
                [none, in, out, duplex]. Defaults to out.
            is_binary_input (bool, optional): Is input data binary.
                Defaults to False.
            http_method (str, optional): If api protocol is http, specifies
                method[GET, POST]. Defaults to POST.

        Returns:
            DashScopeAPIResponse: The service response.
        """
        api_key, model = BaseAioApi._validate_params(api_key, model)
        if workspace is not None:
            headers = {
                "X-DashScope-WorkSpace": workspace,
                **kwargs.pop("headers", {}),
            }
            kwargs["headers"] = headers
        request = _build_api_request(
            model=model,
            input=input,
            task_group=task_group,
            task=task,
            function=function,
            api_key=api_key,
            **kwargs,
        )
        # call request service.
        return await request.aio_call()


class BaseApi:
    """BaseApi, internal use only."""

    @classmethod
    def _validate_params(cls, api_key, model):
        if api_key is None:
            api_key = get_default_api_key()
        if model is None or not model:
            raise ModelRequired("Model is required!")
        return api_key, model

    @classmethod
    def call(
        cls,
        model: str,
        input: object,  # pylint: disable=redefined-builtin
        task_group: str,
        task: str = None,
        function: str = None,
        api_key: str = None,
        workspace: str = None,
        **kwargs,
    ) -> DashScopeAPIResponse:
        """Call service and get result.

        Args:
            model (str): The requested model, such as gpt3-v2
            input (object): The api input data, cannot be None.
            task_group (str, optional): The api task group.
            task (str, optional): The task name. Defaults to None.
            function (str, optional): The function of the task.
                Defaults to None.
            api_key (str, optional): The api api_key, if not present,
                will get by default rule(TODO: api key doc). Defaults to None.
            api_protocol (str, optional): Api protocol websocket or http.
                Defaults to None.
            ws_stream_mode (str, optional): websocket stream mode,
                [none, in, out, duplex]. Defaults to out.
            is_binary_input (bool, optional): Is input data binary.
                Defaults to False.
            http_method (str, optional): If api protocol is http, specifies
                method[GET, POST]. Defaults to POST.

        Returns:
            DashScopeAPIResponse: The service response.
        """
        api_key, model = BaseApi._validate_params(api_key, model)
        if workspace is not None:
            headers = {
                "X-DashScope-WorkSpace": workspace,
                **kwargs.pop("headers", {}),
            }
            kwargs["headers"] = headers
        request = _build_api_request(
            model=model,
            input=input,
            task_group=task_group,
            task=task,
            function=function,
            api_key=api_key,
            **kwargs,
        )
        # call request service.
        return request.call()


def _workspace_header(workspace) -> Dict:
    if workspace is not None:
        headers = {"X-DashScope-WorkSpace": workspace}
    else:
        headers = {}
    return headers


def _normalization_url(base_address, *args):
    if base_address:
        url = base_address
    else:
        url = dashscope.base_http_api_url
    return join_url(url, *args)


class AsyncTaskGetMixin:
    @classmethod
    def _get(
        cls,
        task_id: str,
        api_key: str = None,
        workspace: str = None,
        **kwargs,
    ) -> DashScopeAPIResponse:
        base_url = kwargs.pop("base_address", None)
        status_url = _normalization_url(base_url, "tasks", task_id)
        custom_headers = kwargs.pop("headers", None)
        headers = {
            **_workspace_header(workspace),
            **default_headers(api_key),
        }
        if custom_headers:
            headers = {
                **custom_headers,
                **headers,
            }
        with requests.Session() as session:
            logger.debug("Starting request: %s", status_url)
            response = session.get(
                status_url,
                headers=headers,
                timeout=DEFAULT_REQUEST_TIMEOUT_SECONDS,
            )
            logger.debug("Starting processing response: %s", status_url)
            return _handle_http_response(response)


class BaseAsyncApi(AsyncTaskGetMixin):
    """BaseAsyncApi,for async task, internal use only."""

    @classmethod
    def _validate_params(cls, api_key, model):
        if api_key is None:
            api_key = get_default_api_key()
        if model is None or not model:
            raise ModelRequired("Model is required!")
        return api_key, model

    @classmethod
    def call(
        cls,
        *args,
        api_key: str = None,
        workspace: str = None,
        **kwargs,
    ) -> DashScopeAPIResponse:
        """Call service and get result."""
        task_response = cls.async_call(  # type: ignore[misc]
            *args,
            api_key=api_key,
            workspace=workspace,
            **kwargs,
        )
        response = cls.wait(
            task_response,
            api_key=api_key,
            workspace=workspace,
        )
        return response

    @classmethod
    def _get_task_id(cls, task):
        if isinstance(task, str):
            task_id = task
        elif isinstance(task, DashScopeAPIResponse):
            if task.status_code == HTTPStatus.OK:
                task_id = task.output["task_id"]
            else:
                raise InvalidTask(
                    f"Invalid task, task create failed: {task}",
                )
        else:
            raise InvalidParameter("Task invalid!")
        if task_id is None or task_id == "":
            raise InvalidParameter("Task id required!")
        return task_id

    @classmethod
    def cancel(
        cls,
        task: Union[str, DashScopeAPIResponse],
        api_key: str = None,
        workspace: str = None,
        **kwargs,
    ) -> DashScopeAPIResponse:
        """Cancel PENDING task.

        Args:
            task (Union[str, DashScopeAPIResponse]): The task_id, or
                async_call response.
            api_key (str, optional): The api-key. Defaults to None.

        Returns:
            DashScopeAPIResponse: The cancel result.
        """
        task_id = cls._get_task_id(task)
        base_url = kwargs.pop("base_address", None)
        url = _normalization_url(base_url, "tasks", task_id, "cancel")
        with requests.Session() as session:
            response = session.post(
                url,
                headers={
                    **_workspace_header(workspace),
                    **default_headers(api_key),
                },
            )
            return _handle_http_response(response)

    @classmethod
    def list(
        cls,
        start_time: str = None,
        end_time: str = None,
        model_name: str = None,
        api_key_id: str = None,
        region: str = None,
        status: str = None,
        page_no: int = 1,
        page_size: int = 10,
        api_key: str = None,
        workspace: str = None,
        **kwargs,
    ) -> DashScopeAPIResponse:
        """List async tasks.

        Args:
            start_time (str, optional): The tasks start time,
                for example: 20230420000000. Defaults to None.
            end_time (str, optional): The tasks end time,
                for example: 20230420000000. Defaults to None.
            model_name (str, optional): The tasks model name.
                Defaults to None.
            api_key_id (str, optional): The tasks api-key-id.
                Defaults to None.
            region (str, optional): The service region,
                for example: cn-beijing. Defaults to None.
            status (str, optional): The status of tasks[PENDING,
                RUNNING, SUCCEEDED, FAILED, CANCELED]. Defaults to None.
            page_no (int, optional): The page number. Defaults to 1.
            page_size (int, optional): The page size. Defaults to 10.
            api_key (str, optional): The user api-key. Defaults to None.

        Returns:
            DashScopeAPIResponse: The response data.
        """
        base_url = kwargs.pop("base_address", None)
        url = _normalization_url(base_url, "tasks")
        params = {"page_no": page_no, "page_size": page_size}
        if start_time is not None:
            params["start_time"] = start_time
        if end_time is not None:
            params["end_time"] = end_time
        if model_name is not None:
            params["model_name"] = model_name
        if api_key_id is not None:
            params["api_key_id"] = api_key_id
        if region is not None:
            params["region"] = region
        if status is not None:
            params["status"] = status

        with requests.Session() as session:
            response = session.get(
                url,
                params=params,
                headers={
                    **_workspace_header(workspace),
                    **default_headers(api_key),
                },
            )
            if response.status_code == HTTPStatus.OK:
                json_content = response.json()
                request_id = ""
                if "request_id" in json_content:
                    request_id = json_content["request_id"]
                    json_content.pop("request_id")
                return DashScopeAPIResponse(
                    request_id=request_id,
                    status_code=response.status_code,
                    code=None,  # type: ignore[arg-type]
                    output=json_content,
                    usage=None,
                    message="",
                )
            else:
                return _handle_http_failed_response(response)

    @classmethod
    def fetch(
        cls,
        task: Union[str, DashScopeAPIResponse],
        api_key: str = None,
        workspace: str = None,
        **kwargs,
    ) -> DashScopeAPIResponse:
        """Query async task status.

        Args:
            task (Union[str, DashScopeAPIResponse]): The task_id, or
                async_call response.
            api_key (str, optional): The api_key. Defaults to None.

        Returns:
            DashScopeAPIResponse: The async task information.
        """
        task_id = cls._get_task_id(task)
        return cls._get(task_id, api_key, workspace, **kwargs)

    @classmethod
    def wait(
        cls,
        task: Union[str, DashScopeAPIResponse],
        api_key: str = None,
        workspace: str = None,
        **kwargs,
    ) -> DashScopeAPIResponse:
        """Wait for async task completion and return task result.

        Args:
            task (Union[str, DashScopeAPIResponse]): The task_id, or
                async_call response.
            api_key (str, optional): The api_key. Defaults to None.

        Returns:
            DashScopeAPIResponse: The async task information.
        """
        task_id = cls._get_task_id(task)
        wait_seconds = 1
        max_wait_seconds = 5
        increment_steps = 3
        step = 0
        while True:
            step += 1
            # we start by querying once every second, and double
            # the query interval after every 3(increment_steps)
            # intervals, until we hit the max waiting interval
            # of 5(seconds）
            # TODO: investigate if we can use long-poll
            # (server side return immediately when ready)
            if wait_seconds < max_wait_seconds and step % increment_steps == 0:
                wait_seconds = min(wait_seconds * 2, max_wait_seconds)
            rsp = cls._get(task_id, api_key, workspace=workspace, **kwargs)
            if rsp.status_code == HTTPStatus.OK:
                if rsp.output is None:
                    return rsp

                task_status = rsp.output["task_status"]
                if task_status in [
                    TaskStatus.FAILED,
                    TaskStatus.CANCELED,
                    TaskStatus.SUCCEEDED,
                    TaskStatus.UNKNOWN,
                ]:
                    return rsp
                else:
                    logger.info("The task %s is  %s", task_id, task_status)
                    time.sleep(wait_seconds)
            elif rsp.status_code in REPEATABLE_STATUS:
                logger.warning(
                    "Get task: %s temporary failure, "
                    "status_code: %s, code: %s message: %s, will try again.",
                    task_id,
                    rsp.status_code,
                    rsp.code,
                    rsp.message,
                )
                time.sleep(wait_seconds)
            else:
                return rsp

    @classmethod
    def async_call(
        cls,
        model: str,
        input: object,  # pylint: disable=redefined-builtin
        task_group: str,
        task: str = None,
        function: str = None,
        api_key: str = None,
        workspace: str = None,
        **kwargs,
    ) -> DashScopeAPIResponse:
        """Call async service return async task information.

        Args:
            model (str): The requested model, such as gpt3-v2
            input (object): The api input data, cannot be None.
            task_group (str, optional): The api task group.
            task (str, optional): The task name. Defaults to None.
            function (str, optional): The function of the task.
                Defaults to None.
            api_key (str, optional): The api api_key, if not present,
                will get by default rule(TODO: api key doc). Defaults to None.

        Returns:
            DashScopeAPIResponse: The async task information,
                which contains the task id, you can use the task id
                to query the task status.
        """
        is_stream = kwargs.pop("stream", None)  # async api not support stream.
        if is_stream:
            logger.warning("async_call do not support stream argument")
        # Access BaseApi's validation method for consistency
        (
            api_key,
            model,
        ) = BaseApi._validate_params(  # pylint: disable=protected-access
            api_key,
            model,
        )
        if workspace is not None:
            headers = {
                "X-DashScope-WorkSpace": workspace,
                **kwargs.pop("headers", {}),
            }
            kwargs["headers"] = headers
        request = _build_api_request(
            model=model,
            input=input,
            task_group=task_group,
            task=task,
            function=function,
            api_key=api_key,
            async_request=True,
            query=False,
            **kwargs,
        )
        return request.call()


# pylint: disable=dangerous-default-value
def _get(
    url,
    params={},
    api_key=None,
    flattened_output=False,
    workspace: str = None,
    **kwargs,
) -> Union[DashScopeAPIResponse, Dict]:
    timeout = kwargs.pop(
        REQUEST_TIMEOUT_KEYWORD,
        DEFAULT_REQUEST_TIMEOUT_SECONDS,
    )
    with requests.Session() as session:
        logger.debug("Starting request: %s", url)
        response = session.get(
            url,
            headers={
                **_workspace_header(workspace),
                **default_headers(api_key),
                **kwargs.pop("headers", {}),
            },
            params=params,
            timeout=timeout,
        )
        logger.debug("Starting processing response: %s", url)
        return _handle_http_response(response, flattened_output)


def _get_url(custom_base_url, default_path, path):
    if not custom_base_url:
        base_url = dashscope.base_http_api_url
    else:
        base_url = custom_base_url
    if path is not None:
        url = join_url(base_url, path)
    else:
        url = join_url(base_url, default_path)
    return url


class ListObjectMixin:
    @classmethod
    def list(
        cls,
        limit: int = None,
        order: str = None,
        after: str = None,
        before: str = None,
        path: str = None,
        workspace: str = None,
        api_key: str = None,
        **kwargs,
    ) -> Any:
        """List object

        Args:
            limit (int, optional): How many object to list. Defaults to None.
            order (str, optional): The order of result. Defaults to None.
            after (str, optional): The id of the object begin. Defaults to None.  # noqa: E501
            before (str, optional): The if of the object end. Defaults to None.
            path (str, optional): The request path. Defaults to None.
            workspace (str, optional): The DashScope workspace id. Defaults to None.  # noqa: E501
            api_key (str, optional): The DashScope api_key. Defaults to None.

        Returns:
            Any: The object list.
        """
        custom_base_url = kwargs.pop("base_address", None)
        url = _get_url(custom_base_url, cls.SUB_PATH.lower(), path)
        params = {}
        if limit is not None:
            if limit < 0:
                raise InvalidParameter("limit should >= 0")
            params["limit"] = limit
        if order is not None:
            params["order"] = order
        if after is not None:
            params["after"] = after
        if before is not None:
            params["before"] = before
        return _get(
            url,
            params=params,
            api_key=api_key,
            workspace=workspace,
            **kwargs,
        )


class ListMixin:
    @classmethod
    def list(
        cls,
        page_no=1,
        page_size=10,
        api_key: str = None,
        path: str = None,
        workspace: str = None,
        **kwargs,
    ) -> Union[DashScopeAPIResponse, Dict]:
        """list objects

        Args:
            api_key (str, optional): The api api_key, if not present,
                will get by default rule(TODO: api key doc). Defaults to None.
            path (str, optional): The path of the api, if not default.
            page_no (int, optional): Page number. Defaults to 1.
            page_size (int, optional): Items per page. Defaults to 10.

        Returns:
            DashScopeAPIResponse: The object list in output.
        """
        custom_base_url = kwargs.pop("base_address", None)
        url = _get_url(custom_base_url, cls.SUB_PATH.lower(), path)
        params = {"page_no": page_no, "page_size": page_size}
        return _get(
            url,
            params=params,
            api_key=api_key,
            workspace=workspace,
            **kwargs,
        )


class LogMixin:
    @classmethod
    def logs(  # pylint: disable=unused-argument
        cls,
        job_id: str,
        offset=1,
        line=1000,
        api_key: str = None,
        path: str = None,
        workspace: str = None,
        **kwargs,
    ) -> Union[DashScopeAPIResponse, Dict]:
        """Get log of the job.

        Args:
            job_id (str): The job id(used for fine-tune)
            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.

        Returns:
            DashScopeAPIResponse: The response
        """
        custom_base_url = kwargs.pop("base_address", None)
        if not custom_base_url:
            url = join_url(
                dashscope.base_http_api_url,
                cls.SUB_PATH.lower(),
                job_id,
                "logs",
            )
        else:
            url = custom_base_url
        params = {"offset": offset, "line": line}
        return _get(
            url,
            params=params,
            api_key=api_key,
            workspace=workspace,
            **kwargs,
        )


class GetMixin:
    @classmethod
    # pylint: disable=dangerous-default-value
    def get(
        cls,
        target,
        api_key: str = None,
        params: dict = {},
        path: str = None,
        workspace: str = None,
        **kwargs,
    ) -> Union[DashScopeAPIResponse, Dict]:
        """Get object information.

        Args:
            target (str): The target to get, such as model_id.
            api_key (str, optional): The api api_key, if not present,
                will get by default rule(TODO: api key doc). Defaults to None.

        Returns:
            DashScopeAPIResponse: The object information in output.
        """
        custom_base_url = kwargs.pop("base_address", None)
        if custom_base_url:
            base_url = custom_base_url
        else:
            base_url = dashscope.base_http_api_url

        if path is not None:
            url = join_url(base_url, path)
        else:
            url = join_url(base_url, cls.SUB_PATH.lower(), target)
        flattened_output = kwargs.pop("flattened_output", False)
        return _get(
            url,
            api_key=api_key,
            params=params,
            flattened_output=flattened_output,
            workspace=workspace,
            **kwargs,
        )


class GetStatusMixin:
    @classmethod
    def get(
        cls,
        target,
        api_key: str = None,
        path: str = None,
        workspace: str = None,
        **kwargs,
    ) -> Union[DashScopeAPIResponse, Dict]:
        """Get object information.

        Args:
            target (str): The target to get, such as model_id.
            api_key (str, optional): The api api_key, if not present,
                will get by default rule(TODO: api key doc). Defaults to None.

        Returns:
            DashScopeAPIResponse: The object information in output.
        """
        custom_base_url = kwargs.pop("base_address", None)
        if custom_base_url:
            base_url = custom_base_url
        else:
            base_url = dashscope.base_http_api_url
        if path is not None:
            url = join_url(base_url, path)
        else:
            url = join_url(base_url, cls.SUB_PATH.lower(), target)
        flattened_output = kwargs.pop("flattened_output", False)
        return _get(
            url,
            api_key=api_key,
            flattened_output=flattened_output,
            workspace=workspace,
            **kwargs,
        )


class DeleteMixin:
    @classmethod
    def delete(
        cls,
        target: str,
        api_key: str = None,
        path: str = None,
        workspace: str = None,
        flattened_output=False,
        **kwargs,
    ) -> Union[DashScopeAPIResponse, Dict]:
        """Delete object.

        Args:
            target (str): The object to delete, .
            api_key (str, optional): The api api_key, if not present,
                will get by default rule(TODO: api key doc). Defaults to None.

        Returns:
            DashScopeAPIResponse: The delete result.
        """
        custom_base_url = kwargs.pop("base_address", None)
        if custom_base_url:
            base_url = custom_base_url
        else:
            base_url = dashscope.base_http_api_url
        if path is not None:
            url = join_url(base_url, path)
        else:
            url = join_url(base_url, cls.SUB_PATH.lower(), target)
        timeout = kwargs.pop(
            REQUEST_TIMEOUT_KEYWORD,
            DEFAULT_REQUEST_TIMEOUT_SECONDS,
        )
        with requests.Session() as session:
            logger.debug("Starting request: %s", url)
            response = session.delete(
                url,
                headers={
                    **_workspace_header(workspace),
                    **default_headers(api_key),
                    **kwargs.pop("headers", {}),
                },
                timeout=timeout,
            )
            logger.debug("Starting processing response: %s", url)
            return _handle_http_response(response, flattened_output)


class CreateMixin:
    @classmethod
    def call(
        cls,
        data: object,
        api_key: str = None,
        path: str = None,
        stream: bool = False,
        workspace: str = None,
        **kwargs,
    ) -> Union[DashScopeAPIResponse, Dict]:
        """Create a object

        Args:
            data (object): The create request json body.
            api_key (str, optional): The api api_key, if not present,
                will get by default rule(TODO: api key doc). Defaults to None.

        Returns:
            DashScopeAPIResponse: The created object in output.
        """
        url = _get_url(
            kwargs.pop("base_address", None),
            cls.SUB_PATH.lower(),
            path,
        )
        timeout = kwargs.pop(
            REQUEST_TIMEOUT_KEYWORD,
            DEFAULT_REQUEST_TIMEOUT_SECONDS,
        )
        flattened_output = kwargs.pop("flattened_output", False)
        with requests.Session() as session:
            logger.debug("Starting request: %s", url)
            response = session.post(
                url,
                json=data,
                stream=stream,
                headers={
                    **_workspace_header(workspace),
                    **default_headers(api_key),
                    **kwargs.pop("headers", {}),
                },
                timeout=timeout,
            )
            logger.debug("Starting processing response: %s", url)
            response = _handle_http_stream_response(response, flattened_output)
            if stream:
                return (item for item in response)  # type: ignore
            else:
                _, output = next(response)
                try:
                    next(response)
                except StopIteration:
                    pass
                return output


class UpdateMixin:
    @classmethod
    def update(
        cls,
        target: str,
        json: object,
        api_key: str = None,
        path: str = None,
        workspace: str = None,
        method: str = "patch",
        **kwargs,
    ) -> Union[DashScopeAPIResponse, Dict]:
        """Async update a object

        Args:
            target (str): The target to update.
            json (object): The create request json body.
            api_key (str, optional): The api api_key, if not present,
                will get by default rule(TODO: api key doc). Defaults to None.

        Returns:
            DashScopeAPIResponse: The updated object information in output.
        """
        custom_base_url = kwargs.pop("base_address", None)
        if custom_base_url:
            base_url = custom_base_url
        else:
            base_url = dashscope.base_http_api_url
        if path is not None:
            url = join_url(base_url, path)
        else:
            url = join_url(base_url, cls.SUB_PATH.lower(), target)
        timeout = kwargs.pop(
            REQUEST_TIMEOUT_KEYWORD,
            DEFAULT_REQUEST_TIMEOUT_SECONDS,
        )
        flattened_output = kwargs.pop("flattened_output", False)
        with requests.Session() as session:
            logger.debug("Starting request: %s", url)
            if method == "post":
                response = session.post(
                    url,
                    json=json,
                    headers={
                        **_workspace_header(workspace),
                        **default_headers(api_key),
                        **kwargs.pop("headers", {}),
                    },
                    timeout=timeout,
                )
            else:
                response = session.patch(
                    url,
                    json=json,
                    headers={
                        **_workspace_header(workspace),
                        **default_headers(api_key),
                        **kwargs.pop("headers", {}),
                    },
                    timeout=timeout,
                )
            logger.debug("Starting processing response: %s", url)
            return _handle_http_response(response, flattened_output)


class PutMixin:
    @classmethod
    def put(
        cls,
        target: str,
        json: object,
        path: str = None,
        api_key: str = None,
        workspace: str = None,
        **kwargs,
    ) -> Union[DashScopeAPIResponse, Dict]:
        """Async update a object

        Args:
            target (str): The target to update.
            json (object): The create request json body.
            api_key (str, optional): The api api_key, if not present,
                will get by default rule(TODO: api key doc). Defaults to None.

        Returns:
            DashScopeAPIResponse: The updated object information in output.
        """
        custom_base_url = kwargs.pop("base_address", None)
        if custom_base_url:
            base_url = custom_base_url
        else:
            base_url = dashscope.base_http_api_url
        if path is None:
            url = join_url(base_url, cls.SUB_PATH.lower(), target)
        else:
            url = join_url(base_url, path)
        timeout = kwargs.pop(
            REQUEST_TIMEOUT_KEYWORD,
            DEFAULT_REQUEST_TIMEOUT_SECONDS,
        )
        with requests.Session() as session:
            logger.debug("Starting request: %s", url)
            response = session.put(
                url,
                json=json,
                headers={
                    **_workspace_header(workspace),
                    **default_headers(api_key),
                    **kwargs.pop("headers", {}),
                },
                timeout=timeout,
            )
            logger.debug("Starting processing response: %s", url)
            return _handle_http_response(response)


class FileUploadMixin:
    @classmethod
    def upload(  # pylint: disable=unused-argument
        cls,
        files: list,
        descriptions: List[str] = None,
        params: dict = None,
        api_key: str = None,
        workspace: str = None,
        **kwargs,
    ) -> Union[DashScopeAPIResponse, Dict]:
        """Upload files

        Args:
            files (list): List of (name, opened file, file_name).
            descriptions (list[str]): The file description messages.
            params (dict): The parameters
            api_key (str, optional): The api api_key, if not present,
                will get by default rule(TODO: api key doc). Defaults to None.

        Returns:
            DashScopeAPIResponse: The uploaded file information in the output.
        """
        custom_base_url = kwargs.pop("base_address", None)
        if custom_base_url:
            base_url = custom_base_url
        else:
            base_url = dashscope.base_http_api_url
        url = join_url(base_url, cls.SUB_PATH.lower())
        js = None
        if descriptions:
            js = {"descriptions": descriptions}
        timeout = kwargs.pop(
            REQUEST_TIMEOUT_KEYWORD,
            DEFAULT_REQUEST_TIMEOUT_SECONDS,
        )
        with requests.Session() as session:
            logger.debug("Starting request: %s", url)
            response = session.post(
                url,
                data=js,
                headers={
                    **_workspace_header(workspace),
                    **default_headers(api_key),
                    **kwargs.pop("headers", {}),
                },
                files=files,
                timeout=timeout,
            )
            logger.debug("Starting processing response: %s", url)
            return _handle_http_response(response)


class CancelMixin:
    @classmethod
    def cancel(
        cls,
        target: str,
        path: str = None,
        api_key: str = None,
        workspace: str = None,
        **kwargs,
    ) -> Union[DashScopeAPIResponse, Dict]:
        """Cancel a job.

        Args:
            target (str): The request params, key/value map.
            api_key (str, optional): The api api_key, if not present,
                will get by default rule(TODO: api key doc). Defaults to None.

        Returns:
            DashScopeAPIResponse: The cancel result.
        """
        custom_base_url = kwargs.pop("base_address", None)
        if custom_base_url:
            base_url = custom_base_url
        else:
            base_url = dashscope.base_http_api_url
        if not path:
            url = join_url(base_url, cls.SUB_PATH.lower(), target, "cancel")
        else:
            url = join_url(base_url, path)
        timeout = kwargs.pop(
            REQUEST_TIMEOUT_KEYWORD,
            DEFAULT_REQUEST_TIMEOUT_SECONDS,
        )
        flattened_output = kwargs.pop("flattened_output", False)
        with requests.Session() as session:
            logger.debug("Starting request: %s", url)
            response = session.post(
                url,
                headers={
                    **_workspace_header(workspace),
                    **default_headers(api_key),
                    **kwargs.pop("headers", {}),
                },
                timeout=timeout,
            )
            logger.debug("Starting processing response: %s", url)
            return _handle_http_response(response, flattened_output)


class StreamEventMixin:
    @classmethod
    def _handle_stream(cls, response: requests.Response):
        # TODO define done message.
        is_error = False
        status_code = HTTPStatus.INTERNAL_SERVER_ERROR
        for line in response.iter_lines():
            if line:
                line = line.decode("utf8")
                line = line.rstrip("\n").rstrip("\r")
                if line.startswith("event:error"):
                    is_error = True
                elif line.startswith("status:"):
                    status_code = line[len("status:") :]
                    status_code = int(status_code.strip())
                elif line.startswith("data:"):
                    line = line[len("data:") :]
                    yield (is_error, status_code, line)
                    if is_error:
                        break
                else:
                    continue  # ignore heartbeat...

    @classmethod
    def _handle_response(cls, response: requests.Response):
        request_id = ""
        if (
            response.status_code == HTTPStatus.OK
            and SSE_CONTENT_TYPE
            in response.headers.get(
                "content-type",
                "",
            )
        ):
            for is_error, status_code, data in cls._handle_stream(response):
                if is_error:
                    yield DashScopeAPIResponse(
                        request_id=request_id,
                        status_code=status_code,
                        output=None,
                        code="",
                        message="",
                    )  # noqa E501
                else:
                    yield DashScopeAPIResponse(
                        request_id=request_id,
                        status_code=HTTPStatus.OK,
                        output=data,
                        usage=None,
                    )
        elif response.status_code == HTTPStatus.OK:
            json_content = response.json()
            request_id = ""
            if "request_id" in json_content:
                request_id = json_content["request_id"]
            yield DashScopeAPIResponse(
                request_id=request_id,
                status_code=HTTPStatus.OK,
                output=json_content,
                usage=None,
            )
        else:
            yield _handle_http_failed_response(response)

    @classmethod
    def stream_events(
        cls,
        target,
        api_key: str = None,
        workspace: str = None,
        **kwargs,
    ) -> Iterator[DashScopeAPIResponse]:
        """Get job log.

        Args:
            target (str): The target to get, such as model_id.
            api_key (str, optional): The api api_key, if not present,
                will get by default rule(TODO: api key doc). Defaults to None.

        Returns:
            DashScopeAPIResponse: The target outputs.
        """
        custom_base_url = kwargs.pop("base_address", None)
        if custom_base_url:
            base_url = custom_base_url
        else:
            base_url = dashscope.base_http_api_url
        url = join_url(base_url, cls.SUB_PATH.lower(), target, "stream")
        timeout = kwargs.pop(
            REQUEST_TIMEOUT_KEYWORD,
            DEFAULT_REQUEST_TIMEOUT_SECONDS,
        )
        with requests.Session() as session:
            logger.debug("Starting request: %s", url)
            response = session.get(
                url,
                headers={
                    **_workspace_header(workspace),
                    **default_headers(api_key),
                    **kwargs.pop("headers", {}),
                },
                stream=True,
                timeout=timeout,
            )
            logger.debug("Starting processing response: %s", url)
            for rsp in cls._handle_response(response):
                yield rsp