dashscope 1.24.2__py3-none-any.whl → 1.24.3__py3-none-any.whl

dashscope/aigc/video_synthesis.py

@@ -4,9 +4,8 @@ from typing import Any, Dict, Union
 
 from dashscope.api_entities.dashscope_response import (DashScopeAPIResponse,
                                                        VideoSynthesisResponse)
-from dashscope.client.base_api import BaseAsyncApi
+from dashscope.client.base_api import BaseAsyncApi, BaseAsyncAioApi
 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
 
@@ -91,7 +90,7 @@ class VideoSynthesis(BaseAsyncApi):
                             **kwargs)
 
     @classmethod
-    def async_call(cls,
+    def _get_input(cls,
                    model: str,
                    prompt: Any = None,
                    img_url: str = None,
@@ -101,41 +100,14 @@ class VideoSynthesis(BaseAsyncApi):
                    template: str = None,
                    api_key: str = None,
                    extra_input: Dict = None,
-                   workspace: str = None,
                    task: str = None,
+                   function: str = None,
                    head_frame: str = None,
                    tail_frame: str = None,
                    first_frame_url: str = None,
                    last_frame_url: 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): @deprecated, use prompt_extend in parameters
-            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.
-            first_frame_url (str): The URL of the first frame image for generating the video.
-            last_frame_url (str): The URL of the last frame image for generating the video.
-            **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.
+                   **kwargs):
 
-        Raises:
-            InputRequired: The prompt cannot be empty.
-
-        Returns:
-            DashScopeAPIResponse: The video synthesis
-                task id in the response.
-        """
-        task_group, function = _get_task_group_and_task(__name__)
         inputs = {PROMPT: prompt, 'extend_prompt': extend_prompt}
         if negative_prompt:
             inputs['negative_prompt'] = negative_prompt
@@ -192,6 +164,61 @@ class VideoSynthesis(BaseAsyncApi):
             task = VideoSynthesis.task
         if model is not None and model and 'kf2v' in model:
             task = 'image2video'
+
+        return inputs, kwargs, task
+
+    @classmethod
+    def async_call(cls,
+                   model: str,
+                   prompt: Any = None,
+                   img_url: str = None,
+                   # """@deprecated, use prompt_extend in parameters """
+                   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,
+                   head_frame: str = None,
+                   tail_frame: str = None,
+                   first_frame_url: str = None,
+                   last_frame_url: 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): @deprecated, use prompt_extend in parameters
+            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.
+            first_frame_url (str): The URL of the first frame image for generating the video.
+            last_frame_url (str): The URL of the last frame image for generating the video.
+            **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.
+        """
+        task_group, function = _get_task_group_and_task(__name__)
+
+        inputs, kwargs, task = cls._get_input(
+            model, prompt, img_url, extend_prompt, negative_prompt, template, api_key,
+            extra_input, task, function, head_frame, tail_frame,
+            first_frame_url, last_frame_url, **kwargs)
+
         response = super().async_call(
             model=model,
             task_group=task_group,
@@ -305,3 +332,225 @@ class VideoSynthesis(BaseAsyncApi):
                             api_key=api_key,
                             workspace=workspace,
                             **kwargs)
+
+class AioVideoSynthesis(BaseAsyncAioApi):
+    @classmethod
+    async def call(cls,
+                   model: str,
+                   prompt: Any = None,
+                   img_url: str = None,
+                   # """@deprecated, use prompt_extend in parameters """
+                   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,
+                   head_frame: str = None,
+                   tail_frame: str = None,
+                   first_frame_url: str = None,
+                   last_frame_url: 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): @deprecated, use prompt_extend in parameters
+            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.
+            first_frame_url (str): The URL of the first frame image for generating the video.
+            last_frame_url (str): The URL of the last frame image for generating the video.
+            **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.
+        """
+        task_group, f = _get_task_group_and_task(__name__)
+        inputs, kwargs, task = VideoSynthesis._get_input(
+            model, prompt, img_url, extend_prompt, negative_prompt, template, api_key,
+            extra_input, task, f, head_frame, tail_frame,
+            first_frame_url, last_frame_url, **kwargs)
+        response = await super().call(model, inputs, task_group, task, f, api_key, workspace, **kwargs)
+        return VideoSynthesisResponse.from_api_response(response)
+
+    @classmethod
+    async def async_call(cls,
+                   model: str,
+                   prompt: Any = None,
+                   img_url: str = None,
+                   # """@deprecated, use prompt_extend in parameters """
+                   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,
+                   head_frame: str = None,
+                   tail_frame: str = None,
+                   first_frame_url: str = None,
+                   last_frame_url: 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): @deprecated, use prompt_extend in parameters
+            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.
+            first_frame_url (str): The URL of the first frame image for generating the video.
+            last_frame_url (str): The URL of the last frame image for generating the video.
+            **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.
+        """
+        task_group, function = _get_task_group_and_task(__name__)
+
+        inputs, kwargs, task = VideoSynthesis._get_input(
+            model, prompt, img_url, extend_prompt, negative_prompt, template, api_key,
+            extra_input, task, function, head_frame, tail_frame,
+            first_frame_url, last_frame_url, **kwargs)
+
+        response = await 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
+    async def fetch(cls,
+                    task: Union[str, VideoSynthesisResponse],
+                    api_key: str = None,
+                    workspace: str = None,
+                    **kwargs) -> 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 = await super().fetch(task, api_key=api_key, workspace=workspace)
+        return VideoSynthesisResponse.from_api_response(response)
+
+    @classmethod
+    async def wait(cls,
+                task: Union[str, VideoSynthesisResponse],
+                api_key: str = None,
+                workspace: str = None,
+                **kwargs) -> 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 = await super().wait(task, api_key, workspace=workspace)
+        return VideoSynthesisResponse.from_api_response(response)
+
+    @classmethod
+    async def cancel(cls,
+                   task: Union[str, VideoSynthesisResponse],
+                   api_key: str = None,
+                   workspace: str = None,
+                   **kwargs) -> 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 await super().cancel(task, api_key, workspace=workspace)
+
+    @classmethod
+    async 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 await 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/api_request_factory.py

