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

dashscope/api_entities/http_request.py

@@ -1,18 +1,28 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+import datetime
 import json
+import ssl
 from http import HTTPStatus
+from typing import Optional
 
+import aiohttp
+import certifi
 import requests
 
-from dashscope.api_entities.base_request import BaseRequest
+from dashscope.api_entities.base_request import AioBaseRequest
 from dashscope.api_entities.dashscope_response import DashScopeAPIResponse
 from dashscope.common.constants import (DEFAULT_REQUEST_TIMEOUT_SECONDS,
-                                        SSE_CONTENT_TYPE, HTTPMethod,
-                                        StreamResultMode)
+                                        SSE_CONTENT_TYPE, HTTPMethod)
 from dashscope.common.error import UnsupportedHTTPMethod
 from dashscope.common.logging import logger
+from dashscope.common.utils import (_handle_aio_stream,
+                                    _handle_aiohttp_failed_response,
+                                    _handle_http_failed_response,
+                                    _handle_stream)
+from dashscope.api_entities.encryption import Encryption
 
 
-class HttpRequest(BaseRequest):
+class HttpRequest(AioBaseRequest):
     def __init__(self,
                  url: str,
                  api_key: str,
@@ -20,9 +30,11 @@ class HttpRequest(BaseRequest):
                  stream: bool = True,
                  async_request: bool = False,
                  query: bool = False,
-                 stream_result_mode: str = StreamResultMode.ACCUMULATE,
                  timeout: int = DEFAULT_REQUEST_TIMEOUT_SECONDS,
-                 task_id: str = None) -> None:
+                 task_id: str = None,
+                 flattened_output: bool = False,
+                 encryption: Optional[Encryption] = None,
+                 user_agent: str = '') -> None:
         """HttpSSERequest, processing http server sent event stream.
 
         Args:
@@ -32,16 +44,31 @@ class HttpRequest(BaseRequest):
             stream (bool, optional): Is stream request. Defaults to True.
             timeout (int, optional): Total request timeout.
                 Defaults to DEFAULT_REQUEST_TIMEOUT_SECONDS.
+            user_agent (str, optional): Additional user agent string to
+                append. Defaults to ''.
         """
 
-        super().__init__()
+        super().__init__(user_agent=user_agent)
         self.url = url
+        self.flattened_output = flattened_output
         self.async_request = async_request
+        self.encryption = encryption
         self.headers = {
             'Accept': 'application/json',
             'Authorization': 'Bearer %s' % api_key,
             **self.headers,
         }
