Get Translation Result

import requests

# Your API authentication
headers = {
    "x-api-key": "your-api-key",  # Replace with your actual API key
}

# The run_id from your completed translation task
run_id = 12345  # Replace with your actual run ID

# Retrieve the translations
response = requests.get(
    f"https://client.camb.ai/apis/translation-result/{run_id}",
    headers=headers
)

# Check if the request was successful
response.raise_for_status()

# Extract the translations
result_data = response.json()
translations = result_data["texts"]

# Use the translations in your application
for i, translation in enumerate(translations):
    print(f"Translation {i+1}: {translation}")

# Assuming you've stored your original texts
original_texts = [
    "This is the first sentence to translate.",
    "Here is the second one.",
    "And finally, the third sentence."
]

# And you've retrieved the translations as shown above
translations = result_data["texts"]

# Create parallel display
for original, translated in zip(original_texts, translations):
    print("Original: " + original)
    print("Translated: " + translated)
    print("---")

import sqlite3

# Set up database connection (replace with your actual database logic)
conn = sqlite3.connect("translations.db")
cursor = conn.cursor()

# Create table if it doesn't exist
cursor.execute("""
CREATE TABLE IF NOT EXISTS translations (
    id INTEGER PRIMARY KEY,
    original_text TEXT,
    translated_text TEXT,
    source_language INTEGER,
    target_language INTEGER,
    translation_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP
)
""")

# Insert translations into database
for original, translated in zip(original_texts, translations):
    cursor.execute(
        "INSERT INTO translations (original_text, translated_text, source_language, target_language) VALUES (?, ?, ?, ?)",
        (original, translated, 1, 2)  # Replace with your actual language codes
    )

# Commit the changes
conn.commit()
conn.close()

import requests
import time

def get_translation_result(run_id, api_key, max_retries=3, retry_delay=2):
    """
    Retrieve translation results with retry logic for better reliability.
    
    Parameters:
    -----------
    run_id : str
        The run identifier for the completed translation task
    api_key : str
        Your API authentication key
    max_retries : int
        Maximum number of retry attempts if the request fails
    retry_delay : int
        Initial delay between retries in seconds (doubles after each retry)
    
    Returns:
    --------
    list
        Array of translated texts if successful, None otherwise
    """
    headers = {
        "x-api-key": api_key,
        "Content-Type": "application/json"
    }
    
    url = f"https://client.camb.ai/apis/translation-result/{run_id}"
    
    # Initialize retry counter
    retries = 0
    current_delay = retry_delay
    
    while retries <= max_retries:
        try:
            response = requests.get(url, headers=headers)
            
            # If successful, return the translations
            if response.status_code == 200:
                result_data = response.json()
                return result_data.get("texts", [])
            
            # If the run_id is invalid or results expired
            elif response.status_code == 404:
                print(f"Translation results not found for run_id: {run_id}")
                print("This could mean the run_id is invalid or the results have expired.")
                return None
            
            # If server error, retry after delay
            elif response.status_code >= 500:
                if retries < max_retries:
                    print(f"Server error occurred. Retrying in {current_delay} seconds...")
                    time.sleep(current_delay)
                    current_delay *= 2  # Exponential backoff
                    retries += 1
                    continue
                else:
                    print("Maximum retries reached. Please try again later.")
                    return None
            
            # Handle other errors
            else:
                print(f"Error retrieving translations: HTTP {response.status_code}")
                print(f"Response: {response.text}")
                return None
                
        except requests.exceptions.RequestException as e:
            if retries < max_retries:
                print(f"Connection error: {str(e)}. Retrying in {current_delay} seconds...")
                time.sleep(current_delay)
                current_delay *= 2
                retries += 1
                continue
            else:
                print(f"Connection error after {max_retries} retries: {str(e)}")
                return None
    
    return None