caches.list

client.caches.list(
    config: Optional[ListCachedContentsConfigOrDict] = None
) -> Pager[CachedContent]

from google import genai

client = genai.Client(api_key='your-api-key')

# List and print all caches
for cached in client.caches.list():
    print(f"Name: {cached.display_name or cached.name}")
    print(f"Model: {cached.model}")
    print(f"Created: {cached.create_time}")
    print(f"Expires: {cached.expire_time}")
    print(f"Tokens: {cached.usage_metadata.total_token_count}")
    print("---")

# Get caches in smaller batches
for cached in client.caches.list(config={'page_size': 10}):
    print(f"{cached.display_name}: {cached.usage_metadata.total_token_count} tokens")

# Count all cached contents
cache_count = sum(1 for _ in client.caches.list())
print(f"Total caches: {cache_count}")

# Find cache by display name
def find_cache_by_name(display_name: str):
    for cached in client.caches.list():
        if cached.display_name == display_name:
            return cached
    return None

cached = find_cache_by_name('My Important Cache')
if cached:
    print(f"Found: {cached.name}")
else:
    print("Cache not found")

# Calculate total tokens across all caches
total_tokens = sum(
    c.usage_metadata.total_token_count 
    for c in client.caches.list()
)

print(f"Total cached tokens: {total_tokens:,}")
print(f"Approximate storage: {total_tokens / 1000:.1f}K tokens")

from collections import defaultdict

# Group caches by model
by_model = defaultdict(list)
for cached in client.caches.list():
    by_model[cached.model].append(cached)

for model, caches in by_model.items():
    print(f"{model}: {len(caches)} caches")
    for cached in caches:
        print(f"  - {cached.display_name}")

from datetime import datetime, timedelta

# Find caches expiring in the next hour
expiring_soon = []
now = datetime.now()

for cached in client.caches.list():
    time_remaining = cached.expire_time - now
    if time_remaining < timedelta(hours=1):
        expiring_soon.append(cached)

print(f"Caches expiring soon: {len(expiring_soon)}")
for cached in expiring_soon:
    print(f"- {cached.display_name}: {cached.expire_time}")

import asyncio

async def list_caches():
    # List caches asynchronously
    async for cached in await client.aio.caches.list():
        print(f"Cache: {cached.display_name}")
        print(f"Expires: {cached.expire_time}")

asyncio.run(list_caches())

import json

# Export cache metadata to JSON
caches_data = []
for cached in client.caches.list():
    caches_data.append({
        'name': cached.name,
        'display_name': cached.display_name,
        'model': cached.model,
        'create_time': cached.create_time.isoformat() if cached.create_time else None,
        'expire_time': cached.expire_time.isoformat() if cached.expire_time else None,
        'tokens': cached.usage_metadata.total_token_count
    })

with open('caches_list.json', 'w') as f:
    json.dump(caches_data, f, indent=2)

print(f"Exported {len(caches_data)} caches to caches_list.json")

from datetime import datetime, timedelta

# Check cache health status
print("Cache Health Report")
print("=" * 50)

healthy = 0
expiring = 0
expired = 0
now = datetime.now()

for cached in client.caches.list():
    time_remaining = cached.expire_time - now
    
    if time_remaining < timedelta(0):
        expired += 1
    elif time_remaining < timedelta(hours=1):
        expiring += 1
    else:
        healthy += 1

print(f"Healthy: {healthy}")
print(f"Expiring soon (< 1 hour): {expiring}")
print(f"Expired: {expired}")

from datetime import datetime, timedelta

# Auto-extend caches expiring soon
for cached in client.caches.list():
    time_remaining = cached.expire_time - datetime.now()
    
    if timedelta(0) < time_remaining < timedelta(minutes=30):
        # Extend by 1 hour
        updated = client.caches.update(
            name=cached.name,
            config={'ttl': '3600s'}
        )
        print(f"Extended {cached.display_name} to {updated.expire_time}")

from datetime import datetime, timedelta

# Delete caches older than 24 hours
deleted_count = 0
for cached in client.caches.list():
    age = datetime.now() - cached.create_time
    
    if age > timedelta(hours=24):
        client.caches.delete(name=cached.name)
        deleted_count += 1
        print(f"Deleted old cache: {cached.display_name}")

print(f"Deleted {deleted_count} old caches")

# Show summary of all caches
print("Cache Summary")
print("=" * 60)

total_caches = 0
total_tokens = 0
oldest = None
newest = None

for cached in client.caches.list():
    total_caches += 1
    total_tokens += cached.usage_metadata.total_token_count
    
    if oldest is None or cached.create_time < oldest.create_time:
        oldest = cached
    if newest is None or cached.create_time > newest.create_time:
        newest = cached

print(f"Total caches: {total_caches}")
print(f"Total tokens: {total_tokens:,}")
if oldest:
    print(f"Oldest cache: {oldest.display_name} ({oldest.create_time})")
if newest:
    print(f"Newest cache: {newest.display_name} ({newest.create_time})")

# Find caches containing specific content type
for cached in client.caches.list():
    # Check if cache has file data
    has_files = any(
        any(part.file_data for part in content.parts)
        for content in cached.contents
    )
    
    if has_files:
        print(f"Cache with files: {cached.display_name}")

# Manually control pagination
config = {'page_size': 5}
response = client.caches._list(config=config)

# First page
print("Page 1:")
for cached in response.cached_contents:
    print(f"  {cached.display_name}")

# Get next page if available
if response.next_page_token:
    config['page_token'] = response.next_page_token
    response = client.caches._list(config=config)
    print("Page 2:")
    for cached in response.cached_contents:
        print(f"  {cached.display_name}")

try:
    caches = list(client.caches.list())
    print(f"Found {len(caches)} caches")
except Exception as e:
    print(f"Error listing caches: {e}")