+
+        if encryption and encryption.is_valid():
+            self.headers = {
+                "X-DashScope-EncryptionKey": json.dumps({
+                    "public_key_id": encryption.get_pub_key_id(),
+                    "encrypt_key": encryption.get_encrypted_aes_key_str(),
+                    "iv": encryption.get_base64_iv_str()
+                }),
+                **self.headers,
+            }
+
         self.query = query
         if self.async_request and self.query is False:
             self.headers = {
@@ -83,34 +110,177 @@ class HttpRequest(BaseRequest):
                 pass
             return output
 
-    def _handle_stream(self, 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
+    async def aio_call(self):
+        response = self._handle_aio_request()
+        if self.stream:
+            return (item async for item in response)
+        else:
+            result = await response.__anext__()
+            try:
+                await response.__anext__()
+            except StopAsyncIteration:
+                pass
+            return result
+
+    async def _handle_aio_request(self):
+        try:
+            connector = aiohttp.TCPConnector(
+                ssl=ssl.create_default_context(
+                    cafile=certifi.where()))
+            async with aiohttp.ClientSession(
+                    connector=connector,
+                    timeout=aiohttp.ClientTimeout(total=self.timeout),
+                    headers=self.headers) as session:
+                logger.debug('Starting request: %s' % self.url)
+                if self.method == HTTPMethod.POST:
+                    is_form, obj = False, {}
+                    if hasattr(self, 'data') and self.data is not None:
+                        is_form, obj = self.data.get_aiohttp_payload()
+                    if is_form:
+                        headers = {**self.headers, **obj.headers}
+                        response = await session.post(url=self.url,
+                                                      data=obj,
+                                                      headers=headers)
+                    else:
+                        response = await session.request('POST',
+                                                         url=self.url,
+                                                         json=obj,
+                                                         headers=self.headers)
+                elif self.method == HTTPMethod.GET:
+                    # 添加条件判断
+                    params = {}
+                    if hasattr(self, 'data') and self.data is not None:
+                        params = getattr(self.data, 'parameters', {})
+                    if params:
+                        params = self.__handle_parameters(params)
+                    response = await session.get(url=self.url,
+                                                 params=params,
+                                                 headers=self.headers)
                 else:
-                    continue  # ignore heartbeat...
+                    raise UnsupportedHTTPMethod('Unsupported http method: %s' %
+                                                self.method)
+                logger.debug('Response returned: %s' % self.url)
+                async with response:
+                    async for rsp in self._handle_aio_response(response):
+                        yield rsp
+        except aiohttp.ClientConnectorError as e:
+            logger.error(e)
+            raise e
+        except BaseException as e:
+            logger.error(e)
+            raise e
+
+    @staticmethod
+    def __handle_parameters(params: dict) -> dict:
+        def __format(value):
+            if isinstance(value, bool):
+                return str(value).lower()
+            elif isinstance(value, (str, int, float)):
+                return value
+            elif value is None:
+                return ''
+            elif isinstance(value, (datetime.datetime, datetime.date)):
+                return value.isoformat()
+            elif isinstance(value, (list, tuple)):
+                return ','.join(str(__format(x)) for x in value)
+            elif isinstance(value, dict):
+                return json.dumps(value)
+            else:
+                try:
+                    return str(value)
+                except Exception as e:
+                    raise ValueError(f"Unsupported type {type(value)} for param formatting: {e}")
+
+        formatted = {}
+        for k, v in params.items():
+            formatted[k] = __format(v)
+        return formatted
+
+    async def _handle_aio_response(self, response: aiohttp.ClientResponse):
+        request_id = ''
+        if (response.status == HTTPStatus.OK and self.stream
+                and SSE_CONTENT_TYPE in response.content_type):
+            async for is_error, status_code, data in _handle_aio_stream(
+                    response):
+                try:
+                    output = None
+                    usage = None
+                    msg = json.loads(data)
+                    if not is_error:
+                        if 'output' in msg:
+                            output = msg['output']
+                        if 'usage' in msg:
+                            usage = msg['usage']
+                    if 'request_id' in msg:
+                        request_id = msg['request_id']
+                except json.JSONDecodeError:
+                    yield DashScopeAPIResponse(
+                        request_id=request_id,
+                        status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
+                        code='Unknown',
+                        message=data)
+                    continue
+                if is_error:
+                    yield DashScopeAPIResponse(request_id=request_id,
+                                               status_code=status_code,
+                                               code=msg['code'],
+                                               message=msg['message'])
+                else:
+                    if self.encryption and self.encryption.is_valid():
+                        output = self.encryption.decrypt(output)
+                    yield DashScopeAPIResponse(request_id=request_id,
+                                               status_code=HTTPStatus.OK,
+                                               output=output,
+                                               usage=usage)
+        elif (response.status == HTTPStatus.OK
+              and 'multipart' in response.content_type):
+            reader = aiohttp.MultipartReader.from_response(response)
+            output = {}
+            while True:
+                part = await reader.next()
+                if part is None:
+                    break
+                output[part.name] = await part.read()
+            if 'request_id' in output:
+                request_id = output['request_id']
+            if self.encryption and self.encryption.is_valid():
+                output = self.encryption.decrypt(output)
+            yield DashScopeAPIResponse(request_id=request_id,
+                                       status_code=HTTPStatus.OK,
+                                       output=output)
+        elif response.status == HTTPStatus.OK:
+            json_content = await response.json()
+            output = None
+            usage = None
+            if 'output' in json_content and json_content['output'] is not None:
+                output = json_content['output']
+            # Compatible with wan
+            elif 'data' in json_content and json_content['data'] is not None\
+                    and isinstance(json_content['data'], list)\
+                    and len(json_content['data']) > 0\
+                    and 'task_id' in json_content['data'][0]:
+                output = json_content
+            if 'usage' in json_content:
+                usage = json_content['usage']
+            if 'request_id' in json_content:
+                request_id = json_content['request_id']
+            if self.encryption and self.encryption.is_valid():
+                output = self.encryption.decrypt(output)
+            yield DashScopeAPIResponse(request_id=request_id,
+                                       status_code=HTTPStatus.OK,
+                                       output=output,
+                                       usage=usage)
+        else:
+            yield await _handle_aiohttp_failed_response(response)
 
     def _handle_response(self, response: requests.Response):
         request_id = ''
         if (response.status_code == HTTPStatus.OK and self.stream
                 and SSE_CONTENT_TYPE in response.headers.get(
                     'content-type', '')):
-            for is_error, status_code, data in self._handle_stream(response):
+            for is_error, status_code, event in _handle_stream(response):
                 try:
+                    data = event.data
                     output = None
                     usage = None
                     msg = json.loads(data)
@@ -140,10 +310,15 @@ class HttpRequest(BaseRequest):
                         message=msg['message']
                         if 'message' in msg else None)  # noqa E501
                 else:
-                    yield DashScopeAPIResponse(request_id=request_id,
-                                               status_code=HTTPStatus.OK,
-                                               output=output,
-                                               usage=usage)
+                    if self.flattened_output:
+                        yield msg
+                    else:
+                        if self.encryption and self.encryption.is_valid():
+                            output = self.encryption.decrypt(output)
+                        yield DashScopeAPIResponse(request_id=request_id,
+                                                   status_code=HTTPStatus.OK,
+                                                   output=output,
+                                                   usage=usage)
         elif response.status_code == HTTPStatus.OK:
             json_content = response.json()
             logger.debug('Response: %s' % json_content)
@@ -157,38 +332,17 @@ class HttpRequest(BaseRequest):
                 usage = json_content['usage']
             if 'request_id' in json_content:
                 request_id = json_content['request_id']
-            yield DashScopeAPIResponse(request_id=request_id,
-                                       status_code=HTTPStatus.OK,
-                                       output=output,
-                                       usage=usage)
-        else:
-            if 'application/json' in response.headers.get('content-type', ''):
-                error = response.json()
-                if 'request_id' in error:
-                    request_id = error['request_id']
-                if 'message' not in error:
-                    message = ''
-                    logger.error('Request: %s failed, status: %s' %
-                                 (self.url, response.status_code))
-                else:
-                    message = error['message']
-                    logger.error(
-                        'Request: %s failed, status: %s, message: %s' %
-                        (self.url, response.status_code, error['message']))
-                yield DashScopeAPIResponse(
-                    request_id=request_id,
-                    status_code=response.status_code,
-                    output=None,
-                    code=error['code']
-                    if 'code' in error else None,  # noqa E501
-                    message=message)
+            if self.flattened_output:
+                yield json_content
             else:
-                msg = response.content
+                if self.encryption and self.encryption.is_valid():
+                    output = self.encryption.decrypt(output)
                 yield DashScopeAPIResponse(request_id=request_id,
-                                           status_code=response.status_code,
-                                           output=None,
-                                           code='Unknown',
-                                           message=msg.decode('utf-8'))
+                                           status_code=HTTPStatus.OK,
+                                           output=output,
+                                           usage=usage)
+        else:
+            yield _handle_http_failed_response(response)
 
     def _handle_request(self):
         try:
