Update Project

PUT https://api.pictory.ai/pictoryapis/v2/projects/{projectid}

{
  "projectName": "My Updated Video",
  "audioSpeed": 100,
  "videoVolume": 50
}

{
  "scenes": [
    {
      "text": "Your new scene text here",
      "sentence": [
        {
          "text": "Your new ",
          "decoration": ["decor-bold"]
        },
        {
          "text": "scene text",
          "highlight": true,
          "decoration": ["decor-underline"]
        },
        {
          "text": " here"
        }
      ],
      "keywords": ["scene text"]
    }
  ]
}

{
  "scenes": [
    {
      "styleData": {
        "fontName": "Arial",
        "fontDisplayName": "Arial",
        "fontSize": "42",
        "fontColor": "rgb(255,255,255)",
        "fontWeight": 400,
        "textAlign": "left",
        "keywordColor": "rgba(141, 208, 229, 1)",
        "textBackgroundColor": "rgba(0,0,0,0.35)",
        "textShadowColor": "rgba(0,0,0,0)",
        "textShadowWidthFr": 0.03,
        "maxLines": 2,
        "width": 0.7,
        "preset": "bottom-left"
      }
    }
  ]
}

{
  "scenes": [
    {
      "settings": {
        "hideText": false
      }
    }
  ]
}

{
  "scenes": [
    {
      "background": {
        "type": "image",
        "elementData": {
          "url": "https://your-image-url.com/image.jpg",
          "preview_jpg": "https://your-image-url.com/preview.jpg",
          "thumb": "https://your-image-url.com/thumb.jpg",
          "thumb_jpg": "https://your-image-url.com/thumb.jpg",
          "library": "uploads",
          "libraryItemId": "your-item-id",
          "duration": 0
        },
        "styleData": {
          "kenBurns": "kb-364683-oqt0",
          "imageZoomPan": true,
          "width": 0.7,
          "aspectRatio": 1.78,
          "preset": "center-center",
          "colorOverlay": {
            "hide": false,
            "bgColor": "rgb(0,37,60)",
            "opacity": 0.5
          }
        }
      }
    }
  ]
}

{
  "scenes": [
    {
      "background": {
        "type": "video",
        "elementData": {
          "url": "https://your-video-url.com/video.mp4",
          "preview_jpg": "https://your-video-url.com/preview.jpg",
          "thumb": "https://your-video-url.com/thumb.mp4",
          "thumb_jpg": "https://your-video-url.com/thumb.jpg",
          "library": "uploads",
          "libraryItemId": "your-item-id",
          "duration": 10,
          "description": "Video description"
        },
        "styleData": {
          "imageZoomPan": true
        },
        "settings": {
          "loopVideo": true
        }
      }
    }
  ]
}

{
  "scenes": [
    {
      "background": {
        "type": "solid",
        "elementData": {
          "color": "rgb(69,123,113)"
        },
        "styleData": {}
      }
    }
  ]
}

{
  "scenes": [
    {
      "elements": [
        {
          "elementId": "existing-element-id",
          "type": "video",
          "isLogo": false,
          "hide": false,
          "settings": {
            "loopVideo": true,
            "muteClipAudio": true
          },
          "elementData": {
            "url": "https://your-video-url.com/clip.mp4",
            "preview_jpg": "https://your-video-url.com/preview.jpg",
            "thumb": "https://your-video-url.com/thumb.mp4",
            "thumb_jpg": "https://your-video-url.com/thumb.jpg",
            "library": "uploads",
            "libraryItemId": "your-item-id",
            "duration": 16
          },
          "styleData": {
            "top": 4.89,
            "left": 3.96,
            "width": 0.92,
            "aspectRatio": 1.78,
            "preset": null,
            "colorOverlay": {
              "hide": false,
              "bgColor": "rgb(110,111,132)",
              "opacity": 0.3
            }
          }
        }
      ]
    }
  ]
}

