Handling Inputs and Outputs

# Retrieve existing completed projects without creating another generation.
video = client.v1.video_projects.get(id=existing_video_id)
image = client.v1.image_projects.get(id=existing_image_id)

if video.status != "complete" or image.status != "complete":
    raise RuntimeError("Both projects must be complete before reusing their outputs.")
if not video.downloads or not image.downloads:
    raise RuntimeError("No download URL is available. Check the project details.")

result = client.v1.face_swap.create(
    assets={
        "image_file_path": image.downloads[0].url,
        "video_file_path": video.downloads[0].url,
        "video_source": "file"
    },
    start_seconds=0,
    end_seconds=5
)

// Retrieve existing completed projects without creating another generation.
const video = await client.v1.videoProjects.get({ id: existingVideoId });
const image = await client.v1.imageProjects.get({ id: existingImageId });

if (video.status !== "complete" || image.status !== "complete") {
  throw new Error("Both projects must be complete before reusing their outputs.");
}
if (!video.downloads?.length || !image.downloads?.length) {
  throw new Error("No download URL is available. Check the project details.");
}

const result = await client.v1.faceSwap.create({
  assets: {
    imageFilePath: image.downloads[0].url,
    videoFilePath: video.downloads[0].url,
    videoSource: "file",
  },
  startSeconds: 0,
  endSeconds: 5,
});

from magic_hour import Client

client = Client(token="YOUR_API_KEY")

# Upload file and get file_path
file_path = client.v1.files.upload_file("/path/to/your/image.jpg")

# Use in API calls
result = client.v1.face_swap_photo.create(
    assets={
        "source_file_path": file_path,  # Use uploaded file
        "target_file_path": "https://upload.wikimedia.org/wikipedia/commons/e/ec/Chris_Cassidy_-_Official_NASA_Astronaut_Portrait_in_EMU_%28cropped%29.jpg"
    }
)

import { Client } from "magic-hour";

const client = new Client({ token: "YOUR_API_KEY" });

// Upload file and get filePath
const filePath = await client.v1.files.uploadFile("/path/to/your/image.jpg");

// Use in API calls
const result = await client.v1.faceSwapPhoto.create({
  assets: {
    sourceFilePath: filePath, // Use uploaded file
    targetFilePath:
      "https://upload.wikimedia.org/wikipedia/commons/e/ec/Chris_Cassidy_-_Official_NASA_Astronaut_Portrait_in_EMU_%28cropped%29.jpg",
  },
});

package main

import (
	"fmt"
	"net/http"
	"os"

	sdk "github.com/magichourhq/magic-hour-go/client"
	"github.com/magichourhq/magic-hour-go/resources/v1/files/upload_urls"
	"github.com/magichourhq/magic-hour-go/types"
)

func main() {
	client := sdk.NewClient(sdk.WithBearerAuth(os.Getenv("MAGIC_HOUR_API_KEY")))

	// Step 1: Request upload URL
	response, err := client.V1.Files.UploadUrls.Create(upload_urls.CreateRequest{
		Items: []types.V1FilesUploadUrlsCreateBodyItemsItem{
			{Extension: "mp4", Type: types.V1FilesUploadUrlsCreateBodyItemsItemTypeEnumVideo},
		},
	})

	if err != nil {
		fmt.Println(err)
		return
	}

	// Step 2: Upload file to the URL
	localPath := "/path/to/file/video.mp4"
	file, err := os.Open(localPath)
	if err != nil {
		fmt.Println(err)
		return
	}
	defer file.Close()

	req, err := http.NewRequest("PUT", response.Items[0].UploadUrl, file)
	if err != nil {
		fmt.Println(err)
		return
	}

	fileClient := &http.Client{}
	uploadResponse, err := fileClient.Do(req)
	if err != nil {
		fmt.Println(err)
		return
	}

	defer uploadResponse.Body.Close()
	if uploadResponse.StatusCode < 200 || uploadResponse.StatusCode >= 300 {
		fmt.Printf("Upload failed: %s\n", uploadResponse.Status)
		return
	}

	// Step 3: Use file_path in API calls
	filePath := response.Items[0].FilePath
	fmt.Printf("✅ File uploaded: %s\n", filePath)

	// Now use filePath in your API calls
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut client = magic_hour::Client::default()
        .with_bearer_auth(&std::env::var("MAGIC_HOUR_API_KEY")?);

    // Step 1: Request upload URL
    let response = client.v1().files().upload_urls()
        .create(magic_hour::resources::v1::files::upload_urls::CreateRequest {
            items: vec![magic_hour::models::V1FilesUploadUrlsCreateBodyItemsItem {
                extension: "mp4".to_string(),
                type_: magic_hour::models::V1FilesUploadUrlsCreateBodyItemsItemTypeEnum::Video,
            }],
        }).await?;

    // Step 2: Upload raw bytes to the signed URL without the API bearer token
    let bytes = std::fs::read("/path/to/file/video.mp4")?;
    reqwest::Client::new()
        .put(&response.items[0].upload_url)
        .body(bytes)
        .send().await?
        .error_for_status()?;

    // Step 3: Use file_path in API calls
    let file_path = &response.items[0].file_path;
    println!("File uploaded: {file_path}");
    Ok(())
}

