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

dashscope/common/utils.py

@@ -1,7 +1,12 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+
 import asyncio
 import json
 import os
 import platform
+import queue
+import threading
+from dataclasses import dataclass
 from http import HTTPStatus
 from typing import Dict
 from urllib.parse import urlparse
@@ -11,11 +16,13 @@ import requests
 
 from dashscope.api_entities.dashscope_response import DashScopeAPIResponse
 from dashscope.common.api_key import get_default_api_key
+from dashscope.common.constants import SSE_CONTENT_TYPE
+from dashscope.common.logging import logger
 from dashscope.version import __version__
 
 
 def is_validate_fine_tune_file(file_path):
-    with open(file_path) as f:
+    with open(file_path, encoding='utf-8') as f:
         for line in f:
             try:
                 json.loads(line)
@@ -72,7 +79,8 @@ def is_url(url: str):
         return False
 
 
-def iter_over_async(ait, loop):
+def iter_over_async(ait):
+    loop = asyncio.get_event_loop_policy().new_event_loop()
     ait = ait.__aiter__()
 
     async def get_next():
@@ -82,20 +90,54 @@ def iter_over_async(ait, loop):
         except StopAsyncIteration:
             return True, None
 
+    def iter_thread(loop, message_queue):
+        while True:
+            try:
+                done, obj = loop.run_until_complete(get_next())
+                if done:
+                    message_queue.put((True, None, None))
+                    break
+                message_queue.put((False, None, obj))
+            except BaseException as e:  # noqa E722
+                logger.exception(e)
+                message_queue.put((True, e, None))
+                break
+
+    message_queue = queue.Queue()
+    x = threading.Thread(target=iter_thread,
+                         args=(loop, message_queue),
+                         name='iter_async_thread')
+    x.start()
     while True:
-        done, obj = loop.run_until_complete(get_next())
-        if done:
+        finished, error, obj = message_queue.get()
+        if finished:
+            if error is not None:
+                yield DashScopeAPIResponse(
+                    -1,
+                    '',
+                    'Unknown',
+                    message='Error type: %s, message: %s' %
+                    (type(error), error))
             break
-        yield obj
+        else:
+            yield obj
 
 
 def async_to_sync(async_generator):
-    loop = asyncio.get_event_loop_policy().new_event_loop()
-    asyncio.set_event_loop(loop)
-    for message in iter_over_async(async_generator, loop):
+    for message in iter_over_async(async_generator):
         yield message
 
 
+def get_user_agent():
+    ua = 'dashscope/%s; python/%s; platform/%s; processor/%s' % (
+        __version__,
+        platform.python_version(),
+        platform.platform(),
+        platform.processor(),
+    )
+    return ua
+
+
 def default_headers(api_key: str = None) -> Dict[str, str]:
     ua = 'dashscope/%s; python/%s; platform/%s; processor/%s' % (
         __version__,
@@ -116,7 +158,8 @@ def join_url(base_url, *args):
         base_url = base_url + '/'
     url = base_url
     for arg in args:
-        url += arg + '/'
+        if arg is not None:
+            url += arg + '/'
     return url[:-1]
 
 
@@ -151,58 +194,245 @@ async def _handle_aiohttp_response(response: aiohttp.ClientResponse):
                                         message=msg)
 
 
-def _handle_http_failed_response(
-        response: requests.Response) -> DashScopeAPIResponse:
-    msg = ''
+@dataclass
+class SSEEvent:
+    id: str
+    eventType: str
+    data: str
+
+    def __init__(self, id: str, type: str, data: str):
+        self.id = id
+        self.eventType = type
+        self.data = data
+
+
+def _handle_stream(response: requests.Response):
+    # TODO define done message.
+    is_error = False
+    status_code = HTTPStatus.BAD_REQUEST
+    event = SSEEvent(None, None, None)
+    eventType = None
+    for line in response.iter_lines():
+        if line:
+            line = line.decode('utf8')
+            line = line.rstrip('\n').rstrip('\r')
+            if line.startswith('id:'):
+                id = line[len('id:'):]
+                event.id = id.strip()
+            elif line.startswith('event:'):
+                eventType = line[len('event:'):]
+                event.eventType = eventType.strip()
+                if eventType == '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:'):]
+                event.data = line.strip()
+                if eventType is not None and eventType == 'done':
+                    continue
+                yield (is_error, status_code, event)
+                if is_error:
+                    break
+            else:
+                continue  # ignore heartbeat...
+
+
+def _handle_error_message(error, status_code, flattened_output):
     code = None
