Get Text Styles

GET https://api.pictory.ai/pictoryapis/v1/styles

import requests

url = "https://api.pictory.ai/pictoryapis/v1/styles"
headers = {
    "Authorization": "YOUR_API_KEY",
    "accept": "application/json"
}

response = requests.get(url, headers=headers)
styles = response.json()

print(f"Total styles: {len(styles)}\n")

# Group by category (based on name patterns)
captions = [s for s in styles if 'caption' in s['name'].lower()]
headings = [s for s in styles if 'heading' in s['name'].lower() or 'title' in s['name'].lower()]
others = [s for s in styles if s not in captions and s not in headings]

print(f"Caption styles: {len(captions)}")
print(f"Heading/Title styles: {len(headings)}")
print(f"Other styles: {len(others)}")

import requests

def search_styles(api_key, search_term):
    """
    Search for text styles by name.

    Args:
        api_key: Your API key
        search_term: Text to search for in style names
    """
    url = "https://api.pictory.ai/pictoryapis/v1/styles"
    headers = {
        "Authorization": api_key,
        "accept": "application/json"
    }

    response = requests.get(url, headers=headers)
    styles = response.json()

    # Case-insensitive search
    search_term_lower = search_term.lower()
    matches = [
        style for style in styles
        if search_term_lower in style['name'].lower()
    ]

    return matches

# Usage - Find all "black" styles
black_styles = search_styles("YOUR_API_KEY", "black")

print(f"Found {len(black_styles)} styles containing 'black':")
for style in black_styles:
    print(f"- {style['name']}")

# Find caption styles
caption_styles = search_styles("YOUR_API_KEY", "caption")
print(f"\nFound {len(caption_styles)} caption styles")

import requests

def get_styles_for_selector(api_key, category=None):
    """
    Get text styles formatted for a UI selector.

    Args:
        api_key: Your API key
        category: Optional filter ('caption', 'heading', 'title', etc.)
    """
    url = "https://api.pictory.ai/pictoryapis/v1/styles"
    headers = {
        "Authorization": api_key,
        "accept": "application/json"
    }

    response = requests.get(url, headers=headers)
    styles = response.json()

    # Filter by category if specified
    if category:
        styles = [
            s for s in styles
            if category.lower() in s['name'].lower()
        ]

    # Format for UI selector
    selector_options = [
        {
            "value": style['id'],
            "label": style['name']
        }
        for style in sorted(styles, key=lambda x: x['name'])
    ]

    return selector_options

# Usage
all_options = get_styles_for_selector("YOUR_API_KEY")
caption_options = get_styles_for_selector("YOUR_API_KEY", category="caption")

print(f"All styles: {len(all_options)}")
print(f"Caption styles: {len(caption_options)}")

# Example output for first 5
print("\nFirst 5 options:")
for option in all_options[:5]:
    print(f"  {option['label']} -> {option['value']}")

import requests
import json
from datetime import datetime, timedelta

class StyleCache:
    def __init__(self, api_key, cache_duration_hours=24):
        self.api_key = api_key
        self.cache_duration = timedelta(hours=cache_duration_hours)
        self.cache_file = "text_styles_cache.json"
        self.styles = None
        self.last_updated = None

    def get_styles(self, force_refresh=False):
        """Get styles from cache or API."""
        # Check if cache is valid
        if not force_refresh and self._is_cache_valid():
            print("Using cached styles")
            return self.styles

        # Fetch from API
        print("Fetching styles from API")
        url = "https://api.pictory.ai/pictoryapis/v1/styles"
        headers = {
            "Authorization": self.api_key,
            "accept": "application/json"
        }

        response = requests.get(url, headers=headers)
        self.styles = response.json()
        self.last_updated = datetime.now()

        # Save to cache file
        self._save_cache()

        return self.styles

    def _is_cache_valid(self):
        """Check if cache exists and is still valid."""
        try:
            with open(self.cache_file, 'r') as f:
                cache_data = json.load(f)

            last_updated = datetime.fromisoformat(cache_data['last_updated'])
            if datetime.now() - last_updated < self.cache_duration:
                self.styles = cache_data['styles']
                self.last_updated = last_updated
                return True
        except (FileNotFoundError, json.JSONDecodeError, KeyError):
            pass

        return False

    def _save_cache(self):
        """Save styles to cache file."""
        cache_data = {
            'styles': self.styles,
            'last_updated': self.last_updated.isoformat()
        }

        with open(self.cache_file, 'w') as f:
            json.dump(cache_data, f)

# Usage
cache = StyleCache("YOUR_API_KEY", cache_duration_hours=24)

# First call - fetches from API
styles = cache.get_styles()
print(f"Loaded {len(styles)} styles")

# Second call - uses cache
styles = cache.get_styles()
print(f"Loaded {len(styles)} styles")

# Force refresh
styles = cache.get_styles(force_refresh=True)
print(f"Loaded {len(styles)} styles (refreshed)")

import requests
from collections import defaultdict

def categorize_styles(api_key):
    """
    Categorize text styles based on their names.

    Args:
        api_key: Your API key

    Returns:
        Dictionary with categorized styles
    """
    url = "https://api.pictory.ai/pictoryapis/v1/styles"
    headers = {
        "Authorization": api_key,
        "accept": "application/json"
    }

    response = requests.get(url, headers=headers)
    styles = response.json()

    categories = {
        'Captions': [],
        'Headings/Titles': [],
        'Colors': [],
        'Standard': [],
        'Special Effects': [],
        'Other': []
    }

    for style in styles:
        name_lower = style['name'].lower()

        if 'caption' in name_lower:
            categories['Captions'].append(style)
        elif 'heading' in name_lower or 'title' in name_lower:
            categories['Headings/Titles'].append(style)
        elif any(color in name_lower for color in ['black', 'blue', 'yellow', 'red', 'purple', 'orange', 'green', 'pink']):
            categories['Colors'].append(style)
        elif 'standard' in name_lower or 'default' in name_lower:
            categories['Standard'].append(style)
        elif any(effect in name_lower for effect in ['bold', 'flash', 'retro', 'handwritten', 'cartoon']):
            categories['Special Effects'].append(style)
        else:
            categories['Other'].append(style)

    return categories

# Usage
categories = categorize_styles("YOUR_API_KEY")

for category, styles in categories.items():
    print(f"\n{category} ({len(styles)} styles):")
    for style in styles[:5]:  # Show first 5 of each category
        print(f"  - {style['name']}")
    if len(styles) > 5:
        print(f"  ... and {len(styles) - 5} more")