[Feat] new video generation providers

edenai_apis/apis/google/google_video_api.py

@@ -1,17 +1,17 @@
 import base64
 import json
+import mimetypes
 from datetime import datetime, timezone
+from io import BytesIO
 from pathlib import Path
 from time import sleep, time
-from typing import Any, Dict, List
+from typing import Any, Dict, List, Optional
 
 import requests
 from dateutil.parser import parse
 from google.cloud import videointelligence
 
-from edenai_apis.apis.amazon.helpers import check_webhook_result
 from edenai_apis.apis.google.google_helpers import (
-    GoogleVideoFeatures,
     calculate_usage_tokens,
     google_video_get_job,
     score_to_content,
@@ -69,6 +69,9 @@
     VideoTextBoundingBox,
     VideoTextFrames,
 )
+from edenai_apis.features.video.generation_async.generation_async_dataclass import (
+    GenerationAsyncDataClass,
+)
 from edenai_apis.features.video.video_interface import VideoInterface
 from edenai_apis.utils.exception import (
     ProviderException,
@@ -82,6 +85,10 @@
     AsyncResponseType,
     ResponseType,
 )
+from edenai_apis.utils.upload_s3 import (
+    USER_PROCESS,
+    upload_file_bytes_to_s3,
+)
 
 
 class GoogleVideoApi(VideoInterface):
@@ -918,3 +925,93 @@ def video__question_answer_async__get_job_result(
                 standardized_response=standardized_response,
                 provider_job_id=provider_job_id,
             )
+
+    def video__generation_async__launch_job(
+        self,
+        text: str,
+        duration: Optional[int] = 6,
+        fps: Optional[int] = 24,
+        dimension: Optional[str] = "1280x720",
+        seed: Optional[float] = 12,
+        file: Optional[str] = None,
+        file_url: Optional[str] = None,
+        model: Optional[str] = None,
+        **kwargs,
+    ) -> AsyncLaunchJobResponseType:
+        api_key = self.api_settings.get("genai_api_key")
+        url = f"https://generativelanguage.googleapis.com/v1beta/models/{model}:predictLongRunning?key={api_key}"
+        prompt = {"prompt": text}
+        if file:
+            with open(file, "rb") as file_:
+                file_content = file_.read()
+                input_image_base64 = base64.b64encode(file_content).decode("utf-8")
+                mime_type = mimetypes.guess_type(file)[0]
+                image = {
+                    "bytesBase64Encoded": input_image_base64,
+                    "mimeType": mime_type,
+                }
+                prompt["image"] = image
+
+        payload = {
+            "instances": [prompt],
+            "parameters": {
+                "durationSeconds": duration,
+                # "personGeneration": "allow_adult",
+            },
+        }
+        response = requests.post(url=url, json=payload)
+        try:
+            original_response = response.json()
+        except json.JSONDecodeError as exc:
+            raise ProviderException(
+                "An error occurred while parsing the response."
+            ) from exc
+
+        if response.status_code != 200:
+            raise ProviderException(
+                message=original_response["error"]["message"],
+                code=response.status_code,
+            )
+        # {'name': 'models/veo-2.0-generate-001/operations/0gbm5qefte2y'}
+
+        provider_job_id = original_response["name"]
+        return AsyncLaunchJobResponseType(provider_job_id=provider_job_id)
+
+    def video__generation_async__get_job_result(
+        self, provider_job_id: str
+    ) -> GenerationAsyncDataClass:
+        api_key = self.api_settings.get("genai_api_key")
+        url = f"https://generativelanguage.googleapis.com/v1beta/{provider_job_id}?key={api_key}"
+        response = requests.get(url)
+        try:
+            original_response = response.json()
+        except json.JSONDecodeError as exc:
+            raise ProviderException(
+                "An error occurred while parsing the response."
+            ) from exc
+        if "error" in original_response:
+            raise ProviderException(
+                message=original_response["error"]["message"],
+                code=original_response["error"]["code"],
+            )
+        if original_response.get("done") is True:
+            uri = original_response["response"]["generateVideoResponse"][
+                "generatedSamples"
+            ][0]["video"]["uri"]
+            headers = {"x-goog-api-key": api_key}
+            response = requests.get(uri, headers=headers)
+            file_content = response.content
+            base64_encoded_string = base64.b64encode(file_content).decode("utf-8")
+            resource_url = upload_file_bytes_to_s3(
+                BytesIO(file_content), ".mp4", USER_PROCESS
+            )
+            standardized_response = GenerationAsyncDataClass(
+                video=base64_encoded_string, video_resource_url=resource_url
+            )
+            return AsyncResponseType[GenerationAsyncDataClass](
+                original_response=original_response,
+                standardized_response=standardized_response,
+                provider_job_id=provider_job_id,
+            )
+
+        return AsyncPendingResponseType(provider_job_id=provider_job_id)

