dashscope 1.20.14__py3-none-any.whl → 1.22.0__py3-none-any.whl

dashscope/__init__.py

@@ -5,6 +5,7 @@ from dashscope.aigc.code_generation import CodeGeneration
 from dashscope.aigc.conversation import Conversation, History, HistoryItem
 from dashscope.aigc.generation import AioGeneration, Generation
 from dashscope.aigc.image_synthesis import ImageSynthesis
+from dashscope.aigc.video_synthesis import VideoSynthesis
 from dashscope.aigc.multimodal_conversation import MultiModalConversation
 from dashscope.app.application import Application
 from dashscope.assistants import Assistant, AssistantList, Assistants
@@ -84,6 +85,7 @@ __all__ = [
     RunStep,
     MessageFile,
     AssistantFile,
+    VideoSynthesis,
 ]
 
 logging.getLogger(__name__).addHandler(NullHandler())

dashscope/aigc/__init__.py

@@ -2,6 +2,7 @@ from .conversation import Conversation, History, HistoryItem
 from .generation import Generation
 from .image_synthesis import ImageSynthesis
 from .multimodal_conversation import MultiModalConversation
+from .video_synthesis import VideoSynthesis
 
 __all__ = [
     Generation,
@@ -10,4 +11,5 @@ __all__ = [
     History,
     ImageSynthesis,
     MultiModalConversation,
+    VideoSynthesis,
 ]

dashscope/aigc/video_synthesis.py

@@ -0,0 +1,242 @@
+from typing import Any, Dict, Union
+
+from dashscope.api_entities.dashscope_response import (DashScopeAPIResponse,
+                                                       VideoSynthesisResponse)
+from dashscope.client.base_api import BaseAsyncApi
+from dashscope.common.constants import 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 VideoSynthesis(BaseAsyncApi):
+    task = 'video-generation'
+    """API for video synthesis.
+    """
+    class Models:
+        wanx_txt2video_pro = 'wanx-txt2video-pro'
+        wanx_img2video_pro = 'wanx-img2video-pro'
+        wanx_2_1_t2v_turbo = 'wanx2.1-t2v-turbo'
+        wanx_2_1_t2v_plus = 'wanx2.1-t2v-plus'
+
+    @classmethod
+    def call(cls,
+             model: str,
+             prompt: Any,
+             extend_prompt: bool = True,
+             negative_prompt: str = None,
+             template: str = None,
+             img_url: str = None,
+             api_key: str = None,
+             extra_input: Dict = None,
+             workspace: str = None,
+             task: str = None,
+             **kwargs) -> VideoSynthesisResponse:
+        """Call video synthesis service and get result.
+
+        Args:
+            model (str): The model, reference ``Models``.
+            prompt (Any): The prompt for video synthesis.
+            extend_prompt (bool): The extend_prompt. Whether to enable write expansion. The default value is True.
+            negative_prompt (str): The negative prompt is the opposite of the prompt meaning.
+            template (str): LoRa input, such as gufeng, katong, etc.
+            img_url (str): The input image url, Generate the URL of the image referenced by the video.
+            api_key (str, optional): The api api_key. Defaults to None.
+            workspace (str): The dashscope workspace id.
+            extra_input (Dict): The extra input parameters.
+            task (str): The task of api, ref doc.
+            **kwargs:
+                size(str, `optional`): The output video size(width*height).
+                duration(int, optional): The duration. Duration of video generation. The default value is 5, in seconds.
+                seed(int, optional): The seed. The random seed for video generation. The default value is 5.
+
+        Raises:
+            InputRequired: The prompt cannot be empty.
+
+        Returns:
+            VideoSynthesisResponse: The video synthesis result.
+        """
+        return super().call(model,
+                            prompt,
+                            img_url=img_url,
+                            api_key=api_key,
+                            extend_prompt=extend_prompt,
+                            negative_prompt=negative_prompt,
+                            template=template,
+                            workspace=workspace,
+                            extra_input=extra_input,
+                            task=task,
+                            **kwargs)
+
+    @classmethod
+    def async_call(cls,
+                   model: str,
+                   prompt: Any,
+                   img_url: str = None,
+                   extend_prompt: bool = True,
+                   negative_prompt: str = None,
+                   template: str = None,
+                   api_key: str = None,
+                   extra_input: Dict = None,
+                   workspace: str = None,
+                   task: str = None,
+                   **kwargs) -> VideoSynthesisResponse:
+        """Create a video synthesis task, and return task information.
+
+        Args:
+            model (str): The model, reference ``Models``.
+            prompt (Any): The prompt for video synthesis.
+            extend_prompt (bool): The extend_prompt. Whether to enable write expansion. The default value is True.
+            negative_prompt (str): The negative prompt is the opposite of the prompt meaning.
+            template (str): LoRa input, such as gufeng, katong, etc.
+            img_url (str): The input image url, Generate the URL of the image referenced by the video.
+            api_key (str, optional): The api api_key. Defaults to None.
+            workspace (str): The dashscope workspace id.
+            extra_input (Dict): The extra input parameters.
+            task (str): The task of api, ref doc.
+            **kwargs:
+                size(str, `optional`): The output video size(width*height).
+                duration(int, optional): The duration. Duration of video generation. The default value is 5, in seconds.
+                seed(int, optional): The seed. The random seed for video generation. The default value is 5.
+
+        Raises:
+            InputRequired: The prompt cannot be empty.
+
+        Returns:
+            DashScopeAPIResponse: The video synthesis
+                task id in the response.
+        """
+        if prompt is None or not prompt:
+            raise InputRequired('prompt is required!')
+        task_group, function = _get_task_group_and_task(__name__)
+        inputs = {PROMPT: prompt, 'extend_prompt': extend_prompt}
+        if negative_prompt:
+            inputs['negative_prompt'] = negative_prompt
+        if template:
+            inputs['template'] = template
+        has_upload = False
+        if img_url is not None and img_url:
+            is_upload, res_img_url = check_and_upload_local(
+                model, img_url, api_key)
+            if is_upload:
+                has_upload = True
+            inputs['img_url'] = res_img_url
+        if extra_input is not None and extra_input:
+            inputs = {**inputs, **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,
+            task=VideoSynthesis.task if task is None else task,
+            function=function,
+            api_key=api_key,
+            input=inputs,
+            workspace=workspace,
+            **kwargs)
+        return VideoSynthesisResponse.from_api_response(response)
+
+    @classmethod
+    def fetch(cls,
+              task: Union[str, VideoSynthesisResponse],
+              api_key: str = None,
+              workspace: str = None) -> VideoSynthesisResponse:
+        """Fetch video synthesis task status or result.
+
+        Args:
+            task (Union[str, VideoSynthesisResponse]): The task_id or
+                VideoSynthesisResponse return by async_call().
+            api_key (str, optional): The api api_key. Defaults to None.
+            workspace (str): The dashscope workspace id.
+
+        Returns:
+            VideoSynthesisResponse: The task status or result.
+        """
+        response = super().fetch(task, api_key=api_key, workspace=workspace)
+        return VideoSynthesisResponse.from_api_response(response)
+
+    @classmethod
+    def wait(cls,
+             task: Union[str, VideoSynthesisResponse],
+             api_key: str = None,
+             workspace: str = None) -> VideoSynthesisResponse:
+        """Wait for video synthesis task to complete, and return the result.
+
+        Args:
+            task (Union[str, VideoSynthesisResponse]): The task_id or
+                VideoSynthesisResponse return by async_call().
+            api_key (str, optional): The api api_key. Defaults to None.
+            workspace (str): The dashscope workspace id.
+
+        Returns:
+            VideoSynthesisResponse: The task result.
+        """
+        response = super().wait(task, api_key, workspace=workspace)
+        return VideoSynthesisResponse.from_api_response(response)
+
+    @classmethod
+    def cancel(cls,
+               task: Union[str, VideoSynthesisResponse],
+               api_key: str = None,
+               workspace: str = None) -> DashScopeAPIResponse:
+        """Cancel video synthesis task.
+        Only tasks whose status is PENDING can be canceled.
+
+        Args:
+            task (Union[str, VideoSynthesisResponse]): The task_id or
+                VideoSynthesisResponse return by async_call().
+            api_key (str, optional): The api api_key. Defaults to None.
+            workspace (str): The dashscope workspace id.
+
+        Returns:
+            DashScopeAPIResponse: The response data.
+        """
+        return super().cancel(task, api_key, workspace=workspace)
+
+    @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,
+             workspace: 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.
+            workspace (str): The dashscope workspace id.
+
+        Returns:
+            DashScopeAPIResponse: The response data.
+        """
+        return super().list(start_time=start_time,
+                            end_time=end_time,
+                            model_name=model_name,
+                            api_key_id=api_key_id,
+                            region=region,
+                            status=status,
+                            page_no=page_no,
+                            page_size=page_size,
+                            api_key=api_key,
+                            workspace=workspace,
+                            **kwargs)

dashscope/api_entities/aiohttp_request.py

@@ -2,7 +2,6 @@ import json
 from http import HTTPStatus
 
 import aiohttp
-
 from dashscope.api_entities.base_request import AioBaseRequest
 from dashscope.api_entities.dashscope_response import DashScopeAPIResponse
 from dashscope.common.constants import (DEFAULT_REQUEST_TIMEOUT_SECONDS,

dashscope/api_entities/api_request_data.py

@@ -2,7 +2,6 @@ import json
 from urllib.parse import urlencode
 
 import aiohttp
-
 from dashscope.common.constants import ApiProtocol
 from dashscope.io.input_output import InputResolver
 

dashscope/api_entities/api_request_factory.py

@@ -81,13 +81,15 @@ def _build_api_request(model: str,
             websocket_url = base_address
         else:
             websocket_url = dashscope.base_websocket_api_url
+        pre_task_id = kwargs.pop('pre_task_id', None)
         request = WebSocketRequest(url=websocket_url,
                                    api_key=api_key,
                                    stream=stream,
                                    ws_stream_mode=ws_stream_mode,
                                    is_binary_input=is_binary_input,
                                    timeout=request_timeout,
-                                   flattened_output=flattened_output)
+                                   flattened_output=flattened_output,
+                                   pre_task_id=pre_task_id)
     else:
         raise UnsupportedApiProtocol(
             'Unsupported protocol: %s, support [http, https, websocket]' %

dashscope/api_entities/dashscope_response.py

@@ -458,6 +458,24 @@ class ImageSynthesisOutput(DictMixin):
                          **kwargs)
 
 
+@dataclass(init=False)
+class VideoSynthesisOutput(DictMixin):
+    task_id: str
+    task_status: str
+    video_url: str
+
+    def __init__(self,
+                 task_id: str,
+                 task_status: str,
+                 video_url: str = '',
+                 **kwargs):
+        super().__init__(self,
+                         task_id=task_id,
+                         task_status=task_status,
+                         video_url=video_url,
+                         **kwargs)
+
+
 @dataclass(init=False)
 class ImageSynthesisUsage(DictMixin):
     image_count: int
@@ -466,6 +484,14 @@ class ImageSynthesisUsage(DictMixin):
         super().__init__(image_count=image_count, **kwargs)
 
 
+@dataclass(init=False)
+class VideoSynthesisUsage(DictMixin):
+    video_count: int
+
+    def __init__(self, video_count: int = 1, **kwargs):
+        super().__init__(video_count=video_count, **kwargs)
+
+
 @dataclass(init=False)
 class ImageSynthesisResponse(DashScopeAPIResponse):
     output: ImageSynthesisOutput
@@ -495,6 +521,35 @@ class ImageSynthesisResponse(DashScopeAPIResponse):
                                           message=api_response.message)
 
 
+@dataclass(init=False)
+class VideoSynthesisResponse(DashScopeAPIResponse):
+    output: VideoSynthesisOutput
+    usage: VideoSynthesisUsage
+
+    @staticmethod
+    def from_api_response(api_response: DashScopeAPIResponse):
+        if api_response.status_code == HTTPStatus.OK:
+            output = None
+            usage = None
+            if api_response.output is not None:
+                output = VideoSynthesisOutput(**api_response.output)
+            if api_response.usage is not None:
+                usage = VideoSynthesisUsage(**api_response.usage)
+
+            return VideoSynthesisResponse(status_code=api_response.status_code,
+                                          request_id=api_response.request_id,
+                                          code=api_response.code,
+                                          message=api_response.message,
+                                          output=output,
+                                          usage=usage)
+
+        else:
+            return VideoSynthesisResponse(status_code=api_response.status_code,
+                                          request_id=api_response.request_id,
+                                          code=api_response.code,
+                                          message=api_response.message)
+
+
 @dataclass(init=False)
 class ReRankResult(DictMixin):
     index: int

dashscope/api_entities/http_request.py

@@ -3,7 +3,6 @@ from http import HTTPStatus
 
 import aiohttp
 import requests
-
 from dashscope.api_entities.base_request import AioBaseRequest
 from dashscope.api_entities.dashscope_response import DashScopeAPIResponse
 from dashscope.common.constants import (DEFAULT_REQUEST_TIMEOUT_SECONDS,

dashscope/api_entities/websocket_request.py

@@ -5,7 +5,6 @@ from http import HTTPStatus
 from typing import Tuple, Union
 
 import aiohttp
-
 from dashscope.api_entities.base_request import AioBaseRequest
 from dashscope.api_entities.dashscope_response import DashScopeAPIResponse
 from dashscope.common.constants import (DEFAULT_REQUEST_TIMEOUT_SECONDS,
@@ -31,6 +30,7 @@ class WebSocketRequest(AioBaseRequest):
         is_binary_input: bool = False,
         timeout: int = DEFAULT_REQUEST_TIMEOUT_SECONDS,
         flattened_output: bool = False,
+        pre_task_id=None,
     ) -> None:
         super().__init__()
         """HttpRequest.
@@ -61,6 +61,7 @@ class WebSocketRequest(AioBaseRequest):
         self.task_headers = {
             'streaming': self.ws_stream_mode,
         }
+        self.pre_task_id = pre_task_id
 
     def add_headers(self, headers):
         self.headers = {**self.headers, **headers}
@@ -77,6 +78,10 @@ class WebSocketRequest(AioBaseRequest):
                 pass
             return output
 
+    async def close(self):
+        if self.ws is not None and not self.ws.closed:
+            await self.ws.close()
+
     async def aio_call(self):
         response = self.connection_handler()
         if self.stream:
@@ -140,7 +145,11 @@ class WebSocketRequest(AioBaseRequest):
                                        code=e.name,
                                        message=e.message)
         except aiohttp.ClientConnectorError as e:
