NanoGPT

## OpenAI compatible streaming example

import requests
import json

BASE_URL = "https://nano-gpt.com/api/v1"
API_KEY = "YOUR_API_KEY"  # Replace with your API key

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
    "Accept": "text/event-stream"  # Required for SSE streaming
}


def stream_chat_completion(messages, model="chatgpt-4o-latest"):
    """
    Send a streaming chat completion request using the OpenAI-compatible endpoint.

    Args:
        messages (list): List of message dictionaries with 'role' and 'content'
        model (str): Model to use for completion
    """
    data = {
        "model": model,
        "messages": messages,
        "stream": True  # Enable streaming
    }

    # Make streaming request
    response = requests.post(
        f"{BASE_URL}/chat/completions",
        headers=headers,
        json=data,
        stream=True  # Enable streaming in requests
    )

    if response.status_code != 200:
        raise Exception(f"Error: {response.status_code}")

    # Process the streaming response
    for line in response.iter_lines():
        if line:
            # Remove "data: " prefix
            line = line.decode('utf-8')
            if line.startswith('data: '):
                line = line[6:]

            # Skip "[DONE]" message
            if line == '[DONE]':
                break

            try:
                # Parse the JSON data
                chunk = json.loads(line)
                # Extract the content delta if it exists
                if chunk['choices'][0]['delta'].get('content'):
                    yield chunk['choices'][0]['delta']['content']
            except json.JSONDecodeError:
                continue


if __name__ == "__main__":
    # Create messages in OpenAI format
    messages = [
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Please explain the concept of artificial intelligence."}
    ]

    try:
        print("Assistant's Response:")
        # Stream the response
        for content_chunk in stream_chat_completion(messages):
            print(content_chunk, end='', flush=True)
        print("")

    except Exception as e:
        print(f"Error: {str(e)}")

## OpenAI compatible non-streaming example

import requests
import json

BASE_URL = "https://nano-gpt.com/api/v1"
API_KEY = "YOUR_API_KEY"  # Replace with your API key

def non_streaming_chat_completion(messages, model="chatgpt-4o-latest"):
    """
    Send a non-streaming chat completion request using the OpenAI-compatible endpoint.

    Args:
        messages (list): List of message dictionaries with 'role' and 'content'
        model (str): Model to use for completion
        
    Returns:
        dict: The complete response from the API
    """
    data = {
        "model": model,
        "messages": messages,
        "stream": False  # Disable streaming
    }
    
    # Define headers without streaming requirement
    non_stream_headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json"
    }

    # Make non-streaming request
    response = requests.post(
        f"{BASE_URL}/chat/completions",
        headers=non_stream_headers,
        json=data
    )

    if response.status_code != 200:
        raise Exception(f"Error: {response.status_code}, {response.text}")
    
    # Return the complete JSON response
    return response.json()


if __name__ == "__main__":
    # Create messages in OpenAI format
    messages = [
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Please explain the concept of artificial intelligence."}
    ]

    try:
        print("Non-streaming Response:")
        # Get the complete response
        response = non_streaming_chat_completion(messages)
        # Print the full response structure
        print("Complete API Response:")
        print(json.dumps(response, indent=2))
        
        # Also print just the content for convenience
        if 'choices' in response and len(response['choices']) > 0:
            print("\nAssistant's Message Content:")
            print(response['choices'][0]['message']['content'])

    except Exception as e:
        print(f"Error: {str(e)}")

import requests
import json

NANOGPT_API_BASE_URL = 'https://nano-gpt.com/api/v1/'
NANOGPT_API_MODELS = NANOGPT_API_BASE_URL + 'models'

API_KEY = "YOUR_API_KEY"  # Replace with your API key

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json"
}


def get_models():
    print("Retrieving available models...")
    try:
        response = requests.get(NANOGPT_API_MODELS, headers=headers)
        response.raise_for_status()
        models_data = response.json()
        print("Models data retrieved successfully")
        return models_data
    except requests.RequestException as e:
        print(f"Error retrieving models: {e}")
        if hasattr(e, 'response') and e.response is not None:
            print(f"Response status code: {e.response.status_code}")
            print(f"Response content: {e.response.text}")
        return None