@@ -220,6 +374,6 @@ class HttpRequest(BaseRequest):
                                                 self.method)
                 for rsp in self._handle_response(response):
                     yield rsp
-        except Exception as e:
+        except BaseException as e:
             logger.error(e)
             raise e

dashscope/api_entities/websocket_request.py

@@ -1,3 +1,5 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+
 import asyncio
 import json
 import uuid
@@ -10,7 +12,7 @@ from dashscope.api_entities.base_request import AioBaseRequest
 from dashscope.api_entities.dashscope_response import DashScopeAPIResponse
 from dashscope.common.constants import (DEFAULT_REQUEST_TIMEOUT_SECONDS,
                                         SERVICE_503_MESSAGE,
-                                        WEBSOCKET_ERROR_CODE, StreamResultMode)
+                                        WEBSOCKET_ERROR_CODE)
 from dashscope.common.error import (RequestFailure, UnexpectedMessageReceived,
                                     UnknownMessageReceived)
 from dashscope.common.logging import logger
@@ -29,10 +31,12 @@ class WebSocketRequest(AioBaseRequest):
         stream: bool = True,
         ws_stream_mode: str = WebsocketStreamingMode.OUT,
         is_binary_input: bool = False,
-        stream_result_mode: str = StreamResultMode.ACCUMULATE,
         timeout: int = DEFAULT_REQUEST_TIMEOUT_SECONDS,
