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

dashscope/client/base_api.py

@@ -1,6 +1,9 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+import asyncio
+import collections
 import time
 from http import HTTPStatus
-from typing import List, Union
+from typing import Any, Dict, Iterator, List, Union
 
 import requests
 
@@ -11,20 +14,307 @@ 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)
+                                        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, default_headers,
-                                    join_url)
+                                    _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)
 
-def _normalization_url(*args):
-    url = dashscope.base_http_api_url
-    return join_url(url, *args)
+    @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,
+                   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,
+                  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('Invalid task, task create failed: %s' %
+                                  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.warn(
+                    ('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.
 
-class BaseAioApi():
+        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.
 
     """
@@ -37,14 +327,15 @@ class BaseAioApi():
         return api_key, model
 
     @classmethod
-    def aio_call(cls,
-                 model: str,
-                 input: object,
-                 task_group: str,
-                 task: str = None,
-                 function: str = None,
-                 api_key: str = None,
-                 **kwargs) -> DashScopeAPIResponse:
+    async def call(cls,
+                   model: str,
+                   input: object,
+                   task_group: str,
+                   task: str = None,
+                   function: str = None,
+                   api_key: str = None,
+                   workspace: str = None,
+                   **kwargs) -> DashScopeAPIResponse:
         """Call service and get result.
 
         Args:
@@ -69,6 +360,12 @@ class BaseAioApi():
             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,
@@ -77,7 +374,7 @@ class BaseAioApi():
                                      api_key=api_key,
                                      **kwargs)
         # call request service.
-        return request.aio_call()
+        return await request.aio_call()
 
 
 class BaseApi():
@@ -100,6 +397,7 @@ class BaseApi():
              task: str = None,
              function: str = None,
              api_key: str = None,
+             workspace: str = None,
              **kwargs) -> DashScopeAPIResponse:
         """Call service and get result.
 
@@ -125,6 +423,12 @@ class BaseApi():
             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,
@@ -136,16 +440,45 @@ class BaseApi():
         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) -> DashScopeAPIResponse:
-        status_url = _normalization_url('tasks', task_id)
+    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={
-                                       **default_headers(api_key),
-                                   },
+                                   headers=headers,
                                    timeout=DEFAULT_REQUEST_TIMEOUT_SECONDS)
             logger.debug('Starting processing response: %s' % status_url)
             return _handle_http_response(response)
@@ -164,11 +497,20 @@ class BaseAsyncApi(AsyncTaskGetMixin):
         return api_key, model
 
     @classmethod
-    def call(cls, *args, **kwargs) -> DashScopeAPIResponse:
+    def call(cls,
+             *args,
+             api_key: str = None,
+             workspace: str = None,
+             **kwargs) -> DashScopeAPIResponse:
         """Call service and get result.
         """
-        task_response = cls.async_call(*args, **kwargs)
-        response = cls.wait(task_response)
+        task_response = cls.async_call(*args,
+                                       api_key=api_key,
+                                       workspace=workspace,
+                                       **kwargs)
+        response = cls.wait(task_response,
+                            api_key=api_key,
+                            workspace=workspace)
         return response
 
     @classmethod
@@ -182,7 +524,9 @@ class BaseAsyncApi(AsyncTaskGetMixin):
                 raise InvalidTask('Invalid task, task create failed: %s' %
                                   task)
         else:
-            raise InvalidParameter('task invalid!')
+            raise InvalidParameter('Task invalid!')
+        if task_id is None or task_id == '':
+            raise InvalidParameter('Task id required!')
         return task_id
 
     @classmethod
@@ -190,6 +534,8 @@ class BaseAsyncApi(AsyncTaskGetMixin):
         cls,
         task: Union[str, DashScopeAPIResponse],
         api_key: str = None,
+        workspace: str = None,
+        **kwargs,
     ) -> DashScopeAPIResponse:
         """Cancel PENDING task.
 
@@ -202,10 +548,12 @@ class BaseAsyncApi(AsyncTaskGetMixin):
             DashScopeAPIResponse: The cancel result.
         """
         task_id = cls._get_task_id(task)
-        url = _normalization_url('tasks', task_id, 'cancel')
+        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)
@@ -221,6 +569,7 @@ class BaseAsyncApi(AsyncTaskGetMixin):
              page_no: int = 1,
              page_size: int = 10,
              api_key: str = None,
+             workspace: str = None,
              **kwargs) -> DashScopeAPIResponse:
         """List async tasks.
 
@@ -229,8 +578,10 @@ class BaseAsyncApi(AsyncTaskGetMixin):
                 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.
+            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,
@@ -242,7 +593,8 @@ class BaseAsyncApi(AsyncTaskGetMixin):
         Returns:
             DashScopeAPIResponse: The response data.
         """
-        url = _normalization_url('tasks')
+        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
@@ -261,6 +613,7 @@ class BaseAsyncApi(AsyncTaskGetMixin):
             response = session.get(url,
                                    params=params,
                                    headers={
+                                       **_workspace_header(workspace),
                                        **default_headers(api_key),
                                    })
             if response.status_code == HTTPStatus.OK:
@@ -283,6 +636,8 @@ class BaseAsyncApi(AsyncTaskGetMixin):
         cls,
         task: Union[str, DashScopeAPIResponse],
         api_key: str = None,
+        workspace: str = None,
+        **kwargs,
     ) -> DashScopeAPIResponse:
         """Query async task status.
 
@@ -295,12 +650,13 @@ class BaseAsyncApi(AsyncTaskGetMixin):
             DashScopeAPIResponse: The async task information.
         """
         task_id = cls._get_task_id(task)
-        return cls._get(task_id, api_key)
+        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.
 
@@ -313,8 +669,21 @@ class BaseAsyncApi(AsyncTaskGetMixin):
             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:
-            rsp = cls._get(task_id, api_key)
+            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
@@ -327,13 +696,13 @@ class BaseAsyncApi(AsyncTaskGetMixin):
                     return rsp
                 else:
                     logger.info('The task %s is  %s' % (task_id, task_status))
-                    time.sleep(5)
+                    time.sleep(wait_seconds)
             elif rsp.status_code in REPEATABLE_STATUS:
                 logger.warn(
                     ('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(5)
+                time.sleep(wait_seconds)
             else:
                 return rsp
 
@@ -345,6 +714,7 @@ class BaseAsyncApi(AsyncTaskGetMixin):
                    task: str = None,
                    function: str = None,
                    api_key: str = None,
+                   workspace: str = None,
                    **kwargs) -> DashScopeAPIResponse:
         """Call async service return async task information.
 
@@ -367,6 +737,12 @@ class BaseAsyncApi(AsyncTaskGetMixin):
         if is_stream:
             logger.warn('async_call do not support stream argument')
         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,
@@ -379,20 +755,83 @@ class BaseAsyncApi(AsyncTaskGetMixin):
         return request.call()
 
 
-def _get(url, params={}, api_key=None, **kwargs) -> DashScopeAPIResponse:
+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)
+        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.
+            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.
+            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():
@@ -401,21 +840,29 @@ class ListMixin():
              page_no=1,
              page_size=10,
              api_key: str = None,
