dashscope 1.20.7__py3-none-any.whl → 1.20.9__py3-none-any.whl

dashscope/aigc/image_synthesis.py

@@ -6,6 +6,7 @@ from dashscope.client.base_api import BaseAsyncApi
 from dashscope.common.constants import IMAGES, NEGATIVE_PROMPT, PROMPT
 from dashscope.common.error import InputRequired
 from dashscope.common.utils import _get_task_group_and_task
+from dashscope.utils.oss_utils import check_and_upload_local
 
 
 class ImageSynthesis(BaseAsyncApi):
@@ -38,7 +39,8 @@ class ImageSynthesis(BaseAsyncApi):
             images (List[str]): The input list of images url,
                 currently not supported.
             api_key (str, optional): The api api_key. Defaults to None.
-            sketch_image_url (str, optional): Only for wanx-sketch-to-image-v1.
+            sketch_image_url (str, optional): Only for wanx-sketch-to-image-v1,
+                can be local file.
                 Defaults to None.
             workspace (str): The dashscope workspace id.
             extra_input (Dict): The extra input parameters.
@@ -120,17 +122,31 @@ class ImageSynthesis(BaseAsyncApi):
             raise InputRequired('prompt is required!')
         task_group, function = _get_task_group_and_task(__name__)
         input = {PROMPT: prompt}
+        has_upload = False
         if negative_prompt is not None:
             input[NEGATIVE_PROMPT] = negative_prompt
         if images is not None:
             input[IMAGES] = images
         if sketch_image_url is not None and sketch_image_url:
+            is_upload, sketch_image_url = check_and_upload_local(
+                model, sketch_image_url, api_key)
+            if is_upload:
+                has_upload = True
             input['sketch_image_url'] = sketch_image_url
         if ref_img is not None and ref_img:
+            is_upload, ref_img = check_and_upload_local(
+                model, ref_img, api_key)
+            if is_upload:
+                has_upload = True
             input['ref_img'] = ref_img
         if extra_input is not None and extra_input:
             input = {**input, **extra_input}
 
