@pipedream/sonix 0.0.1 → 1.0.0

package/README.md

@@ -0,0 +1,11 @@
+# Overview
+
+The Sonix API enables automated transcription of audio and video files into text, offering functions like uploading media, managing files, and retrieving transcripts. Leveraging Pipedream’s capabilities, you can integrate the Sonix API with various services to streamline media processing workflows, making transcription tasks more efficient. By automating interactions with Sonix, you can trigger actions based on the transcription status, analyze content, and connect transcribed text with other apps for further processing or analysis.
+
+# Example Use Cases
+
+- **Transcription Triggered from Cloud Storage Upload**: When a new audio file is uploaded to cloud storage (e.g., Google Drive), Pipedream detects the event and triggers a workflow that uploads the file to Sonix for transcription. Once the transcript is ready, it can be saved back to Google Drive or sent via email.
+
+- **Media Management with Slack Notifications**: Use Pipedream to monitor your Sonix account for new transcripts. When a transcript is completed, send a notification with details and a download link to a designated Slack channel. This keeps the team updated on transcription progress in real-time without manual checks.
+
+- **Content Analysis and Keyword Extraction**: After a transcript is generated, a workflow can pass the text to a natural language processing (NLP) service, like the Google Cloud Language API, to extract keywords and analyze sentiment. The results could then be sent to a Google Sheet for tracking trends over time.

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,90 @@
+import { getFileStreamAndMetadata } from "@pipedream/platform";
+import FormData from "form-data";
+import { LANGUAGE_OPTIONS } from "../../common/constants.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: "1.0.0",
+  type: "action",
+  props: {
+    sonix,
+    file: {
+      type: "string",
+      label: "File Path or URL",
+      description: "The audio or video file to upload (max 100MB). Provide either a file URL or a path to a file in the `/tmp` directory (for example, `/tmp/myFile.txt`)",
+    },
+    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({ $ }) {
+    const formData = new FormData();
+
+    const {
+      stream, metadata,
+    } = await getFileStreamAndMetadata(this.file);
+    formData.append("file", stream, {
+      contentType: metadata.contentType,
+      knownLength: metadata.size,
+      filename: metadata.name,
+    });
+
+    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": "1.0.0",
   "description": "Pipedream Sonix Components",
   "main": "sonix.app.mjs",
   "keywords": [
@@ -11,5 +11,9 @@
   "author": "Pipedream <support@pipedream.com> (https://pipedream.com/)",
   "publishConfig": {
     "access": "public"
+  },
+  "dependencies": {
+    "@pipedream/platform": "^3.1.0",
+    "form-data": "^4.0.0"
   }
 }

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();
+  },
+};