{
  "scenes": [
    {
      "elements": [
        {
          "elementId": "existing-element-id",
          "type": "text",
          "componentName": "main_title",
          "settings": {
            "textMode": "writeAnything"
          },
          "elementData": {
            "sentence": [
              {
                "text": "Your Custom Text",
                "decoration": ["decor-bold", "decor-underline"]
              }
            ]
          },
          "styleData": {
            "fontName": "Arial",
            "fontSize": "42",
            "fontColor": "rgb(255,255,255)",
            "textAlign": "center",
            "preset": "center-center",
            "width": 0.7,
            "animation": {
              "textAnimation": [
                {
                  "name": "Typewriter",
                  "type": ["entry"],
                  "writingStyle": "character",
                  "direction": "up",
                  "speed": { "value": 1 }
                },
                {
                  "name": "None",
                  "type": ["exit"]
                }
              ],
              "textBgAnimation": []
            }
          }
        }
      ]
    }
  ]
}

import requests

def update_scene_background(project_id, scene_index, new_media_url, media_type, api_key):
    """
    Update the background visual for a specific scene

    media_type: "image" or "video"
    """
    headers = {"Authorization": api_key, "Content-Type": "application/json"}

    # Get current project
    get_url = f"https://api.pictory.ai/pictoryapis/v2/projects/{project_id}"
    response = requests.get(get_url, headers=headers)
    project = response.json()

    # Update the scene background
    if scene_index < len(project.get('scenes', [])):
        background = project['scenes'][scene_index].get('background', {})
        background['type'] = media_type
        background['elementData'] = background.get('elementData', {})
        background['elementData']['url'] = new_media_url
        background['elementData']['preview_jpg'] = new_media_url
        background['elementData']['library'] = 'uploads'

        if media_type == 'video':
            background['settings'] = {'loopVideo': True}

        project['scenes'][scene_index]['background'] = background
        print(f"Updated scene {scene_index} background to: {new_media_url}")

        # Send update
        put_url = f"https://api.pictory.ai/pictoryapis/v2/projects/{project_id}"
        update_response = requests.put(put_url, json=project, headers=headers)
        result = update_response.json()

        if result.get('success'):
            print("Project updated successfully")
            return result
        else:
            print(f"Update failed: {result.get('message')}")
            return None
    else:
        print(f"Scene index {scene_index} out of range")
        return None

# Example usage
update_scene_background(
    "YOUR_PROJECT_ID",
    0,  # First scene
    "https://your-media-url.com/new-image.jpg",
    "image",
    "YOUR_API_KEY"
)

async function updateSceneText(projectId, sceneUpdates, apiKey) {
  const headers = {
    'Authorization': `${apiKey}`,
    'Content-Type': 'application/json'
  };

  // Get current project
  const getResponse = await fetch(
    `https://api.pictory.ai/pictoryapis/v2/projects/${projectId}`,
    { headers }
  );
  const project = await getResponse.json();

  // Update scene text
  sceneUpdates.forEach(({ sceneIndex, newText, keywords }) => {
    if (sceneIndex < project.scenes.length) {
      // Update the text field
      project.scenes[sceneIndex].text = newText;

      // Update sentence array with formatting
      project.scenes[sceneIndex].sentence = [
        {
          text: newText,
          highlight: false,
          decoration: ['decor-bold']
        }
      ];

      // Update keywords if provided
      if (keywords) {
        project.scenes[sceneIndex].keywords = keywords;
      }

      console.log(`Updated scene ${sceneIndex} text`);
    }
  });

  // Send update
  const updateResponse = await fetch(
    `https://api.pictory.ai/pictoryapis/v2/projects/${projectId}`,
    {
      method: 'PUT',
      headers,
      body: JSON.stringify(project)
    }
  );

  const result = await updateResponse.json();
  return result;
}

// Example usage
const updates = [
  { sceneIndex: 0, newText: 'A Stunning Masterpiece', keywords: ['Stunning Masterpiece'] },
  { sceneIndex: 1, newText: 'Sweeping views with year-round sunsets', keywords: ['Sweeping views', 'sunsets'] }
];

const result = await updateSceneText('YOUR_PROJECT_ID', updates, 'YOUR_API_KEY');
console.log('Update result:', result);