+        flattened_output: bool = False,
+        pre_task_id=None,
+        user_agent: str = '',
     ) -> None:
-        super().__init__()
+        super().__init__(user_agent=user_agent)
         """HttpRequest.
 
         Args:
@@ -45,12 +49,12 @@ class WebSocketRequest(AioBaseRequest):
         """
         self.url = url
         self.stream = stream
+        self.flattened_output = flattened_output
         if timeout is None:
             self.timeout = DEFAULT_REQUEST_TIMEOUT_SECONDS
         else:
             self.timeout = timeout
         self.ws_stream_mode = ws_stream_mode
-        self.stream_result_mode = stream_result_mode
         self.is_binary_input = is_binary_input
 
         self.headers = {
@@ -61,6 +65,7 @@ class WebSocketRequest(AioBaseRequest):
         self.task_headers = {
             'streaming': self.ws_stream_mode,
         }
+        self.pre_task_id = pre_task_id
 
     def add_headers(self, headers):
         self.headers = {**self.headers, **headers}
@@ -77,6 +82,10 @@ class WebSocketRequest(AioBaseRequest):
                 pass
             return output
 
+    async def close(self):
+        if self.ws is not None and not self.ws.closed:
+            await self.ws.close()
+
     async def aio_call(self):
         response = self.connection_handler()
         if self.stream:
@@ -140,7 +149,11 @@ class WebSocketRequest(AioBaseRequest):
                                        code=e.name,
                                        message=e.message)
         except aiohttp.ClientConnectorError as e:
-            raise e
+            logger.exception(e)
+            yield DashScopeAPIResponse(request_id='',
+                                       status_code=-1,
+                                       code='ClientConnectorError',
+                                       message=str(e))
         except aiohttp.WSServerHandshakeError as e:
             code = e.status
             msg = e.message
@@ -154,6 +167,13 @@ class WebSocketRequest(AioBaseRequest):
                                        status_code=code,
                                        code=code,
                                        message=msg)
+        except BaseException as e:
+            logger.exception(e)
+            yield DashScopeAPIResponse(request_id='',
+                                       status_code=-1,
+                                       code='Unknown',
+                                       message='Error type: %s, message: %s' %
+                                       (type(e), e))
 
     def _to_DashScopeAPIResponse(self, task_id, is_binary, result):
         if is_binary:
@@ -177,7 +197,6 @@ class WebSocketRequest(AioBaseRequest):
         # check if request stream data, re return an iterator,
         # otherwise we collect data and return user.
         # no matter what, the response is streaming
-        final_payload = None
         is_binary_output = False
         while True:
             msg = await ws.receive()
