valenceai 0.4.0

package/src/config.js

@@ -0,0 +1,36 @@
+import dotenv from 'dotenv';
+dotenv.config();
+
+/**
+ * Configuration object for the Valence SDK
+ * Loads settings from environment variables with sensible defaults
+ */
+export const config = {
+  apiKey: process.env.VALENCE_API_KEY,
+  discreteAudioUrl: process.env.VALENCE_DISCRETE_URL || 'https://xc8n2bo4f0.execute-api.us-west-2.amazonaws.com/emotionprediction',
+  asyncAudioUrl: process.env.VALENCE_ASYNC_URL || 'https://wsgol61783.execute-api.us-west-2.amazonaws.com/prod',
+  logLevel: process.env.VALENCE_LOG_LEVEL || 'info',
+};
+
+/**
+ * Validates the current configuration
+ * @throws {Error} If required configuration is missing or invalid
+ */
+export function validateConfig() {
+  if (!config.apiKey) {
+    throw new Error('VALENCE_API_KEY environment variable is required');
+  }
+  
+  if (!config.discreteAudioUrl || !config.discreteAudioUrl.startsWith('https://')) {
+    throw new Error('VALENCE_DISCRETE_URL must be a valid HTTPS URL');
+  }
+  
+  if (!config.asyncAudioUrl || !config.asyncAudioUrl.startsWith('https://')) {
+    throw new Error('VALENCE_ASYNC_URL must be a valid HTTPS URL');
+  }
+  
+  const validLogLevels = ['debug', 'info', 'warn', 'error'];
+  if (!validLogLevels.includes(config.logLevel)) {
+    throw new Error(`VALENCE_LOG_LEVEL must be one of: ${validLogLevels.join(', ')}`);
+  }
+}

package/src/discreteAudio.js

@@ -0,0 +1,61 @@
+import axios from 'axios';
+import { getHeaders } from './client.js';
+import { config } from './config.js';
+import { log } from './utils/logger.js';
+import fs from 'fs';
+import FormData from 'form-data';
+
+/**
+ * Predicts emotions for discrete (short) audio files
+ * @param {string} filePath - Path to the audio file
+ * @param {string} model - Model type ('4emotions' or '7emotions')
+ * @returns {Promise<Object>} Emotion prediction results
+ * @throws {Error} If file doesn't exist, API key missing, or request fails
+ */
+export async function predictDiscreteAudioEmotion(filePath, model = '4emotions') {
+  // Validation
+  if (!filePath || typeof filePath !== 'string') {
+    throw new Error('filePath is required and must be a string');
+  }
+  
+  if (!['4emotions', '7emotions'].includes(model)) {
+    throw new Error('model must be either "4emotions" or "7emotions"');
+  }
+  
+  if (!config.apiKey) {
+    throw new Error('VALENCE_API_KEY is required');
+  }
+  
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`File not found: ${filePath}`);
+  }
+  
+  log(`Predicting emotions for ${filePath} using ${model} model`, 'info');
+  
+  try {
+    const formData = new FormData();
+    formData.append('file', fs.createReadStream(filePath));
+    const url = `${config.discreteAudioUrl}?model=${model}`;
+    
+    const response = await axios.post(url, formData, {
+      headers: {
+        ...getHeaders(),
+        ...formData.getHeaders()
+      },
+      timeout: 30000 // 30 second timeout
+    });
+    
+    log('Emotion prediction completed successfully', 'info');
+    return response.data;
+  } catch (error) {
+    log(`Error predicting emotions: ${error.message}`, 'error');
+    
+    if (error.response) {
+      throw new Error(`API error (${error.response.status}): ${error.response.data?.message || error.response.statusText}`);
+    } else if (error.request) {
+      throw new Error('Network error: Unable to reach the API');
+    } else {
+      throw new Error(`Request error: ${error.message}`);
+    }
+  }
+}

package/src/index.js

@@ -0,0 +1,2 @@
+export { ValenceClient } from './valenceClient.js';
+export { validateConfig } from './config.js';

package/src/utils/logger.js

@@ -0,0 +1,16 @@
+/**
+ * Simple logger function controlled by VALENCE_LOG_LEVEL environment variable
+ * @param {string} message - Message to log
+ * @param {string} level - Log level ('debug', 'info', 'warn', 'error')
+ */
+export function log(message, level = 'info') {
+  const logLevel = process.env.VALENCE_LOG_LEVEL || 'info';
+  const levels = { debug: 0, info: 1, warn: 2, error: 3 };
+  const currentLevel = levels[logLevel] || 1;
+  const messageLevel = levels[level] || 1;
+  
+  if (messageLevel >= currentLevel) {
+    const timestamp = new Date().toISOString();
+    console.log(`[${timestamp}] [${level.toUpperCase()}] ${message}`);
+  }
+}

package/src/valenceClient.js

@@ -0,0 +1,256 @@
+import axios from 'axios';
+import fs from 'fs';
+import FormData from 'form-data';
+import { config } from './config.js';
+import { getHeaders } from './client.js';
+import { log } from './utils/logger.js';
+
+/**
+ * Client for discrete (short) audio processing
+ */
+class DiscreteClient {
+  constructor() {}
+
+  /**
+   * Get emotions for discrete (short) audio files
+   * @param {string} filePath - Path to the audio file
+   * @param {string} model - Model type ('4emotions' or '7emotions')
+   * @returns {Promise<Object>} Emotion prediction results
+   * @throws {Error} If file doesn't exist, API key missing, or request fails
+   */
+  async emotions(filePath, model = '4emotions') {
+    // Validation
+    if (!filePath || typeof filePath !== 'string') {
+      throw new Error('filePath is required and must be a string');
+    }
+    
+    if (!['4emotions', '7emotions'].includes(model)) {
+      throw new Error('model must be either "4emotions" or "7emotions"');
+    }
+    
+    if (!config.apiKey) {
+      throw new Error('VALENCE_API_KEY is required');
+    }
+    
+    if (!fs.existsSync(filePath)) {
+      throw new Error(`File not found: ${filePath}`);
+    }
+    
+    log(`Getting emotions for discrete audio: ${filePath} using ${model} model`, 'info');
+    
+    try {
+      const formData = new FormData();
+      formData.append('file', fs.createReadStream(filePath));
+      const url = `${config.discreteAudioUrl}?model=${model}`;
+      
+      const response = await axios.post(url, formData, {
+        headers: {
+          ...getHeaders(),
+          ...formData.getHeaders()
+        },
+        timeout: 30000 // 30 second timeout
+      });
+      
+      log('Discrete emotion prediction completed successfully', 'info');
+      return response.data;
+    } catch (error) {
+      log(`Error getting discrete emotions: ${error.message}`, 'error');
+      
+      if (error.response) {
+        throw new Error(`API error (${error.response.status}): ${error.response.data?.message || error.response.statusText}`);
+      } else if (error.request) {
+        throw new Error('Network error: Unable to reach the API');
+      } else {
+        throw new Error(`Request error: ${error.message}`);
+      }
+    }
+  }
+}
+
+/**
+ * Client for async (long) audio processing
+ */
+class AsyncClient {
+  constructor(partSize = 5 * 1024 * 1024, maxRetries = 3) {
+    this.partSize = partSize;
+    this.maxRetries = maxRetries;
+  }
+
+  /**
+   * Upload async (long) audio files using multipart upload
+   * @param {string} filePath - Path to the audio file
+   * @returns {Promise<string>} Request ID for tracking the upload
+   * @throws {Error} If file doesn't exist, API key missing, or upload fails
+   */
+  async upload(filePath) {
+    // Validation
+    if (!filePath || typeof filePath !== 'string') {
+      throw new Error('filePath is required and must be a string');
+    }
+    
+    if (!config.apiKey) {
+      throw new Error('VALENCE_API_KEY is required');
+    }
+    
+    if (!fs.existsSync(filePath)) {
+      throw new Error(`File not found: ${filePath}`);
+    }
+    
+    if (this.partSize < 1024 * 1024 || this.partSize > 100 * 1024 * 1024) {
+      throw new Error('partSize must be between 1MB and 100MB');
+    }
+    
+    log(`Starting async audio upload for ${filePath}`, 'info');
+    
+    try {
+      const fileSize = fs.statSync(filePath).size;
+      const partCount = Math.ceil(fileSize / this.partSize);
+      const initiateUrl = `${config.asyncAudioUrl}/upload/initiate`;
+
+      log(`File size: ${fileSize} bytes, parts: ${partCount}`, 'debug');
+
+      const { data } = await axios.get(initiateUrl, {
+        headers: getHeaders(),
+        params: { file_name: filePath.split('/').pop(), part_count: partCount },
+        timeout: 30000
+      });
+
+      const fileStream = fs.createReadStream(filePath, { highWaterMark: this.partSize });
+      const parts = [];
+      let index = 0;
+
+      for await (const chunk of fileStream) {
+        if (!data.presigned_urls || !data.presigned_urls[index]) {
+          throw new Error(`Missing presigned URL for part ${index + 1}`);
+        }
+        
+        const part = data.presigned_urls[index];
+        const partNumber = part.part_number;
+        const url = part.url;
+
+        log(`Uploading part ${index + 1}/${partCount}`, 'debug');
+
+        const res = await axios.put(url, chunk, {
+          headers: { 'Content-Length': chunk.length },
+          timeout: 60000 // 1 minute timeout for each part
+        });
+
+        if (!res.headers.etag) {
+          throw new Error(`Failed to get ETag for part ${partNumber}`);
+        }
+
+        parts.push({ ETag: res.headers.etag, PartNumber: partNumber });
+        index++;
+      }
+
+      log('All parts uploaded, completing multipart upload', 'info');
+
+      const completeUrl = `${config.asyncAudioUrl}/upload/complete`;
+      await axios.post(completeUrl, {
+        request_id: data.request_id,
+        upload_id: data.upload_id,
+        parts: parts.sort((a, b) => a.PartNumber - b.PartNumber)
+      }, {
+        headers: getHeaders(),
+        timeout: 30000
+      });
+
+      log(`Async audio upload completed. Request ID: ${data.request_id}`, 'info');
+      return data.request_id;
+    } catch (error) {
+      log(`Error uploading async audio: ${error.message}`, 'error');
+      
+      if (error.response) {
+        throw new Error(`API error (${error.response.status}): ${error.response.data?.message || error.response.statusText}`);
+      } else if (error.request) {
+        throw new Error('Network error: Unable to reach the API');
+      } else {
+        throw new Error(`Upload error: ${error.message}`);
+      }
+    }
+  }
+
+  /**
+   * Get emotion prediction results for async audio processing
+   * @param {string} requestId - Request ID from upload method
+   * @param {number} maxAttempts - Maximum polling attempts (default: 20)
+   * @param {number} intervalSeconds - Polling interval in seconds (default: 5)
+   * @returns {Promise<Object>} Emotion prediction results
+   * @throws {Error} If requestId is invalid or prediction times out
+   */
+  async emotions(requestId, maxAttempts = 20, intervalSeconds = 5) {
+    // Validation
+    if (!requestId || typeof requestId !== 'string') {
+      throw new Error('requestId is required and must be a string');
+    }
+    
+    if (!config.apiKey) {
+      throw new Error('VALENCE_API_KEY is required');
+    }
+    
+    if (maxAttempts < 1 || maxAttempts > 100) {
+      throw new Error('maxAttempts must be between 1 and 100');
+    }
+    
+    if (intervalSeconds < 1 || intervalSeconds > 60) {
+      throw new Error('intervalSeconds must be between 1 and 60');
+    }
+    
+    log(`Starting emotion prediction polling for request ${requestId}`, 'info');
+    
+    const url = `${config.asyncAudioUrl}/prediction`;
+    const intervalMs = intervalSeconds * 1000;
+
+    for (let i = 0; i < maxAttempts; i++) {
+      try {
+        log(`Polling attempt ${i + 1}/${maxAttempts}`, 'debug');
+        
+        const res = await axios.get(url, {
+          headers: getHeaders(),
+          params: { request_id: requestId },
+          timeout: 15000
+        });
+
+        if (res.status === 200 && res.data) {
+          log(`Emotions retrieved for request ID: ${requestId}`, 'info');
+          return res.data;
+        }
+        
+        if (res.status === 202) {
+          log('Prediction still processing, waiting...', 'debug');
+        }
+        
+      } catch (error) {
+        if (error.response?.status === 404) {
+          throw new Error(`Request ID not found: ${requestId}`);
+        } else if (error.response?.status >= 400 && error.response?.status < 500) {
+          throw new Error(`Client error (${error.response.status}): ${error.response.data?.message || error.response.statusText}`);
+        }
+        
+        log(`Polling error (attempt ${i + 1}): ${error.message}`, 'warn');
+      }
+      
+      if (i < maxAttempts - 1) {
+        await new Promise(resolve => setTimeout(resolve, intervalMs));
+      }
+    }
+
+    throw new Error(`Prediction not available after ${maxAttempts} attempts. The request may still be processing.`);
+  }
+}
+
+/**
+ * Main client for Valence API with nested discrete and async clients
+ */
+export class ValenceClient {
+  /**
+   * Initialize the Valence client
+   * @param {number} partSize - Size of each part in bytes for async uploads (default: 5MB)
+   * @param {number} maxRetries - Maximum retry attempts for async uploads (default: 3)
+   */
+  constructor(partSize = 5 * 1024 * 1024, maxRetries = 3) {
+    // Initialize nested clients
+    this.discrete = new DiscreteClient();
+    this.asynch = new AsyncClient(partSize, maxRetries);
+  }
+}