JSON Interoperability

import glyph

# JSON → GLYPH → JSON (lossless)
original = {
    "name": "Bob",
    "age": 30,
    "active": True,
    "scores": [95, 87, 92],
    "metadata": None,
}

glyph_form = glyph.from_json(original)
restored = glyph.to_json(glyph.parse(glyph_form))

assert restored == original  # ✓ Identical

import glyph
import json

def serialize(data: dict, use_glyph: bool = False) -> str:
    """Wrapper for gradual migration."""
    if use_glyph:
        return glyph.from_json(data)
    return json.dumps(data)

def deserialize(text: str) -> dict:
    """Auto-detect format and parse."""
    text = text.strip()
    
    # Check if it looks like GLYPH
    if text.startswith("{") and "=" in text[:50]:
        # GLYPH format: {key=value ...}
        return glyph.to_json(glyph.parse(text))
    
    # Default to JSON
    return json.loads(text)

# Works with both formats
data1 = deserialize('{"name": "Bob"}')
data2 = deserialize('{name=Bob}')
assert data1 == data2

import glyph
from typing import List, Dict

class ContextBuilder:
    """Build LLM context with GLYPH for token savings."""
    
    def __init__(self, use_glyph: bool = True):
        self.use_glyph = use_glyph
    
    def build_user_context(self, user: Dict) -> str:
        """Format user data."""
        if self.use_glyph:
            return f"User: {glyph.from_json(user)}"
        return f"User: {json.dumps(user)}"
    
    def build_history_context(self, history: List[Dict]) -> str:
        """Format conversation history."""
        if self.use_glyph:
            lines = [glyph.from_json(h) for h in history]
            return "History:\n" + "\n".join(lines)
        return "History:\n" + json.dumps(history, indent=2)
    
    def build_full_context(self, user: Dict, history: List[Dict], 
                          system: str) -> str:
        """Build complete context."""
        parts = [
            system,
            self.build_user_context(user),
            self.build_history_context(history),
        ]
        return "\n\n".join(parts)

# Usage
builder = ContextBuilder(use_glyph=True)

user = {
    "id": "user_123",
    "name": "Alice",
    "preferences": {"language": "en", "timezone": "UTC"},
}

history = [
    {"role": "user", "content": "Hello"},
    {"role": "assistant", "content": "Hi! How can I help?"},
]

context = builder.build_full_context(user, history, "You are a helpful assistant.")

# Compare token counts
context_json = ContextBuilder(use_glyph=False).build_full_context(user, history, "You are a helpful assistant.")

print(f"GLYPH context: ~{len(context.split())} tokens")
print(f"JSON context:  ~{len(context_json.split())} tokens")
print(f"Savings: {100 * (1 - len(context)/len(context_json)):.0f}%")

import glyph
from datetime import datetime

# With type markers
data = {
    "id": "^user:123",  # Reference ID
    "created_at": datetime.now(),  # Timestamp
    "avatar": b"\x89PNG...",  # Binary data
}

# Convert to GLYPH (preserves types)
glyph_text = glyph.from_json(data, options={
    "parse_refs": True,
    "parse_dates": True,
})

# Parse back (types preserved)
restored = glyph.to_json(glyph.parse(glyph_text), options={
    "format_dates": True,
    "compact_refs": True,
})

print(type(restored["id"]))         # str (with ^ prefix)
print(type(restored["created_at"])) # datetime
print(type(restored["avatar"]))     # bytes

from fastapi import FastAPI, Request, Response
from fastapi.responses import JSONResponse
import glyph

app = FastAPI()

class GLYPHResponse(Response):
    media_type = "application/glyph"
    
    def render(self, content: any) -> bytes:
        return glyph.from_json(content).encode('utf-8')

@app.get("/users/{user_id}")
async def get_user(user_id: str, request: Request):
    user = get_user_from_db(user_id)
    
    # Check Accept header
    accept = request.headers.get("Accept", "")
    
    if "application/glyph" in accept:
        return GLYPHResponse(content=user)
    else:
        return JSONResponse(content=user)

# Client usage
import httpx

# Request GLYPH format
response = httpx.get(
    "http://api.example.com/users/123",
    headers={"Accept": "application/glyph"}
)

if response.headers["content-type"] == "application/glyph":
    user = glyph.to_json(glyph.parse(response.text))
else:
    user = response.json()

import pytest
import glyph
import json

@pytest.mark.parametrize("test_case", [
    {"simple": "value"},
    {"nested": {"key": "value"}},
    {"list": [1, 2, 3]},
    {"mixed": {"str": "hello", "int": 42, "bool": True, "null": None}},
    {"complex": {"users": [{"id": 1, "name": "Alice"}, {"id": 2, "name": "Bob"}]}},
])
def test_json_roundtrip(test_case):
    """Test JSON → GLYPH → JSON roundtrip."""
    
    # Convert to GLYPH
    glyph_text = glyph.from_json(test_case)
    
    # Parse back
    restored = glyph.to_json(glyph.parse(glyph_text))
    
    # Should be identical
    assert restored == test_case

def test_token_savings():
    """Verify token savings."""
    
    test_data = {
        "user": "alice",
        "action": "search",
        "query": "weather in NYC",
        "max_results": 10,
        "filters": {"type": "forecast"},
    }
    
    json_text = json.dumps(test_data)
    glyph_text = glyph.from_json(test_data)
    
    savings = 1 - len(glyph_text) / len(json_text)
    
    print(f"JSON:  {len(json_text)} chars")
    print(f"GLYPH: {len(glyph_text)} chars")
    print(f"Savings: {savings*100:.1f}%")
    
    assert savings > 0.3  # At least 30% savings