Create Template

POST https://api.pictory.ai/pictoryapis/v1/templates

{{variable_name}}

Dear {{customer_name}},

Your payment of ${{payment_amount}} is due on {{payment_date}}.

Account Number: {{loan_account_number}}

For assistance, contact us at {{customer_support_number}}
or email {{support_email_id}}.

import requests

def upload_template(file_path, api_key):
    """
    Upload a .pictai file to create a template
    """
    url = "https://api.pictory.ai/pictoryapis/v1/templates"
    headers = {
        "Authorization": api_key,
        "Content-Type": "application/octet-stream"
    }

    try:
        with open(file_path, "rb") as file:
            response = requests.post(url, headers=headers, data=file)

        if response.status_code == 200:
            template = response.json()
            print(f"✓ Template created: {template['name']}")
            print(f"  Template ID: {template['templateId']}")
            print(f"  Language: {template['language']}")
            print(f"  Scenes: {len(template.get('scenes', []))}")
            print(f"  Variables: {', '.join(template.get('variables', {}).keys())}")
            return template
        else:
            error = response.json()
            print(f"✗ Upload failed: {error.get('message')}")
            return None

    except FileNotFoundError:
        print(f"✗ File not found: {file_path}")
        return None
    except Exception as e:
        print(f"✗ Error: {str(e)}")
        return None

# Example usage
template = upload_template(
    "Pending Loan Payment.pictai",
    "YOUR_API_KEY",
    user_id="user_12345"
)

import os
import requests
from pathlib import Path

def batch_upload_templates(directory, api_key):
    """
    Upload all .pictai files from a directory
    """
    url = "https://api.pictory.ai/pictoryapis/v1/templates"
    headers = {
        "Authorization": api_key,
        "Content-Type": "application/octet-stream"
    }

    # Find all .pictai files
    template_files = list(Path(directory).glob("*.pictai"))

    if not template_files:
        print("No .pictai files found in directory")
        return []

    results = []

    for file_path in template_files:
        print(f"Uploading: {file_path.name}")

        try:
            with open(file_path, "rb") as file:
                response = requests.post(url, headers=headers, data=file)

            if response.status_code == 200:
                template = response.json()
                results.append({
                    'file': file_path.name,
                    'status': 'success',
                    'template_id': template['templateId'],
                    'name': template['name']
                })
                print(f"  ✓ Success: {template['templateId']}")
            else:
                error = response.json()
                results.append({
                    'file': file_path.name,
                    'status': 'failed',
                    'error': error.get('message')
                })
                print(f"  ✗ Failed: {error.get('message')}")

        except Exception as e:
            results.append({
                'file': file_path.name,
                'status': 'error',
                'error': str(e)
            })
            print(f"  ✗ Error: {str(e)}")

    # Print summary
    successful = sum(1 for r in results if r['status'] == 'success')
    print(f"\nSummary: {successful}/{len(results)} templates uploaded successfully")

    return results

# Example usage
results = batch_upload_templates(
    "./templates",
    "YOUR_API_KEY",
    user_id="user_12345"
)

const fs = require('fs');

async function uploadAndAnalyzeTemplate(filePath, apiKey) {
  const url = 'https://api.pictory.ai/pictoryapis/v1/templates';

  const headers = {
    'Authorization': `${apiKey}`,
    'Content-Type': 'application/octet-stream'
  };

  try {
    // Read and upload file
    const fileBuffer = fs.readFileSync(filePath);
    const response = await fetch(url, {
      method: 'POST',
      headers,
      body: fileBuffer
    });

    if (!response.ok) {
      const error = await response.json();
      throw new Error(error.message || 'Upload failed');
    }

    const template = await response.json();

    // Extract template information
    const info = {
      id: template.templateId,
      name: template.name,
      language: template.language,
      sceneCount: template.scenes?.length || 0,
      variables: Object.keys(template.variables || {}),
      hasMusic: Boolean(template.audio?.musicUrl),
      hasAiVoice: Boolean(template.audio?.aiVoice),
      published: template.published
    };

    console.log('Template Created:', info);
    return info;

  } catch (error) {
    console.error('Upload failed:', error.message);
    return null;
  }
}

// Example usage
const info = await uploadAndAnalyzeTemplate(
  'Pending Loan Payment.pictai',
  'YOUR_API_KEY',
  'user_12345'
);

import os
import requests
from pathlib import Path

def validate_and_upload_template(file_path, api_key):
    """
    Validate template file before upload
    """
    # Validation checks
    if not os.path.exists(file_path):
        return {'success': False, 'error': 'File does not exist'}

    if not file_path.endswith('.pictai'):
        return {'success': False, 'error': 'File must be a .pictai file'}

    file_size = os.path.getsize(file_path)
    max_size = 50 * 1024 * 1024  # 50 MB

    if file_size > max_size:
        return {
            'success': False,
            'error': f'File size ({file_size / 1024 / 1024:.1f} MB) exceeds limit'
        }

    if file_size == 0:
        return {'success': False, 'error': 'File is empty'}

    # Upload
    url = "https://api.pictory.ai/pictoryapis/v1/templates"
    headers = {
        "Authorization": api_key,
        "Content-Type": "application/octet-stream"
    }

    print(f"Uploading {Path(file_path).name} ({file_size / 1024:.1f} KB)...")

    try:
        with open(file_path, "rb") as file:
            response = requests.post(url, headers=headers, data=file)

        if response.status_code == 200:
            template = response.json()
            return {
                'success': True,
                'template': template,
                'template_id': template['templateId']
            }
        else:
            error = response.json()
            return {
                'success': False,
                'error': error.get('message', 'Upload failed')
            }

    except Exception as e:
        return {'success': False, 'error': str(e)}

# Example usage
result = validate_and_upload_template(
    "template.pictai",
    "YOUR_API_KEY",
    user_id="user_12345"
)

if result['success']:
    print(f"Success! Template ID: {result['template_id']}")
else:
    print(f"Error: {result['error']}")

import requests
from tqdm import tqdm

class ProgressFileReader:
    def __init__(self, file_path):
        self.file_path = file_path
        self.file_size = os.path.getsize(file_path)
        self.file = open(file_path, 'rb')
        self.progress = tqdm(total=self.file_size, unit='B', unit_scale=True)

    def read(self, size=-1):
        data = self.file.read(size)
        self.progress.update(len(data))
        return data

    def __enter__(self):
        return self

    def __exit__(self, *args):
        self.file.close()
        self.progress.close()

def upload_template_with_progress(file_path, api_key):
    """
    Upload template with progress bar
    """
    url = "https://api.pictory.ai/pictoryapis/v1/templates"
    headers = {
        "Authorization": api_key,
        "Content-Type": "application/octet-stream"
    }

    print(f"Uploading {os.path.basename(file_path)}...")

    with ProgressFileReader(file_path) as file:
        response = requests.post(url, headers=headers, data=file)

    if response.status_code == 200:
        template = response.json()
        print(f"\n✓ Upload complete: {template['templateId']}")
        return template
    else:
        error = response.json()
        print(f"\n✗ Upload failed: {error.get('message')}")
        return None

# Example usage
template = upload_template_with_progress(
    "large-template.pictai",
    "YOUR_API_KEY"
)