SDK Python Frame.io — Guida al caricamento

Questa guida spiega come caricare i file in Frame.io usando l’SDK Python Frame.io (frameio). L’SDK gestisce caricamenti multi-parte basati su chunk verso S3 tramite URL pre-firmati, con worker paralleli, nuovi tentativi automatici e tracciamento facoltativo dello stato di avanzamento. Per i concetti generali dell’API di caricamento (URL di caricamento, intestazioni, suddivisione in chunk), consulta Come funzionano i caricamenti locali e remoti.


Prerequisiti

1

Autenticazione

Hai un client Frameio funzionante. Consulta la guida all’autenticazione per informazioni sulla configurazione.

2

Installa l'SDK

$ pip install frameio
3

Cartella di destinazione

Hai bisogno dell’account_id e del folder_id in cui deve essere caricato il file. Usa l’SDK per trovarli:

1 # List your accounts
2 accounts = client.accounts.index()
3 account_id = accounts.data[0].id
4
5 # List workspaces in the account
6 workspaces = client.workspaces.index(account_id=account_id)
7 workspace_id = workspaces.data[0].id
8
9 # List projects in the workspace
10 projects = client.projects.index(account_id=account_id, workspace_id=workspace_id)
11 project = projects.data[0]
12
13 # The project's root folder is the top-level upload target
14 folder_id = project.root_folder_id
15
16 # Or list subfolders to upload into a specific one
17 folders = client.folders.list(account_id=account_id, folder_id=folder_id)

Avvio rapido

1import os
2from frameio import Frameio
3from frameio.files import FileCreateLocalUploadParamsData
4from frameio.upload import FrameioUploader
5
6client = Frameio(token="YOUR_TOKEN")
7
8file_path = "/path/to/video.mp4"
9file_size = os.path.getsize(file_path)
10
11# 1. Create the file resource and get pre-signed upload URLs
12response = client.files.create_local_upload(
13 account_id="YOUR_ACCOUNT_ID",
14 folder_id="YOUR_FOLDER_ID",
15 data=FileCreateLocalUploadParamsData(
16 name="video.mp4",
17 file_size=file_size,
18 ),
19)
20
21# 2. Upload the file to S3
22with open(file_path, "rb") as f:
23 FrameioUploader(response.data, f).upload()

Ecco fatto. L’SDK suddivide il file in chunk in base agli URL di caricamento restituiti dall’API, li carica in parallelo e gestisce automaticamente i nuovi tentativi.


Come funziona

Il caricamento locale è un processo in due fasi:

1

Crea una risorsa di file

Chiama client.files.create_local_upload() con il nome e la dimensione del file. L’API crea un file segnaposto e restituisce URL PUT S3 pre-firmati, uno per chunk. Il numero di URL (e perciò di chunk) dipende dalla dimensione del file.

2

Carica in S3

FrameioUploader legge gli URL di caricamento dalla risposta, suddivide il file in chunk corrispondenti e invia ciascun chunk al rispettivo URL in parallelo utilizzando un pool di thread. Ogni richiesta include le intestazioni obbligatorie x-amz-acl: private e Content-Type.

Il caricamento avviene direttamente dalla tua applicazione a S3, senza passare attraverso i server dell’API Frame.io. È lo stesso schema utilizzato da servizi come YouTube, Vimeo e Dropbox per il caricamento di file di grandi dimensioni.


Utilizzo di FrameioUploader

FrameioUploader è il modo consigliato per caricare file. Racchiude l’uploader basato su chunk a livello inferiore e gestisce tutti i dettagli: estrazione degli URL di caricamento dalla risposta dell’API, impostazione delle intestazioni richieste, suddivisione del file in chunk e caricamento in parallelo.

Tracciamento dello stato di avanzamento

Utilizza il callback on_progress per tenere traccia dello stato di avanzamento del caricamento:

1def on_progress(bytes_uploaded: int, total_bytes: int) -> None:
2 pct = bytes_uploaded / total_bytes * 100
3 print(f"\r{pct:.1f}% ({bytes_uploaded:,} / {total_bytes:,} bytes)", end="", flush=True)
4
5with open(file_path, "rb") as f:
6 FrameioUploader(response.data, f, on_progress=on_progress).upload()
7
8print("\nUpload complete!")

Il callback viene richiamato una volta dopo il completamento di ogni chunk, con i byte cumulativi caricati finora e la dimensione totale del file.

