@pipedream/sonix 0.0.1 → 0.1.0

package/actions/create-new-translation/create-new-translation.mjs

@@ -0,0 +1,37 @@
+import { LANGUAGE_OPTIONS } from "../../common/constants.mjs";
+import sonix from "../../sonix.app.mjs";
+
+export default {
+  key: "sonix-create-new-translation",
+  name: "Create New Translation",
+  description: "Creates a new translation for a selected media file. [See the documentation](https://sonix.ai/docs/api#create_translation)",
+  version: "0.0.1",
+  type: "action",
+  props: {
+    sonix,
+    mediaId: {
+      propDefinition: [
+        sonix,
+        "mediaId",
+      ],
+    },
+    language: {
+      type: "string",
+      label: "Language",
+      description: "Language code for the translation",
+      options: LANGUAGE_OPTIONS,
+    },
+  },
+  async run({ $ }) {
+    const response = await this.sonix.createTranslation({
+      $,
+      mediaId: this.mediaId,
+      data: {
+        language: this.language,
+      },
+    });
+
+    $.export("$summary", `Successfully created translation for media ID: ${this.mediaId}`);
+    return response;
+  },
+};

package/actions/get-text-transcript/get-text-transcript.mjs

@@ -0,0 +1,23 @@
+import sonix from "../../sonix.app.mjs";
+
+export default {
+  key: "sonix-get-text-transcript",
+  name: "Get Text Transcript",
+  description: "Gets the text transcript of a selected media file. [See the documentation](https://sonix.ai/docs/api#get_transcript)",
+  version: "0.0.1",
+  type: "action",
+  props: {
+    sonix,
+    mediaId: {
+      propDefinition: [
+        sonix,
+        "mediaId",
+      ],
+    },
+  },
+  async run({ $ }) {
+    const response = await this.sonix.getTextTranscript(this.mediaId);
+    $.export("$summary", `Successfully fetched transcript for media ID: ${this.mediaId}`);
+    return response;
+  },
+};

package/actions/upload-media/upload-media.mjs

@@ -0,0 +1,100 @@
+import { ConfigurationError } from "@pipedream/platform";
+import FormData from "form-data";
+import fs from "fs";
+import { LANGUAGE_OPTIONS } from "../../common/constants.mjs";
+import { checkTmp } from "../../common/utils.mjs";
+import sonix from "../../sonix.app.mjs";
+
+export default {
+  key: "sonix-upload-media",
+  name: "Upload Media",
+  description: "Submits new media for processing. [See the documentation](https://sonix.ai/docs/api#new_media)",
+  version: "0.0.1",
+  type: "action",
+  props: {
+    sonix,
+    file: {
+      type: "string",
+      label: "File",
+      description: "Path of the audio or video file in /tmp folder. The limit is 100MB using this parameter. For larger files, use **File URL**. `NOTE: Only one of **File** or **File URL** is required.` To upload a file to /tmp folder, please follow the [doc here](https://pipedream.com/docs/code/nodejs/working-with-files/#writing-a-file-to-tmp)",
+      optional: true,
+    },
+    fileUrl: {
+      type: "string",
+      label: "File URL",
+      description: "URL pointing to the audio/video file. `NOTE: Only one of **File** or **File URL** is required.`",
+      optional: true,
+    },
+    language: {
+      type: "string",
+      label: "Language",
+      description: "Language code for the transcription.",
+      options: LANGUAGE_OPTIONS,
+    },
+    folderId: {
+      propDefinition: [
+        sonix,
+        "folderId",
+      ],
+      optional: true,
+    },
+    name: {
+      type: "string",
+      label: "Name",
+      description: "Name of the file in Sonix. If no name is provided, we will default to the filename.",
+      optional: true,
+    },
+    transcriptText: {
+      type: "boolean",
+      label: "Transcript Text",
+      description: "Existing transcript - if present, will align the transcript rather than transcribing.",
+      optional: true,
+    },
+    keywords: {
+      type: "string[]",
+      label: "Keywords",
+      description: "Comma separated list of words or phrases to use as hints to the transcription engine. If this is provided, then the account level keywords will not be used.",
+      optional: true,
+    },
+    customData: {
+      type: "object",
+      label: "Custom Data",
+      description: "Set of key-value pairs that you can attach to the media. This can be useful for storing additional information about file.",
+      optional: true,
+    },
+    callbackUrl: {
+      type: "string",
+      label: "Callback URL",
+      description: "URL for Sonix to make a POST request notifying of a change in transcript status (either failed or completed). The POST will include the media status JSON.",
+      optional: true,
+    },
+  },
+  async run({ $ }) {
+    if (!this.file && !this.fileUrl) {
+      throw new ConfigurationError("You must provite whether **File** or **File URL**.");
+    }
+
+    const formData = new FormData();
+
+    if (this.file) {
+      const filePath = checkTmp(this.file);
+      formData.append("file", fs.createReadStream(filePath));
+    }
+
+    this.fileUrl && formData.append("file_url", this.fileUrl);
+    this.language && formData.append("language", this.language);
+    this.name && formData.append("name", this.name);
+    this.transcriptText && formData.append("transcript_text", `${this.transcriptText}`);
+    this.folderId && formData.append("folder_id", this.folderId);
+    this.keywords && formData.append("keywords", this.keywords.toString());
+    this.customData && formData.append("custom_data", JSON.stringify(this.customData));
+    this.callbackUrl && formData.append("callback_url", this.callbackUrl);
+
+    const response = await this.sonix.submitNewMedia({
+      data: formData,
+      headers: formData.getHeaders(),
+    });
+    $.export("$summary", `Successfully uploaded media with ID: ${response.id}`);
+    return response;
+  },
+};

