Graphic Design for Content Creators: A Data-Backed Analysis

import os
import sys
import logging
from pathlib import Path
from PIL import Image, ImageDraw, ImageFont
import subprocess
from typing import List, Optional

# Configure logging for audit trails
logging.basicConfig(
    level=logging.INFO,
    format=\"%(asctime)s - %(levelname)s - %(message)s\",
    handlers=[logging.StreamHandler(sys.stdout)]
)
logger = logging.getLogger(__name__)

class SocialMediaAssetProcessor:
    \"\"\"Batch process raw design assets into platform-specific social media formats.\"\"\"

    # Platform-specific dimensions (width x height in pixels)
    PLATFORM_DIMS = {
        \"instagram_post\": (1080, 1080),
        \"instagram_story\": (1080, 1920),
        \"tiktok_video_cover\": (1080, 1920),
        \"youtube_thumbnail\": (1280, 720),
        \"twitter_header\": (1500, 500)
    }

    def __init__(self, input_dir: str, output_dir: str, font_path: Optional[str] = None):
        self.input_dir = Path(input_dir)
        self.output_dir = Path(output_dir)
        self.font_path = font_path or \"/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf\"
        self._validate_dirs()

    def _validate_dirs(self) -> None:
        \"\"\"Ensure input and output directories exist, create output if missing.\"\"\"
        if not self.input_dir.exists():
            logger.error(f\"Input directory {self.input_dir} does not exist\")
            raise FileNotFoundError(f\"Input directory {self.input_dir} missing\")
        self.output_dir.mkdir(parents=True, exist_ok=True)
        logger.info(f\"Initialized processor: input={self.input_dir}, output={self.output_dir}\")

    def _get_platform_suffix(self, platform: str) -> str:
        \"\"\"Return file suffix for platform, default to instagram_post.\"\"\"
        return platform if platform in self.PLATFORM_DIMS else \"instagram_post\"

    def resize_with_pillow(self, input_path: Path, platform: str) -> Path:
        \"\"\"Resize image to platform dimensions using Pillow, preserve aspect ratio.\"\"\"
        try:
            target_w, target_h = self.PLATFORM_DIMS.get(platform, (1080, 1080))
            with Image.open(input_path) as img:
                # Convert to RGB to avoid alpha channel issues
                if img.mode not in (\"RGB\", \"RGBA\"):
                    img = img.convert(\"RGB\")
                # Calculate aspect ratio-preserving resize
                img_ratio = img.width / img.height
                target_ratio = target_w / target_h
                if img_ratio > target_ratio:
                    # Image is wider than target: fit to width
                    new_w = target_w
                    new_h = int(target_w / img_ratio)
                else:
                    # Image is taller than target: fit to height
                    new_h = target_h
                    new_w = int(target_h * img_ratio)
                resized = img.resize((new_w, new_h), Image.Resampling.LANCZOS)
                # Create canvas with target dimensions, paste resized image centered
                canvas = Image.new(\"RGB\", (target_w, target_h), (255, 255, 255))
                paste_x = (target_w - new_w) // 2
                paste_y = (target_h - new_h) // 2
                canvas.paste(resized, (paste_x, paste_y))
                # Add platform watermark for audit
                draw = ImageDraw.Draw(canvas)
                font = ImageFont.truetype(self.font_path, 24)
                draw.text((10, 10), f\"Processed for {platform}\", fill=(0, 0, 0), font=font)
                # Save output
                output_path = self.output_dir / f\"{input_path.stem}_{platform}{input_path.suffix}\"
                canvas.save(output_path, quality=95, optimize=True)
                logger.info(f\"Processed {input_path.name} to {platform} format: {output_path}\")
                return output_path
        except Exception as e:
            logger.error(f\"Failed to process {input_path.name} with Pillow: {str(e)}\")
            raise

    def batch_process(self, platforms: List[str]) -> int:
        \"\"\"Process all supported images in input dir for all specified platforms.\"\"\"
        supported_exts = {\".png\", \".jpg\", \".jpeg\", \".webp\", \".svg\"}
        processed_count = 0
        for img_path in self.input_dir.iterdir():
            if img_path.suffix.lower() in supported_exts:
                for platform in platforms:
                    try:
                        if img_path.suffix.lower() == \".svg\":
                            # Use ImageMagick for SVG rasterization (better than Pillow)
                            self._process_svg_imagemagick(img_path, platform)
                        else:
                            self.resize_with_pillow(img_path, platform)
                        processed_count += 1
                    except Exception as e:
                        logger.warning(f\"Skipping {img_path.name} for {platform}: {str(e)}\")
                        continue
        logger.info(f\"Batch processing complete: {processed_count} assets generated\")
        return processed_count

    def _process_svg_imagemagick(self, svg_path: Path, platform: str) -> Path:
        \"\"\"Use ImageMagick CLI for SVG rasterization to avoid Pillow SVG limitations.\"\"\"
        target_w, target_h = self.PLATFORM_DIMS.get(platform, (1080, 1080))
        output_path = self.output_dir / f\"{svg_path.stem}_{platform}.png\"
        try:
            # ImageMagick command: resize SVG to target dimensions, preserve aspect ratio
            cmd = [
                \"magick\", \"convert\",
                \"-background\", \"white\",
                \"-density\", \"300\",  # High DPI for sharp rasterization
                str(svg_path),
                \"-resize\", f\"{target_w}x{target_h}\",
                \"-gravity\", \"center\",
                \"-extent\", f\"{target_w}x{target_h}\",
                str(output_path)
            ]
            result = subprocess.run(cmd, check=True, capture_output=True, text=True)
            logger.info(f\"Processed SVG {svg_path.name} to {platform}: {output_path}\")
            return output_path
        except subprocess.CalledProcessError as e:
            logger.error(f\"ImageMagick failed for {svg_path.name}: {e.stderr}\")
            raise

if __name__ == \"__main__\":
    # Example usage: process all assets for Instagram and YouTube
    processor = SocialMediaAssetProcessor(
        input_dir=\"./raw_assets\",
        output_dir=\"./processed_assets\",
        font_path=\"./fonts/OpenSans-Bold.ttf\"
    )
    try:
        count = processor.batch_process(platforms=[\"instagram_post\", \"youtube_thumbnail\"])
        print(f\"Successfully generated {count} assets\")
    except Exception as e:
        logger.error(f\"Batch processing failed: {str(e)}\")
        sys.exit(1)

const fs = require('fs');
const path = require('path');
const { Canva } = require('@canva/api-node-sdk'); // SDK from https://github.com/canva/canva-api-node-sdk
const sharp = require('sharp');
const { promisify } = require('util');

// Promisify fs methods for async/await
const writeFileAsync = promisify(fs.writeFile);
const readdirAsync = promisify(fs.readdir);
const statAsync = promisify(fs.stat);

// Validate required environment variables
const REQUIRED_ENV = ['CANVA_CLIENT_ID', 'CANVA_CLIENT_SECRET', 'CANVA_BRAND_ID'];
for (const envVar of REQUIRED_ENV) {
    if (!process.env[envVar]) {
        console.error(`Missing required environment variable: ${envVar}`);
        process.exit(1);
    }
}

// Initialize Canva SDK client
const canva = new Canva({
    clientId: process.env.CANVA_CLIENT_ID,
    clientSecret: process.env.CANVA_CLIENT_SECRET,
    redirectUri: process.env.CANVA_REDIRECT_URI || 'http://localhost:3000/callback'
});

/**
 * Generate programmatic social media designs using Canva's design automation API
 * Documentation: https://www.canva.com/developers/docs/design-automation/
 */
class CanvaDesignAutomator {
    constructor(brandId, outputDir = './canva_designs') {
        this.brandId = brandId;
        this.outputDir = outputDir;
        this._initOutputDir();
    }

    _initOutputDir() {
        if (!fs.existsSync(this.outputDir)) {
            fs.mkdirSync(this.outputDir, { recursive: true });
            console.log(`Created output directory: ${this.outputDir}`);
        }
    }

    /**
     * Create a template-based design for a given platform
     * @param {string} templateId - Canva template ID from brand library
     * @param {Object} dynamicData - Key-value pairs to replace template placeholders
     * @param {string} platform - Target platform (instagram, youtube, etc.)
     * @returns {Promise} Path to exported design file
     */
    async createDesignFromTemplate(templateId, dynamicData, platform) {
        try {
            // 1. Create design from template
            const design = await canva.designs.create({
                brand: this.brandId,
                templateId: templateId,
                title: `Auto-generated ${platform} design - ${new Date().toISOString()}`
            });
            console.log(`Created design ${design.id} from template ${templateId}`);

            // 2. Populate dynamic template fields
            const elements = await canva.designs.getElements(design.id);
            for (const element of elements.data) {
                if (element.type === 'TEXT' && dynamicData[element.name]) {
                    await canva.designs.updateElement(design.id, element.id, {
                        text: dynamicData[element.name]
                    });
                    console.log(`Updated text element ${element.name} with value: ${dynamicData[element.name]}`);
                }
            }

            // 3. Export design to platform-specific format
            const exportFormat = platform === 'youtube' ? 'PNG' : 'JPEG';
            const exportResult = await canva.designs.export(design.id, {
                format: exportFormat,
                quality: 'HIGH'
            });

            // 4. Download exported design and optimize with Sharp
            const designBuffer = await canva.files.download(exportResult.fileId);
            const outputPath = path.join(this.outputDir, `${design.id}_${platform}.${exportFormat.toLowerCase()}`);

            // Optimize image for platform
            let optimizedBuffer;
            if (platform === 'instagram_post') {
                optimizedBuffer = await sharp(designBuffer)
                    .resize(1080, 1080, { fit: 'cover' })
                    .jpeg({ quality: 90 })
                    .toBuffer();
            } else if (platform === 'youtube_thumbnail') {
                optimizedBuffer = await sharp(designBuffer)
                    .resize(1280, 720, { fit: 'cover' })
                    .png({ compressionLevel: 9 })
                    .toBuffer();
            } else {
                optimizedBuffer = designBuffer;
            }

            await writeFileAsync(outputPath, optimizedBuffer);
            console.log(`Exported and optimized design to ${outputPath}`);

            // 5. Cleanup: delete temporary design from Canva
            await canva.designs.delete(design.id);
            console.log(`Cleaned up temporary design ${design.id}`);

            return outputPath;
        } catch (error) {
            console.error(`Failed to create design from template ${templateId}: ${error.message}`);
            throw error;
        }
    }

    /**
     * Batch process multiple template designs for a content calendar
     * @param {Array} designRequests - Array of { templateId, dynamicData, platform }
     * @returns {Promise>} Paths to generated design files
     */
    async batchProcessDesigns(designRequests) {
        const results = [];
        for (const request of designRequests) {
            try {
                const outputPath = await this.createDesignFromTemplate(
                    request.templateId,
                    request.dynamicData,
                    request.platform
                );
                results.push(outputPath);
            } catch (error) {
                console.warn(`Skipping design request for ${request.platform}: ${error.message}`);
            }
        }
        console.log(`Batch processing complete: ${results.length} designs generated`);
        return results;
    }
}

// Example usage
(async () => {
    const automator = new CanvaDesignAutomator(process.env.CANVA_BRAND_ID);

    // Define design requests for weekly content calendar
    const designRequests = [
        {
            templateId: 'template_12345', // Instagram post template from brand library
            dynamicData: {
                'headline': 'New Open Source Release!',
                'date': '2024-06-15',
                'cta': 'Link in bio to download'
            },
            platform: 'instagram_post'
        },
        {
            templateId: 'template_67890', // YouTube thumbnail template
            dynamicData: {
                'video_title': 'Data-Backed Design Analysis',
                'host_name': 'Senior Dev Weekly'
            },
            platform: 'youtube_thumbnail'
        }
    ];

    try {
        const generatedDesigns = await automator.batchProcessDesigns(designRequests);
        console.log('Generated designs:', generatedDesigns);
    } catch (error) {
        console.error('Batch design processing failed:', error);
        process.exit(1);
    }
})();

#!/bin/bash

# Exit on error, undefined variables, and pipe failures
set -euo pipefail
IFS=$'\n\t'

# Configuration: adjust these variables for your pipeline
INPUT_DIR=\"./raw_svgs\"
OUTPUT_DIR=\"./optimized_assets\"
TARGET_PLATFORMS=(\"instagram_post\" \"youtube_thumbnail\" \"tiktok_cover\")
LOG_FILE=\"./design_pipeline_$(date +%Y%m%d_%H%M%S).log\"

# Platform dimension mapping (width x height)
declare -A PLATFORM_DIMS=(
    [\"instagram_post\"]=\"1080x1080\"
    [\"youtube_thumbnail\"]=\"1280x720\"
    [\"tiktok_cover\"]=\"1080x1920\"
)

# Logging function to write to stdout and log file
log() {
    local level=\"$1\"
    local message=\"$2\"
    local timestamp=$(date +\"%Y-%m-%d %H:%M:%S\")
    echo \"[${timestamp}] [${level}] ${message}\" | tee -a \"${LOG_FILE}\"
}

# Validate required dependencies are installed
validate_dependencies() {
    local deps=(\"svgo\" \"magick\" \"jq\" \"parallel\")
    for dep in \"${deps[@]}\"; do
        if ! command -v \"${dep}\" &> /dev/null; then
            log \"ERROR\" \"Missing required dependency: ${dep}\"
            log \"INFO\" \"Install with: sudo apt-get install ${dep} (svgo: npm install -g svgo)\"
            exit 1
        fi
    done
    log \"INFO\" \"All dependencies validated successfully\"
}

# Create output directories for each platform
create_output_dirs() {
    mkdir -p \"${OUTPUT_DIR}\"
    for platform in \"${TARGET_PLATFORMS[@]}\"; do
        mkdir -p \"${OUTPUT_DIR}/${platform}\"
    done
    log \"INFO\" \"Created output directories in ${OUTPUT_DIR}\"
}

# Optimize SVG files using svgo to reduce file size
optimize_svgs() {
    log \"INFO\" \"Starting SVG optimization with svgo...\"
    local svg_count=0
    for svg_file in \"${INPUT_DIR}\"/*.svg; do
        if [[ -f \"${svg_file}\" ]]; then
            local filename=$(basename \"${svg_file}\")
            log \"INFO\" \"Optimizing ${filename}...\"
            # Run svgo with config to preserve accessibility attributes
            if svgo --config '{\"plugins\":[{\"removeViewBox\":false},{\"removeTitle\":false}]}' \
                -i \"${svg_file}\" \
                -o \"${OUTPUT_DIR}/optimized_${filename}\"; then
                log \"INFO\" \"Optimized ${filename} successfully\"
                ((svg_count++))
            else
                log \"WARNING\" \"Failed to optimize ${filename}\"
            fi
        fi
    done
    log \"INFO\" \"SVG optimization complete: ${svg_count} files processed\"
}

# Rasterize optimized SVGs to platform-specific PNGs using ImageMagick
rasterize_to_platforms() {
    log \"INFO\" \"Starting SVG rasterization for platforms: ${TARGET_PLATFORMS[*]}\"
    local raster_count=0
    for svg_file in \"${OUTPUT_DIR}\"/optimized_*.svg; do
        if [[ -f \"${svg_file}\" ]]; then
            local filename=$(basename \"${svg_file}\" .svg | sed 's/optimized_//')
            for platform in \"${TARGET_PLATFORMS[@]}\"; do
                local dims=\"${PLATFORM_DIMS[$platform]}\"
                local output_path=\"${OUTPUT_DIR}/${platform}/${filename}_${platform}.png\"
                log \"INFO\" \"Rasterizing ${filename}.svg to ${platform} (${dims})...\"
                # ImageMagick command: high DPI, center extent, white background
                if magick convert \
                    -background white \
                    -density 300 \
                    \"${svg_file}\" \
                    -resize \"${dims}\" \
                    -gravity center \
                    -extent \"${dims}\" \
                    \"${output_path}\"; then
                    log \"INFO\" \"Rasterized to ${output_path}\"
                    ((raster_count++))
                else
                    log \"WARNING\" \"Failed to rasterize ${filename}.svg for ${platform}\"
                fi
            done
        fi
    done
    log \"INFO\" \"Rasterization complete: ${raster_count} platform assets generated\"
}

# Generate performance report comparing original and optimized assets
generate_report() {
    log \"INFO\" \"Generating performance report...\"
    local report_path=\"${OUTPUT_DIR}/pipeline_report.json\"
    local total_original_size=0
    local total_optimized_size=0
    local total_raster_size=0

    # Calculate original SVG size
    for svg_file in \"${INPUT_DIR}\"/*.svg; do
        if [[ -f \"${svg_file}\" ]]; then
            total_original_size=$((total_original_size + $(stat -c%s \"${svg_file}\")))
        fi
    done

    # Calculate optimized SVG size
    for svg_file in \"${OUTPUT_DIR}\"/optimized_*.svg; do
        if [[ -f \"${svg_file}\" ]]; then
            total_optimized_size=$((total_optimized_size + $(stat -c%s \"${svg_file}\")))
        fi
    done

    # Calculate rasterized asset size
    for platform in \"${TARGET_PLATFORMS[@]}\"; do
        for png_file in \"${OUTPUT_DIR}/${platform}\"/*.png; do
            if [[ -f \"${png_file}\" ]]; then
                total_raster_size=$((total_raster_size + $(stat -c%s \"${png_file}\")))
            fi
        done
    done

    # Write JSON report
    jq -n \
        --arg total_original \"$((total_original_size / 1024))KB\" \
        --arg total_optimized \"$((total_optimized_size / 1024))KB\" \
        --arg total_raster \"$((total_raster_size / 1024))KB\" \
        --arg optimization_savings \"$(( (total_original_size - total_optimized_size) / 1024 ))KB\" \
        '{
            \"pipeline_report\": {
                \"total_original_svg_size\": $total_original,
                \"total_optimized_svg_size\": $total_optimized,
                \"total_raster_asset_size\": $total_raster,
                \"svg_optimization_savings\": $optimization_savings,
                \"platforms_processed\": $ARGS.positional
            }
        }' --args \"${TARGET_PLATFORMS[@]}\" > \"${report_path}\"

    log \"INFO\" \"Performance report generated: ${report_path}\"
}

# Main execution flow
main() {
    log \"INFO\" \"Starting graphic design pipeline...\"
    validate_dependencies
    create_output_dirs
    optimize_svgs
    rasterize_to_platforms
    generate_report
    log \"INFO\" \"Pipeline completed successfully. Logs: ${LOG_FILE}\"
}

main