801 lines
31 KiB
Python
801 lines
31 KiB
Python
import time
|
||
from http import HTTPStatus
|
||
from typing import List, Union
|
||
|
||
import dashscope
|
||
import requests
|
||
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
|
||
from dashscope.common.constants import (DEFAULT_REQUEST_TIMEOUT_SECONDS,
|
||
REPEATABLE_STATUS,
|
||
REQUEST_TIMEOUT_KEYWORD,
|
||
SSE_CONTENT_TYPE, TaskStatus)
|
||
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)
|
||
|
||
|
||
class BaseAioApi():
|
||
"""BaseApi, internal use only.
|
||
|
||
"""
|
||
@classmethod
|
||
def _validate_params(cls, api_key, model):
|
||
if api_key is None:
|
||
api_key = get_default_api_key()
|
||
if model is None or not model:
|
||
raise ModelRequired('Model is required!')
|
||
return api_key, model
|
||
|
||
@classmethod
|
||
def aio_call(cls,
|
||
model: str,
|
||
input: object,
|
||
task_group: str,
|
||
task: str = None,
|
||
function: str = None,
|
||
api_key: str = None,
|
||
**kwargs) -> DashScopeAPIResponse:
|
||
"""Call service and get result.
|
||
|
||
Args:
|
||
model (str): The requested model, such as gpt3-v2
|
||
input (object): The api input data, cannot be None.
|
||
task_group (str, optional): The api task group.
|
||
task (str, optional): The task name. Defaults to None.
|
||
function (str, optional): The function of the task.
|
||
Defaults to None.
|
||
api_key (str, optional): The api api_key, if not present,
|
||
will get by default rule(TODO: api key doc). Defaults to None.
|
||
api_protocol (str, optional): Api protocol websocket or http.
|
||
Defaults to None.
|
||
ws_stream_mode (str, optional): websocket stream mode,
|
||
[none, in, out, duplex]. Defaults to out.
|
||
is_binary_input (bool, optional): Is input data binary.
|
||
Defaults to False.
|
||
http_method (str, optional): If api protocol is http, specifies
|
||
method[GET, POST]. Defaults to POST.
|
||
|
||
Returns:
|
||
DashScopeAPIResponse: The service response.
|
||
"""
|
||
api_key, model = BaseAioApi._validate_params(api_key, model)
|
||
request = _build_api_request(model=model,
|
||
input=input,
|
||
task_group=task_group,
|
||
task=task,
|
||
function=function,
|
||
api_key=api_key,
|
||
**kwargs)
|
||
# call request service.
|
||
return request.aio_call()
|
||
|
||
|
||
class BaseApi():
|
||
"""BaseApi, internal use only.
|
||
|
||
"""
|
||
@classmethod
|
||
def _validate_params(cls, api_key, model):
|
||
if api_key is None:
|
||
api_key = get_default_api_key()
|
||
if model is None or not model:
|
||
raise ModelRequired('Model is required!')
|
||
return api_key, model
|
||
|
||
@classmethod
|
||
def call(cls,
|
||
model: str,
|
||
input: object,
|
||
task_group: str,
|
||
task: str = None,
|
||
function: str = None,
|
||
api_key: str = None,
|
||
**kwargs) -> DashScopeAPIResponse:
|
||
"""Call service and get result.
|
||
|
||
Args:
|
||
model (str): The requested model, such as gpt3-v2
|
||
input (object): The api input data, cannot be None.
|
||
task_group (str, optional): The api task group.
|
||
task (str, optional): The task name. Defaults to None.
|
||
function (str, optional): The function of the task.
|
||
Defaults to None.
|
||
api_key (str, optional): The api api_key, if not present,
|
||
will get by default rule(TODO: api key doc). Defaults to None.
|
||
api_protocol (str, optional): Api protocol websocket or http.
|
||
Defaults to None.
|
||
ws_stream_mode (str, optional): websocket stream mode,
|
||
[none, in, out, duplex]. Defaults to out.
|
||
is_binary_input (bool, optional): Is input data binary.
|
||
Defaults to False.
|
||
http_method (str, optional): If api protocol is http, specifies
|
||
method[GET, POST]. Defaults to POST.
|
||
|
||
Returns:
|
||
DashScopeAPIResponse: The service response.
|
||
"""
|
||
api_key, model = BaseApi._validate_params(api_key, model)
|
||
request = _build_api_request(model=model,
|
||
input=input,
|
||
task_group=task_group,
|
||
task=task,
|
||
function=function,
|
||
api_key=api_key,
|
||
**kwargs)
|
||
# call request service.
|
||
return request.call()
|
||
|
||
|
||
class AsyncTaskGetMixin():
|
||
@classmethod
|
||
def _get(cls, task_id: str, api_key: str = None) -> DashScopeAPIResponse:
|
||
status_url = _normalization_url('tasks', task_id)
|
||
with requests.Session() as session:
|
||
logger.debug('Starting request: %s' % status_url)
|
||
response = session.get(status_url,
|
||
headers={
|
||
**default_headers(api_key),
|
||
},
|
||
timeout=DEFAULT_REQUEST_TIMEOUT_SECONDS)
|
||
logger.debug('Starting processing response: %s' % status_url)
|
||
return _handle_http_response(response)
|
||
|
||
|
||
class BaseAsyncApi(AsyncTaskGetMixin):
|
||
"""BaseAsyncApi,for async task, internal use only.
|
||
|
||
"""
|
||
@classmethod
|
||
def _validate_params(cls, api_key, model):
|
||
if api_key is None:
|
||
api_key = get_default_api_key()
|
||
if model is None or not model:
|
||
raise ModelRequired('Model is required!')
|
||
return api_key, model
|
||
|
||
@classmethod
|
||
def call(cls, *args, api_key: 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)
|
||
return response
|
||
|
||
@classmethod
|
||
def _get_task_id(cls, task):
|
||
if isinstance(task, str):
|
||
task_id = task
|
||
elif isinstance(task, DashScopeAPIResponse):
|
||
if task.status_code == HTTPStatus.OK:
|
||
task_id = task.output['task_id']
|
||
else:
|
||
raise InvalidTask('Invalid task, task create failed: %s' %
|
||
task)
|
||
else:
|
||
raise InvalidParameter('Task invalid!')
|
||
if task_id is None or task_id == '':
|
||
raise InvalidParameter('Task id required!')
|
||
return task_id
|
||
|
||
@classmethod
|
||
def cancel(
|
||
cls,
|
||
task: Union[str, DashScopeAPIResponse],
|
||
api_key: str = None,
|
||
) -> DashScopeAPIResponse:
|
||
"""Cancel PENDING task.
|
||
|
||
Args:
|
||
task (Union[str, DashScopeAPIResponse]): The task_id, or
|
||
async_call response.
|
||
api_key (str, optional): The api-key. Defaults to None.
|
||
|
||
Returns:
|
||
DashScopeAPIResponse: The cancel result.
|
||
"""
|
||
task_id = cls._get_task_id(task)
|
||
url = _normalization_url('tasks', task_id, 'cancel')
|
||
with requests.Session() as session:
|
||
response = session.post(url,
|
||
headers={
|
||
**default_headers(api_key),
|
||
})
|
||
return _handle_http_response(response)
|
||
|
||
@classmethod
|
||
def list(cls,
|
||
start_time: str = None,
|
||
end_time: str = None,
|
||
model_name: str = None,
|
||
api_key_id: str = None,
|
||
region: str = None,
|
||
status: str = None,
|
||
page_no: int = 1,
|
||
page_size: int = 10,
|
||
api_key: str = None,
|
||
**kwargs) -> DashScopeAPIResponse:
|
||
"""List async tasks.
|
||
|
||
Args:
|
||
start_time (str, optional): The tasks start time,
|
||
for example: 20230420000000. Defaults to None.
|
||
end_time (str, optional): The tasks end time,
|
||
for example: 20230420000000. Defaults to None.
|
||
model_name (str, optional): The tasks model name.
|
||
Defaults to None.
|
||
api_key_id (str, optional): The tasks api-key-id.
|
||
Defaults to None.
|
||
region (str, optional): The service region,
|
||
for example: cn-beijing. Defaults to None.
|
||
status (str, optional): The status of tasks[PENDING,
|
||
RUNNING, SUCCEEDED, FAILED, CANCELED]. Defaults to None.
|
||
page_no (int, optional): The page number. Defaults to 1.
|
||
page_size (int, optional): The page size. Defaults to 10.
|
||
api_key (str, optional): The user api-key. Defaults to None.
|
||
|
||
Returns:
|
||
DashScopeAPIResponse: The response data.
|
||
"""
|
||
url = _normalization_url('tasks')
|
||
params = {'page_no': page_no, 'page_size': page_size}
|
||
if start_time is not None:
|
||
params['start_time'] = start_time
|
||
if end_time is not None:
|
||
params['end_time'] = end_time
|
||
if model_name is not None:
|
||
params['model_name'] = model_name
|
||
if api_key_id is not None:
|
||
params['api_key_id'] = api_key_id
|
||
if region is not None:
|
||
params['region'] = region
|
||
if status is not None:
|
||
params['status'] = status
|
||
|
||
with requests.Session() as session:
|
||
response = session.get(url,
|
||
params=params,
|
||
headers={
|
||
**default_headers(api_key),
|
||
})
|
||
if response.status_code == HTTPStatus.OK:
|
||
json_content = response.json()
|
||
request_id = ''
|
||
if 'request_id' in json_content:
|
||
request_id = json_content['request_id']
|
||
json_content.pop('request_id')
|
||
return DashScopeAPIResponse(request_id=request_id,
|
||
status_code=response.status_code,
|
||
code=None,
|
||
output=json_content,
|
||
usage=None,
|
||
message='')
|
||
else:
|
||
return _handle_http_failed_response(response)
|
||
|
||
@classmethod
|
||
def fetch(
|
||
cls,
|
||
task: Union[str, DashScopeAPIResponse],
|
||
api_key: str = None,
|
||
) -> DashScopeAPIResponse:
|
||
"""Query async task status.
|
||
|
||
Args:
|
||
task (Union[str, DashScopeAPIResponse]): The task_id, or
|
||
async_call response.
|
||
api_key (str, optional): The api_key. Defaults to None.
|
||
|
||
Returns:
|
||
DashScopeAPIResponse: The async task information.
|
||
"""
|
||
task_id = cls._get_task_id(task)
|
||
return cls._get(task_id, api_key)
|
||
|
||
@classmethod
|
||
def wait(cls,
|
||
task: Union[str, DashScopeAPIResponse],
|
||
api_key: str = None,
|
||
**kwargs) -> DashScopeAPIResponse:
|
||
"""Wait for async task completion and return task result.
|
||
|
||
Args:
|
||
task (Union[str, DashScopeAPIResponse]): The task_id, or
|
||
async_call response.
|
||
api_key (str, optional): The api_key. Defaults to None.
|
||
|
||
Returns:
|
||
DashScopeAPIResponse: The async task information.
|
||
"""
|
||
task_id = cls._get_task_id(task)
|
||
wait_seconds = 1
|
||
max_wait_seconds = 5
|
||
increment_steps = 3
|
||
step = 0
|
||
while True:
|
||
step += 1
|
||
# we start by querying once every second, and double
|
||
# the query interval after every 3(increment_steps)
|
||
# intervals, until we hit the max waiting interval
|
||
# of 5(seconds）
|
||
# TODO: investigate if we can use long-poll
|
||
# (server side return immediately when ready)
|
||
if wait_seconds < max_wait_seconds and step % increment_steps == 0:
|
||
wait_seconds = min(wait_seconds * 2, max_wait_seconds)
|
||
rsp = cls._get(task_id, api_key)
|
||
if rsp.status_code == HTTPStatus.OK:
|
||
if rsp.output is None:
|
||
return rsp
|
||
|
||
task_status = rsp.output['task_status']
|
||
if task_status in [
|
||
TaskStatus.FAILED, TaskStatus.CANCELED,
|
||
TaskStatus.SUCCEEDED, TaskStatus.UNKNOWN
|
||
]:
|
||
return rsp
|
||
else:
|
||
logger.info('The task %s is %s' % (task_id, task_status))
|
||
time.sleep(wait_seconds)
|
||
elif rsp.status_code in REPEATABLE_STATUS:
|
||
logger.warn(
|
||
('Get task: %s temporary failure, \
|
||
status_code: %s, code: %s message: %s, will try again.'
|
||
) % (task_id, rsp.status_code, rsp.code, rsp.message))
|
||
time.sleep(wait_seconds)
|
||
else:
|
||
return rsp
|
||
|
||
@classmethod
|
||
def async_call(cls,
|
||
model: str,
|
||
input: object,
|
||
task_group: str,
|
||
task: str = None,
|
||
function: str = None,
|
||
api_key: str = None,
|
||
**kwargs) -> DashScopeAPIResponse:
|
||
"""Call async service return async task information.
|
||
|
||
Args:
|
||
model (str): The requested model, such as gpt3-v2
|
||
input (object): The api input data, cannot be None.
|
||
task_group (str, optional): The api task group.
|
||
task (str, optional): The task name. Defaults to None.
|
||
function (str, optional): The function of the task.
|
||
Defaults to None.
|
||
api_key (str, optional): The api api_key, if not present,
|
||
will get by default rule(TODO: api key doc). Defaults to None.
|
||
|
||
Returns:
|
||
DashScopeAPIResponse: The async task information,
|
||
which contains the task id, you can use the task id
|
||
to query the task status.
|
||
"""
|
||
is_stream = kwargs.pop('stream', None) # async api not support stream.
|
||
if is_stream:
|
||
logger.warn('async_call do not support stream argument')
|
||
api_key, model = BaseApi._validate_params(api_key, model)
|
||
request = _build_api_request(model=model,
|
||
input=input,
|
||
task_group=task_group,
|
||
task=task,
|
||
function=function,
|
||
api_key=api_key,
|
||
async_request=True,
|
||
query=False,
|
||
**kwargs)
|
||
return request.call()
|
||
|
||
|
||
def _get(url, params={}, api_key=None, **kwargs) -> DashScopeAPIResponse:
|
||
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={
|
||
**default_headers(api_key),
|
||
**kwargs.pop('headers', {})
|
||
},
|
||
params=params,
|
||
timeout=timeout)
|
||
logger.debug('Starting processing response: %s' % url)
|
||
return _handle_http_response(response)
|
||
|
||
|
||
class ListMixin():
|
||
@classmethod
|
||
def list(cls,
|
||
page_no=1,
|
||
page_size=10,
|
||
api_key: str = None,
|
||
**kwargs) -> DashScopeAPIResponse:
|
||
"""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.
|
||
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())
|
||
params = {'page_no': page_no, 'page_size': page_size}
|
||
return _get(url, params=params, api_key=api_key, **kwargs)
|
||
|
||
|
||
class LogMixin():
|
||
@classmethod
|
||
def logs(cls,
|
||
job_id: str,
|
||
offset=1,
|
||
line=1000,
|
||
api_key: str = None,
|
||
**kwargs) -> DashScopeAPIResponse:
|
||
"""Get log of the job.
|
||
|
||
Args:
|
||
job_id (str): The job id(used for fine-tune)
|
||
offset (int, optional): start log line. Defaults to 1.
|
||
line (int, optional): total line return. Defaults to 1000.
|
||
api_key (str, optional): The api key. Defaults to None.
|
||
|
||
Returns:
|
||
DashScopeAPIResponse: The response
|
||
"""
|
||
url = join_url(dashscope.base_http_api_url, cls.SUB_PATH.lower(),
|
||
job_id, 'logs')
|
||
params = {'offset': offset, 'line': line}
|
||
return _get(url, params=params, api_key=api_key, **kwargs)
|
||
|
||
|
||
class GetMixin():
|
||
@classmethod
|
||
def get(cls,
|
||
target,
|
||
api_key: str = None,
|
||
params: dict = {},
|
||
**kwargs) -> DashScopeAPIResponse:
|
||
"""Get object information.
|
||
|
||
Args:
|
||
target (str): The target to get, such as model_id.
|
||
api_key (str, optional): The api api_key, if not present,
|
||
will get by default rule(TODO: api key doc). Defaults to None.
|
||
|
||
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)
|
||
|
||
|
||
class GetStatusMixin():
|
||
@classmethod
|
||
def get(cls,
|
||
target,
|
||
api_key: str = None,
|
||
**kwargs) -> DashScopeAPIResponse:
|
||
"""Get object information.
|
||
|
||
Args:
|
||
target (str): The target to get, such as model_id.
|
||
api_key (str, optional): The api api_key, if not present,
|
||
will get by default rule(TODO: api key doc). Defaults to None.
|
||
|
||
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)
|
||
|
||
|
||
class DeleteMixin():
|
||
@classmethod
|
||
def delete(cls,
|
||
target: str,
|
||
api_key: str = None,
|
||
**kwargs) -> DashScopeAPIResponse:
|
||
"""Delete object.
|
||
|
||
Args:
|
||
target (str): The object to delete, .
|
||
api_key (str, optional): The api api_key, if not present,
|
||
will get by default rule(TODO: api key doc). Defaults to None.
|
||
|
||
Returns:
|
||
DashScopeAPIResponse: The delete result.
|
||
"""
|
||
url = join_url(dashscope.base_http_api_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={
|
||
**default_headers(api_key),
|
||
**kwargs.pop('headers', {})
|
||
},
|
||
timeout=timeout)
|
||
logger.debug('Starting processing response: %s' % url)
|
||
return _handle_http_response(response)
|
||
|
||
|
||
class CreateMixin():
|
||
@classmethod
|
||
def call(cls,
|
||
data: object,
|
||
api_key: str = None,
|
||
**kwargs) -> DashScopeAPIResponse:
|
||
"""Create a object
|
||
|
||
Args:
|
||
data (object): The create request json body.
|
||
api_key (str, optional): The api api_key, if not present,
|
||
will get by default rule(TODO: api key doc). Defaults to None.
|
||
|
||
Returns:
|
||
DashScopeAPIResponse: The created object in output.
|
||
"""
|
||
url = join_url(dashscope.base_http_api_url, cls.SUB_PATH.lower())
|
||
timeout = kwargs.pop(REQUEST_TIMEOUT_KEYWORD,
|
||
DEFAULT_REQUEST_TIMEOUT_SECONDS)
|
||
with requests.Session() as session:
|
||
logger.debug('Starting request: %s' % url)
|
||
response = session.post(url,
|
||
json=data,
|
||
headers={
|
||
**default_headers(api_key),
|
||
**kwargs.pop('headers', {})
|
||
},
|
||
timeout=timeout)
|
||
logger.debug('Starting processing response: %s' % url)
|
||
return _handle_http_response(response)
|
||
|
||
|
||
class UpdateMixin():
|
||
@classmethod
|
||
def update(cls,
|
||
target: str,
|
||
json: object,
|
||
api_key: str = None,
|
||
**kwargs) -> DashScopeAPIResponse:
|
||
"""Async update a object
|
||
|
||
Args:
|
||
target (str): The target to update.
|
||
json (object): The create request json body.
|
||
api_key (str, optional): The api api_key, if not present,
|
||
will get by default rule(TODO: api key doc). Defaults to None.
|
||
|
||
Returns:
|
||
DashScopeAPIResponse: The updated object information in output.
|
||
"""
|
||
url = join_url(dashscope.base_http_api_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.patch(url,
|
||
json=json,
|
||
headers={
|
||
**default_headers(api_key),
|
||
**kwargs.pop('headers', {})
|
||
},
|
||
timeout=timeout)
|
||
logger.debug('Starting processing response: %s' % url)
|
||
return _handle_http_response(response)
|
||
|
||
|
||
class PutMixin():
|
||
@classmethod
|
||
def put(cls,
|
||
target: str,
|
||
json: object,
|
||
extra_path: str = None,
|
||
api_key: str = None,
|
||
**kwargs) -> DashScopeAPIResponse:
|
||
"""Async update a object
|
||
|
||
Args:
|
||
target (str): The target to update.
|
||
json (object): The create request json body.
|
||
api_key (str, optional): The api api_key, if not present,
|
||
will get by default rule(TODO: api key doc). Defaults to None.
|
||
|
||
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)
|
||
else:
|
||
url = join_url(dashscope.base_http_api_url, cls.SUB_PATH.lower(),
|
||
target, extra_path)
|
||
print(url)
|
||
timeout = kwargs.pop(REQUEST_TIMEOUT_KEYWORD,
|
||
DEFAULT_REQUEST_TIMEOUT_SECONDS)
|
||
with requests.Session() as session:
|
||
logger.debug('Starting request: %s' % url)
|
||
response = session.put(url,
|
||
json=json,
|
||
headers={
|
||
**default_headers(api_key),
|
||
**kwargs.pop('headers', {})
|
||
},
|
||
timeout=timeout)
|
||
logger.debug('Starting processing response: %s' % url)
|
||
return _handle_http_response(response)
|
||
|
||
|
||
class FileUploadMixin():
|
||
@classmethod
|
||
def upload(cls,
|
||
files: list,
|
||
descriptions: List[str] = None,
|
||
params: dict = None,
|
||
api_key: str = None,
|
||
**kwargs) -> DashScopeAPIResponse:
|
||
"""Upload files
|
||
|
||
Args:
|
||
files (list): List of (name, opened file, file_name).
|
||
descriptions (list[str]): The file description messages.
|
||
params (dict): The parameters
|
||
api_key (str, optional): The api api_key, if not present,
|
||
will get by default rule(TODO: api key doc). Defaults to None.
|
||
|
||
Returns:
|
||
DashScopeAPIResponse: The uploaded file information in the output.
|
||
"""
|
||
url = join_url(dashscope.base_http_api_url, cls.SUB_PATH.lower())
|
||
js = None
|
||
if descriptions:
|
||
js = {'descriptions': descriptions}
|
||
timeout = kwargs.pop(REQUEST_TIMEOUT_KEYWORD,
|
||
DEFAULT_REQUEST_TIMEOUT_SECONDS)
|
||
with requests.Session() as session:
|
||
logger.debug('Starting request: %s' % url)
|
||
response = session.post(url,
|
||
data=js,
|
||
headers={
|
||
**default_headers(api_key),
|
||
**kwargs.pop('headers', {})
|
||
},
|
||
files=files,
|
||
timeout=timeout)
|
||
logger.debug('Starting processing response: %s' % url)
|
||
return _handle_http_response(response)
|
||
|
||
|
||
class CancelMixin():
|
||
@classmethod
|
||
def cancel(cls,
|
||
target: str,
|
||
api_key: str = None,
|
||
**kwargs) -> DashScopeAPIResponse:
|
||
"""Cancel a job.
|
||
|
||
Args:
|
||
target (str): The request params, key/value map.
|
||
api_key (str, optional): The api api_key, if not present,
|
||
will get by default rule(TODO: api key doc). Defaults to None.
|
||
|
||
Returns:
|
||
DashScopeAPIResponse: The cancel result.
|
||
"""
|
||
url = join_url(dashscope.base_http_api_url, cls.SUB_PATH.lower(),
|
||
target, 'cancel')
|
||
timeout = kwargs.pop(REQUEST_TIMEOUT_KEYWORD,
|
||
DEFAULT_REQUEST_TIMEOUT_SECONDS)
|
||
with requests.Session() as session:
|
||
logger.debug('Starting request: %s' % url)
|
||
response = session.post(url,
|
||
headers={
|
||
**default_headers(api_key),
|
||
**kwargs.pop('headers', {})
|
||
},
|
||
timeout=timeout)
|
||
logger.debug('Starting processing response: %s' % url)
|
||
return _handle_http_response(response)
|
||
|
||
|
||
class StreamEventMixin():
|
||
@classmethod
|
||
def _handle_stream(cls, 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
|
||
else:
|
||
continue # ignore heartbeat...
|
||
|
||
@classmethod
|
||
def _handle_response(cls, response: requests.Response):
|
||
request_id = ''
|
||
if (response.status_code == HTTPStatus.OK
|
||
and SSE_CONTENT_TYPE in response.headers.get(
|
||
'content-type', '')):
|
||
for is_error, status_code, data in cls._handle_stream(response):
|
||
if is_error:
|
||
yield DashScopeAPIResponse(request_id=request_id,
|
||
status_code=status_code,
|
||
output=None,
|
||
code='',
|
||
message='') # noqa E501
|
||
else:
|
||
yield DashScopeAPIResponse(request_id=request_id,
|
||
status_code=HTTPStatus.OK,
|
||
output=data,
|
||
usage=None)
|
||
elif response.status_code == HTTPStatus.OK:
|
||
json_content = response.json()
|
||
request_id = ''
|
||
if 'request_id' in json_content:
|
||
request_id = json_content['request_id']
|
||
yield DashScopeAPIResponse(request_id=request_id,
|
||
status_code=HTTPStatus.OK,
|
||
output=json_content,
|
||
usage=None)
|
||
else:
|
||
_handle_http_failed_response(response)
|
||
|
||
@classmethod
|
||
def stream_events(cls,
|
||
target,
|
||
api_key: str = None,
|
||
**kwargs) -> DashScopeAPIResponse:
|
||
"""Get job log.
|
||
|
||
Args:
|
||
target (str): The target to get, such as model_id.
|
||
api_key (str, optional): The api api_key, if not present,
|
||
will get by default rule(TODO: api key doc). Defaults to None.
|
||
|
||
Returns:
|
||
DashScopeAPIResponse: The target outputs.
|
||
"""
|
||
url = join_url(dashscope.base_http_api_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={
|
||
**default_headers(api_key),
|
||
**kwargs.pop('headers', {})
|
||
},
|
||
stream=True,
|
||
timeout=timeout)
|
||
logger.debug('Starting processing response: %s' % url)
|
||
for rsp in cls._handle_response(response):
|
||
yield rsp
|