package/common/constants.mjs

@@ -0,0 +1,154 @@
+export const LANGUAGE_OPTIONS = [
+  {
+    label: "English",
+    value: "en",
+  },
+  {
+    label: "French",
+    value: "fr",
+  },
+  {
+    label: "German",
+    value: "de",
+  },
+  {
+    label: "Spanish",
+    value: "es",
+  },
+  {
+    label: "Arabic",
+    value: "ar",
+  },
+  {
+    label: "Armenian",
+    value: "hy-AM",
+  },
+  {
+    label: "Bulgarian",
+    value: "bg",
+  },
+  {
+    label: "Catalan",
+    value: "ca",
+  },
+  {
+    label: "Croatian",
+    value: "hr",
+  },
+  {
+    label: "Chinese (Cantonese)",
+    value: "yue-Hant-HK",
+  },
+  {
+    label: "Chinese (Mandarin)",
+    value: "cmn-Hans-CN",
+  },
+  {
+    label: "Czech",
+    value: "cs",
+  },
+  {
+    label: "Danish",
+    value: "da",
+  },
+  {
+    label: "Dutch",
+    value: "nl",
+  },
+  {
+    label: "Finnish",
+    value: "fi",
+  },
+  {
+    label: "Greek",
+    value: "el",
+  },
+  {
+    label: "Hebrew",
+    value: "he-IL",
+  },
+  {
+    label: "Hindi",
+    value: "hi",
+  },
+  {
+    label: "Hungarian",
+    value: "hu",
+  },
+  {
+    label: "Indonesian",
+    value: "id-ID",
+  },
+  {
+    label: "Italian",
+    value: "it",
+  },
+  {
+    label: "Japanese",
+    value: "ja",
+  },
+  {
+    label: "Korean",
+    value: "ko",
+  },
+  {
+    label: "Latvian",
+    value: "lv",
+  },
+  {
+    label: "Lithuanian",
+    value: "lt",
+  },
+  {
+    label: "Malay",
+    value: "ms-MY",
+  },
+  {
+    label: "Norwegian",
+    value: "nb-NO",
+  },
+  {
+    label: "Polish",
+    value: "pl",
+  },
+  {
+    label: "Portuguese",
+    value: "pt",
+  },
+  {
+    label: "Romanian",
+    value: "ro",
+  },
+  {
+    label: "Russian",
+    value: "ru",
+  },
+  {
+    label: "Slovak",
+    value: "sk",
+  },
+  {
+    label: "Slovenian",
+    value: "sl",
+  },
+  {
+    label: "Swedish",
+    value: "sv",
+  },
+  {
+    label: "Thai",
+    value: "th-TH",
+  },
+  {
+    label: "Turkish",
+    value: "tr-TR",
+  },
+  {
+    label: "Ukrainian",
+    value: "uk",
+  },
+  {
+    label: "Vietnamese",
+    value: "vi-VN",
+  },
+];

package/common/utils.mjs

