Get Video Brands

GET https://api.pictory.ai/pictoryapis/v1/brands/video

import requests

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

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

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

# Display with details
for i, brand in enumerate(brands, 1):
    print(f"{i}. {brand['name']}")
    print(f"   ID: {brand['id']}")
    print()

import requests

def get_brands_for_selector(api_key):
    """
    Get video brands formatted for a UI selector.

    Args:
        api_key: Your API key

    Returns:
        List of selector options
    """
    url = "https://api.pictory.ai/pictoryapis/v1/brands/video"
    headers = {
        "Authorization": api_key,
        "accept": "application/json"
    }

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

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

    return selector_options

# Usage
options = get_brands_for_selector("YOUR_API_KEY")

print(f"Brand options: {len(options)}\n")

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

import requests

def search_brands(api_key, search_term):
    """
    Search for video brands by name.

    Args:
        api_key: Your API key
        search_term: Text to search for in brand names

    Returns:
        List of matching brand objects
    """
    url = "https://api.pictory.ai/pictoryapis/v1/brands/video"
    headers = {
        "Authorization": api_key,
        "accept": "application/json"
    }

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

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

    return matches

# Usage - Find all "default" brands
default_brands = search_brands("YOUR_API_KEY", "default")

print(f"Found {len(default_brands)} brands containing 'default':")
for brand in default_brands:
    print(f"- {brand['name']}")

import requests
import json
from datetime import datetime, timedelta

class BrandCache:
    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 = "video_brands_cache.json"
        self.brands = None
        self.last_updated = None

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

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

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

        # Save to cache file
        self._save_cache()

        return self.brands

    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.brands = cache_data['brands']
                self.last_updated = last_updated
                return True
        except (FileNotFoundError, json.JSONDecodeError, KeyError):
            pass

        return False

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

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

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

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

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

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

import requests

def validate_brand_id(api_key, brand_id):
    """
    Validate if a brand ID exists in available brands.

    Args:
        api_key: Your API key
        brand_id: The brand ID to validate

    Returns:
        Tuple of (is_valid, brand_name or None)
    """
    url = "https://api.pictory.ai/pictoryapis/v1/brands/video"
    headers = {
        "Authorization": api_key,
        "accept": "application/json"
    }

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

    # Search for brand by ID
    for brand in brands:
        if brand['id'] == brand_id:
            return True, brand['name']

    return False, None

# Usage
brand_id = "eb67b4ba-0eef-41fa-a772-d9675cc3645c"
is_valid, brand_name = validate_brand_id("YOUR_API_KEY", brand_id)

if is_valid:
    print(f"✓ Brand ID is valid: {brand_name}")
else:
    print("✗ Brand ID not found")

import requests

def apply_brand_to_project(api_key, project_id, brand_id):
    """
    Apply a video brand to an existing project.

    Args:
        api_key: Your API key
        project_id: The project to update
        brand_id: The brand ID to apply
    """
    # First, validate the brand exists
    brands_url = "https://api.pictory.ai/pictoryapis/v1/brands/video"
    headers = {
        "Authorization": api_key,
        "accept": "application/json"
    }

    brands_response = requests.get(brands_url, headers=headers)
    brands = brands_response.json()

    # Check if brand exists
    brand_exists = any(b['id'] == brand_id for b in brands)

    if not brand_exists:
        raise ValueError(f"Brand ID {brand_id} not found")

    # Apply brand to project (example - actual endpoint may vary)
    print(f"Applying brand {brand_id} to project {project_id}")
    # Implementation depends on project update endpoint

# Usage
apply_brand_to_project(
    "YOUR_API_KEY",
    "project-123",
    "eb67b4ba-0eef-41fa-a772-d9675cc3645c"
)