+    msg = ''
+    request_id = ''
+    if flattened_output:
+        error['status_code'] = status_code
+        return error
+    if 'message' in error:
+        msg = error['message']
+    if 'msg' in error:
+        msg = error['msg']
+    if 'code' in error:
+        code = error['code']
+    if 'request_id' in error:
+        request_id = error['request_id']
+    return DashScopeAPIResponse(request_id=request_id,
+                                status_code=status_code,
+                                code=code,
+                                message=msg)
+
+
+def _handle_http_failed_response(
+        response: requests.Response,
+        flattened_output: bool = False) -> DashScopeAPIResponse:
     request_id = ''
     if 'application/json' in response.headers.get('content-type', ''):
         error = response.json()
-        if 'message' in error:
-            msg = error['message']
-        if 'msg' in error:
-            msg = error['msg']
-        if 'code' in error:
-            code = error['code']
-        if 'request_id' in error:
-            request_id = error['request_id']
+        return _handle_error_message(error, response.status_code,
+                                     flattened_output)
+    elif SSE_CONTENT_TYPE in response.headers.get('content-type', ''):
+        msgs = response.content.decode('utf-8').split('\n')
+        for msg in msgs:
+            if msg.startswith('data:'):
+                error = json.loads(msg.replace('data:', '').strip())
+                return _handle_error_message(error, response.status_code,
+                                             flattened_output)
         return DashScopeAPIResponse(request_id=request_id,
                                     status_code=response.status_code,
-                                    code=code,
-                                    message=msg)
+                                    code='Unknown',
+                                    message=msgs)
     else:
         msg = response.content.decode('utf-8')
+        if flattened_output:
+            return {'status_code': response.status_code, 'message': msg}
         return DashScopeAPIResponse(request_id=request_id,
                                     status_code=response.status_code,
                                     code='Unknown',
                                     message=msg)
 
 
-def _handle_http_response(response: requests.Response):
+async def _handle_aio_stream(response):
+    # TODO define done message.
+    is_error = False
+    status_code = HTTPStatus.BAD_REQUEST
+    async for line in response.content:
+        if line:
+            line = line.decode('utf8')
+            line = line.rstrip('\n').rstrip('\r')
+            if line.startswith('event:error'):
+                is_error = True
+            elif line.startswith('status:'):
+                status_code = line[len('status:'):]
+                status_code = int(status_code.strip())
+            elif line.startswith('data:'):
+                line = line[len('data:'):]
+                yield (is_error, status_code, line)
+                if is_error:
+                    break
+            else:
+                continue  # ignore heartbeat...
+
+
+async def _handle_aiohttp_failed_response(
+        response: requests.Response,
+        flattened_output: bool = False) -> DashScopeAPIResponse:
     request_id = ''
-    if response.status_code == HTTPStatus.OK:
-        output = None
-        usage = None
-        code = None
-        msg = ''
-        json_content = response.json()
-        if 'data' in json_content:
-            output = json_content['data']
-        if 'code' in json_content:
-            code = json_content['code']
-        if 'message' in json_content:
-            msg = json_content['message']
-        if 'output' in json_content:
-            output = json_content['output']
-        if 'usage' in json_content:
-            usage = json_content['usage']
-        if 'request_id' in json_content:
-            request_id = json_content['request_id']
+    if 'application/json' in response.content_type:
+        error = await response.json()
+        return _handle_error_message(error, response.status, flattened_output)
+    elif SSE_CONTENT_TYPE in response.content_type:
+        async for _, _, data in _handle_aio_stream(response):
+            error = json.loads(data)
+        return _handle_error_message(error, response.status, flattened_output)
+    else:
+        msg = response.content.decode('utf-8')
+        if flattened_output:
+            return {'status_code': response.status, 'message': msg}
         return DashScopeAPIResponse(request_id=request_id,
-                                    status_code=response.status_code,
-                                    code=code,
-                                    output=output,
-                                    usage=usage,
+                                    status_code=response.status,
+                                    code='Unknown',
                                     message=msg)
