Guía de carga del SDK para Python de Frame.io

Esta guía explica cómo cargar archivos en Frame.io mediante el SDK para Python de Frame.io (frameio). El SDK gestiona cargas fragmentadas de varias partes en S3 mediante URL con firma previa, con trabajadores paralelos, reintentos automáticos y seguimiento opcional del progreso. Para consultar los conceptos generales de la API de carga, como URL de carga, encabezados y fragmentación, consulte Funcionamiento de las cargas locales y remotas.


Requisitos previos

1

Autenticación

Tiene un cliente de Frameio en funcionamiento. Consulte la Guía de autenticación para obtener información sobre la configuración.

2

Instalar el SDK

$ pip install frameio
3

Carpeta de destino

Necesita el account_id y el folder_id donde se cargará el archivo. Utilice el SDK para encontrarlos:

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)

Inicio rápido

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()

Eso es todo. El SDK divide el archivo en fragmentos según las URL de carga devueltas por la API, los carga en paralelo y gestiona automáticamente los reintentos.


Funcionamiento

La carga local es un proceso de dos pasos:

1

Creación del recurso de archivo

Llame a client.files.create_local_upload() con el nombre y el tamaño del archivo. La API crea un archivo marcador de posición y devuelve URL PUT de S3 con firma previa, una por fragmento. El número de URL (y, por tanto, de fragmentos) depende del tamaño del archivo.

2

Carga en S3

FrameioUploader lee las URL de carga de la respuesta, divide el archivo en fragmentos correspondientes y carga cada fragmento en su URL con PUT en paralelo mediante un grupo de subprocesos. Cada solicitud incluye los encabezados obligatorios x-amz-acl: private y Content-Type.

La carga va directamente de la aplicación a S3, no pasa por los servidores de API de Frame.io. Es el mismo patrón que usan servicios como YouTube, Vimeo y Dropbox para cargas de archivos grandes.


Uso de FrameioUploader

FrameioUploader es la forma recomendada de cargar archivos. Envuelve el cargador fragmentado de nivel inferior y gestiona todos los detalles: extrae las URL de carga de la respuesta de la API, define los encabezados obligatorios, fragmenta el archivo y lo carga en paralelo.

Seguimiento del progreso

Use la devolución de llamada on_progress para hacer un seguimiento del progreso de la carga:

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!")

La devolución de llamada se invoca una vez tras completarse cada fragmento, con los bytes acumulados cargados hasta el momento y el tamaño total del archivo.

Barra de progreso con Rich

Para disfrutar de una experiencia de terminal más cuidada, use 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()

Configuración

FrameioUploader acepta varios parámetros opcionales:

ParámetroPredeterminadoDescripción
max_workers5Número de subprocesos de carga simultáneos
headers{"x-amz-acl": "private"}Encabezados enviados con cada solicitud PUT de S3. Los encabezados personalizados se combinan con los predeterminados.
max_retries3Intentos de reintento por fragmento (con espera exponencial: 1 s, 2 s, 4 s, etc.)
on_progressNoneDevolución de llamada (bytes_uploaded, total_bytes) que se activa tras cada fragmento
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()

Ejemplo completo

Ejemplo completo con autenticación, carga y seguimiento del progreso:

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}")

Si necesita control total sobre el proceso de carga, por ejemplo, para gestionar la fragmentación manualmente, integrarlo con una canalización asíncrona o personalizar la lógica de reintento, consulte Funcionamiento de las cargas locales y remotas para ver el flujo de API sin procesar y un ejemplo de script independiente de Python.


Carga remota

Si el archivo ya está disponible mediante una URL pública, use la carga remota. No se necesita fragmentación; Frame.io obtiene el archivo directamente:

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}")

Actualmente, la carga remota tiene un límite de tamaño de archivo de 50 GB. Para archivos de más de 50 GB, utilice la carga local.


Comprobación del estado de carga

Después de cargar, puede verificar que el archivo se haya recibido:

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}")