-             **kwargs) -> DashScopeAPIResponse:
+             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.
         """
-        url = join_url(dashscope.base_http_api_url, cls.SUB_PATH.lower())
+        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, **kwargs)
+        return _get(url,
+                    params=params,
+                    api_key=api_key,
+                    workspace=workspace,
+                    **kwargs)
 
 
 class LogMixin():
@@ -425,7 +872,9 @@ class LogMixin():
              offset=1,
              line=1000,
              api_key: str = None,
-             **kwargs) -> DashScopeAPIResponse:
+             path: str = None,
+             workspace: str = None,
+             **kwargs) -> Union[DashScopeAPIResponse, Dict]:
         """Get log of the job.
 
         Args:
@@ -437,10 +886,18 @@ class LogMixin():
         Returns:
             DashScopeAPIResponse: The response
         """
-        url = join_url(dashscope.base_http_api_url, cls.SUB_PATH.lower(),
-                       job_id, 'logs')
+        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, **kwargs)
+        return _get(url,
+                    params=params,
+                    api_key=api_key,
+                    workspace=workspace,
+                    **kwargs)
 
 
 class GetMixin():
@@ -448,7 +905,10 @@ class GetMixin():
     def get(cls,
             target,
             api_key: str = None,
-            **kwargs) -> DashScopeAPIResponse:
+            params: dict = {},
+            path: str = None,
+            workspace: str = None,
+            **kwargs) -> Union[DashScopeAPIResponse, Dict]:
         """Get object information.
 
         Args:
@@ -459,9 +919,23 @@ class GetMixin():
         Returns:
             DashScopeAPIResponse: The object information in output.
         """
-        url = join_url(dashscope.base_http_api_url, cls.SUB_PATH.lower(),
-                       target)
-        return _get(url, api_key, **kwargs)
+        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():
@@ -469,7 +943,9 @@ class GetStatusMixin():
     def get(cls,
             target,
             api_key: str = None,
-            **kwargs) -> DashScopeAPIResponse:
+            path: str = None,
+            workspace: str = None,
+            **kwargs) -> Union[DashScopeAPIResponse, Dict]:
         """Get object information.
 
         Args:
@@ -480,9 +956,21 @@ class GetStatusMixin():
         Returns:
             DashScopeAPIResponse: The object information in output.
         """
-        url = join_url(dashscope.base_http_api_url, cls.SUB_PATH.lower(),
-                       target)
-        return _get(url, api_key, **kwargs)
+        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():
@@ -490,7 +978,10 @@ class DeleteMixin():
     def delete(cls,
                target: str,
                api_key: str = None,
-               **kwargs) -> DashScopeAPIResponse:
+               path: str = None,
+               workspace: str = None,
+               flattened_output=False,
+               **kwargs) -> Union[DashScopeAPIResponse, Dict]:
         """Delete object.
 
         Args:
@@ -501,20 +992,28 @@ class DeleteMixin():
         Returns:
             DashScopeAPIResponse: The delete result.
         """
-        url = join_url(dashscope.base_http_api_url, cls.SUB_PATH.lower(),
-                       target)
+        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)
+            return _handle_http_response(response, flattened_output)
 
 
 class CreateMixin():
@@ -522,7 +1021,10 @@ class CreateMixin():
     def call(cls,
              data: object,
              api_key: str = None,
-             **kwargs) -> DashScopeAPIResponse:
+             path: str = None,
+             stream: bool = False,
+             workspace: str = None,
+             **kwargs) -> Union[DashScopeAPIResponse, Dict]:
         """Create a object
 
         Args:
@@ -533,20 +1035,33 @@ class CreateMixin():
         Returns:
             DashScopeAPIResponse: The created object in output.
         """
-        url = join_url(dashscope.base_http_api_url, cls.SUB_PATH.lower())
+        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)
-            return _handle_http_response(response)
+            response = _handle_http_stream_response(response, flattened_output)
+            if stream:
+                return (item for item in response)
+            else:
+                _, output = next(response)
+                try:
+                    next(response)
+                except StopIteration:
+                    pass
+                return output
 
 
 class UpdateMixin():
@@ -555,7 +1070,10 @@ class UpdateMixin():
                target: str,
                json: object,
                api_key: str = None,
-               **kwargs) -> DashScopeAPIResponse:
+               path: str = None,
+               workspace: str = None,
+               method: str = 'patch',
+               **kwargs) -> Union[DashScopeAPIResponse, Dict]:
         """Async update a object
 
         Args:
@@ -567,21 +1085,40 @@ class UpdateMixin():
         Returns:
             DashScopeAPIResponse: The updated object information in output.
         """
-        url = join_url(dashscope.base_http_api_url, cls.SUB_PATH.lower(),
-                       target)
+        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)
-            response = session.patch(url,
-                                     json=json,
-                                     headers={
-                                         **default_headers(api_key),
-                                         **kwargs.pop('headers', {})
-                                     },
-                                     timeout=timeout)
+            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)
+            return _handle_http_response(response, flattened_output)
 
 
 class PutMixin():
@@ -589,9 +1126,10 @@ class PutMixin():
     def put(cls,
             target: str,
             json: object,
-            extra_path: str = None,
+            path: str = None,
             api_key: str = None,
-            **kwargs) -> DashScopeAPIResponse:
+            workspace: str = None,
+            **kwargs) -> Union[DashScopeAPIResponse, Dict]:
         """Async update a object
 
         Args:
@@ -603,13 +1141,15 @@ class PutMixin():
         Returns:
             DashScopeAPIResponse: The updated object information in output.
         """
-        if extra_path is None:
-            url = join_url(dashscope.base_http_api_url, cls.SUB_PATH.lower(),
-                           target)
+        custom_base_url = kwargs.pop('base_address', None)
+        if custom_base_url:
+            base_url = custom_base_url
         else:
-            url = join_url(dashscope.base_http_api_url, cls.SUB_PATH.lower(),
-                           target, extra_path)
-        print(url)
+            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:
@@ -617,6 +1157,7 @@ class PutMixin():
             response = session.put(url,
                                    json=json,
                                    headers={
+                                       **_workspace_header(workspace),
                                        **default_headers(api_key),
                                        **kwargs.pop('headers', {})
                                    },
@@ -632,7 +1173,8 @@ class FileUploadMixin():
                descriptions: List[str] = None,
                params: dict = None,
                api_key: str = None,
-               **kwargs) -> DashScopeAPIResponse:
+               workspace: str = None,
+               **kwargs) -> Union[DashScopeAPIResponse, Dict]:
         """Upload files
 
         Args:
@@ -645,7 +1187,12 @@ class FileUploadMixin():
         Returns:
             DashScopeAPIResponse: The uploaded file information in the output.
         """
-        url = join_url(dashscope.base_http_api_url, cls.SUB_PATH.lower())
+        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}
@@ -656,6 +1203,7 @@ class FileUploadMixin():
             response = session.post(url,
                                     data=js,
                                     headers={
+                                        **_workspace_header(workspace),
                                         **default_headers(api_key),
                                         **kwargs.pop('headers', {})
                                     },
@@ -669,8 +1217,10 @@ class CancelMixin():
     @classmethod
     def cancel(cls,
                target: str,
+               path: str = None,
                api_key: str = None,
-               **kwargs) -> DashScopeAPIResponse:
+               workspace: str = None,
+               **kwargs) -> Union[DashScopeAPIResponse, Dict]:
         """Cancel a job.
 
         Args:
@@ -681,20 +1231,29 @@ class CancelMixin():
         Returns:
             DashScopeAPIResponse: The cancel result.
         """
-        url = join_url(dashscope.base_http_api_url, cls.SUB_PATH.lower(),
-                       target, 'cancel')
+        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)
+            return _handle_http_response(response, flattened_output)
 
 
 class StreamEventMixin():
@@ -748,13 +1307,14 @@ class StreamEventMixin():
                                        output=json_content,
                                        usage=None)
         else:
-            _handle_http_failed_response(response)
+            yield _handle_http_failed_response(response)
 
     @classmethod
     def stream_events(cls,
                       target,
                       api_key: str = None,
-                      **kwargs) -> DashScopeAPIResponse:
+                      workspace: str = None,
+                      **kwargs) -> Iterator[DashScopeAPIResponse]:
         """Get job log.
 
         Args:
@@ -765,14 +1325,19 @@ class StreamEventMixin():
         Returns:
             DashScopeAPIResponse: The target outputs.
         """
-        url = join_url(dashscope.base_http_api_url, cls.SUB_PATH.lower(),
-                       target, 'stream')
+        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', {})
                                    },