+
+
+def _handle_http_response(response: requests.Response,
+                          flattened_output: bool = False):
+    response = _handle_http_stream_response(response, flattened_output)
+    _, output = next(response)
+    try:
+        next(response)
+    except StopIteration:
+        pass
+    return output
+
+
+def _handle_http_stream_response(response: requests.Response,
+                                 flattened_output: bool = False):
+    request_id = ''
+    if (response.status_code == HTTPStatus.OK
+            and SSE_CONTENT_TYPE in response.headers.get('content-type', '')):
+        for is_error, status_code, event in _handle_stream(response):
+            if not is_error:
+                try:
+                    output = None
+                    usage = None
+                    msg = json.loads(event.data)
+                    if flattened_output:
+                        msg['status_code'] = response.status_code
+                        yield event.eventType, msg
+                    else:
+                        logger.debug('Stream message: %s' % msg)
+                        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']
+                        yield event.eventType, DashScopeAPIResponse(
+                            request_id=request_id,
+                            status_code=HTTPStatus.OK,
+                            output=output,
+                            usage=usage)
+                except json.JSONDecodeError as e:
+                    if flattened_output:
+                        yield event.eventType, {
+                            'status_code': response.status_code,
+                            'message': e.message
+                        }
+                    else:
+                        yield event.eventType, DashScopeAPIResponse(
+                            request_id=request_id,
+                            status_code=HTTPStatus.BAD_REQUEST,
+                            output=None,
+                            code='Unknown',
+                            message=event.data)
+                    continue
+            else:
+                if flattened_output:
+                    yield event.eventType, {
+                        'status_code': status_code,
+                        'message': event.data
+                    }
+                else:
+                    msg = json.loads(event.eventType)
+                    yield event.eventType, DashScopeAPIResponse(
+                        request_id=request_id,
+                        status_code=status_code,
+                        output=None,
+                        code=msg['code']
+                        if 'code' in msg else None,  # noqa E501
+                        message=msg['message']
+                        if 'message' in msg else None)  # noqa E501
+    elif response.status_code == HTTPStatus.OK or response.status_code == HTTPStatus.CREATED:
+        json_content = response.json()
+        if flattened_output:
+            json_content['status_code'] = response.status_code
+            yield None, json_content
+        else:
+            output = None
+            usage = None
+            code = None
+            msg = ''
+            if 'data' in json_content:
+                output = json_content['data']
+            if 'code' in json_content:
+                code = json_content['code']
+            if 'message' in json_content:
+                msg = json_content['message']
+            if 'output' in json_content:
+                output = json_content['output']
+            if 'usage' in json_content:
+                usage = json_content['usage']
+            if 'request_id' in json_content:
+                request_id = json_content['request_id']
+                json_content.pop('request_id', None)
+
+            if 'data' not in json_content and 'output' not in json_content:
+                output = json_content
+
+            yield None, DashScopeAPIResponse(request_id=request_id,
+                                             status_code=response.status_code,
+                                             code=code,
+                                             output=output,
+                                             usage=usage,
+                                             message=msg)
     else:
-        return _handle_http_failed_response(response)
+        yield None, _handle_http_failed_response(response, flattened_output)

dashscope/customize/customize_types.py