-            raise e
+            logger.exception(e)
+            yield DashScopeAPIResponse(request_id='',
+                                       status_code=-1,
+                                       code='ClientConnectorError',
+                                       message=str(e))
         except aiohttp.WSServerHandshakeError as e:
             code = e.status
             msg = e.message
@@ -227,17 +236,22 @@ class WebSocketRequest(AioBaseRequest):
         raise error
 
     async def _start_task(self, ws):
-        self.task_headers['task_id'] = uuid.uuid4().hex  # create task id.
+        if self.pre_task_id is not None:
+            self.task_headers['task_id'] = self.pre_task_id
+        else:
+            self.task_headers['task_id'] = uuid.uuid4().hex  # create task id.
         task_header = {**self.task_headers, ACTION_KEY: ActionType.START}
         # for binary data, the start action has no input, only parameters.
         start_data = self.data.get_websocket_start_data()
         message = self._build_up_message(task_header, start_data)
+        logger.debug('Send start task: {}'.format(message))
         await ws.send_str(message)
 
     async def _send_finished_task(self, ws):
         task_header = {**self.task_headers, ACTION_KEY: ActionType.FINISHED}
         payload = {'input': {}}
         message = self._build_up_message(task_header, payload)
+        logger.debug('Send finish task: {}'.format(message))
         await ws.send_str(message)
 
     async def _send_continue_task_data(self, ws):
