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

dashscope/client/base_api.py

@@ -1,9 +1,10 @@
 import time
 from http import HTTPStatus
-from typing import List, Union
+from typing import Any, Dict, Iterator, List, Union
 
-import dashscope
 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
@@ -14,13 +15,9 @@ from dashscope.common.constants import (DEFAULT_REQUEST_TIMEOUT_SECONDS,
 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)
-
-
-def _normalization_url(*args):
-    url = dashscope.base_http_api_url
-    return join_url(url, *args)
+                                    _handle_http_response,
+                                    _handle_http_stream_response,
+                                    default_headers, join_url)
 
 
 class BaseAioApi():
@@ -43,6 +40,7 @@ class BaseAioApi():
                  task: str = None,
                  function: str = None,
                  api_key: str = None,
+                 workspace: str = None,
                  **kwargs) -> DashScopeAPIResponse:
         """Call service and get result.
 
@@ -68,6 +66,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,
@@ -99,6 +103,7 @@ class BaseApi():
              task: str = None,
              function: str = None,
              api_key: str = None,
+             workspace: str = None,
              **kwargs) -> DashScopeAPIResponse:
         """Call service and get result.
 
@@ -124,6 +129,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,
@@ -135,14 +146,36 @@ 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)
         with requests.Session() as session:
             logger.debug('Starting request: %s' % status_url)
             response = session.get(status_url,
                                    headers={
+                                       **_workspace_header(workspace),
                                        **default_headers(api_key),
                                    },
                                    timeout=DEFAULT_REQUEST_TIMEOUT_SECONDS)
@@ -163,11 +196,20 @@ class BaseAsyncApi(AsyncTaskGetMixin):
         return api_key, model
 
     @classmethod
-    def call(cls, *args, api_key: None, **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, api_key=api_key, **kwargs)
-        response = cls.wait(task_response, api_key=api_key)
+        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
@@ -191,6 +233,8 @@ class BaseAsyncApi(AsyncTaskGetMixin):
         cls,
         task: Union[str, DashScopeAPIResponse],
         api_key: str = None,
+        workspace: str = None,
+        **kwargs,
     ) -> DashScopeAPIResponse:
         """Cancel PENDING task.
 
@@ -203,10 +247,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)
@@ -222,6 +268,7 @@ class BaseAsyncApi(AsyncTaskGetMixin):
              page_no: int = 1,
              page_size: int = 10,
              api_key: str = None,
+             workspace: str = None,
              **kwargs) -> DashScopeAPIResponse:
         """List async tasks.
 
@@ -245,7 +292,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
@@ -264,6 +312,7 @@ class BaseAsyncApi(AsyncTaskGetMixin):
             response = session.get(url,
                                    params=params,
                                    headers={
+                                       **_workspace_header(workspace),
                                        **default_headers(api_key),
                                    })
             if response.status_code == HTTPStatus.OK:
@@ -286,6 +335,8 @@ class BaseAsyncApi(AsyncTaskGetMixin):
         cls,
         task: Union[str, DashScopeAPIResponse],
         api_key: str = None,
+        workspace: str = None,
+        **kwargs,
     ) -> DashScopeAPIResponse:
         """Query async task status.
 
@@ -298,12 +349,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.
 
@@ -330,7 +382,7 @@ class BaseAsyncApi(AsyncTaskGetMixin):
             # (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)
+            rsp = cls._get(task_id, api_key, workspace=workspace, **kwargs)
             if rsp.status_code == HTTPStatus.OK:
                 if rsp.output is None:
                     return rsp
@@ -361,6 +413,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.
 
@@ -383,6 +436,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,
@@ -395,20 +454,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():
@@ -417,21 +539,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():
@@ -441,7 +571,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:
@@ -453,10 +585,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():
@@ -465,7 +605,9 @@ class GetMixin():
             target,
             api_key: str = None,
             params: dict = {},
-            **kwargs) -> DashScopeAPIResponse:
+            path: str = None,
+            workspace: str = None,
+            **kwargs) -> Union[DashScopeAPIResponse, Dict]:
         """Get object information.
 
         Args:
@@ -476,9 +618,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=api_key, params=params, **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():
@@ -486,7 +642,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:
@@ -497,9 +655,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():
@@ -507,7 +677,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:
@@ -518,20 +691,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():
@@ -539,7 +720,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:
@@ -550,20 +734,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():
@@ -572,7 +769,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:
@@ -584,21 +784,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():
@@ -606,9 +825,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:
@@ -620,13 +840,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:
@@ -634,6 +856,7 @@ class PutMixin():
             response = session.put(url,
                                    json=json,
                                    headers={
+                                       **_workspace_header(workspace),
                                        **default_headers(api_key),
                                        **kwargs.pop('headers', {})
                                    },
@@ -649,7 +872,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:
@@ -662,7 +886,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}
@@ -673,6 +902,7 @@ class FileUploadMixin():
             response = session.post(url,
                                     data=js,
                                     headers={
+                                        **_workspace_header(workspace),
                                         **default_headers(api_key),
                                         **kwargs.pop('headers', {})
                                     },
@@ -686,8 +916,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:
@@ -698,20 +930,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():
@@ -771,7 +1012,8 @@ class StreamEventMixin():
     def stream_events(cls,
                       target,
                       api_key: str = None,
-                      **kwargs) -> DashScopeAPIResponse:
+                      workspace: str = None,
+                      **kwargs) -> Iterator[DashScopeAPIResponse]:
         """Get job log.
 
         Args:
@@ -782,14 +1024,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', {})
                                    },