dashscope 1.22.2__py3-none-any.whl → 1.23.0__py3-none-any.whl

dashscope/audio/asr/transcribe.py

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

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

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

dashscope/finetune.py

@@ -1,175 +0,0 @@
-from typing import Union
-
-from dashscope.api_entities.dashscope_response import DashScopeAPIResponse
-from dashscope.client.base_api import (CancelMixin, CreateMixin, DeleteMixin,
-                                       GetStatusMixin, ListMixin, LogMixin,
-                                       StreamEventMixin)
-
-
-class FineTune(CreateMixin, CancelMixin, DeleteMixin, ListMixin,
-               GetStatusMixin, StreamEventMixin, LogMixin):
-    SUB_PATH = 'fine-tunes'
-
-    @classmethod
-    def call(cls,
-             model: str,
-             training_file_ids: Union[list, str],
-             validation_file_ids: Union[list, str] = None,
-             mode: str = None,
-             hyper_parameters: dict = {},
-             api_key: str = None,
-             workspace: str = None,
-             **kwargs) -> DashScopeAPIResponse:
-        """Create fine-tune job
-
-        Args:
-            model (str): The model to be fine-tuned
-            training_file_ids (list, str): Ids of the fine-tune training data,
-                which can be pre-uploaded using the File API.
-            validation_file_ids ([list,str], optional): Ids of the fine-tune
-                validating data, which can be pre-uploaded using the File API.
-            mode (str): The fine-tune mode, sft or efficient_sft.
-            hyper_parameters (dict, optional): The fine-tune hyper parameters.
-                Defaults to empty.
-            api_key (str, optional): The api key. Defaults to None.
-            workspace (str): The dashscope workspace id.
-
-        Returns:
-            DashScopeAPIResponse: The request result.
-        """
-        request = {
-            'model': model,
-            'training_file_ids': training_file_ids,
-            'validation_file_ids': validation_file_ids,
-            'hyper_parameters': hyper_parameters if hyper_parameters else {},
-        }
-        if mode is not None:
-            request['training_type'] = mode
-        if 'finetuned_output' in kwargs:
-            request['finetuned_output'] = kwargs['finetuned_output']
-        return super().call(request,
-                            api_key=api_key,
-                            workspace=workspace,
-                            **kwargs)
-
-    @classmethod
-    def cancel(cls,
-               job_id: str,
-               api_key: str = None,
-               workspace: str = None,
-               **kwargs) -> DashScopeAPIResponse:
-        """Cancel a running fine-tune job.
-
-        Args:
-            job_id (str): The fine-tune job id.
-            api_key (str, optional): The api api_key, can be None,
-                if None, will get by default rule(TODO: api key doc).
-            workspace (str): The dashscope workspace id.
-
-        Returns:
-            DashScopeAPIResponse: The request result.
-        """
-        return super().cancel(job_id, api_key, workspace=workspace, **kwargs)
-
-    @classmethod
-    def list(cls,
-             page=1,
-             page_size=10,
-             api_key: str = None,
-             workspace: str = None,
-             **kwargs) -> DashScopeAPIResponse:
-        """List fine-tune job.
-
-        Args:
-            api_key (str, optional): The api key
-            page (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 fine-tune jobs in the result.
-        """
-        return super().list(page,
-                            page_size,
-                            api_key,
-                            workspace=workspace,
-                            **kwargs)
-
-    @classmethod
-    def get(cls,
-            job_id: str,
-            api_key: str = None,
-            workspace: str = None,
-            **kwargs) -> DashScopeAPIResponse:
-        """Get fine-tune job information.
-
-        Args:
-            job_id (str): The fine-tune job id
-            api_key (str, optional): The api key. Defaults to None.
-            workspace (str): The dashscope workspace id.
-
-        Returns:
-            DashScopeAPIResponse: The job info
-        """
-        return super().get(job_id, api_key, workspace=workspace, **kwargs)
-
-    @classmethod
-    def delete(cls,
-               job_id: str,
-               api_key: str = None,
-               workspace: str = None,
-               **kwargs) -> DashScopeAPIResponse:
-        """Delete a fine-tune job.
-
-        Args:
-            job_id (str): The fine-tune job 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(job_id, api_key, workspace=workspace, **kwargs)
-
-    @classmethod
-    def stream_events(cls,
-                      job_id: str,
-                      api_key: str = None,
-                      workspace: str = None,
-                      **kwargs) -> DashScopeAPIResponse:
-        """Get fine-tune job events.
-
-        Args:
-            job_id (str): The fine-tune job id
-            api_key (str, optional): the api key. Defaults to None.
-            workspace (str): The dashscope workspace id.
-
-        Returns:
-            DashScopeAPIResponse: The job log events.
-        """
-        return super().stream_events(job_id,
-                                     api_key,
-                                     workspace=workspace,
-                                     **kwargs)
-
-    @classmethod
-    def logs(cls,
-             job_id: str,
-             offset=1,
-             line=1000,
-             api_key: str = None,
-             workspace: 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.
-            workspace (str): The dashscope workspace id.
-
-        Returns:
-            DashScopeAPIResponse: The response
-        """
-        return super().logs(job_id, offset, line, workspace=workspace)