# Example usage
if __name__ == "__main__":
    models_data = get_models()
    if models_data:
        print("Models data:")
        print(json.dumps(models_data, indent=2))

        # The response follows OpenAI's format:
        # {
        #   "object": "list",
        #   "data": [
        #     {
        #       "id": "model-id",
        #       "object": "model",
        #       "created": 1234567890,
        #       "owned_by": "organization-owner"
        #     },
        #     ...
        #   ]
        # }

#!/usr/bin/env python3
"""
TEE Attestation & Signature Verification Example for NanoGPT.
"""
import requests
import json
import hashlib
from cryptography import x509
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.backends import default_backend
import base64
try:
    from eth_account.messages import encode_defunct
    from eth_account.account import Account
except ImportError:
    raise ImportError("Please install eth_account: pip install eth-account")
import os
from cryptography.x509.oid import ObjectIdentifier  # if needed

# Hardcoded configuration - set your values here or even better use env vars!
API_KEY = "INSERT_API_KEY_HERE"
BASE_URL = "https://nano-gpt.com/api"  # Production base URL
MODEL = "TEE/hermes-3-llama-3.1-70b"

def fetch_attestation(base_url, api_key, model):
    url = f"{base_url}/v1/tee/attestation"
    headers = {"Authorization": f"Bearer {api_key}"}
    # generate challenge nonce to prevent replay attacks
    nonce = base64.b64encode(os.urandom(16)).decode()
    params = {"model": model, "nonce": nonce}
    resp = requests.get(url, headers=headers, params=params)
    print("=== Attestation Report ===")
    print(f"Status: {resp.status_code}")
    try:
        data = resp.json()
        print(json.dumps(data, indent=2))
    except ValueError:
        print(resp.text)
        data = None
    # verify the nonce was echoed back
    if data and data.get("nonce") != nonce:
        raise Exception(f"Nonce mismatch! Expected {nonce}, got {data.get('nonce')}")
    print("Nonce successfully verified.")
    return data


def chat_completion(base_url, api_key, model, stream=False):
    url = f"{base_url}/v1/chat/completions"
    headers = {
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    }
    payload = {
        "model": model,
        "stream": stream,
        "messages": [
            {"role": "system", "content": "You are a helpful assistant."},
            {"role": "user",   "content": "What is your model name?"}
        ]
    }
    if stream:
        resp = requests.post(url, headers=headers, json=payload, stream=True)
        print("=== Streaming Chat Completion ===")
        request_id = None
        for line in resp.iter_lines(decode_unicode=True):
            if line.startswith("data: "):
                data_str = line[len("data: "):]
                if data_str == "[DONE]":
                    print("[DONE]")
                    break
                chunk = json.loads(data_str)
                print(json.dumps(chunk, indent=2))
                if not request_id and "id" in chunk:
                    request_id = chunk["id"]
        return request_id
    else:
        payload_str = json.dumps(payload, separators=(",", ":"), ensure_ascii=False)
        req_hash = hashlib.sha256(payload_str.encode("utf-8")).hexdigest()
        resp = requests.post(url, headers=headers, json=payload)
        resp_text = resp.text
        resp_hash = hashlib.sha256(resp_text.encode("utf-8")).hexdigest()
        print("=== Chat Completion ===")
        print("Request Payload Hash:", req_hash)
        print(resp_text)
        print("Response Body Hash:", resp_hash)
        result = json.loads(resp_text)
        return {"id": result.get("id"), "request_hash": req_hash, "response_hash": resp_hash}


def fetch_signature(base_url, api_key, model, request_id, algo="ecdsa"):
    url = f"{base_url}/v1/tee/signature/{request_id}"
    headers = {"Authorization": f"Bearer {api_key}"}
    params = {"model": model, "signing_algo": algo}
    resp = requests.get(url, headers=headers, params=params)
    print("=== Signature ===")
    print(f"Status: {resp.status_code}")
    try:
        data = resp.json()
        print(json.dumps(data, indent=2))
    except ValueError:
        print(resp.text)
        data = None
    return data


def verify_signature(signing_address, message, signature_hex):
    print("=== Verifying Signature ===")
    # Use eth_account for ECDSA recovery with Ethereum prefixed message
    signature = signature_hex if signature_hex.startswith("0x") else "0x" + signature_hex
    msg = encode_defunct(text=message)
    recovered = Account.recover_message(msg, signature=signature)
    if recovered.lower() == signing_address.lower():
        print("Signature verification succeeded.")
    else:
        raise Exception(f"Signature verification failed: expected address {signing_address}, got {recovered}")


