Python SDK in Frame.io – Upload-Leitfaden

In diesem Leitfaden wird erklärt, wie Sie mit dem Python SDK in Frame.io (frameio) Dateien in Frame.io hochladen.Im SDK werden mehrteilige Uploads von Chunks in S3 über vorsignierte URLs verarbeitet, mit parallel ausgeführten Prozessen, automatischen Wiederholungsversuchen und optionaler Fortschrittsverfolgung.Informationen zu den allgemeinen API-Konzepten für den Upload (Upload-URLs, Header, Chunking) finden Sie unter So funktionieren lokale und Remote-Uploads.


Voraussetzungen

1

Authentifizierung

Sie verfügen über einen funktionierenden Frame.io-Client. Informationen zum Setup finden Sie im Authentifizierungsleitfaden.

2

SDK installieren

$ pip install frameio
3

Zielordner

Sie benötigen die Account_ID und die Folder_ID, in die die Datei hochgeladen werden soll. Suchen Sie mit dem SDK danach:

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)

Schnellstart

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

Das ist alles.Im SDK wird die Datei basierend auf den Upload-URLs, die von der API zurückgegeben werden, in Chunks aufgeteilt und parallel hochgeladen. Wiederholungsversuche werden automatisch verarbeitet.


Grundlegendes

Der lokale Upload ist ein zweistufiger Prozess:

1

Dateiressource erstellen

Rufen Sie client.files.create_local_upload() mit Dateinamen und -größe auf.In der API wird eine Platzhalterdatei erstellt und es werden vorsignierte S3 PUT-URLs zurückgegeben, eine pro Chunk.Die Anzahl der URLs (und daher Chunks) ist abhängig von der Dateigröße.

2

Hochladen in S3

Die Upload-URLs werden von FrameioUploader aus der Antwort gelesen. Anschließend wird Ihre Datei in passende Chunks aufgeteilt. Mit PUT und einem Thread-Pool werden die einzelnen Chunks parallel zu ihrer jeweiligen URL platziert.Jede Anfrage enthält die erforderlichen Header x-amz-acl: private und Content-Type.

Der Upload geht direkt von Ihrer Anwendung in S3, er läuft nicht über die Frame.io-API-Server.Das ist dasselbe Muster, das von Diensten wie YouTube, Vimeo und Dropbox für große Datei-Uploads verwendet wird.


Verwendung von FrameioUploader

FrameioUploader ist die empfohlene Methode zum Hochladen von Dateien.Der Chunk-Uploader auf der niedrigeren Ebene wird umhüllt, und alle Details werden verarbeitet: Upload-URLs werden aus der API-Antwort extrahiert, erforderliche Header werden gesetzt, die Datei wird aufgeteilt und parallel hochgeladen.

Fortschrittsverfolgung

Mit dem Rückruf on_progress verfolgen Sie den Fortschritt des Uploads:

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

Der Rückruf wird einmal nach Abschluss jedes Chunks aufgerufen, mit den bisher aufgelaufenen hochgeladenen Bytes und der gesamten Dateigröße.

Rich-Fortschrittsbalken

Nutzen Sie Rich für eine elegante Terminal-Erfahrung:

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

Konfiguration

In FrameioUploader werden mehrere optionale Parameter akzeptiert:

ParameterStandardBeschreibung
max_workers5Anzahl der gleichzeitigen Upload-Threads
headers{"x-amz-acl": "private"}Header, die mit jeder S3 PUT-Anfrage gesendet werdenSelbstdefinierte Header werden mit den Standardwerten zusammengeführt.
max_retries3Wiederholungsversuche pro Chunk (exponentieller Rückzug: 1s, 2s, 4s …)
on_progressNoneRückruf (bytes_uploaded, total_bytes) wird nach jedem Chunk ausgelöst.
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()

Vollständiges Beispiel

Ein vollständiges Beispiel mit Authentifizierung, Upload und Fortschrittsverfolgung:

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

Wenn Sie vollständige Kontrolle über den Upload-Prozess benötigen – zum Beispiel, um das Chunking (Aufteilung in Chunks) manuell zu verarbeiten, mit einer asynchronen Pipeline zu integrieren oder die Logik für Wiederholungen anzupassen –, sehen Sie sich So funktionieren lokale und Remote-Uploads an. Dort finden Sie den rohen API-Fluss und ein eigenständiges Python-Skript-Beispiel.


Remote-Upload

Wenn Ihre Datei bereits über eine öffentliche URL zugänglich ist, verwenden Sie stattdessen den Remote-Upload.Es ist kein Chunking erforderlich, die Datei wird direkt von Frame.io abgerufen:

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

Für den Remote-Upload besteht derzeit eine Dateigrößenbegrenzung von 50 GB.Nutzen Sie bei Dateien von mehr als 50 GB stattdessen den lokalen Upload.


Überprüfen des Upload-Status

Nach dem Upload können Sie überprüfen, ob die Datei empfangen wurde:

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