@@ -127,4 +127,4 @@ def _build_api_request(model: str,
     request_data.add_resources(resources)
     request_data.add_parameters(**kwargs)
     request.data = request_data
-    return request
+    return request

dashscope/api_entities/dashscope_response.py

@@ -445,8 +445,8 @@ class ImageSynthesisOutput(DictMixin):
     results: List[ImageSynthesisResult]
 
     def __init__(self,
-                 task_id: str,
-                 task_status: str,
+                 task_id: str =  None,
+                 task_status: str =  None,
                  results: List[ImageSynthesisResult] = [],
                  **kwargs):
         res = []

dashscope/api_entities/http_request.py

@@ -1,10 +1,12 @@
 # Copyright (c) Alibaba, Inc. and its affiliates.
-
+import datetime
 import json
+import ssl
 from http import HTTPStatus
 from typing import Optional
 
 import aiohttp
+import certifi
 import requests
 
 from dashscope.api_entities.base_request import AioBaseRequest
@@ -119,12 +121,18 @@ class HttpRequest(AioBaseRequest):
 
     async def _handle_aio_request(self):
         try:
+            connector = aiohttp.TCPConnector(
+                ssl=ssl.create_default_context(
+                    cafile=certifi.where()))
             async with aiohttp.ClientSession(
+                    connector=connector,
                     timeout=aiohttp.ClientTimeout(total=self.timeout),
                     headers=self.headers) as session:
                 logger.debug('Starting request: %s' % self.url)
                 if self.method == HTTPMethod.POST:
-                    is_form, obj = self.data.get_aiohttp_payload()
+                    is_form, obj = False, {}
+                    if hasattr(self, 'data') and self.data is not None:
+                        is_form, obj = self.data.get_aiohttp_payload()
                     if is_form:
                         headers = {**self.headers, **obj.headers}
                         response = await session.post(url=self.url,
@@ -136,8 +144,14 @@ class HttpRequest(AioBaseRequest):
                                                          json=obj,
                                                          headers=self.headers)
                 elif self.method == HTTPMethod.GET:
+                    # 添加条件判断
+                    params = {}
+                    if hasattr(self, 'data') and self.data is not None:
+                        params = getattr(self.data, 'parameters', {})
+                    if params:
+                        params = self.__handle_parameters(params)
                     response = await session.get(url=self.url,
-                                                 params=self.data.parameters,
+                                                 params=params,
                                                  headers=self.headers)
                 else:
                     raise UnsupportedHTTPMethod('Unsupported http method: %s' %
@@ -153,6 +167,32 @@ class HttpRequest(AioBaseRequest):
             logger.error(e)
             raise e
 
+    @staticmethod
+    def __handle_parameters(params: dict) -> dict:
+        def __format(value):
+            if isinstance(value, bool):
+                return str(value).lower()
+            elif isinstance(value, (str, int, float)):
+                return value
+            elif value is None:
+                return ''
+            elif isinstance(value, (datetime.datetime, datetime.date)):
+                return value.isoformat()
+            elif isinstance(value, (list, tuple)):
+                return ','.join(str(__format(x)) for x in value)
+            elif isinstance(value, dict):
+                return json.dumps(value)
+            else:
+                try:
+                    return str(value)
+                except Exception as e:
+                    raise ValueError(f"Unsupported type {type(value)} for param formatting: {e}")
+
+        formatted = {}
+        for k, v in params.items():
+            formatted[k] = __format(v)
+        return formatted
+
     async def _handle_aio_response(self, response: aiohttp.ClientResponse):
         request_id = ''
         if (response.status == HTTPStatus.OK and self.stream
@@ -211,6 +251,12 @@ class HttpRequest(AioBaseRequest):
             usage = None
             if 'output' in json_content and json_content['output'] is not None:
                 output = json_content['output']
+            # Compatible with wan
+            elif 'data' in json_content and json_content['data'] is not None\
+                    and isinstance(json_content['data'], list)\
+                    and len(json_content['data']) > 0\
+                    and 'task_id' in json_content['data'][0]:
+                output = json_content
             if 'usage' in json_content:
                 usage = json_content['usage']
             if 'request_id' in json_content: