Model Availability

import requests

# Get model list
response = requests.get(
    "https://api.laozhang.ai/v1/models",
    headers={"Authorization": "Bearer your_api_key"}
)

models = response.json()
for model in models['data']:
    print(f"{model['id']}: {model['status']}")

import time

def call_with_fallback(primary_model, fallback_model, prompt):
    """Call with fallback model"""
    try:
        # Try primary model
        response = client.chat.completions.create(
            model=primary_model,
            messages=[{"role": "user", "content": prompt}]
        )
        return response
    except Exception as e:
        if "model_unavailable" in str(e):
            # Switch to fallback model
            print(f"{primary_model} unavailable, switching to {fallback_model}")
            response = client.chat.completions.create(
                model=fallback_model,
                messages=[{"role": "user", "content": prompt}]
            )
            return response
        else:
            raise e

# Usage example
result = call_with_fallback(
    primary_model="gpt-4-turbo",
    fallback_model="gpt-3.5-turbo",
    prompt="Hello, world!"
)

from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception_type

class ModelUnavailableError(Exception):
    pass

@retry(
    retry=retry_if_exception_type(ModelUnavailableError),
    stop=stop_after_attempt(3),
    wait=wait_exponential(multiplier=1, min=4, max=10)
)
def call_api_with_retry(model, prompt):
    """API call with retry"""
    try:
        response = client.chat.completions.create(
            model=model,
            messages=[{"role": "user", "content": prompt}]
        )
        return response
    except Exception as e:
        if "model_unavailable" in str(e):
            raise ModelUnavailableError(f"{model} unavailable")
        raise e

MODEL_FALLBACK_CHAIN = {
    "gpt-4-turbo": ["gpt-4", "claude-sonnet-4", "gpt-3.5-turbo"],
    "claude-opus": ["claude-sonnet-4", "gpt-4-turbo", "claude-haiku"],
    "gemini-2.5-pro": ["gemini-1.5-pro", "gpt-4-turbo", "claude-sonnet-4"]
}

def call_with_fallback_chain(model, prompt):
    """Try call with fallback chain"""
    models_to_try = [model] + MODEL_FALLBACK_CHAIN.get(model, [])
    
    for current_model in models_to_try:
        try:
            response = client.chat.completions.create(
                model=current_model,
                messages=[{"role": "user", "content": prompt}]
            )
            if current_model != model:
                print(f"Using fallback model: {current_model}")
            return response
        except Exception as e:
            if "model_unavailable" in str(e):
                continue
            raise e
    
    raise Exception("All models unavailable")

import time
import requests

def monitor_model_status(models, interval=60):
    """Monitor model status"""
    while True:
        for model in models:
            try:
                start_time = time.time()
                response = client.chat.completions.create(
                    model=model,
                    messages=[{"role": "user", "content": "test"}],
                    max_tokens=5
                )
                response_time = time.time() - start_time
                
                print(f"{model}: ✅ Available, Response time: {response_time:.2f}s")
            except Exception as e:
                print(f"{model}: ❌ Unavailable, Error: {str(e)}")
        
        time.sleep(interval)

# Monitor key models
models_to_monitor = ["gpt-4-turbo", "claude-sonnet-4", "gemini-2.5-pro"]
monitor_model_status(models_to_monitor)

def select_model(task_type, complexity, budget):
    """Smart model selection"""
    if budget == "low":
        return "gpt-3.5-turbo"
    
    if complexity == "high":
        if task_type == "code":
            return "gpt-4-turbo"
        elif task_type == "long_text":
            return "claude-sonnet-4"
        else:
            return "gpt-4-turbo"
    else:
        return "gpt-3.5-turbo"

import random

AVAILABLE_MODELS = [
    "gpt-4-turbo",
    "claude-sonnet-4",
    "gemini-2.5-pro"
]

def load_balanced_call(prompt):
    """Load balanced call"""
    model = random.choice(AVAILABLE_MODELS)
    try:
        return client.chat.completions.create(
            model=model,
            messages=[{"role": "user", "content": prompt}]
        )
    except Exception as e:
        # Try other models if one fails
        for backup_model in AVAILABLE_MODELS:
            if backup_model != model:
                try:
                    return client.chat.completions.create(
                        model=backup_model,
                        messages=[{"role": "user", "content": prompt}]
                    )
                except:
                    continue
        raise e

from functools import lru_cache
import hashlib

@lru_cache(maxsize=1000)
def cached_completion(model, prompt_hash):
    """Cached completion"""
    # Actual API call
    response = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": prompt_hash}]
    )
    return response

def get_completion(model, prompt):
    """Get completion with cache"""
    prompt_hash = hashlib.md5(prompt.encode()).hexdigest()
    return cached_completion(model, prompt_hash)