edenai_apis/apis/google/info.json

@@ -1353,6 +1353,9 @@
                 ]
             },
             "version": "v1Beta"
+        },
+        "generation_async": {
+            "version": "v1Beta"
         }
     },
     "image": {

edenai_apis/apis/microsoft/info.json

@@ -1766,6 +1766,11 @@
       "version": "Azure AI Foundry"
     }
   },
+  "video": {
+    "generation_async": {
+      "version": "Azure AI Foundry"
+    }
+  },
   "_metadata": {
     "privacy_url": "https://privacy.microsoft.com/en-us"
   }

edenai_apis/apis/microsoft/microsoft_api.py

@@ -6,6 +6,7 @@
     get_microsoft_urls,
 )
 from edenai_apis.apis.microsoft.microsoft_image_api import MicrosoftImageApi
+from edenai_apis.apis.microsoft.microsoft_video_api import MicrosoftVideoApi
 from edenai_apis.apis.microsoft.microsoft_ocr_api import MicrosoftOcrApi
 from edenai_apis.apis.microsoft.microsoft_text_api import MicrosoftTextApi
 from edenai_apis.apis.microsoft.microsoft_translation_api import MicrosoftTranslationApi
@@ -26,6 +27,7 @@ class MicrosoftApi(
     MicrosoftAudioApi,
     MicrosoftMultimodalApi,
     MicrosoftLLMApi,
+    MicrosoftVideoApi,
 ):
     provider_name = "microsoft"
 

edenai_apis/apis/microsoft/microsoft_video_api.py