@@ -0,0 +1,6 @@
+export const checkTmp = (filename) => {
+  if (filename.indexOf("/tmp") === -1) {
+    return `/tmp/${filename}`;
+  }
+  return filename;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pipedream/sonix",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "description": "Pipedream Sonix Components",
   "main": "sonix.app.mjs",
   "keywords": [
@@ -11,5 +11,10 @@
   "author": "Pipedream <support@pipedream.com> (https://pipedream.com/)",
   "publishConfig": {
     "access": "public"
+  },
+  "dependencies": {
+    "@pipedream/platform": "^1.5.1",
+    "form-data": "^4.0.0",
+    "fs": "^0.0.1-security"
   }
 }

package/sonix.app.mjs

@@ -1,11 +1,129 @@
+import { axios } from "@pipedream/platform";
+
 export default {
   type: "app",
   app: "sonix",
-  propDefinitions: {},
+  propDefinitions: {
+    folderId: {
+      type: "string",
+      label: "Folder ID",
+      description: "ID of folder to place the media in",
+      async options() {
+        const { folders } = await this.listFolders();
+
+        return folders.map(({
+          id: value, name, email,
+        }) => ({
+          label: name || email,
+          value,
+        }));
+      },
+    },
+    mediaId: {
+      type: "string",
+      label: "Media ID",
+      description: "ID of the media file",
+      async options({ page }) {
+        const { media } = await this.listMedia({
+          params: {
+            page: page + 1,
+            status: "completed",
+          },
+        });
+
+        return media.map(({
+          name: label, id: value,
+        }) => ({
+          label,
+          value,
+        }));
+      },
+    },
+  },
   methods: {
-    // this.$auth contains connected account data
-    authKeys() {
-      console.log(Object.keys(this.$auth));
+    _getApiKey() {
+      return this.$auth.api_key;
+    },
+    _baseUrl() {
+      return "https://api.sonix.ai/v1";
+    },
+    _getHeaders(headers) {
+      return {
+        ...headers,
+        Authorization: `Bearer ${this._getApiKey()}`,
+      };
+    },
+    _makeRequest({
+      $ = this, path, headers, ...otherOpts
+    }) {
+      const config = {
+        ...otherOpts,
+        url: this._baseUrl() + path,
+        headers: this._getHeaders(headers),
+      };
+
+      return axios($, config);
+    },
+    listFolders() {
+      return this._makeRequest({
+        path: "/folders",
+      });
+    },
+    listMedia(opts = {}) {
+      return this._makeRequest({
+        ...opts,
+        path: "/media",
+      });
+    },
+    submitNewMedia(opts = {}) {
+      return this._makeRequest({
+        ...opts,
+        method: "POST",
+        path: "/media",
+      });
+    },
+    getTextTranscript(mediaId) {
+      return this._makeRequest({
+        path: `/media/${mediaId}/transcript`,
+      });
+    },
+    createTranslation({
+      mediaId, ...opts
+    }) {
+      return this._makeRequest({
+        ...opts,
+        method: "POST",
+        path: `/media/${mediaId}/translations`,
+      });
+    },
+    async *paginate({
+      fn, params = {}, maxResults = null,
+    }) {
+      let hasMore = false;
+      let count = 0;
+      let page = 0;
+
+      do {
+        params.page = ++page;
+        const {
+          media,
+          page: currentPage,
+          total_pages: lastPage,
+        } = await fn({
+          params,
+        });
+
+        for (const d of media) {
+          yield d;
+
+          if (maxResults && ++count === maxResults) {
+            return count;
+          }
+        }
+
+        hasMore = currentPage != lastPage;
+
+      } while (hasMore);
     },
   },
-};
+};

package/sources/media-upload-complete/media-upload-complete.mjs

@@ -0,0 +1,66 @@
+import { DEFAULT_POLLING_SOURCE_TIMER_INTERVAL } from "@pipedream/platform";
+import sonix from "../../sonix.app.mjs";
+
+export default {
+  key: "sonix-media-upload-complete",
+  name: "New Media Upload Complete",
+  description: "Emit new event any time the media status of an item changes to completed.",
+  version: "0.0.1",
+  type: "source",
+  dedupe: "unique",
+  props: {
+    sonix,
+    db: "$.service.db",
+    timer: {
+      type: "$.interface.timer",
+      default: {
+        intervalSeconds: DEFAULT_POLLING_SOURCE_TIMER_INTERVAL,
+      },
+    },
+  },
+  methods: {
+    _getLastDate() {
+      return this.db.get("lastDate") ?? 0;
+    },
+    _setLastDate(status) {
+      this.db.set("lastDate", status);
+    },
+    async startEvent(maxResults = 0) {
+      const lastDate = this._getLastDate();
+      const items = this.sonix.paginate({
+        fn: this.sonix.listMedia,
+        maxResults,
+        params: {
+          status: "completed",
+        },
+      });
+
+      let responseArray = [];
+
+      for await (const item of items) {
+        if (new Date(item.created_at) <= new Date(lastDate)) break;
+        responseArray.push(item);
+      }
+      if (responseArray.length) this._setLastDate(responseArray[0].created_at);
+
+      for (const item of responseArray.reverse()) {
+        this.$emit(
+          item,
+          {
+            id: item.id,
+            summary: `Media upload completed: ${item.name}`,
+            ts: Date.parse(item.created_at),
+          },
+        );
+      }
+    },
+  },
+  hooks: {
+    async deploy() {
+      await this.startEvent(25);
+    },
+  },
+  async run() {
+    await this.startEvent();
+  },
+};