@@ -250,12 +264,19 @@ class WebSocketRequest(AioBaseRequest):
                 if len(input) > 0:
                     if isinstance(input, bytes):
                         await ws.send_bytes(input)
+                        logger.debug(
+                            'Send continue task with bytes: {}'.format(
+                                len(input)))
                     else:
                         await ws.send_bytes(list(input.values())[0])
+                        logger.debug(
+                            'Send continue task with list[byte]: {}'.format(
+                                len(input)))
             else:
                 if len(input) > 0:
                     message = self._build_up_message(headers=headers,
                                                      payload=input)
+                    logger.debug('Send continue task: {}'.format(message))
                     await ws.send_str(message)
             await asyncio.sleep(0.000001)
 

dashscope/audio/asr/__init__.py

@@ -1,9 +1,18 @@
 from .asr_phrase_manager import AsrPhraseManager
 from .recognition import Recognition, RecognitionCallback, RecognitionResult
 from .transcription import Transcription
+from .translation_recognizer import (TranscriptionResult, Translation,
+                                     TranslationRecognizerCallback,
+                                     TranslationRecognizerChat,
+                                     TranslationRecognizerRealtime,
+                                     TranslationRecognizerResultPack,
+                                     TranslationResult)
 from .vocabulary import VocabularyService, VocabularyServiceException
 
 __all__ = [
     'Transcription', 'Recognition', 'RecognitionCallback', 'RecognitionResult',
-    'AsrPhraseManager', 'VocabularyServiceException', 'VocabularyService'
+    'AsrPhraseManager', 'VocabularyServiceException', 'VocabularyService',
+    'TranslationRecognizerRealtime', 'TranslationRecognizerChat',
+    'TranslationRecognizerCallback', 'Translation', 'TranslationResult',
+    'TranscriptionResult', 'TranslationRecognizerResultPack'
 ]