How to Use TOON Format in Python - Complete Tutorial

from openai import OpenAI
from toon import dumps, count_tokens
import json

client = OpenAI(api_key="your-api-key")

customers = [
    {"id": 1, "name": "Metro Wireless", "email": "[email protected]", "active": True},
    {"id": 2, "name": "5G Networks Inc", "email": "[email protected]", "active": True},
    # ... more customers
]

# Compare token usage
json_data = json.dumps(customers)
toon_data = dumps({"customers": customers})

json_tokens = count_tokens(json_data)
toon_tokens = count_tokens(toon_data)
saved_tokens = json_tokens - toon_tokens

print(f"JSON would use: {json_tokens} tokens")
print(f"TOON uses: {toon_tokens} tokens")
print(f"You save: {saved_tokens} tokens ({(saved_tokens/json_tokens)*100:.1f}%)")

# At $0.01 per 1K tokens for GPT-4:
cost_saved = (saved_tokens / 1000) * 0.01
print(f"Cost saved per call: ${cost_saved:.4f}")

# Now use the efficient TOON version
response = client.chat.completions.create(
    model="gpt-4",
    messages=[
        {"role": "user", "content": f"Analyze this data:\n{toon_data}"}
    ]
)

print(response.choices[0].message.content)

from anthropic import Anthropic
from toon import dumps

client = Anthropic(api_key="your-api-key")

def analyze_with_claude(data):
    """Send data to Claude using efficient TOON format"""
    
    # Convert to TOON
    toon_data = dumps(data)
    
    message = client.messages.create(
        model="claude-3-opus-20240229",
        max_tokens=1024,
        messages=[
            {
                "role": "user",
                "content": f"Analyze this data in TOON format:\n{toon_data}"
            }
        ]
    )
    
    return message.content[0].text

# Usage
sales_data = {
    "sales": [
        {"id": 1, "product": "Laptop", "amount": 999.99, "qty": 5},
        {"id": 2, "product": "Mouse", "amount": 29.99, "qty": 20},
        {"id": 3, "product": "Keyboard", "amount": 79.99, "qty": 10}
    ]
}

result = analyze_with_claude(sales_data)
print(result)

from toon import parse, dumps, ToonSyntaxError, ToonValidationError
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

def safe_parse(toon_data: str) -> dict | None:
    """Safely parse TOON data with error handling"""
    try:
        return parse(toon_data)
    except ToonSyntaxError as e:
        logger.error(f"TOON syntax error at line {e.line_number}: {e.message}")
        return None
    except ToonValidationError as e:
        logger.error(f"TOON validation failed: {e.message}")
        return None
    except Exception as e:
        logger.error(f"Unexpected error parsing TOON: {e}")
        return None

def safe_dumps(data: dict) -> str | None:
    """Safely convert dict to TOON with error handling"""
    try:
        return dumps(data)
    except Exception as e:
        logger.error(f"Failed to serialize to TOON: {e}")
        return None

# Usage
toon_data = """
name: "Tower A"
age: 30
"""

result = safe_parse(toon_data)
if result:
    print("Parsed successfully:", result)
else:
    print("Failed to parse")

#!/usr/bin/env python3
"""
TOON Format Python Demo
Demonstrates parsing, serializing, and OpenAI integration
"""

from openai import OpenAI
from toon import dumps, parse, count_tokens
import json

def main():
    print("🚀 TOON Format Python Demo\n")
    
    # 1. Create sample data
    customers = [
        {"id": 1, "name": "Metro Wireless", "email": "[email protected]", "active": True},
        {"id": 2, "name": "5G Networks Inc", "email": "[email protected]", "active": True},
        {"id": 3, "name": "FiberNet Solutions", "email": "[email protected]", "active": False}
    ]
    
    # 2. Serialize to TOON
    toon_data = dumps({"customers": customers})
    
    print("📊 Customer Data in TOON format:")
    print(toon_data)
    print()
    
    # 3. Compare token counts
    json_data = json.dumps({"customers": customers})
    json_tokens = count_tokens(json_data)
    toon_tokens = count_tokens(toon_data)
    saved = json_tokens - toon_tokens
    percentage = (saved / json_tokens) * 100
    
    print(f"📈 Token Comparison:")
    print(f"   JSON: {json_tokens} tokens")
    print(f"   TOON: {toon_tokens} tokens")
    print(f"   Saved: {saved} tokens ({percentage:.1f}%)")
    print()
    
    # 4. Send to OpenAI (if API key is set)
    import os
    if os.getenv("OPENAI_API_KEY"):
        print("🤖 Sending to OpenAI...")
        client = OpenAI()
        
        response = client.chat.completions.create(
            model="gpt-4",
            messages=[
                {"role": "user", "content": f"Analyze these customers:\n{toon_data}"}
            ],
            max_tokens=200
        )
        
        print("💬 AI Response:")
        print(response.choices[0].message.content)
    else:
        print("ℹ️  Set OPENAI_API_KEY environment variable to test OpenAI integration")
    
    print("\n✅ Demo complete!")

if __name__ == "__main__":
    main()

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from toon import dumps, parse
from openai import OpenAI

app = FastAPI()
client = OpenAI()

class AnalyzeRequest(BaseModel):
    data: dict

@app.post("/analyze")
async def analyze_data(request: AnalyzeRequest):
    """Analyze data using OpenAI with TOON format for efficiency"""
    try:
        # Convert to TOON (saves 50% tokens)
        toon_data = dumps(request.data)
        
        # Send to OpenAI
        response = client.chat.completions.create(
            model="gpt-4",
            messages=[
                {"role": "user", "content": f"Analyze:\n{toon_data}"}
            ]
        )
        
        return {
            "analysis": response.choices[0].message.content,
            "format_used": "TOON",
            "token_savings": "~50%"
        }
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

# Run with: uvicorn main:app --reload