# Step 1: Request upload URL
response=$(curl -fsS https://api.magichour.ai/v1/files/upload-urls \
  --request POST \
  --header 'Authorization: Bearer YOUR_API_KEY' \
  --header 'Content-Type: application/json' \
  --data '{
    "items": [
      { "type": "video", "extension": "mp4" }
    ]
  }')

# Step 2: Upload file to the URL
upload_url=$(echo "$response" | jq -r '.items[0].upload_url')
curl -fsS "$upload_url" \
  --request PUT \
  --data-binary @/path/to/file/video.mp4

# Step 3: Extract file_path for API calls
file_path=$(echo "$response" | jq -r '.items[0].file_path')
echo "File uploaded: $file_path"

response = client.v1.files.upload_urls.create(
    items=[
        {"type": "video", "extension": "mp4"},
        {"type": "image", "extension": "jpg"},
        {"type": "audio", "extension": "mp3"}
    ]
)

# Upload each file to its corresponding upload_url before using these paths.
# Requesting URLs alone does not upload any bytes; order matches the request.
video_path = response.items[0].file_path
image_path = response.items[1].file_path
audio_path = response.items[2].file_path

const response = await client.v1.files.uploadUrls.create({
  items: [
    { type: "video", extension: "mp4" },
    { type: "image", extension: "jpg" },
    { type: "audio", extension: "mp3" },
  ],
});

// Upload each file to its corresponding uploadUrl before using these paths.
// Requesting URLs alone does not upload any bytes; order matches the request.
const videoPath = response.items[0].filePath;
const imagePath = response.items[1].filePath;
const audioPath = response.items[2].filePath;

# Get fresh download URLs for completed project
status = client.v1.video_projects.get(id="project_id")
download_url = status.downloads[0].url

// Get fresh download URLs for completed project
const status = await client.v1.videoProjects.get({ id: "project_id" });
const downloadUrl = status.downloads[0].url;

import requests
from pathlib import Path
import time

def download_file(url, output_path, max_retries=3):
    """Download file with retries and streaming for large files"""

    # Create output directory
    Path(output_path).parent.mkdir(parents=True, exist_ok=True)

    for attempt in range(max_retries):
        try:
            print(f"Downloading (attempt {attempt + 1}/{max_retries})...")

            response = requests.get(url, stream=True, timeout=60)
            response.raise_for_status()

            # Stream download for large files
            with open(output_path, "wb") as f:
                for chunk in response.iter_content(chunk_size=8192):
                    f.write(chunk)

            file_size = Path(output_path).stat().st_size
            print(f"✅ Downloaded: {output_path} ({file_size:,} bytes)")
            return True

        except requests.exceptions.RequestException as e:
            print(f"❌ Download failed: {e}")
            if attempt < max_retries - 1:
                wait_time = 2 ** attempt  # Exponential backoff
                print(f"   Retrying in {wait_time} seconds...")
                time.sleep(wait_time)
            else:
                print("   Max retries exceeded")
                return False

    return False