+        if has_upload:
+            headers = kwargs.pop('headers', {})
+            headers['X-DashScope-OssResourceResolve'] = 'enable'
+            kwargs['headers'] = headers
+
         response = super().async_call(
             model=model,
             task_group=task_group,

dashscope/audio/asr/transcribe.py

@@ -0,0 +1,270 @@
+import asyncio
+import os
+from http import HTTPStatus
+from typing import Any, Dict
+from urllib.parse import urlparse
+
+import aiohttp
+
+from dashscope.api_entities.dashscope_response import DashScopeAPIResponse
+from dashscope.client.base_api import BaseApi
+from dashscope.common.constants import ApiProtocol, HTTPMethod
+from dashscope.common.error import InputRequired
+from dashscope.common.utils import _get_task_group_and_task
+
+
+class Transcribe(BaseApi):
+    """API for File Transcriber models.
+
+    """
+
+    MAX_QUERY_TRY_COUNT = 3
+
+    @classmethod
+    def call(cls, model: str, file: str, **kwargs) -> DashScopeAPIResponse:
+        """Call file transcriber model service.
+
+        Args:
+            model (str): The requested model, such as paraformer-16k-1
+            file (str): The local path or URL of the file.
+            channel_id (List[int], optional): The selected channel_id of audio file. # noqa: E501
+
+        Returns:
+            DashScopeAPIResponse: The response body.
+
+        Raises:
+            InputRequired: The file cannot be empty.
+        """
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        return loop.run_until_complete(cls.async_call(model, file, **kwargs))
+
+    @classmethod
+    async def async_call(cls, model: str, file: str,
+                         **kwargs) -> DashScopeAPIResponse:
+        """Async call file transcriber model service.
+
+        Args:
+            model (str): The requested model, such as paraformer-16k-1
+            file (str): The local path or URL of the file.
+            channel_id (List[int], optional): The selected channel_id of audio file. # noqa: E501
+
+        Returns:
+            DashScopeAPIResponse: The response body.
+
+        Raises:
+            InputRequired: The file cannot be empty.
+        """
+        cls.is_url = cls._validate_file(file)
+        cls.file_name = file
+        cls.model_id = model
+
+        request = {'file': cls.file_name, 'is_url': cls.is_url}
+
+        # launch transcribe request, and get task info.
+        task = await cls._async_launch_requests(request, **kwargs)
+
+        response = await cls._async_get_result(task, **kwargs)
+
+        return response
+
+    @classmethod
+    async def _async_launch_requests(cls, request: Dict[str, Any], **kwargs):
+        """Async submit transcribe request.
+
+        Args:
+            inputs (Dict[str, Any]): The input parameters.
+
+        Returns:
+            task (Dict[str, Any]): The result of the task request.
+        """
+        inputs = {'file_link': request['file']}
+        task = {'file': request['file']}
+        local_file = None
+        try_count: int = 0
+        response = DashScopeAPIResponse(id='', code=HTTPStatus.OK, output=None)
+        if not request['is_url']:
+            try:
+                local_file = open(inputs['file_link'], 'rb')
+            except IOError as e:
+                raise InputRequired(f'File cannot be opened. {e}')
+
+            kwargs['form'] = {'av_file': local_file}
+
+        task_name, function = _get_task_group_and_task(__name__)
+        kwargs['async_request'] = True
+        kwargs['query'] = False
+
+        while True:
+            try:
+                response = await super().async_call(
+                    model=cls.model_id,
+                    task_group='audio',
+                    task=task_name,
+                    function=function,
+                    input=inputs,
+                    api_protocol=ApiProtocol.HTTP,
+                    http_method=HTTPMethod.POST,
+                    **kwargs)
+
+                task['request_id'] = response.id
+                task['code'] = response.code
+                task['status'] = response.status
+
+                if response.code == HTTPStatus.OK and response.output is not None:  # noqa: E501
+                    task.update(response.output)
+                else:
+                    task['message'] = response.message
+
+                break
+
+            except (asyncio.TimeoutError, aiohttp.ClientConnectorError) as e:
+                try_count += 1
+                if try_count > Transcribe.MAX_QUERY_TRY_COUNT:
+                    task['request_id'] = response.id
+                    task['code'] = HTTPStatus.REQUEST_TIMEOUT
+                    task['status'] = response.status
+                    task['message'] = str(e)
+                    break
+                else:
+                    await asyncio.sleep(2)
+                    continue
+            except Exception as e:
+                task['request_id'] = response.id
+                task['code'] = HTTPStatus.BAD_REQUEST
+                task['status'] = response.status
+                task['message'] = str(e)
+                break
+
+        if local_file is not None:
+            local_file.close()
+
+        return task
+
+    @classmethod
+    async def _async_get_result(cls, task, **kwargs):
+        """Async get transcribe result by polling.
+
+        Args:
+            task (Dict[str, Any]): The info of the task request.
+
+        Returns:
+            DashScopeAPIResponse: The response body.
+        """
+        request = task
+        responses = []
+        item = {}
+        response = DashScopeAPIResponse(id=request['request_id'],
+                                        code=request['code'],
+                                        output=None,
+                                        status=request['status'],
+                                        message=request['message'])
+
+        if request['code'] != HTTPStatus.OK:
+            item['file'] = request['file']
+            item['request_id'] = response.id
+            item['code'] = request['code']
+            item['status'] = request['status']
+            item['message'] = request['message']
+            responses.append(item)
+        else:
+            try_count: int = 0
+            while True:
+                item['file'] = request['file']
+                item['task_Id'] = request['task_id']
+
+                try:
+                    inputs = {}
+                    inputs['task_Id'] = request['task_id']
+                    kwargs['async_request'] = True
+                    kwargs['query'] = True
+
+                    response = await super().async_call(
+                        model=cls.model_id,
+                        task_group=None,
+                        task='tasks',
+                        input=inputs,
+                        task_id=inputs['task_Id'],
+                        api_protocol=ApiProtocol.HTTP,
+                        http_method=HTTPMethod.GET,
+                        **kwargs)
+                except (asyncio.TimeoutError,
+                        aiohttp.ClientConnectorError) as e:
+                    try_count += 1
+                    if try_count > Transcribe.MAX_QUERY_TRY_COUNT:
+                        item['request_id'] = response.id
+                        item['code'] = HTTPStatus.REQUEST_TIMEOUT
+                        item['status'] = response.status
+                        item['message'] = str(e)
+                        responses.append(item)
+                        break
+                    else:
+                        await asyncio.sleep(2)
+                        continue
+                except Exception as e:
+                    item['request_id'] = response.id
+                    item['code'] = HTTPStatus.BAD_REQUEST
+                    item['status'] = response.status
+                    item['message'] = str(e)
+                    responses.append(item)
+                    break
+
+                try_count = 0
+                item['request_id'] = response.id
+                item['code'] = response.code
+                item['status'] = response.status
+
+                if response.code == HTTPStatus.OK:
+                    if 'task_status' in response.output:
+                        task_status = response.output['task_status']
+                        if task_status == 'QUEUING' or task_status == 'PROCESSING':  # noqa: E501
+                            await asyncio.sleep(2)
+                            continue
+
+                    item.update(response.output)
+                else:
+                    item['message'] = response.message
+
+                responses.append(item)
+                break
+
+        output = {}
+        output['results'] = responses
+
+        return DashScopeAPIResponse(id=response.id,
+                                    code=response.code,
+                                    status=response.status,
+                                    message=response.message,
+                                    output=output)
+
+    @classmethod
+    def _validate_file(cls, file: str):
+        """Check the validity of the file
+        and whether the file is a URL or a local path.
+
+        Args:
+            file (str): The local path or URL of the file.
+
+        Returns:
+            bool: Whether the file is a URL.
+        """
+        if file is None or len(file) == 0:
+            raise InputRequired(
+                'Input an illegal file, please ensure that the file type is a local path or URL!'  # noqa: *
+            )
+
+        if os.path.isfile(file):
+            return False
+        else:
+            result = urlparse(file)
+            if result.scheme is not None and len(result.scheme) > 0:
+                if result.scheme != 'http' and result.scheme != 'https':
+                    raise InputRequired(
+                        f'The URL protocol({result.scheme}) of file({file}) is not http or https.'  # noqa: *
+                    )
+            else:
+                raise InputRequired(
+                    f'Input an illegal file({file}), maybe the file is inexistent.'  # noqa: *
+                )
+
+        return True

dashscope/deployment.py

@@ -0,0 +1,163 @@
+from dashscope.api_entities.dashscope_response import DashScopeAPIResponse
+from dashscope.client.base_api import (CreateMixin, DeleteMixin, GetMixin,
+                                       ListMixin, PutMixin, StreamEventMixin)
+
+
+class Deployment(CreateMixin, DeleteMixin, ListMixin, GetMixin,
+                 StreamEventMixin, PutMixin):
+    SUB_PATH = 'deployments'
+    """Deploy a model.
+    """
+    @classmethod
+    def call(cls,
+             model: str,
+             capacity: int,
+             version: str = None,
+             suffix: str = None,
+             api_key: str = None,
+             workspace: str = None,
+             **kwargs) -> DashScopeAPIResponse:
+        """Call to deployment a model service.
+
+        Args:
+            model (str): The model name.
+            version (str, optional): The model version, unnecessary
+                for fine-tuned model. Defaults to None.
+            suffix (str, optional): The name suffix of the model deployment,
+                If specified, the final model name will be model_suffix.
+                Defaults to None.
+            capacity (int, optional): The model service capacity.
+            api_key (str, optional): The api-key. Defaults to None.
+            workspace (str): The dashscope workspace id.
+
+        Returns:
+            DashScopeAPIResponse: _description_
+        """
+        req = {'model_name': model, 'capacity': capacity}
+
+        if version is not None:
+            req['model_version'] = version
+        if suffix is not None:
+            req['suffix'] = suffix
+        return super().call(req,
+                            api_key=api_key,
+                            workspace=workspace,
+                            **kwargs)
+
+    @classmethod
+    def list(cls,
+             page_no=1,
+             page_size=10,
+             api_key: str = None,
+             workspace: str = None,
+             **kwargs) -> DashScopeAPIResponse:
+        """List deployments.
+
+        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.
+            workspace (str): The dashscope workspace id.
+
+        Returns:
+            DashScopeAPIResponse: The deployment list.
+        """
+        return super().list(page_no,
+                            page_size,
+                            api_key,
+                            workspace=workspace,
+                            **kwargs)
+
+    @classmethod
+    def get(cls,
+            deployed_model: str,
+            api_key: str = None,
+            workspace: str = None,
+            **kwargs) -> DashScopeAPIResponse:
+        """Get model deployment information.
+
+        Args:
+            deployed_model (str): The deployment_id.
+            api_key (str, optional): The api key. Defaults to None.
+            workspace (str): The dashscope workspace id.
+
+        Returns:
+            DashScopeAPIResponse: The deployment information.
+        """
+        return super().get(deployed_model,
+                           api_key,
+                           workspace=workspace,
+                           **kwargs)
+
+    @classmethod
+    def delete(cls,
+               deployment_id: str,
+               api_key: str = None,
+               workspace: str = None,
+               **kwargs) -> DashScopeAPIResponse:
+        """Delete model deployment.
+
+        Args:
+            deployment_id (str): The deployment id.
+            api_key (str, optional): The api key. Defaults to None.
+            workspace (str): The dashscope workspace id.
+
+        Returns:
+            DashScopeAPIResponse: The delete result.
+        """
+        return super().delete(deployment_id,
+                              api_key,
+                              workspace=workspace,
+                              **kwargs)
+
+    @classmethod
+    def update(cls,
+               deployment_id: str,
+               version: str,
+               api_key: str = None,
+               workspace: str = None,
+               **kwargs) -> DashScopeAPIResponse:
+        """Update model deployment.
+
+        Args:
+            deployment_id (str): The deployment id.
+            version (str): The target model version.
+            api_key (str, optional): The api key. Defaults to None.
+            workspace (str): The dashscope workspace id.
+
+        Returns:
+            DashScopeAPIResponse: The delete result.
+        """
+        req = {'deployment_model': deployment_id, 'model_version': version}
+        return super().put(deployment_id,
+                           req,
+                           api_key,
+                           workspace=workspace,
+                           **kwargs)
+
+    @classmethod
+    def scale(cls,
+              deployment_id: str,
+              capacity: int,
+              api_key: str = None,
+              workspace: str = None,
+              **kwargs) -> DashScopeAPIResponse:
+        """Scaling model deployment.
+
+        Args:
+            deployment_id (str): The deployment id.
+            capacity (int): The target service capacity.
+            api_key (str, optional): The api key. Defaults to None.
+
+        Returns:
+            DashScopeAPIResponse: The delete result.
+        """
+        req = {'deployed_model': deployment_id, 'capacity': capacity}
+        path = '%s/%s/scale' % (cls.SUB_PATH.lower(), deployment_id)
+        return super().put(deployment_id,
+                           req,
+                           path=path,
+                           api_key=api_key,
+                           workspace=workspace,
+                           **kwargs)

dashscope/file.py

@@ -0,0 +1,94 @@
+import os
+
+from dashscope.api_entities.dashscope_response import DashScopeAPIResponse
+from dashscope.client.base_api import (DeleteMixin, FileUploadMixin, GetMixin,
+                                       ListMixin)
+from dashscope.common.constants import FilePurpose
+from dashscope.common.error import InvalidFileFormat
+from dashscope.common.utils import is_validate_fine_tune_file
+
+
+class File(FileUploadMixin, ListMixin, DeleteMixin, GetMixin):
+    SUB_PATH = 'files'
+
+    @classmethod
+    def upload(cls,
+               file_path: str,
+               purpose: str = FilePurpose.fine_tune,
+               description: str = None,
+               api_key: str = None,
+               **kwargs) -> DashScopeAPIResponse:
+        """Upload file for model fine-tune or other tasks.
+
+        Args:
+            file_path (str): The local file name to upload.
+            purpose (str): The purpose of the file[fine-tune|inference]
+            description (str, optional): The file description message.
+            api_key (str, optional): The api key. Defaults to None.
+
+        Returns:
+            DashScopeAPIResponse: The upload information
+        """
+        if purpose == FilePurpose.fine_tune:
+            if not is_validate_fine_tune_file(file_path):
+                raise InvalidFileFormat(
+                    'The file %s is not in valid jsonl format' % file_path)
+        with open(file_path, 'rb') as f:
+            return super().upload(files=[('files', (os.path.basename(f.name),
+                                                    f, None))],
+                                  descriptions=[description]
+                                  if description is not None else None,
+                                  api_key=api_key,
+                                  **kwargs)
+
+    @classmethod
+    def list(cls,
+             page=1,
+             page_size=10,
+             api_key: str = None,
+             **kwargs) -> DashScopeAPIResponse:
+        """List uploaded files.
+
+        Args:
+            api_key (str, optional):
+            The api api_key, can be None,
+                if None, will get by default rule(TODO: api key doc).
+            page (int, optional): Page number. Defaults to 1.
+            page_size (int, optional): Items per page. Defaults to 10.
+
+        Returns:
+            DashScopeAPIResponse: The fine-tune jobs in the result.
+        """
+        return super().list(page, page_size, api_key, **kwargs)
+
+    @classmethod
+    def get(cls,
+            file_id: str,
+            api_key: str = None,
+            **kwargs) -> DashScopeAPIResponse:
+        """Get the file info.
+
+        Args:
+            file_id (str): The file id.
+            api_key (str, optional): The api key. Defaults to None.
+
+        Returns:
+            DashScopeAPIResponse: The job info
+        """
+        return super().get(file_id, api_key, **kwargs)
+
+    @classmethod
+    def delete(cls,
+               file_id: str,
+               api_key: str = None,
+               **kwargs) -> DashScopeAPIResponse:
+        """Delete uploaded file.
+
+        Args:
+            file_id (str): The file id want to delete.
+            api_key (str, optional): The api key. Defaults to None.
+
+        Returns:
+            DashScopeAPIResponse: Delete result.
+        """
+        return super().delete(file_id, api_key, **kwargs)