API Reference

import os
import time
import requests
from typing import Optional

class NoLangAPI:
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = "https://api.no-lang.com/v1"
        self.headers = {"Authorization": f"Bearer {api_key}"}

    def generate_video_from_text(self, video_setting_id: str, text: str) -> dict:
        """Generate a video from text"""
        url = f"{self.base_url}/videos/generate/"
        data = {
            "video_setting_id": video_setting_id,
            "text": text
        }
        response = requests.post(url, headers=self.headers, data=data)
        response.raise_for_status()
        return response.json()

    def generate_video_from_pdf(self, video_setting_id: str, pdf_path: str) -> dict:
        """Generate a video from a PDF"""
        url = f"{self.base_url}/videos/generate/"
        data = {"video_setting_id": video_setting_id}
        files = {"pdf_file": open(pdf_path, "rb")}
        response = requests.post(url, headers=self.headers, data=data, files=files)
        response.raise_for_status()
        return response.json()

    def get_video_status(self, video_id: str) -> dict:
        """Retrieve the status of a video"""
        url = f"{self.base_url}/videos/{video_id}/"
        response = requests.get(url, headers=self.headers)
        response.raise_for_status()
        return response.json()

    def get_convert_options(self, video_id: str) -> dict:
        """Retrieve whether a video can be converted and the values you can convert it to"""
        url = f"{self.base_url}/videos/{video_id}/conversions/"
        response = requests.get(url, headers=self.headers)
        response.raise_for_status()
        return response.json()

    def convert_video(
        self,
        video_id: str,
        language: Optional[str] = None,
        aspect_ratio: Optional[str] = None,
    ) -> dict:
        """Generate a new video by converting an existing video to another language or aspect ratio"""
        url = f"{self.base_url}/videos/{video_id}/conversions/"
        payload = {}
        if language:
            payload["language"] = language
        if aspect_ratio:
            payload["aspect_ratio"] = aspect_ratio
        response = requests.post(url, headers=self.headers, json=payload)
        response.raise_for_status()
        return response.json()

    def wait_for_completion(self, video_id: str, timeout: int = 600) -> Optional[str]:
        """Wait for video generation to finish and return the download URL"""
        start_time = time.time()
        while time.time() - start_time < timeout:
            status_data = self.get_video_status(video_id)
            if status_data["status"] == "completed":
                return status_data["download_url"]
            elif status_data["status"] == "failed":
                raise Exception("Video generation failed")
            time.sleep(10)  # Poll every 10 seconds
        raise TimeoutError("Video generation timed out")

# Example usage
api = NoLangAPI(os.environ["NOLANG_API_KEY"])

# Generate a video from text
result = api.generate_video_from_text(
    video_setting_id="123e4567-e89b-12d3-a456-426614174000",
    text="Let's learn the basics of Python programming"
)
print(f"Video ID: {result['video_id']}")

# Wait for completion and download
download_url = api.wait_for_completion(result['video_id'])
print(f"Download URL: {download_url}")

# Convert the generated video to English + vertical (9:16)
options = api.get_convert_options(result['video_id'])
if options["is_convertible"] and "en" in options["available_languages"]:
    converted = api.convert_video(result['video_id'], language="en", aspect_ratio="9:16")
    converted_url = api.wait_for_completion(converted['video_id'])
    print(f"Converted URL: {converted_url}")

const axios = require('axios');
const FormData = require('form-data');
const fs = require('fs');

class NoLangAPI {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseUrl = 'https://api.no-lang.com/v1';
    this.headers = { 'Authorization': `Bearer ${apiKey}` };
  }

  async generateVideoFromText(videoSettingId, text) {
    const formData = new FormData();
    formData.append('video_setting_id', videoSettingId);
    formData.append('text', text);

    const response = await axios.post(
      `${this.baseUrl}/videos/generate/`,
      formData,
      {
        headers: {
          ...this.headers,
          ...formData.getHeaders()
        }
      }
    );
    return response.data;
  }

  async generateVideoFromPDF(videoSettingId, pdfPath) {
    const formData = new FormData();
    formData.append('video_setting_id', videoSettingId);
    formData.append('pdf_file', fs.createReadStream(pdfPath));

    const response = await axios.post(
      `${this.baseUrl}/videos/generate/`,
      formData,
      {
        headers: {
          ...this.headers,
          ...formData.getHeaders()
        }
      }
    );
    return response.data;
  }

  async getVideoStatus(videoId) {
    const response = await axios.get(
      `${this.baseUrl}/videos/${videoId}/`,
      { headers: this.headers }
    );
    return response.data;
  }

  async getConvertOptions(videoId) {
    const response = await axios.get(
      `${this.baseUrl}/videos/${videoId}/conversions/`,
      { headers: this.headers }
    );
    return response.data;
  }

  async convertVideo(videoId, { language, aspectRatio } = {}) {
    const payload = {};
    if (language) payload.language = language;
    if (aspectRatio) payload.aspect_ratio = aspectRatio;

    const response = await axios.post(
      `${this.baseUrl}/videos/${videoId}/conversions/`,
      payload,
      {
        headers: {
          ...this.headers,
          'Content-Type': 'application/json'
        }
      }
    );
    return response.data;
  }

  async waitForCompletion(videoId, timeout = 600000) {
    const startTime = Date.now();

    while (Date.now() - startTime < timeout) {
      const status = await this.getVideoStatus(videoId);

      if (status.status === 'completed') {
        return status.download_url;
      } else if (status.status === 'failed') {
        throw new Error('Video generation failed');
      }

      // Wait 10 seconds
      await new Promise(resolve => setTimeout(resolve, 10000));
    }

    throw new Error('Video generation timed out');
  }
}

// Example usage
(async () => {
  const api = new NoLangAPI(process.env.NOLANG_API_KEY);

  try {
    // Generate a video from text
    const result = await api.generateVideoFromText(
      '123e4567-e89b-12d3-a456-426614174000',
      "Explain asynchronous processing in JavaScript"
    );

    console.log(`Video ID: ${result.video_id}`);

    // Wait for completion
    const downloadUrl = await api.waitForCompletion(result.video_id);
    console.log(`Download URL: ${downloadUrl}`);

    // Convert the generated video to English + vertical (9:16)
    const options = await api.getConvertOptions(result.video_id);
    if (options.is_convertible && options.available_languages.includes('en')) {
      const converted = await api.convertVideo(result.video_id, {
        language: 'en',
        aspectRatio: '9:16'
      });
      const convertedUrl = await api.waitForCompletion(converted.video_id);
      console.log(`Converted URL: ${convertedUrl}`);
    }

  } catch (error) {
    console.error('Error:', error.message);
  }
})();