Add dubbing a video example using node(typescript)

examples/dubbing/node/.env.example

@@ -0,0 +1 @@
+ELEVENLABS_API_KEY=

examples/dubbing/node/createADubFromFile.ts

@@ -0,0 +1,73 @@
+import * as dotenv from "dotenv";
+import * as fs from "fs";
+import * as path from "path";
+import { ElevenLabs } from "elevenlabs"; // Assume this is the ElevenLabs TypeScript import
+import { downloadDubbedFile, waitForDubbingCompletion } from "./dubbingUtils"; // Assuming corresponding TypeScript functions
+
+dotenv.config();
+
+const ELEVENLABS_API_KEY = process.env.ELEVENLABS_API_KEY;
+if (!ELEVENLABS_API_KEY) {
+  throw new Error(
+    "ELEVENLABS_API_KEY environment variable not found. " +
+      "Please set the API key in your environment variables."
+  );
+}
+
+const client = new ElevenLabs({ apiKey: ELEVENLABS_API_KEY });
+
+async function createDubFromFile(
+  inputFilePath: string,
+  fileFormat: string,
+  sourceLanguage: string,
+  targetLanguage: string
+): Promise<string | null> {
+  if (!fs.existsSync(inputFilePath)) {
+    throw new Error(`The input file does not exist: ${inputFilePath}`);
+  }
+
+  const fileStream = fs.createReadStream(inputFilePath);
+  const response = await client.dubbing.dubAVideoOrAnAudioFile({
+    file: {
+      value: fileStream,
+      options: {
+        filename: path.basename(inputFilePath),
+        contentType: fileFormat,
+      },
+    },
+    target_lang: targetLanguage,
+    mode: "automatic",
+    source_lang: sourceLanguage,
+    num_speakers: 1,
+    watermark: false,
+  });
+
+  const dubbingId = response.dubbing_id;
+  const dubbingCompleted = await waitForDubbingCompletion(dubbingId);
+  if (dubbingCompleted) {
+    const outputFilePath = await downloadDubbedFile(dubbingId, targetLanguage);
+    return outputFilePath;
+  } else {
+    return null;
+  }
+}
+
+// Assuming that this script is being run directly
+(async () => {
+  try {
+    const result = await createDubFromFile(
+      "../example_speech.mp3", // Input file path
+      "audio/mpeg", // File format
+      "en", // Source language
+      "es" // Target language
+    );
+
+    if (result) {
+      console.log("Dubbing was successful! File saved at:", result);
+    } else {
+      console.log("Dubbing failed or timed out.");
+    }
+  } catch (error) {
+    console.error("Error:", error);
+  }
+})();

examples/dubbing/node/createADubFromUrl.ts

@@ -0,0 +1,65 @@
+import * as dotenv from "dotenv";
+import { ElevenLabs } from "elevenlabs"; // Assume this is the ElevenLabs TypeScript import
+import { downloadDubbedFile, waitForDubbingCompletion } from "./dubbingUtils"; // Assuming corresponding TypeScript functions
+
+dotenv.config();
+
+const ELEVENLABS_API_KEY = process.env.ELEVENLABS_API_KEY;
+if (!ELEVENLABS_API_KEY) {
+  throw new Error(
+    "ELEVENLABS_API_KEY environment variable not found. " +
+      "Please set the API key in your environment variables."
+  );
+}
+
+// Assuming the class is correctly imported and the constructor accepts an object with an API key
+const client = new ElevenLabs({ apiKey: ELEVENLABS_API_KEY });
+
+async function createDubFromUrl(
+  sourceUrl: string,
+  sourceLanguage: string,
+  targetLanguage: string
+): Promise<string | null> {
+  const response: any = await client.dubbing.dubAVideoOrAnAudioFile({
+    // Assuming the return type to be `any`. Please replace with the correct return type.
+    source_url: sourceUrl,
+    target_lang: targetLanguage,
+    mode: "automatic",
+    source_lang: sourceLanguage,
+    num_speakers: 1,
+    watermark: true,
+  });
+
+  const dubbingId = response.dubbing_id;
+  const dubbingCompleted: boolean = await waitForDubbingCompletion(dubbingId);
+  if (dubbingCompleted) {
+    const outputFilePath: string = await downloadDubbedFile(
+      dubbingId,
+      targetLanguage
+    );
+    return outputFilePath;
+  } else {
+    return null;
+  }
+}
+
+(async () => {
+  try {
+    const sourceUrl: string = "https://www.youtube.com/watch?v=0EqSXDwTq6U"; // Charlie bit my finger
+    const sourceLanguage: string = "en";
+    const targetLanguage: string = "fr";
+    const result: string | null = await createDubFromUrl(
+      sourceUrl,
+      sourceLanguage,
+      targetLanguage
+    );
+
+    if (result) {
+      console.log("Dubbing was successful! File saved at:", result);
+    } else {
+      console.log("Dubbing failed or timed out.");
+    }
+  } catch (error) {
+    console.error("Error:", error);
+  }
+})();

examples/dubbing/node/dubbingUtils.ts

@@ -0,0 +1,68 @@
+import * as dotenv from "dotenv";
+import * as fs from "fs";
+import * as path from "path";
+import { ElevenLabs } from "elevenlabs"; // Assuming an ElevenLabs TypeScript SDK exists
+
+// Load environment variables
+dotenv.config();
+
+// Retrieve the API key
+const ELEVENLABS_API_KEY = process.env.ELEVENLABS_API_KEY;
+if (!ELEVENLABS_API_KEY) {
+  throw new Error(
+    "ELEVENLABS_API_KEY environment variable not found. " +
+      "Please set the API key in your environment variables."
+  );
+}
+
+const client = new ElevenLabs({ apiKey: ELEVENLABS_API_KEY });
+
+function downloadDubbedFile(
+  dubbingId: string,
+  languageCode: string
+): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const dirPath = path.join("data", dubbingId);
+    fs.mkdirSync(dirPath, { recursive: true });
+
+    const filePath = path.join(dirPath, `${languageCode}.mp4`);
+    const fileStream = fs.createWriteStream(filePath);
+    const dubbedFileStream = client.dubbing.getDubbedFile(
+      dubbingId,
+      languageCode
+    );
+    dubbedFileStream.on("data", (chunk: Buffer) => {
+      fileStream.write(chunk);
+    });
+    dubbedFileStream.on("end", () => {
+      fileStream.end();
+      resolve(filePath);
+    });
+    dubbedFileStream.on("error", reject);
+  });
+}
+
+async function waitForDubbingCompletion(dubbingId: string): Promise<boolean> {
+  const MAX_ATTEMPTS = 120;
+  const CHECK_INTERVAL = 10000; // In milliseconds
+
+  for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
+    const metadata = await client.dubbing.getDubbingProjectMetadata(dubbingId);
+    if (metadata.status === "dubbed") {
+      return true;
+    } else if (metadata.status === "dubbing") {
+      console.log(
+        "Dubbing in progress... Will check status again in",
+        CHECK_INTERVAL / 1000,
+        "seconds."
+      );
+      await new Promise(resolve => setTimeout(resolve, CHECK_INTERVAL));
+    } else {
+      console.log("Dubbing failed:", metadata.error_message);
+      return false;
+    }
+  }
+
+  console.log("Dubbing timed out");
+  return false;
+}