Barra di avanzamento avanzata

Per un’esperienza avanzata del terminale, utilizza Rich:

1from rich.progress import Progress, BarColumn, DownloadColumn, TransferSpeedColumn, TimeRemainingColumn
2
3with Progress(
4 "[progress.description]{task.description}",
5 BarColumn(),
6 DownloadColumn(),
7 TransferSpeedColumn(),
8 TimeRemainingColumn(),
9) as progress:
10 task = progress.add_task("Uploading...", total=file_size)
11
12 with open(file_path, "rb") as f:
13 FrameioUploader(
14 response.data, f,
15 on_progress=lambda done, total: progress.update(task, completed=done),
16 ).upload()

Configurazione

FrameioUploader accetta diversi parametri opzionali:

ParametroPredefinitoDescrizione
max_workers5Numero di thread di caricamento simultanei
headers{"x-amz-acl": "private"}Intestazioni inviate con ogni richiesta PUT S3. Le intestazioni personalizzate vengono unite a quelle predefinite.
max_retries3Tentativi di ripetizione per chunk (backoff esponenziale: 1s, 2s, 4s …)
on_progressNoneCallback (bytes_uploaded, total_bytes) attivato dopo ogni chunk
1with open(file_path, "rb") as f:
2 FrameioUploader(
3 response.data,
4 f,
5 max_workers=10, # more parallelism for high-bandwidth connections
6 max_retries=5, # more resilient on flaky networks
7 on_progress=on_progress,
8 ).upload()

Esempio completo

Un esempio completo con autenticazione, caricamento e tracciamento dello stato di avanzamento:

1import os
2from frameio import Frameio
3from frameio.auth import ServerToServerAuth
4from frameio.files import FileCreateLocalUploadParamsData
5from frameio.upload import FrameioUploader
6
7# Authenticate
8auth = ServerToServerAuth(
9 client_id="YOUR_CLIENT_ID",
10 client_secret="YOUR_CLIENT_SECRET",
11)
12client = Frameio(token=auth.get_token)
13
14# Prepare the file
15file_path = "/path/to/video.mp4"
16file_name = os.path.basename(file_path)
17file_size = os.path.getsize(file_path)
18
19# Create the file resource
20response = client.files.create_local_upload(
21 account_id="YOUR_ACCOUNT_ID",
22 folder_id="YOUR_FOLDER_ID",
23 data=FileCreateLocalUploadParamsData(
24 name=file_name,
25 file_size=file_size,
26 ),
27)
28
29print(f"Uploading {file_name} ({file_size:,} bytes) in {len(response.data.upload_urls)} chunks...")
30
31# Upload with progress
32def on_progress(uploaded: int, total: int) -> None:
33 print(f"\r{uploaded / total:.0%}", end="", flush=True)
34
35with open(file_path, "rb") as f:
36 FrameioUploader(response.data, f, on_progress=on_progress).upload()
37
38print(f"\nDone! View at: {response.data.view_url}")

Se hai bisogno del controllo completo sul processo di caricamento (ad esempio per gestire manualmente i chunk, integrare una pipeline asincrona o personalizzare la logica di ripetizione), consulta Come funzionano i caricamenti locali e remoti per conoscere il flusso completo dell’API e vedere un esempio di script Python autonomo.


Caricamento remoto

Se il file è già accessibile tramite URL pubblico, usa il caricamento remoto. La suddivisone in chunk non è necessaria perché Frame.io recupera il file direttamente:

1from frameio.files import FileCreateRemoteUploadParamsData
2
3response = client.files.create_remote_upload(
4 account_id="YOUR_ACCOUNT_ID",
5 folder_id="YOUR_FOLDER_ID",
6 data=FileCreateRemoteUploadParamsData(
7 name="video.mp4",
8 source_url="https://example.com/video.mp4",
9 ),
10)
11print(f"File created: {response.data.id}")

Il caricamento remoto ha attualmente un limite di dimensione del file di 50 GB. Per file più grandi di 50 GB, utilizza il caricamento locale.


Verifica dello stato di caricamento

Dopo il caricamento, puoi verificare che il file sia stato ricevuto:

1status = client.files.show_file_upload_status(
2 account_id="YOUR_ACCOUNT_ID",
3 file_id=response.data.id,
4)
5print(f"Upload complete: {status.data.upload_complete}")