Integrating Claude API into a Wallpaper App — A Full Implementation Record

import anthropic
import time
 
client = anthropic.Anthropic()
 
TARGET_LANGUAGES = {
    "en": "English (US)",
    "ja": "Japanese",
    "fr": "French",
    "de": "German",
    "es": "Spanish",
    "pt": "Brazilian Portuguese",
    "ko": "Korean",
    "zh-Hans": "Simplified Chinese"
}
 
def generate_localized_description(
    app_name: str,
    base_description_en: str,
    target_lang: str,
    lang_name: str,
    max_chars: int = 4000
) -> str:
    """
    Generate a localized App Store description for a specific language.
    
    Args:
        app_name: App name
        base_description_en: English base description
        target_lang: Language code (e.g., "fr", "de")
        lang_name: Display name of the language
        max_chars: App Store character limit
    
    Returns:
        Localized description text
    """
    
    if target_lang == "en":
        return base_description_en
    
    system_prompt = f"""
You are a copywriter for healing and wellness mobile apps.
Write App Store / Google Play descriptions in {lang_name}.
 
Guidelines:
- Tone: calm, warm, never pushy
- Connect with the user's need for rest and quiet beauty in daily life
- Describe the experience, not just the features
- Stay within {max_chars} characters in {lang_name}
- Write as a native {lang_name} speaker would — not a translation
"""
    
    user_prompt = f"""
App name: {app_name}
 
English description (reference):
{base_description_en}
 
Using this as a reference, write an App Store description in {lang_name}.
Don't translate literally — write naturally for {lang_name} users.
"""
    
    try:
        message = client.messages.create(
            model="claude-sonnet-4-6",  # Sonnet for quality
            max_tokens=1500,
            system=system_prompt,
            messages=[{"role": "user", "content": user_prompt}]
        )
        return message.content[0].text.strip()
        
    except anthropic.RateLimitError:
        time.sleep(30)
        return generate_localized_description(
            app_name, base_description_en, target_lang, lang_name, max_chars
        )
    except anthropic.APIError as e:
        raise RuntimeError(f"Generation failed for {lang_name}: {str(e)}")
 
def generate_all_localizations(app_name: str, base_description_en: str) -> dict:
    """Generate descriptions for all supported languages."""
    results = {}
    
    for lang_code, lang_name in TARGET_LANGUAGES.items():
        print(f"  Generating: {lang_name}...")
        
        try:
            text = generate_localized_description(
                app_name=app_name,
                base_description_en=base_description_en,
                target_lang=lang_code,
                lang_name=lang_name
            )
            results[lang_code] = {
                "status": "success",
                "text": text,
                "char_count": len(text)
            }
        except RuntimeError as e:
            results[lang_code] = {
                "status": "error",
                "error": str(e),
                "text": ""
            }
        
        # Respect rate limits between languages
        if lang_code != list(TARGET_LANGUAGES.keys())[-1]:
            time.sleep(2)
    
    return results

import anthropic
import json
 
client = anthropic.Anthropic()
 
ALLOWED_TAGS = {
    "color": ["monochrome", "pastel", "earth-tones", "cool", "warm"],
    "motif": ["nature", "water", "forest", "sky", "architecture", "abstract"],
    "mood": ["calm", "nostalgic", "minimal", "meditative", "joyful"],
    "time": ["morning", "evening", "night", "golden-hour"],
    "season": ["spring", "summer", "autumn", "winter", "timeless"]
}
 
ALLOWED_CATEGORIES = [
    "nature-calm", "urban-minimal", "abstract-art", "seasonal-special", "monochrome"
]
 
def tag_and_categorize(content_description: str) -> dict:
    """
    Generate tags and a primary category from a content description.
    
    Args:
        content_description: Natural language description of the content
    
    Returns:
        dict with validated tags and primary category
    """
    
    system_prompt = """
You are a content tagging system for a wallpaper app.
Use only the provided tag values and category names.
Return valid JSON only.
"""
    
    user_prompt = f"""
Tag and categorize this wallpaper content:
 
{content_description}
 
Available tags (select 0–2 per group):
{json.dumps(ALLOWED_TAGS)}
 
Available categories (select exactly 1):
{ALLOWED_CATEGORIES}
 
Return:
{{
  "tags": {{
    "color": [...],
    "motif": [...],
    "mood": [...],
    "time": [...],
    "season": [...]
  }},
  "primary_category": "...",
  "confidence": <0.0-1.0>
}}
"""
    
    try:
        message = client.messages.create(
            model="claude-haiku-4-5-20251001",
            max_tokens=400,
            system=system_prompt,
            messages=[{"role": "user", "content": user_prompt}]
        )
        
        response_text = message.content[0].text.strip()
        start = response_text.find('{')
        end = response_text.rfind('}') + 1
        
        if start >= 0 and end > start:
            result = json.loads(response_text[start:end])
            
            # Validate and filter tags against allowed values
            validated_tags = {}
            for group, tags in result.get("tags", {}).items():
                if group in ALLOWED_TAGS:
                    validated_tags[group] = [t for t in tags if t in ALLOWED_TAGS[group]]
            result["tags"] = validated_tags
            
            # Validate category
            if result.get("primary_category") not in ALLOWED_CATEGORIES:
                result["primary_category"] = "nature-calm"
                result["confidence"] = 0.5
            
            return result
        else:
            raise ValueError("No JSON found in response")
            
    except (json.JSONDecodeError, ValueError) as e:
        return {
            "tags": {k: [] for k in ALLOWED_TAGS.keys()},
            "primary_category": "nature-calm",
            "confidence": 0.0,
            "error": str(e)
        }

import json
import os
import time
import random
import anthropic
 
client = anthropic.Anthropic()
STATE_PATH = "curation_state.json"
 
def load_state() -> dict:
    if os.path.exists(STATE_PATH):
        with open(STATE_PATH, encoding="utf-8") as f:
            return json.load(f)
    return {}
 
def save_state(state: dict) -> None:
    # write to a temp file, then swap (so a crash mid-write can't corrupt it)
    tmp = STATE_PATH + ".tmp"
    with open(tmp, "w", encoding="utf-8") as f:
        json.dump(state, f, ensure_ascii=False)
    os.replace(tmp, STATE_PATH)
 
def call_with_backoff(score_fn, item, max_retries: int = 6):
    """Process one item with exponential backoff. Retry only on 429/5xx."""
    for attempt in range(max_retries):
        try:
            return score_fn(item)
        except anthropic.RateLimitError:
            wait = min(2 ** attempt + random.uniform(0, 1), 60)
            print(f"  rate limited, retry in {wait:.1f}s ({attempt + 1}/{max_retries})")
            time.sleep(wait)
        except anthropic.APIStatusError as e:
            if e.status_code and e.status_code >= 500:
                wait = min(2 ** attempt, 30)
                time.sleep(wait)
            else:
                raise  # 4xx is a config bug — surface it immediately
    raise RuntimeError(f"max retries exceeded for {item['id']}")
 
def process_library(items, score_fn):
    """Resumable batch processing — skips items already done."""
    state = load_state()
    done = 0
    for item in items:
        if item["id"] in state:
            continue  # already processed
        result = call_with_backoff(score_fn, item)
        state[item["id"]] = result
        save_state(state)  # persist after every item
        done += 1
    print(f"Done: {done} new / {len(state)} total")
    return state