def update_scene_settings(project_id, settings_updates, api_key):
    """
    Apply settings to multiple scenes

    settings_updates: dict with scene indices as keys and settings as values
    Note:
      - scenes[].settings only supports: hideText
      - scenes[].elements[].settings supports: loopVideo, muteClipAudio
      - scenes[].background.settings supports: loopVideo (for video backgrounds)
      - scenes[].background.styleData supports: imageZoomPan

    Example: {
        0: {"hideText": True},
        2: {"hideText": False}
    }
    """
    headers = {"Authorization": api_key, "Content-Type": "application/json"}

    # Get current project
    get_url = f"https://api.pictory.ai/pictoryapis/v2/projects/{project_id}"
    response = requests.get(get_url, headers=headers)
    project = response.json()

    # Update scene settings (only hideText is supported at scene level)
    for scene_index, new_settings in settings_updates.items():
        if scene_index < len(project.get('scenes', [])):
            current_settings = project['scenes'][scene_index].get('settings', {})
            # Only update hideText at scene level
            if 'hideText' in new_settings:
                current_settings['hideText'] = new_settings['hideText']
            project['scenes'][scene_index]['settings'] = current_settings
            print(f"Updated settings for scene {scene_index}")

    # Send update
    put_url = f"https://api.pictory.ai/pictoryapis/v2/projects/{project_id}"
    update_response = requests.put(put_url, json=project, headers=headers)

    return update_response.json()


def update_element_settings(project_id, scene_index, element_index, element_settings, api_key):
    """
    Update settings for a specific video element overlay

    element_settings supports: loopVideo, muteClipAudio
    """
    headers = {"Authorization": api_key, "Content-Type": "application/json"}

    # Get current project
    get_url = f"https://api.pictory.ai/pictoryapis/v2/projects/{project_id}"
    response = requests.get(get_url, headers=headers)
    project = response.json()

    scenes = project.get('scenes', [])
    if scene_index < len(scenes):
        elements = scenes[scene_index].get('elements', [])
        if element_index < len(elements):
            current_settings = elements[element_index].get('settings', {})
            current_settings.update(element_settings)
            project['scenes'][scene_index]['elements'][element_index]['settings'] = current_settings
            print(f"Updated element {element_index} settings in scene {scene_index}")

    # Send update
    put_url = f"https://api.pictory.ai/pictoryapis/v2/projects/{project_id}"
    update_response = requests.put(put_url, json=project, headers=headers)

    return update_response.json()


# Example usage - Update scene settings (hideText only)
scene_settings = {
    0: {"hideText": True},
    2: {"hideText": False}
}
result = update_scene_settings("YOUR_PROJECT_ID", scene_settings, "YOUR_API_KEY")
print(f"Scene settings update successful: {result.get('success')}")

# Example usage - Update video element settings (loopVideo, muteClipAudio)
result = update_element_settings(
    "YOUR_PROJECT_ID",
    scene_index=0,
    element_index=0,
    element_settings={"loopVideo": True, "muteClipAudio": True},
    api_key="YOUR_API_KEY"
)
print(f"Element settings update successful: {result.get('success')}")

async function updateProjectMetadata(projectId, metadata, apiKey) {
  const headers = {
    'Authorization': `${apiKey}`,
    'Content-Type': 'application/json'
  };

  // Get current project
  const getResponse = await fetch(
    `https://api.pictory.ai/pictoryapis/v2/projects/${projectId}`,
    { headers }
  );
  const project = await getResponse.json();

  // Update metadata
  if (metadata.name) project.projectName = metadata.name;
  if (metadata.audioSpeed) project.audioSpeed = metadata.audioSpeed;
  if (metadata.videoVolume !== undefined) project.videoVolume = metadata.videoVolume;

  console.log('Updated project metadata:', metadata);

  // Send update
  const updateResponse = await fetch(
    `https://api.pictory.ai/pictoryapis/v2/projects/${projectId}`,
    {
      method: 'PUT',
      headers,
      body: JSON.stringify(project)
    }
  );

  return await updateResponse.json();
}

// Example usage
const metadata = {
  name: 'My Updated Project',
  audioSpeed: 105,
  videoVolume: 80
};

const result = await updateProjectMetadata('YOUR_PROJECT_ID', metadata, 'YOUR_API_KEY');
console.log('Result:', result);

