@pipedream/openai 0.1.4 → 0.1.6

package/actions/create-transcription/create-transcription.mjs

@@ -1,18 +1,28 @@
+import axios from "axios";
+import Bottleneck from "bottleneck";
 import fs from "fs";
-import got from "got";
-import { extname } from "path";
+import {
+  join, extname,
+} from "path";
 import FormData from "form-data";
 import { ConfigurationError } from "@pipedream/platform";
 import common from "../common/common.mjs";
 import constants from "../common/constants.mjs";
 import lang from "../common/lang.mjs";
 import openai from "../../app/openai.app.mjs";
+import { promisify } from "util";
+import stream from "stream";
+import { exec } from "child_process";
+import ffmpegInstaller from "@ffmpeg-installer/ffmpeg";
 
 const COMMON_AUDIO_FORMATS_TEXT = "Your audio file must be in one of these formats: mp3, mp4, mpeg, mpga, m4a, wav, or webm.";
 
+const execAsync = promisify(exec);
+const pipelineAsync = promisify(stream.pipeline);
+
 export default {
   name: "Create Transcription",
-  version: "0.0.2",
+  version: "0.0.5",
   key: "openai-create-transcription",
   description: "Transcribes audio into the input language. [See docs here](https://platform.openai.com/docs/api-reference/audio/create).",
   type: "action",
@@ -80,6 +90,102 @@ export default {
 
     return props;
   },
+  methods: {
+    createForm({
+      file, outputDir,
+    }) {
+      const form = new FormData();
+      form.append("model", "whisper-1");
+      if (this.prompt) form.append("prompt", this.prompt);
+      if (this.temperature) form.append("temperature", this.temperature);
+      if (this.language) form.append("language", this.language);
+      if (this.responseFormat) form.append("response_format", this.responseFormat);
+      const readStream = fs.createReadStream(join(outputDir, file));
+      form.append("file", readStream);
+      return form;
+    },
+    async chunkFileAndTranscribe({
+      file, $,
+    }) {
+      const outputDir = join("/tmp", "chunks");
+      await execAsync(`mkdir -p ${outputDir}`);
+      await execAsync(`rm -f ${outputDir}/*`);
+
+      await this.chunkFile({
+        file,
+        outputDir,
+      });
+
+      const files = await fs.promises.readdir(outputDir);
+      const transcription = await this.transcribeFiles({
+        files,
+        outputDir,
+        $,
+      });
+
+      return {
+        transcription,
+      };
+    },
+    async chunkFile({
+      file, outputDir,
+    }) {
+      const ffmpegPath = ffmpegInstaller.path;
+      const ext = extname(file);
+
+      const fileSizeInMB = fs.statSync(file).size / (1024 * 1024);
+      const numberOfChunks = Math.ceil(fileSizeInMB / 24);
+
+      if (numberOfChunks === 1) {
+        await execAsync(`cp ${file} ${outputDir}/chunk-000${ext}`);
+        return;
+      }
+
+      const { stdout } = await execAsync(`${ffmpegPath} -i ${file} 2>&1 | grep "Duration"`);
+      const duration = stdout.match(/\d{2}:\d{2}:\d{2}\.\d{2}/s)[0];
+      const [
+        hours,
+        minutes,
+        seconds,
+      ] = duration.split(":").map(parseFloat);
+
+      const totalSeconds = (hours * 60 * 60) + (minutes * 60) + seconds;
+      const segmentTime = Math.ceil(totalSeconds / numberOfChunks);
+
+      const command = `${ffmpegPath} -i ${file} -f segment -segment_time ${segmentTime} -c copy ${outputDir}/chunk-%03d${ext}`;
+      await execAsync(command);
+    },
+    async transcribeFiles({
+      files, outputDir, $,
+    }) {
+      const limiter = new Bottleneck({
+        maxConcurrent: 1,
+        minTime: 1000 / 59,
+      });
+
+      const transcriptions = await Promise.all(files.map((file) => {
+        return limiter.schedule(() => this.transcribe({
+          file,
+          outputDir,
+          $,
+        }));
+      }));
+      return transcriptions.join(" ");
+    },
+    async transcribe({
+      file, outputDir, $,
+    }) {
+      const form = this.createForm({
+        file,
+        outputDir,
+      });
+      const response = await this.openai.createTranscription({
+        $,
+        form,
+      });
+      return response.text;
+    },
+  },
   async run({ $ }) {
     const {
       url,
@@ -90,38 +196,38 @@ export default {
       throw new Error("Must specify either File URL or File Path");
     }
 
-    const form = new FormData();
-    form.append("model", "whisper-1");
-    if (this.prompt) form.append("prompt", this.prompt);
-    if (this.temperature) form.append("temperature", this.temperature);
-    if (this.language) form.append("language", this.language);
-    if (this.responseFormat) form.append("response_format", this.responseFormat);
+    let file;
 
     if (path) {
       if (!fs.existsSync(path)) {
         throw new Error(`${path} does not exist`);
       }
-      const readStream = fs.createReadStream(path);
-      form.append("file", readStream);
+
+      file = path;
     } else if (url) {
       const ext = extname(url);
-      // OpenAI only supports a few audio formats and uses the extension to determine the format
-      const tempFilePath = `/tmp/audioFile${ext}`;
-
-      const writeStream = fs.createWriteStream(tempFilePath);
-      const responseStream = got.stream(url);
-      responseStream.pipe(writeStream);
-      await new Promise((resolve, reject) => {
-        writeStream.on("finish", resolve);
-        writeStream.on("error", reject);
-        responseStream.on("error", reject);
+
+      const response = await axios({
+        method: "GET",
+        url,
+        responseType: "stream",
+        timeout: 250000,
       });
-      const readStream = fs.createReadStream(tempFilePath);
-      form.append("file", readStream);
+
+      const bufferStream = new stream.PassThrough();
+      response.data.pipe(bufferStream);
+
+      const downloadPath = join("/tmp", `audio${ext}`);
+      const writeStream = fs.createWriteStream(downloadPath);
+
+      await pipelineAsync(bufferStream, writeStream);
+
+      file = downloadPath;
     }
-    const response = await this.openai.createTranscription({
+
+    const response = await this.chunkFileAndTranscribe({
+      file,
       $,
-      form,
     });
 
     if (response) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pipedream/openai",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Pipedream OpenAI Components",
   "main": "app/openai.app.mjs",
   "keywords": [
@@ -14,6 +14,7 @@
     "access": "public"
   },
   "dependencies": {
+    "@ffmpeg-installer/ffmpeg": "^1.1.0",
     "@pipedream/platform": "^1.2.1",
     "@pipedream/types": "^0.1.4",
     "got": "^12.6.0",