def verify_nvidia_attestation(nvidia_payload):
    print("=== Verifying NVIDIA Attestation via NVIDIA Attestation Service ===")
    # ensure payload is a dict
    payload_json = json.loads(nvidia_payload) if isinstance(nvidia_payload, str) else nvidia_payload
    url = "https://nras.attestation.nvidia.com/v3/attest/gpu"
    headers = {"accept": "application/json", "content-type": "application/json"}
    resp = requests.post(url, headers=headers, json=payload_json)
    print(f"Status: {resp.status_code}")
    try:
        result = resp.json()
        print(json.dumps(result, indent=2))
    except ValueError:
        print(resp.text)
        result = None
    if resp.status_code != 200:
        raise Exception(f"NVIDIA attestation verification failed with status {resp.status_code}")
    print("NVIDIA attestation verified successfully.")


# Helpers for enclave identity pinning
def verify_enclave_identity(reported, expected, label):
    print(f"=== Verifying {label} ===")
    if not reported or not expected:
        raise Exception(f"Missing reported or expected {label}")
    if reported.lower() != expected.lower():
        raise Exception(f"{label} mismatch: expected {expected}, got {reported}")
    print(f"{label} matches expected value.")


def parse_nvidia_measurement(nvidia_payload):
    payload = json.loads(nvidia_payload) if isinstance(nvidia_payload, str) else nvidia_payload
    if "evidence" in payload:
        b64 = payload["evidence"]
    elif payload.get("evidence_list") and "evidence" in payload["evidence_list"][0]:
        b64 = payload["evidence_list"][0]["evidence"]
    else:
        raise Exception("no evidence field for NVIDIA payload")
    q = base64.b64decode(b64)
    body = q[48:48+384]
    return body[48:80].hex(), body[112:144].hex()


def parse_intel_measurement(intel_quote):
    qb = bytes.fromhex(intel_quote)
    body = qb[48:48+384]
    return body[48:80].hex(), body[112:144].hex()


def main():
    # will hold cryptography public key object for verification
    pub_key_obj = None
    attestation = fetch_attestation(BASE_URL, API_KEY, MODEL)
    # Full attestation-report verification: NVIDIA payload
    if attestation and "nvidia_payload" in attestation:
        try:
            verify_nvidia_attestation(attestation["nvidia_payload"])
        except Exception as e:
            raise Exception(f"NVIDIA payload verification error: {e}")
    # Intel TDX quote verification instructions
    if attestation and "intel_quote" in attestation:
        print("=== Intel TDX Quote Verification ===")
        intel_quote = attestation["intel_quote"]
        print("To verify the Intel TDX quote, go to https://proof.t16z.com, paste the quote below, and follow the instructions:")
        print(intel_quote)
    # Enclave identity pinning against published measurements
    print("=== Enclave Identity Pinning ===")
    # NVIDIA measurement
    exp_nm = '00000000020133000130008048dfd18fe229bf16eb9d30cca0f11a24dafe6eb7'
    exp_ns = '3000ec80d19d78143549a41d62d0078c56b2d538ed5d394f19e5af7d93bd1a24'
    rep_nm, rep_ns = parse_nvidia_measurement(attestation["nvidia_payload"])
    verify_enclave_identity(rep_nm, exp_nm, "NVIDIA MRENCLAVE")
    verify_enclave_identity(rep_ns, exp_ns, "NVIDIA MRSIGNER")
    # Intel measurement
    exp_im = '6489d6c8e4f92f160b7cad34207b00c100000000000000000000000000000000'
    exp_is = '00000000000000000000001000000000e702060000000000924f8a6140332b2c'
    rep_im, rep_is = parse_intel_measurement(attestation.get("intel_quote", ""))
    verify_enclave_identity(rep_im, exp_im, "Intel MRENCLAVE")
    verify_enclave_identity(rep_is, exp_is, "Intel MRSIGNER")
    # Extract raw EC public key from certificate in the attestation report
    public_key = None
    if attestation and "nvidia_payload" in attestation:
        try:
            # parse nvidia_payload JSON string if needed
            payload = attestation["nvidia_payload"]
            if isinstance(payload, str):
                payload = json.loads(payload)
            # certificate is base64-encoded PEM; decode to get actual PEM bytes
            cert_b64 = payload["evidence_list"][0]["certificate"]
            pem_data = base64.b64decode(cert_b64)
            cert_obj = x509.load_pem_x509_certificate(pem_data, default_backend())
            # get cryptography public key object
            pub_key_obj = cert_obj.public_key()
            # serialize for debugging if needed
            public_key = pub_key_obj.public_bytes(
                encoding=serialization.Encoding.X962,
                format=serialization.PublicFormat.UncompressedPoint
            ).hex()
        except Exception as e:
            print("Failed to extract public key from certificate:", e)
            public_key = None
    # get enclave signing address from attestation
    signing_address = attestation.get("signing_address")
    if not signing_address:
        raise Exception("Attestation response missing 'signing_address'")
    # Non-streaming chat and signature verification
    chat_data = chat_completion(BASE_URL, API_KEY, MODEL, stream=False)
    if chat_data and isinstance(chat_data, dict) and "id" in chat_data:
        request_id = chat_data["id"]
        signature_data = fetch_signature(BASE_URL, API_KEY, MODEL, request_id)
        if signature_data and "text" in signature_data and "signature" in signature_data:
            # ensure signing_address matches the attested one
            if signature_data.get("signing_address") and signature_data["signing_address"].lower() != signing_address.lower():
                raise Exception(f"Unexpected signing_address from signature: {signature_data['signing_address']}")
            message = signature_data["text"]
            signature = signature_data["signature"]
            verify_signature(signing_address, message, signature)
    # Streaming chat and signature verification (no local hashing)
    stream_id = chat_completion(BASE_URL, API_KEY, MODEL, stream=True)
    if stream_id:
        signature_data = fetch_signature(BASE_URL, API_KEY, MODEL, stream_id)
        if signature_data and "text" in signature_data and "signature" in signature_data:
            if signature_data.get("signing_address") and signature_data["signing_address"].lower() != signing_address.lower():
                raise Exception(f"Unexpected signing_address from signature: {signature_data['signing_address']}")
            message = signature_data["text"]
            signature = signature_data["signature"]
            verify_signature(signing_address, message, signature)