@@ -0,0 +1,192 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+
+from dataclasses import dataclass
+from http import HTTPStatus
+from typing import Dict, List
+
+from dashscope.common.base_type import BaseObjectMixin
+
+__all__ = ['Deployment', 'FineTune', 'DeploymentList', 'FineTuneList']
+
+
+@dataclass(init=False)
+class DashScopeBaseList(BaseObjectMixin):
+    page_no: int
+    page_size: int
+    total: int
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+
+@dataclass(init=False)
+class DashScopeBase(BaseObjectMixin):
+    status_code: int
+    request_id: str
+    code: str
+    message: str
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+
+@dataclass(init=False)
+class FineTuneOutput(BaseObjectMixin):
+    job_id: str
+    job_name: str
+    status: str
+    model: str
+    base_model: str
+    finetuned_output: str
+    training_file_ids: List[str]
+    validation_file_ids: List[str]
+    hyper_parameters: Dict
+    training_type: str
+    create_time: str
+    end_time: str
+    user_identity: str
+    modifier: str
+    creator: str
+    group: str
+    usage: int
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+
+@dataclass(init=False)
+class FineTune(DashScopeBase):
+    output: FineTuneOutput
+    usage: Dict
+
+    def __init__(self, **kwargs):
+        status_code = kwargs.get('status_code', None)
+        if status_code == HTTPStatus.OK:
+            self.output = FineTuneOutput(**kwargs.pop('output', {}))
+        super().__init__(**kwargs)
+
+
+@dataclass(init=False)
+class FineTuneListOutput(DashScopeBaseList):
+    jobs: List[FineTuneOutput]
+
+    def __init__(self, **kwargs):
+        self.jobs = []
+        for job in kwargs.pop('jobs', []):
+            self.jobs.append(FineTuneOutput(**job))
+        super().__init__(**kwargs)
+
+
+@dataclass(init=False)
+class FineTuneList(DashScopeBase):
+    output: FineTuneListOutput
+
+    def __init__(self, **kwargs):
+        status_code = kwargs.get('status_code', None)
+        if status_code == HTTPStatus.OK:
+            self.output = FineTuneListOutput(**kwargs.pop('output', {}))
+        super().__init__(**kwargs)
+
+
+@dataclass(init=False)
+class CancelDeleteStatus(BaseObjectMixin):
+    status: str
+
+
+@dataclass(init=False)
+class FineTuneCancel(DashScopeBase):
+    output: CancelDeleteStatus
+
+    def __init__(self, **kwargs):
+        status_code = kwargs.get('status_code', None)
+        if status_code == HTTPStatus.OK:
+            self.output = CancelDeleteStatus(**kwargs.pop('output', {}))
+        super().__init__(**kwargs)
+
+
+@dataclass(init=False)
+class FineTuneDelete(DashScopeBase):
+    output: CancelDeleteStatus
+
+    def __init__(self, **kwargs):
+        status_code = kwargs.get('status_code', None)
+        if status_code == HTTPStatus.OK:
+            self.output = CancelDeleteStatus(**kwargs.pop('output', {}))
+        super().__init__(**kwargs)
+
+
+@dataclass(init=False)
+class FineTuneEvent(DashScopeBase):
+    output: str
+
+    def __init__(self, **kwargs):
+        status_code = kwargs.get('status_code', None)
+        if status_code == HTTPStatus.OK:
+            self.output = kwargs.pop('output', {})
+        super().__init__(**kwargs)
+
+
+@dataclass(init=False)
+class DeploymentOutput(BaseObjectMixin):
+    deployed_model: str
+    gmt_create: str
+    gmt_modified: str
+    status: str
+    model_name: str
+    base_model: str
+    base_capacity: int
+    capacity: int
+    ready_capacity: int
+    workspace_id: str
+    charge_type: str
+    modifier: str
+    creator: str
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+
+@dataclass(init=False)
+class Deployment(DashScopeBase):
+    output: DeploymentOutput
+
+    def __init__(self, **kwargs):
+        output = kwargs.pop('output', {})
+        if output:
+            self.output = DeploymentOutput(**output)
+        else:
+            self.output = None
+        super().__init__(**kwargs)
+
+
+@dataclass(init=False)
+class DeploymentListOutput(DashScopeBaseList):
+    deployments: List[DeploymentOutput]
+
+    def __init__(self, **kwargs):
+        self.deployments = []
+        for job in kwargs.pop('deployments', []):
+            self.deployments.append(DeploymentOutput(**job))
+        super().__init__(**kwargs)
+
+
+@dataclass(init=False)
+class DeploymentList(BaseObjectMixin):
+    output: DeploymentListOutput
+
+    def __init__(self, **kwargs):
+        status_code = kwargs.get('status_code', None)
+        if status_code == HTTPStatus.OK:
+            self.output = DeploymentListOutput(**kwargs.pop('output', {}))
+        super().__init__(**kwargs)
+
+
+@dataclass(init=False)
+class DeploymentDelete(DashScopeBase):
+    output: CancelDeleteStatus
+
+    def __init__(self, **kwargs):
+        status_code = kwargs.get('status_code', None)
+        if status_code == HTTPStatus.OK:
+            self.output = CancelDeleteStatus(**kwargs.pop('output', {}))
+        super().__init__(**kwargs)