@@ -186,36 +205,21 @@ class WebSocketRequest(AioBaseRequest):
                 msg_json = msg.json()
                 logger.debug('Receive %s event' % msg_json[HEADER][EVENT_KEY])
                 if msg_json[HEADER][EVENT_KEY] == EventType.GENERATED:
-                    if final_payload is None:
-                        final_payload = []
                     payload = msg_json['payload']
-                    if self.stream:
-                        yield False, payload
-                    elif self.stream_result_mode == StreamResultMode.ACCUMULATE:  # noqa E501
-                        final_payload = payload
-                    else:
-                        final_payload.append(payload)
+                    yield False, payload
                 elif msg_json[HEADER][EVENT_KEY] == EventType.FINISHED:
-                    if final_payload is None:
-                        final_payload = []
                     payload = None
                     if 'payload' in msg_json:
                         payload = msg_json['payload']
                     logger.debug(payload)
                     if payload:
-                        if self.stream:
-                            yield False, payload
-                        elif self.stream_result_mode == StreamResultMode.ACCUMULATE:  # noqa E501
-                            yield False, payload
-                        else:
-                            final_payload.extend(payload)
-                            yield False, final_payload
+                        yield False, payload
                     else:
                         if not self.stream:
                             if is_binary_output:
-                                yield True, final_payload
+                                yield True, payload
                             else:
-                                yield False, final_payload
+                                yield False, payload
                     break
                 elif msg_json[HEADER][EVENT_KEY] == EventType.FAILED:
                     self._on_failed(msg_json)
@@ -225,14 +229,7 @@ class WebSocketRequest(AioBaseRequest):
                     raise UnknownMessageReceived(error)
             elif msg.type == aiohttp.WSMsgType.BINARY:
                 is_binary_output = True
-                if final_payload is None:
-                    final_payload = b''
-                if self.stream:
-                    yield True, msg.data
-                elif self.stream_result_mode == StreamResultMode.ACCUMULATE:
-                    final_payload = msg.data
-                else:
-                    final_payload += msg.data
+                yield True, msg.data
 
     def _on_failed(self, details):
         error = RequestFailure(request_id=details[HEADER][TASK_ID],
@@ -243,17 +240,22 @@ class WebSocketRequest(AioBaseRequest):
         raise error
 
     async def _start_task(self, ws):
-        self.task_headers['task_id'] = uuid.uuid4().hex  # create task id.
+        if self.pre_task_id is not None:
+            self.task_headers['task_id'] = self.pre_task_id
+        else:
+            self.task_headers['task_id'] = uuid.uuid4().hex  # create task id.
         task_header = {**self.task_headers, ACTION_KEY: ActionType.START}
         # for binary data, the start action has no input, only parameters.
         start_data = self.data.get_websocket_start_data()
         message = self._build_up_message(task_header, start_data)
+        logger.debug('Send start task: {}'.format(message))
         await ws.send_str(message)
 
     async def _send_finished_task(self, ws):
         task_header = {**self.task_headers, ACTION_KEY: ActionType.FINISHED}
         payload = {'input': {}}
         message = self._build_up_message(task_header, payload)
+        logger.debug('Send finish task: {}'.format(message))
         await ws.send_str(message)
 
     async def _send_continue_task_data(self, ws):
@@ -266,12 +268,19 @@ class WebSocketRequest(AioBaseRequest):
                 if len(input) > 0:
                     if isinstance(input, bytes):
                         await ws.send_bytes(input)
+                        logger.debug(
+                            'Send continue task with bytes: {}'.format(
+                                len(input)))
                     else:
                         await ws.send_bytes(list(input.values())[0])
+                        logger.debug(
+                            'Send continue task with list[byte]: {}'.format(
+                                len(input)))
             else:
                 if len(input) > 0:
                     message = self._build_up_message(headers=headers,
                                                      payload=input)
+                    logger.debug('Send continue task: {}'.format(message))
                     await ws.send_str(message)
             await asyncio.sleep(0.000001)
 

dashscope/app/__init__.py

@@ -0,0 +1,5 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+
+from .application import Application
+
+__all__ = [Application]