# Usage
download_file(download_url, "outputs/result.mp4")

import { writeFileSync, mkdirSync } from "fs";
import { dirname } from "path";

async function downloadFile(url, outputPath, maxRetries = 3) {
  // Create output directory
  try {
    mkdirSync(dirname(outputPath), { recursive: true });
  } catch (e) {
    // Directory exists
  }

  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      console.log(`Downloading (attempt ${attempt + 1}/${maxRetries})...`);

      const response = await fetch(url);
      if (!response.ok) {
        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
      }

      const arrayBuffer = await response.arrayBuffer();
      const buffer = Buffer.from(arrayBuffer);

      writeFileSync(outputPath, buffer);

      console.log(`✅ Downloaded: ${outputPath} (${buffer.length.toLocaleString()} bytes)`);
      return true;
    } catch (error) {
      console.log(`❌ Download failed: ${error.message}`);
      if (attempt < maxRetries - 1) {
        const waitTime = Math.pow(2, attempt) * 1000; // Exponential backoff
        console.log(`   Retrying in ${waitTime / 1000} seconds...`);
        await new Promise((resolve) => setTimeout(resolve, waitTime));
      } else {
        console.log("   Max retries exceeded");
        return false;
      }
    }
  }

  return false;
}

// Usage
await downloadFile(downloadUrl, "outputs/result.mp4");

# Download all outputs
status_response = client.v1.image_projects.get(id="project_id")
for i, download in enumerate(status_response.downloads):
    filename = f"output_{i+1}.png"
    filepath = f"outputs/{filename}"
    if download_file(download.url, filepath):
        print(f"Downloaded: {filename}")

// Download all outputs
const statusResponse = await client.v1.imageProjects.get({ id: "project_id" });
for (const [i, download] of statusResponse.downloads.entries()) {
  const filename = `output_${i + 1}.png`;
  const filepath = `outputs/${filename}`;
  if (await downloadFile(download.url, filepath)) {
    console.log(`Downloaded: ${filename}`);
  }
}

result = client.v1.ai_image_generator.generate(
    image_count=1,
    model="z-image-turbo",
    resolution="640px",
    aspect_ratio="16:9",
    style={"prompt": "Cool image", "tool": "ai-anime-generator"},
    name="AI Image Generated by Magic Hour",
    wait_for_completion=True,
    download_outputs=True,
    download_directory="."
)

if result.status != "complete":
    raise RuntimeError(f"Project {result.id}: {result.status}; {result.error}")

paths = result.downloaded_paths or []
if not paths:
    raise RuntimeError(f"Project {result.id} completed, but no files were downloaded. Retrieve this same project ID to retry the download.")
print(f"✅ Downloaded to: {paths}")

const result = await client.v1.aiImageGenerator.generate(
  {
    imageCount: 1,
    model: "z-image-turbo",
    resolution: "640px",
    aspectRatio: "16:9",
    style: { prompt: "Mountain sunset", tool: "ai-anime-generator" },
  },
  {
    waitForCompletion: true,
    downloadOutputs: true, // Auto-download
    downloadDirectory: ".", // Where to save
  }
);

if (result.status !== "complete") {
  throw new Error(`Project ${result.id}: ${result.status}; ${JSON.stringify(result.error)}`);
}
if (!result.downloadedPaths?.length) {
  throw new Error(
    `Project ${result.id} completed, but no files were downloaded. Retrieve this same project ID to retry the download.`
  );
}
console.log(`Downloaded to: ${result.downloadedPaths}`);

# Get fresh download URLs for an existing project
status = client.v1.video_projects.get(id="project_id")
fresh_url = status.downloads[0].url

// Get fresh download URLs for an existing project
const status = await client.v1.videoProjects.get({ id: "project_id" });
const freshUrl = status.downloads[0].url;