def replace_all_backgrounds(project_id, media_items, api_key):
    """
    Replace background media for all scenes

    media_items: list of dicts with 'url' and 'type' keys
    Example: [
        {"url": "https://example.com/image1.jpg", "type": "image"},
        {"url": "https://example.com/video1.mp4", "type": "video"},
    ]
    """
    headers = {"Authorization": api_key, "Content-Type": "application/json"}

    # Get current project
    get_url = f"https://api.pictory.ai/pictoryapis/v2/projects/{project_id}"
    response = requests.get(get_url, headers=headers)
    project = response.json()

    scenes = project.get('scenes', [])

    if len(media_items) != len(scenes):
        print(f"Warning: {len(media_items)} items provided for {len(scenes)} scenes")
        return None

    # Update all scene backgrounds
    for i, media in enumerate(media_items):
        background = scenes[i].get('background', {})
        background['type'] = media['type']
        background['elementData'] = background.get('elementData', {})
        background['elementData']['url'] = media['url']
        background['elementData']['preview_jpg'] = media['url']
        background['elementData']['library'] = 'uploads'

        if media['type'] == 'video':
            background['settings'] = {'loopVideo': True}
            background['elementData']['duration'] = media.get('duration', 10)

        scenes[i]['background'] = background
        print(f"Scene {i}: {media['url']} ({media['type']})")

    project['scenes'] = scenes

    # Send update
    put_url = f"https://api.pictory.ai/pictoryapis/v2/projects/{project_id}"
    update_response = requests.put(put_url, json=project, headers=headers)

    return update_response.json()

# Example usage
new_backgrounds = [
    {"url": "https://media-url.com/scene1.jpg", "type": "image"},
    {"url": "https://media-url.com/scene2.mp4", "type": "video", "duration": 15},
    {"url": "https://media-url.com/scene3.jpg", "type": "image"}
]

result = replace_all_backgrounds("YOUR_PROJECT_ID", new_backgrounds, "YOUR_API_KEY")
if result and result.get('success'):
    print("All backgrounds updated successfully")

import copy

def safe_update_project(project_id, update_function, api_key):
    """
    Safely update project with validation

    update_function: function that takes project dict and modifies it
    """
    headers = {"Authorization": api_key, "Content-Type": "application/json"}

    # Get current project
    get_url = f"https://api.pictory.ai/pictoryapis/v2/projects/{project_id}"
    response = requests.get(get_url, headers=headers)

    if response.status_code != 200:
        print("Failed to fetch project")
        return None

    original_project = response.json()
    updated_project = copy.deepcopy(original_project)

    # Apply updates
    try:
        update_function(updated_project)
    except Exception as e:
        print(f"Error applying updates: {e}")
        return None

    # Validate critical fields are present
    required_fields = ['projectName', 'scenes', 'schemaVersion']
    for field in required_fields:
        if field not in updated_project:
            print(f"Critical field '{field}' missing after update")
            return None

    # Send update
    put_url = f"https://api.pictory.ai/pictoryapis/v2/projects/{project_id}"
    update_response = requests.put(put_url, json=updated_project, headers=headers)

    result = update_response.json()

    if result.get('success'):
        print("Project updated successfully")
    else:
        print(f"Update failed: {result.get('message')}")

    return result

# Example usage
def my_updates(project):
    """Define your updates here"""
    project['projectName'] = 'New Name'
    project['audioSpeed'] = 95

    # Hide text for first scene (scenes[].settings.hideText)
    if project['scenes']:
        if 'settings' not in project['scenes'][0]:
            project['scenes'][0]['settings'] = {}
        project['scenes'][0]['settings']['hideText'] = True

    # Mute audio for first video element (elements[].settings.muteClipAudio)
    if project['scenes'] and project['scenes'][0].get('elements'):
        element = project['scenes'][0]['elements'][0]
        if element.get('type') == 'video':
            if 'settings' not in element:
                element['settings'] = {}
            element['settings']['muteClipAudio'] = True

result = safe_update_project("YOUR_PROJECT_ID", my_updates, "YOUR_API_KEY")