@@ -0,0 +1,113 @@
+import base64
+import json
+from io import BytesIO
+from typing import Optional
+
+import requests
+
+from edenai_apis.features.video.generation_async.generation_async_dataclass import (
+    GenerationAsyncDataClass,
+)
+from edenai_apis.features.video.video_interface import VideoInterface
+from edenai_apis.utils.exception import (
+    ProviderException,
+)
+from edenai_apis.utils.types import (
+    AsyncLaunchJobResponseType,
+    AsyncPendingResponseType,
+    AsyncResponseType,
+)
+from edenai_apis.utils.upload_s3 import (
+    USER_PROCESS,
+    upload_file_bytes_to_s3,
+)
+
+
+class MicrosoftVideoApi(VideoInterface):
+    def video__generation_async__launch_job(
+        self,
+        text: str,
+        duration: Optional[int] = 6,
+        fps: Optional[int] = 24,
+        dimension: Optional[str] = "1280x720",
+        seed: Optional[float] = 12,
+        file: Optional[str] = None,
+        file_url: Optional[str] = None,
+        model: Optional[str] = None,
+        **kwargs,
+    ) -> AsyncLaunchJobResponseType:
+        base_url = self.azure_ai_credentials.get("azure_api_sora")
+        api_key = self.azure_ai_credentials.get("azure_api_key")
+        url = f"{base_url}openai/v1/video/generations/jobs?api-version=preview"
+        try:
+            height, width = dimension.split("x")
+        except (ValueError, AttributeError) as exc:
+            raise ProviderException(
+                message=f"Invalid dimension format: {dimension}. Expected format: 'heightxwidth' (e.g., '1280x720')",
+                code=400,
+            ) from exc
+        payload = {
+            "model": model,
+            "prompt": text,
+            "height": height,
+            "width": width,
+            "n_seconds": duration,
+        }
+        response = requests.post(
+            url=url, json=payload, headers={"Authorization": api_key}
+        )
+        try:
+            original_response = response.json()
+        except json.JSONDecodeError as exc:
+            raise ProviderException(
+                "An error occurred while parsing the response."
+            ) from exc
+        if response.status_code > 201:
+            raise ProviderException(
+                message=original_response["error"]["message"],
+                code=response.status_code,
+            )
+
+        provider_job_id = original_response["id"]
+        return AsyncLaunchJobResponseType(provider_job_id=provider_job_id)
+
+    def video__generation_async__get_job_result(
+        self, provider_job_id: str
+    ) -> GenerationAsyncDataClass:
+        base_url = self.azure_ai_credentials.get("azure_api_sora")
+        api_key = self.azure_ai_credentials.get("azure_api_key")
+        url = f"{base_url}openai/v1/video/generations/jobs/{provider_job_id}?api-version=preview"
+
+        response = requests.get(url, headers={"Authorization": api_key})
+        try:
+            original_response = response.json()
+        except json.JSONDecodeError as exc:
+            raise ProviderException(
+                "An error occurred while parsing the response."
+            ) from exc
+        if "error" in original_response:
+            raise ProviderException(
+                message=original_response["error"]["message"],
+                code=original_response["error"]["code"],
+            )
+        if original_response.get("status") == "succeeded":
+            generations = original_response.get("generations", [])
+            generation_id = generations[0].get("id")
+            video_url = f"{base_url}openai/v1/video/generations/{generation_id}/content/video?api-version=preview"
+            video_response = requests.get(video_url, headers={"Authorization": api_key})
+            base64_encoded_string = base64.b64encode(video_response.content).decode(
+                "utf-8"
+            )
+            resource_url = upload_file_bytes_to_s3(
+                BytesIO(video_response.content), ".mp4", USER_PROCESS
+            )
+            standardized_response = GenerationAsyncDataClass(
+                video=base64_encoded_string, video_resource_url=resource_url
+            )
+            return AsyncResponseType[GenerationAsyncDataClass](
+                original_response=original_response,
+                standardized_response=standardized_response,
+                provider_job_id=provider_job_id,
+            )
+
+        return AsyncPendingResponseType(provider_job_id=provider_job_id)

edenai_apis/apis/minimax/minimax_api.py

@@ -122,10 +122,15 @@ def video__generation_async__get_job_result(
                 raise ProviderException(
                     message=base_msg["status_msg"], code=base_msg["status_code"]
                 )
+            video_url = file_response_data["file"]["download_url"]
+            video_response = requests.get(video_url)
+            base64_encoded_string = base64.b64encode(video_response.content).decode(
+                "utf-8"
+            )
             return AsyncResponseType(
                 original_response=original_response,
                 standardized_response=GenerationAsyncDataClass(
-                    video="",
+                    video=base64_encoded_string,
                     video_resource_url=file_response_data["file"]["download_url"],
                 ),
                 provider_job_id=provider_job_id,

edenai_apis/features/video/generation_async/generation_async_args.py

@@ -24,7 +24,7 @@ def generation_async_arguments(provider_name: str) -> Dict:
     )
     file_wrapper = FileWrapper(image_path, "", file_info)
     return {
-        "text": "Make this image move like the ocean",
+        "text": "Panning wide shot of a calico kitten sleeping in the sunshine",
         "duration": 6,
         "fps": 24,
         "seed": 12,
@@ -34,5 +34,7 @@ def generation_async_arguments(provider_name: str) -> Dict:
             "amazon": "amazon.nova-reel-v1:0",
             "minimax": "MiniMax-Hailuo-02",
             "bytedance": "seedance-1-0-lite-t2v-250428",
+            "google": "veo-2.0-generate-001",
+            "microsoft": "sora",
         },
     }