if __name__ == "__main__":
    main()

import requests
import json
import time


def check_video_status(api_key, run_id, project_id, cost=None, payment_source=None):
    """
    Check the status of a video generation request.

    Args:
        api_key (str): Your API key
        run_id (str): The run ID from the generation request
        project_id (str): The project ID from the generation request
        cost (float, optional): The cost of the video generation
        payment_source (str, optional): The payment source used

    Returns:
        dict: Response containing video status and URL when complete
    """
    # Build query parameters
    params = {
        'runId': run_id,
        'projectId': project_id
    }
    if cost is not None:
        params['cost'] = str(cost)
    if payment_source is not None:
        params['paymentSource'] = payment_source

    url = f"https://www.nano-gpt.com/api/v1/video/status"

    headers = {
        "Content-Type": "application/json",
        "x-api-key": api_key
    }

    try:
        response = requests.get(url, headers=headers, params=params)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f"Error checking status: {str(e)}")
        return {"error": str(e)}


def generate_video(api_key, prompt=None, script=None, framework="default", target_length=70, wait_for_completion=True,
                   max_wait_time=900, director_notes=None):
    """
    Generate a video using the Longstories API.

    Args:
        api_key (str): Your API key
        prompt (str, optional): The prompt for video generation (mutually exclusive with script)
        script (str, optional): A fully-written script to skip AI script generation (takes precedence over prompt)
        framework (str): The story framework to use (default, emotional_story, product_showcase, tutorial)
        target_length (int): Target length in words (default: 70)
        wait_for_completion (bool): Whether to wait for the video to complete
        max_wait_time (int): Maximum time to wait in seconds (default: 15 minutes)
        director_notes (str, optional): Specific instructions for the image generation engine (e.g., 'Warm lighting' or 'Make the first image very impactful')

    Returns:
        dict: Response containing video generation status and details
    """
    if not prompt and not script:
        raise ValueError("Either prompt or script must be provided")

    # API endpoint
    url = "https://www.nano-gpt.com/api/v1/video"

    # Request headers
    headers = {
        "Content-Type": "application/json",
        "x-api-key": api_key
    }

    # Example using Recraft model with a specific style
    recraft_payload = {
        **({"script": script} if script else {"prompt": prompt}),
        "framework": framework,
        "targetLengthInWords": target_length,
        "directorNotes": director_notes,
        "imageConfig": {
            "model": "recraft",
            "style": "realistic_image/studio_portrait"  # Using one of the Recraft styles
        },
        "voice": "pNInz6obpgDQGcFmaJgB",  # Voice ID from AVAILABLE_VOICES
        "captionsShow": True,
        "captionsStyle": "default",  # Style from AVAILABLE_CAPTION_STYLES
        "effects": {
            "transition": "fade",
            "floating": False
        },
        "quality": "medium",  # Options: "low", "medium", "high"
        "motion": {
            "enabled": False,
            "strength": 3
        },
        # Music configuration - must include the full path format
        "music": "video-creation/music/dramatic_cinematic_score.mp3",  # Music slug from AVAILABLE_MUSIC
    }

    # Example using Flux LoRA model with a specific style
    flux_lora_payload = {
        **({"script": script} if script else {"prompt": prompt}),
        "framework": framework,
        "targetLengthInWords": target_length,
        "directorNotes": director_notes,
        "imageConfig": {
            "model": "flux_lora",
            "loraConfig": {
                "loraSlug": "ghibsky-comic-book"  # Using one of the Flux LoRA styles
            }
        },
        "voice": "pNInz6obpgDQGcFmaJgB",  # Voice ID from AVAILABLE_VOICES
        "captionsShow": True,
        "captionsStyle": "default",  # Style from AVAILABLE_CAPTION_STYLES
        "effects": {
            "transition": "fade",
            "floating": False
        },
        "quality": "medium",  # Options: "low", "medium", "high"
        "motion": {
            "enabled": False,
            "strength": 3
        },
        # Music configuration - must include the full path format
        "music": "video-creation/music/dramatic_cinematic_score.mp3",  # Music slug from AVAILABLE_MUSIC
    }

    # Choose which payload to use (this example uses Recraft)
    payload = recraft_payload

    try:
        # Make the API request
        response = requests.post(url, headers=headers, json=payload)
        response.raise_for_status()

        # Parse the response
        result = response.json()

        if "error" in result:
            print(f"Error: {result['error']}")
            return result

        print("Video generation started!")
        print(f"Run ID: {result.get('runId')}")
        print(f"Project ID: {result.get('projectId')}")
        print(f"Cost: {result.get('cost')} {result.get('paymentSource')}")

        if not wait_for_completion:
            return result

        # Wait for completion
        print("
Waiting for video generation to complete...")
        start_time = time.time()
        while True:
            if time.time() - start_time > max_wait_time:
                print(f"
Timeout after {max_wait_time} seconds")
                return {"error": "Timeout", "last_status": result}

            status = check_video_status(
                api_key,
                result['runId'],
                result['projectId'],
                cost=result.get('cost'),
                payment_source=result.get('paymentSource')
            )

            if "error" in status:
                print(f"
Error checking status: {status['error']}")
                return status

            print(f"Status: {status.get('status', 'UNKNOWN')}")

            if status.get('data', {}).get('isCompleted'):
                if status.get('data', {}).get('isSuccess'):
                    print("
Video generation completed successfully!")
                    if 'output' in status.get('data', {}) and 'url' in status['data']['output']:
                        print(f"Video URL: {status['data']['output']['url']}")
                    return status
                else:
                    print("
Video generation failed!")
                    return status

            time.sleep(10)  # Wait 10 seconds before checking again

    except requests.exceptions.RequestException as e:
        print(f"Error making request: {str(e)}")
        return {"error": str(e)}


def main():
    # Replace with your actual API key
    API_KEY = "0a91688d-baf5-4085-a2ab-7cb0a29545b2"

    # Example using prompt with Ghibsky style and music
    result_from_prompt = generate_video(
        api_key=API_KEY,
        prompt="Create a whimsical animated story about a young inventor who creates a flying bicycle, in the style of a beloved animation studio",
        framework="emotional_story",
        target_length=10,
        wait_for_completion=True,
        max_wait_time=900,
        director_notes="Use warm, golden lighting and make the workshop scenes feel cozy and inviting"  # Example director notes
    )

    # Example using script with Ghibsky style and music
    result_from_script = generate_video(
        api_key=API_KEY,
        script="A young inventor's workshop filled with whimsical contraptions and floating gears.",
        framework="emotional_story",
        target_length=10,
        wait_for_completion=True,
        max_wait_time=900,
        director_notes="Make the first image very impactful with dramatic lighting on the contraptions"  # Example director notes
    )

    # Print the final results
    print("
Result from prompt:")
    print(json.dumps(result_from_prompt, indent=2))
    print("
Result from script:")
    print(json.dumps(result_from_script, indent=2))


# Available options for LongStories API configuration
AVAILABLE_MUSIC = {
    "adventure": {
        "temple_of_treasures": {"description": "Adventure theme"},
        "adventurous_intro": {"description": "Short adventure intro"}
    },
    "ambient": {
        "gentle_ambient_loop": {"description": "Gentle ambient music"},
        "serene_ambience": {"description": "Serene ambient theme"},
        "soothing_ambience": {"description": "Soothing ambient music"},
        "soothing_ambient_backdrop": {"description": "Soothing ambient backdrop"},
        "tranquil_ambience": {"description": "Tranquil ambient theme"},
        "dreamscape": {"description": "Dreamlike ambient"},
        "belonging_resonance": {"description": "Emotional ambient"},
        "vivid_memories": {"description": "Memory-evoking ambient"}
    },
    "cinematic": {
        "cinematic_intro": {"description": "Cinematic introduction"},
        "cinematic_teaser": {"description": "Cinematic teaser music"},
        "dramatic_cinematic_score": {"description": "Dramatic cinematic"},
        "thriller_cinema_trailer": {"description": "Intense thriller"},
        "fractured_paintings": {"description": "Artistic cinematic"},
        "promise_of_tomorrow": {"description": "Hopeful cinematic"},
        "spooky_orchestral_theme": {"description": "Spooky orchestral"}
    },
    "upbeat": {
        "light_upbeat_melody": {"description": "Light upbeat"},
        "puzzle_time": {"description": "Playful puzzle theme"},
        "stomping_drums_rhythm": {"description": "Rhythmic drums"},
        "stomps_and_claps_rhythm_track": {"description": "Stomps and claps"}
    },
    "news": {
        "news_theme": {"description": "Professional news theme"}
    },
    "vintage": {
        "burlesque_sweetheart": {"description": "Vintage burlesque"}
    },
    "other": {
        "highway_nocturne_national_sweetheart": {"description": "Highway nocturne"},
        "haptic_sensation": {"description": "Haptic sensation theme"}
    }
}

AVAILABLE_VOICES = {
    "english": {
        "aria": {"id": "9BWtsMINqrJLrRacOk9x", "description": "Female, American, expressive", "best_for": "social media"},
        "roger": {"id": "CwhRBWXzGAHq8TQ4Fs17", "description": "Male, American, confident", "best_for": "social media"},
        "sarah": {"id": "EXAVITQu4vr4xnSDxMaL", "description": "Female, American, soft", "best_for": "news"},
        "laura": {"id": "FGY2WhTYpPnrIDTdsKH5", "description": "Female, American, upbeat", "best_for": "social media"},
        "charlie": {"id": "IKne3meq5aSn9XLyUdCD", "description": "Male, Australian, natural", "best_for": "conversational"},
        "george": {"id": "JBFqnCBsd6RMkjVDRZzb", "description": "Male, British, warm", "best_for": "narration"},
        "callum": {"id": "N2lVS1w4EtoT3dr4eOWO", "description": "Male, Transatlantic, intense", "best_for": "characters"},
        "river": {"id": "SAz9YHcvj6GT2YYXdXww", "description": "Female, American, confident", "best_for": "social media"},
        "liam": {"id": "TX3LPaxmHKxFdv7VOQHJ", "description": "Male, American, articulate", "best_for": "narration"},
        "charlotte": {"id": "XB0fDUnXU5powFXDhCwa", "description": "Female, Swedish, seductive", "best_for": "characters"},
        "alice": {"id": "Xb7hH8MSUJpSbSDYk0k2", "description": "Female, British, confident", "best_for": "news"},
        "matilda": {"id": "XrExE9yKIg1WjnnlVkGX", "description": "Female, American, friendly", "best_for": "narration"},
        "will": {"id": "bIHbv24MWmeRgasZH58o", "description": "Male, American, friendly", "best_for": "social media"},
        "jessica": {"id": "cgSgspJ2msm6clMCkdW9", "description": "Female, American, expressive", "best_for": "conversational"},
        "eric": {"id": "cjVigY5qzO86Huf0OWal", "description": "Male, American, friendly", "best_for": "conversational"},
        "brian": {"id": "nPczCjzI2devNBz1zQrb", "description": "Male, American, deep", "best_for": "narration"},
        "john": {"id": "zWDA589rUKXuLnPRDtAG", "description": "Male, American, wise", "best_for": "characters animation"}
    },
    "spanish": {
        "sara_martin": {"id": "KHCvMklQZZo0O30ERnVn", "description": "Female, Spanish, wise", "best_for": "informative educational"},
        "david_martin": {"id": "Nh2zY9kknu6z4pZy6FhD", "description": "Male, Spanish, confident", "best_for": "narrative story"},
        "juan_carlos": {"id": "YExhVa4bZONzeingloMX", "description": "Male, Latin American, casual", "best_for": "conversational"}
    }
}

AVAILABLE_CAPTION_STYLES = {
    "default": "Simple, no-frills style",
    "minimal": "Clean and modern with subtle highlights",
    "neon": "Vibrant glowing text with dynamic effects",
    "cinematic": "Bold, dramatic text with cinematic shadows",
    "fancy": "Elegant text with golden accents",
    "tiktok": "Bold text with strong outlines, perfect for social media",
    "highlight": "Dynamic highlighting effect for emphasis",
    "gradient": "Smooth color transitions with modern appeal",
    "instagram": "Clean, readable text optimized for social sharing",
    "vida": "Bold 3D text with strong presence",
    "manuscripts": "Distinctive text style with character"
}

AVAILABLE_SCRIPT_STYLES = {
    "default": "Classic story with traditional narrative structure",
    "engaging_conversational": "Casual, dialogue-rich storytelling",
    "kind_biography": "Biographical style with personal touch",
    "hero_journey": "Epic narrative following hero's journey structure",
    "emotional_story": "Emotionally resonant narrative",
    "dramatic_reveal": "Story with dramatic twists and reveals",
    "heartwarming_stories": "Uplifting, feel-good narratives",
    "educational_history": "Educational content with historical context",
    "news_brief": "Concise, journalistic style"
}

# Available styles for different image models
AVAILABLE_STYLES = {
    "recraft": {  # Styles for Recraft model
        "any": "Default style",
        "realistic_image": "Realistic photography",
        "digital_illustration": "Digital art and illustrations",
        "realistic_image/b_and_w": "Black and white photography",
        "realistic_image/hard_flash": "Hard flash photography",
        "realistic_image/hdr": "HDR photography",
        "realistic_image/natural_light": "Natural lighting photography",
        "realistic_image/studio_portrait": "Studio portrait photography",
        "realistic_image/enterprise": "Professional/corporate photography",
        "realistic_image/motion_blur": "Motion blur effect",
        "digital_illustration/pixel_art": "Pixel art style",
        "digital_illustration/hand_drawn": "Hand-drawn illustration",
        "digital_illustration/grain": "Grainy illustration style",
        "digital_illustration/infantile_sketch": "Child-like sketch style",
        "digital_illustration/2d_art_poster": "2D poster art",
        "digital_illustration/handmade_3d": "3D-like illustration",
        "digital_illustration/hand_drawn_outline": "Line art style",
        "digital_illustration/engraving_color": "Color engraving style",
        "digital_illustration/2d_art_poster_2": "Alternative 2D poster style"
        }
}


AVAILABLE_LORA_STYLES = {
    "ghibsky-comic-book": {
        "description": "GHIBSKY style painting",
        "prompt_prefix": "GHIBSKY style painting,"
    },
    "colour-sketches": {
        "description": "Colour Sketches Illustration",
        "prompt_prefix": "illustration"
    },
    "sketch-paint": {
        "description": "Sketch Paint Illustration",
        "prompt_prefix": "sk3tchpa1nt style illustration"
    },
    "90s-anime": {
        "description": "90s Anime Art",
        "prompt_prefix": "90s anime style,"
    },
    "2000s-crime-thrillers": {
        "description": "2000s Crime Thrillers",
        "prompt_prefix": "ArsMovieStill, movie still from a gritty, high-contrast 2000s crime thriller movie,"
    },
    "xno-symbol-flux": {
        "description": "XNO Symbol",
        "prompt_prefix": "xno_symbol"
    }
}

if __name__ == "__main__":
    main()