dashscope 1.18.1__py3-none-any.whl → 1.19.1__py3-none-any.whl

dashscope/cli.py

@@ -47,7 +47,7 @@ class FineTunes:
         if args.params:
             params.update(args.params)
 
-        rsp = dashscope.FineTune.call(
+        rsp = dashscope.FineTunes.call(
             model=args.model,
             training_file_ids=args.training_file_ids,
             validation_file_ids=args.validation_file_ids,
@@ -64,7 +64,7 @@ class FineTunes:
     def wait(cls, job_id):
         try:
             while True:
-                rsp = dashscope.FineTune.get(job_id)
+                rsp = dashscope.FineTunes.get(job_id)
                 if rsp.status_code == HTTPStatus.OK:
                     if rsp.output['status'] == TaskStatus.FAILED:
                         print('Fine-tune FAILED!')
@@ -93,7 +93,7 @@ class FineTunes:
 
     @classmethod
     def get(cls, args):
-        rsp = dashscope.FineTune.get(args.job)
+        rsp = dashscope.FineTunes.get(args.job)
         if rsp.status_code == HTTPStatus.OK:
             if rsp.output['status'] == TaskStatus.FAILED:
                 print('Fine-tune failed!')
@@ -109,8 +109,8 @@ class FineTunes:
 
     @classmethod
     def list(cls, args):
-        rsp = dashscope.FineTune.list(page=args.start_page,
-                                      page_size=args.page_size)
+        rsp = dashscope.FineTunes.list(page=args.start_page,
+                                       page_size=args.page_size)
         if rsp.status_code == HTTPStatus.OK:
             if rsp.output is not None:
                 for job in rsp.output['jobs']:
@@ -131,7 +131,7 @@ class FineTunes:
     @classmethod
     def stream_events(cls, job_id):
         # check job status if job is completed, get log.
-        rsp = dashscope.FineTune.get(job_id)
+        rsp = dashscope.FineTunes.get(job_id)
         if rsp.status_code == HTTPStatus.OK:
             if rsp.output['status'] in [
                     TaskStatus.FAILED, TaskStatus.CANCELED,
@@ -146,7 +146,7 @@ class FineTunes:
             return
         # start streaming events.
         try:
-            stream_events = dashscope.FineTune.stream_events(job_id)
+            stream_events = dashscope.FineTunes.stream_events(job_id)
             for rsp in stream_events:
                 if rsp.status_code == HTTPStatus.OK:
                     print(rsp.output)
@@ -166,7 +166,7 @@ class FineTunes:
         start = 1
         n_line = 1000  # 1000 line per request
         while True:
-            rsp = dashscope.FineTune.logs(job_id, start, n_line)
+            rsp = dashscope.FineTunes.logs(job_id, offset=start, line=n_line)
             if rsp.status_code == HTTPStatus.OK:
                 for line in rsp.output['logs']:
                     print(line)
@@ -179,7 +179,7 @@ class FineTunes:
 
     @classmethod
     def cancel(cls, args):
-        rsp = dashscope.FineTune.cancel(args.job)
+        rsp = dashscope.FineTunes.cancel(args.job)
         if rsp.status_code == HTTPStatus.OK:
             print('Cancel fine-tune job: %s success!')
         else:
@@ -187,7 +187,7 @@ class FineTunes:
 
     @classmethod
     def delete(cls, args):
-        rsp = dashscope.FineTune.delete(args.job)
+        rsp = dashscope.FineTunes.delete(args.job)
         if rsp.status_code == HTTPStatus.OK:
             print('fine_tune job: %s delete success' % args.job)
         else:
@@ -244,15 +244,15 @@ class Files:
 class Deployments:
     @classmethod
     def call(cls, args):
-        rsp = dashscope.Deployment.call(model=args.model,
-                                        capacity=args.capacity,
-                                        suffix=args.suffix)
+        rsp = dashscope.Deployments.call(model=args.model,
+                                         capacity=args.capacity,
+                                         suffix=args.suffix)
         if rsp.status_code == HTTPStatus.OK:
             deployed_model = rsp.output['deployed_model']
             print('Create model: %s deployment' % deployed_model)
             try:
                 while True:  # wait for deployment ok.
-                    status = dashscope.Deployment.get(deployed_model)
+                    status = dashscope.Deployments.get(deployed_model)
                     if status.status_code == HTTPStatus.OK:
                         if status.output['status'] in [
                                 DeploymentStatus.PENDING,
@@ -276,7 +276,7 @@ class Deployments:
 
     @classmethod
     def get(cls, args):
-        rsp = dashscope.Deployment.get(args.deploy)
+        rsp = dashscope.Deployments.get(args.deploy)
         if rsp.status_code == HTTPStatus.OK:
             print('Deployed model: %s capacity: %s status: %s' %
                   (rsp.output['deployed_model'], rsp.output['capacity'],
@@ -286,11 +286,12 @@ class Deployments:
 
     @classmethod
     def list(cls, args):
-        rsp = dashscope.Deployment.list(page_no=args.start_page,
-                                        page_size=args.page_size)
+        rsp = dashscope.Deployments.list(page_no=args.start_page,
+                                         page_size=args.page_size)
         if rsp.status_code == HTTPStatus.OK:
             if rsp.output is not None:
-                if 'deployments' not in rsp.output:
+                if 'deployments' not in rsp.output or len(
+                        rsp.output['deployments']) == 0:
                     print('There is no deployed model!')
                     return
                 for deployment in rsp.output['deployments']:
@@ -304,7 +305,7 @@ class Deployments:
 
     @classmethod
     def update(cls, args):
-        rsp = dashscope.Deployment.update(args.deployed_model, args.version)
+        rsp = dashscope.Deployments.update(args.deployed_model, args.version)
         if rsp.status_code == HTTPStatus.OK:
             if rsp.output is not None:
                 if 'deployments' not in rsp.output:
@@ -321,7 +322,7 @@ class Deployments:
 
     @classmethod
     def scale(cls, args):
-        rsp = dashscope.Deployment.scale(args.deployed_model, args.capacity)
+        rsp = dashscope.Deployments.scale(args.deployed_model, args.capacity)
         if rsp.status_code == HTTPStatus.OK:
             if rsp.output is not None:
                 print('Deployed_model: %s, model: %s, status: %s' %
@@ -334,7 +335,7 @@ class Deployments:
 
     @classmethod
     def delete(cls, args):
-        rsp = dashscope.Deployment.delete(args.deploy)
+        rsp = dashscope.Deployments.delete(args.deploy)
         if rsp.status_code == HTTPStatus.OK:
             print('Deployed model: %s delete success' % args.deploy)
         else:

dashscope/client/base_api.py

@@ -33,15 +33,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,
-                 workspace: 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:
@@ -80,7 +80,7 @@ class BaseAioApi():
                                      api_key=api_key,
                                      **kwargs)
         # call request service.
-        return request.aio_call()
+        return await request.aio_call()
 
 
 class BaseApi():
@@ -1006,7 +1006,7 @@ class StreamEventMixin():
                                        output=json_content,
                                        usage=None)
         else:
-            _handle_http_failed_response(response)
+            yield _handle_http_failed_response(response)
 
     @classmethod
     def stream_events(cls,

dashscope/common/base_type.py

@@ -27,7 +27,7 @@ class BaseObjectMixin(object):
         field_type_map = self._get_fields_type()
         for k, v in kwargs.items():
             field = field_type_map.get(k, None)
-            if field:
+            if field and v is not None:
                 if dataclasses.is_dataclass(field.type):  # process dataclasses
                     self.__setattr__(k, field.type(**v))
                     continue
@@ -88,6 +88,9 @@ class BaseObjectMixin(object):
     def __getitem__(self, __key: Any) -> Any:
         return self.__getattribute__(__key)
 
+    def __contains__(self, item):
+        return hasattr(self, item)
+
     def __delitem__(self, key):
         self.__delattr__(key)
 

dashscope/common/utils.py

@@ -2,6 +2,8 @@ import asyncio
 import json
 import os
 import platform
+import queue
+import threading
 from dataclasses import dataclass
 from http import HTTPStatus
 from typing import Dict
@@ -75,7 +77,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():
@@ -85,18 +88,41 @@ 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:
-            loop.close()
+        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
 
 
@@ -211,29 +237,46 @@ def _handle_stream(response: requests.Response):
                 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:
-    msg = ''
-    code = None
     request_id = ''
     if 'application/json' in response.headers.get('content-type', ''):
         error = response.json()
-        if flattened_output:
-            error['status_code'] = response.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 _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:
@@ -244,6 +287,49 @@ def _handle_http_failed_response(
                                     message=msg)
 
 
+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 '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='Unknown',
+                                    message=msg)
+
+
 def _handle_http_response(response: requests.Response,
                           flattened_output: bool = False):
     response = _handle_http_stream_response(response, flattened_output)

dashscope/customize/customize_types.py

@@ -0,0 +1,190 @@
+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)