Dokumentation durchsuchen
Beispiele
Verwandeln Sie eine YouTube ID-Datei in Metadaten JSON und CSV, mit einem Ergebnis pro Video. Verwenden Sie Python oder Bash mit dem FlashData CLI.
Auf dieser Seite
Bevor Sie anfangen
Verwenden Sie FlashData CLI v1.2.1 auf PATH, plus Python 3.10+ (nur Standardbibliothek) oder Bash mit jq und OpenSSL. Beide Versionen verwenden den CLI für Upload, Job Recovery und Retrieval von Ergebnisteilen. Verwenden Sie unter Windows Git Bash für die Bash-Version.
Sie benötigen einen Besitzer-API-Schlüssel mit youtube_metadata-Berechtigung und verfügbaren Credits. Verwenden Sie Ihr gespeichertes Besitzer-Login erneut oder führen Sie auth login einmal aus und geben Sie den Schlüssel in der versteckten Eingabeaufforderung ein. Agenten können FLASHDATA_API_KEY aus ihrem Geheimladen liefern.
Diese Beispiele verwenden das Standard-CLI-Profil und das Zustandsverzeichnis. Behalten Sie das gleiche Konto und gespeicherten Zustand für die Wiederherstellung. Wenn auth status einen temporären Zugriff anzeigt, fordern Sie ihn an, bevor Sie Bulk starten.
flashdata auth loginflashdata --version
flashdata auth status --json
flashdata account balance --json
flashdata account pricing --source youtube_metadata --request-count 2 --json
flashdata account limits --json1. Bereiten Sie das Video IDs vor
Erstellen Sie einen Ordner zur Massenanreicherung und speichern Sie dort video-ids.txt. Öffnen Sie ein Terminal in diesem Ordner. Verwenden Sie ein 11-Zeichen ID pro Zeile, ohne Kopfzeile, leere Zeilen oder volles YouTube URLs.
Wählen Sie ein Vorbereitungsskript und speichern Sie es neben video-ids.txt. Es lehnt ungültige und doppelte IDs ab und speichert dann einen normalisierten Eingabe-Snapshot, Metadatenoptionen und die Ausführung von ID unter prepared/. Die Eingabereihenfolge bleibt erhalten.
jNQXAC9IVRw
dQw4w9WgXcQ
# Save as bulk-enrichment/prepare.py. Python 3.10+, standard library only.
import hashlib
import json
import os
import re
import sys
from pathlib import Path
from subprocess import run, CalledProcessError, DEVNULL
ROOT = Path(__file__).resolve().parent
try:
os.umask(0o077)
run_id = sys.argv[1]
if not re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9_.:@+-]{0,159}", run_id):
raise ValueError("Choose a valid, stable run ID.")
ids = (ROOT / "video-ids.txt").read_text(encoding="utf-8-sig").splitlines()
ids = [line.strip() for line in ids]
if not ids or any(not re.fullmatch(r"[A-Za-z0-9_-]{11}", value) for value in ids):
raise ValueError("Use one 11-character video ID per line, with no blank rows or URLs.")
if len(set(ids)) != len(ids):
raise ValueError("Remove duplicate IDs before submitting; they would be processed separately.")
data = ("\n".join(ids) + "\n").encode("utf-8")
prepared = ROOT / "prepared"
prepared.mkdir(mode=0o700) # Refuse to overwrite an existing input snapshot.
(prepared / "video-ids.txt").write_bytes(data)
(prepared / "options.json").write_text(json.dumps({
"include_formats": False, "include_chapters": False,
}, indent=2), encoding="utf-8")
if os.name == "nt":
# The CLI requires a private options file, including on Windows.
command = """
$ErrorActionPreference = 'Stop'
$path = [System.IO.Path]::GetFullPath("./prepared/options.json")
$user = [System.Security.Principal.WindowsIdentity]::GetCurrent().User
$acl = [System.Security.AccessControl.FileSecurity]::new()
$acl.SetAccessRuleProtection($true, $false)
$acl.AddAccessRule([System.Security.AccessControl.FileSystemAccessRule]::new($user, 'FullControl', 'Allow'))
[System.IO.File]::SetAccessControl($path, $acl)
"""
run(["powershell.exe", "-NoProfile", "-NonInteractive", "-Command", command],
cwd=ROOT, stdin=DEVNULL, check=True, capture_output=True)
plan = {"run_id": run_id, "source": "youtube_metadata", "input_count": len(ids),
"input_sha256": hashlib.sha256(data).hexdigest()}
(prepared / "plan.json").write_text(json.dumps(plan, indent=2), encoding="utf-8")
print("Prepared", len(ids), "unique videos for", run_id)
except (IndexError, OSError, ValueError, CalledProcessError) as error:
print(str(error), file=sys.stderr)
sys.exit(1)python prepare.py videos-001jq --version
openssl version#!/usr/bin/env bash
# Save as bulk-enrichment/prepare.sh.
set -euo pipefail
trap 'exit 1' ERR
umask 077
cd -- "$(dirname -- "$0")"
case "$(uname -s)" in
MINGW*|MSYS*|CYGWIN*) jq() { command jq --binary "$@"; } ;;
esac
run_id=${1:?Usage: bash prepare.sh videos-001}
[[ "$run_id" =~ ^[A-Za-z0-9][A-Za-z0-9_.:@+-]{0,159}$ ]] || exit 2
# Validate before creating the snapshot; normalize BOM, CRLF and surrounding spaces.
ids=$(jq -Rsc '
sub("^\uFEFF"; "") | split("\n")
| if .[-1] == "" then .[:-1] else . end
| map(gsub("^\\s+|\\s+$"; ""))
| if length == 0 or any(.[]; test("^[A-Za-z0-9_-]{11}$") | not)
then error("Use one 11-character ID per line, with no blank rows or URLs.")
elif length != (unique | length)
then error("Remove duplicate IDs before submitting.")
else . end
' video-ids.txt)
mkdir prepared
printf '%s' "$ids" | jq -r '.[]' > prepared/video-ids.txt
printf '%s\n' '{"include_formats":false,"include_chapters":false}' > prepared/options.json
case "$(uname -s)" in
MINGW*|MSYS*|CYGWIN*)
powershell.exe -NoProfile -NonInteractive -Command '
$ErrorActionPreference = "Stop"
$path = [System.IO.Path]::GetFullPath("./prepared/options.json")
$user = [System.Security.Principal.WindowsIdentity]::GetCurrent().User
$acl = [System.Security.AccessControl.FileSecurity]::new()
$acl.SetAccessRuleProtection($true, $false)
$acl.AddAccessRule([System.Security.AccessControl.FileSystemAccessRule]::new($user, "FullControl", "Allow"))
[System.IO.File]::SetAccessControl($path, $acl)
' </dev/null ;;
esac
hash=$(openssl dgst -sha256 prepared/video-ids.txt | awk '{print $NF}')
printf '%s' "$ids" | jq --arg run "$run_id" --arg hash "$hash" '
{run_id:$run, source:"youtube_metadata", input_count:length, input_sha256:$hash}
' > prepared/plan.json
jq '"Prepared \(.input_count) unique videos for \(.run_id)"' -r prepared/plan.jsonbash prepare.sh videos-001Was ist vorbereitet
Erwarten Sie vorbereitete 2 einzigartige Videos für Videos-001. Halten Sie sich vorbereitet / unverändert. Metadaten verwenden include_formats: false und include_chapters: false. Jedes akzeptierte Video ist ein separater abrechenbarer Artikel; doppelte Zeilen würden separat verarbeitet, so dass dieses Rezept vor dem Einreichen gestoppt wird.
Verwenden Sie eine Ausführung von ID, die Sie nicht für eine andere Aufgabe verwendet haben. Bewahren Sie Videos-001 für die Wiederholungen und Wiederherstellungen dieser Aufgabe auf. Ein neuer Lauf ID ist für einen absichtlichen neuen Datensatz oder eine Aktualisierung.
2. Einreichen und Sammeln der Ergebnisse
Speichern Sie process.py oder process.sh in der Massenanreicherung, bevor Sie es ausführen. Der CLI erstellt einen Bulk-Job, lädt den vorbereiteten IDs hoch, beginnt mit der Verarbeitung und speichert jeden Ergebnisteil in bulk-results.ndjson. Die lokale Wartezeit endet nach 30 Minuten; akzeptierte Serverarbeit geht weiter.
Jeder Versuch erhält seinen eigenen Ordner unter trys/, mit dem CLI-Empfang, dem Fehler und dem gespeicherten Ablauf. ready.txt zeigt auf das letzte vollständige Ergebnis. Exit 2 bedeutet, dass vollständige Ergebnisse fehlerhafte Videos enthalten; exportieren und inspizieren Sie diese Zeilen weiter.
# Save as bulk-enrichment/process.py. Requires the FlashData CLI on PATH.
import hashlib
import json
import os
import sys
import tempfile
from pathlib import Path
from subprocess import run, DEVNULL
ROOT = Path(__file__).resolve().parent
def read_json(path):
return json.loads(path.read_text(encoding="utf-8"))
def main(action):
os.umask(0o077)
plan = read_json(ROOT / "prepared/plan.json")
ids = ROOT / "prepared/video-ids.txt"
if hashlib.sha256(ids.read_bytes()).hexdigest() != plan["input_sha256"]:
raise ValueError("The prepared input changed. Restore it before recovery.")
# Use the same default profile and state directory as auth login/status.
flags = ["--json", "--non-interactive"]
def cli(*args):
return run(["flashdata", *args, *flags], cwd=ROOT, stdin=DEVNULL,
capture_output=True, text=True, encoding="utf-8")
if action == "status":
result = cli("runs", "show", plan["run_id"])
if result.returncode:
raise ValueError(result.stderr)
saved = json.loads(result.stdout)["data"]
print(json.dumps({k: saved.get(k) for k in
("id", "remoteId", "status", "stage", "errorCode")}, indent=2))
if saved.get("remoteId"):
result = cli("bulk", "get", saved["remoteId"])
print(result.stdout or result.stderr)
return result.returncode
return 0
if action not in ("submit", "recover"):
raise ValueError("Choose submit, status or recover.")
attempts = ROOT / "attempts"
attempts.mkdir(exist_ok=True)
directory = Path(tempfile.mkdtemp(prefix="run-", dir=attempts))
output = str(directory / "bulk-results.ndjson")
if action == "submit":
args = ["bulk", "run", "--source", plan["source"], "--input", str(ids),
"--options", str(ROOT / "prepared/options.json"), "--run-id", plan["run_id"]]
else:
args = ["runs", "recover", plan["run_id"]]
result = cli(*args, "--output", output, "--timeout", "30m")
(directory / "receipt.json").write_text(result.stdout, encoding="utf-8")
(directory / "error.json").write_text(result.stderr, encoding="utf-8")
(directory / "exit-code.txt").write_text(str(result.returncode))
print("Attempt:", directory.relative_to(ROOT))
# bulk_item_failures still includes a complete result file with failed rows.
code = json.loads(result.stderr).get("error", {}).get("code") if result.stderr.strip() else None
if result.returncode and code != "bulk_item_failures":
raise ValueError("Collection stopped. Inspect error.json; recover the same run.")
saved = cli("runs", "show", plan["run_id"])
(directory / "run.json").write_text(saved.stdout, encoding="utf-8")
if saved.returncode or not Path(output).is_file():
raise ValueError("Could not save the run record and results together.")
record = json.loads(saved.stdout)
data = record.get("data", {})
if (not record.get("ok") or data.get("status") != "succeeded"
or data.get("id") != plan["run_id"] or data.get("source") != plan["source"]
or data.get("inputFileHash") != plan["input_sha256"]):
raise ValueError("Inspect the run/input binding before exporting.")
pointer = ROOT / "ready.next"
pointer.write_text(directory.relative_to(ROOT).as_posix(), encoding="utf-8")
pointer.replace(ROOT / "ready.txt")
print("Results ready for export." if code is None else "Results ready; inspect failed video rows.")
return 2 if code == "bulk_item_failures" else 0
if __name__ == "__main__":
try:
sys.exit(main(sys.argv[1]))
except (IndexError, KeyError, OSError, ValueError) as error:
print(str(error), file=sys.stderr)
sys.exit(1)python process.py submit#!/usr/bin/env bash
# Save as bulk-enrichment/process.sh. Requires the FlashData CLI on PATH.
set -euo pipefail
umask 077
cd -- "$(dirname -- "$0")"
case "$(uname -s)" in
MINGW*|MSYS*|CYGWIN*) jq() { command jq --binary "$@"; } ;;
esac
action=${1:?Usage: bash process.sh submit|status|recover}
plan=prepared/plan.json
run_id=$(jq -er '.run_id' "$plan")
hash=$(openssl dgst -sha256 prepared/video-ids.txt | awk '{print $NF}')
jq -e --arg hash "$hash" '.source == "youtube_metadata" and .input_sha256 == $hash' "$plan" >/dev/null
# Keep the same default profile and state directory as auth login/status.
cli=(flashdata --json --non-interactive)
if [[ "$action" == status ]]; then
saved=$("${cli[@]}" runs show "$run_id")
printf '%s' "$saved" | jq '.data | {id,remoteId,status,stage,errorCode}'
remote=$(printf '%s' "$saved" | jq -r '.data.remoteId // empty')
[[ -z "$remote" ]] || "${cli[@]}" bulk get "$remote"
exit 0
fi
case "$action" in
submit) args=(bulk run --source youtube_metadata --input prepared/video-ids.txt
--options prepared/options.json --run-id "$run_id") ;;
recover) args=(runs recover "$run_id") ;;
*) echo 'Choose submit, status or recover.' >&2; exit 2 ;;
esac
mkdir -p attempts
directory=$(mktemp -d attempts/run-XXXXXX)
exit_code=0
"${cli[@]}" "${args[@]}" --output "$directory/bulk-results.ndjson" --timeout 30m \
> "$directory/receipt.json" 2> "$directory/error.json" || exit_code=$?
printf '%s' "$exit_code" > "$directory/exit-code.txt"
echo "Attempt: $directory"
code=$(jq -r '.error.code // empty' "$directory/error.json")
if [[ "$exit_code" != 0 && "$code" != bulk_item_failures ]]; then
echo "Collection stopped. Inspect $directory/error.json; recover the same run." >&2
exit 1
fi
"${cli[@]}" runs show "$run_id" > "$directory/run.json"
test -f "$directory/bulk-results.ndjson"
jq -e --arg run "$run_id" --arg hash "$hash" '
.ok and .data.status == "succeeded" and .data.id == $run
and .data.source == "youtube_metadata" and .data.inputFileHash == $hash
' "$directory/run.json" >/dev/null
printf '%s\n' "$directory" > ready.next
mv ready.next ready.txt
echo 'Results ready for export.'
[[ "$code" != bulk_item_failures ]] || { echo 'Inspect failed video rows.'; exit 2; }bash process.sh submitÜberprüfen Sie den Fortschritt von einem anderen Terminal
Führen Sie von der Massenanreicherung mit dem gleichen CLI-Konto aus. Die Statusaktion zeigt den gespeicherten Lauf an und liest den entfernten Bulk-Job, wenn ein ID verfügbar ist. Es schafft oder nimmt die Arbeit nicht wieder auf.
python process.py statusbash process.sh status3. Abgleich und Ausfuhr
Speichern Sie export.py oder export.sh neben den anderen Skripten und führen Sie es aus. Es überprüft den gespeicherten Run- und Input-Hash und passt dann jedes Ergebnis mit dem Null-basierten Index und video_id ab. Ergebnisteile können ausgefallen sein. Fehlende, doppelte oder nicht übereinstimmende Zeilen stoppen den Export.
Der Exporteur behält das vollständige Metadatenobjekt, den Fehler und die gemeldete Verwendung für jede Zeile. Gescheiterte Videos bleiben mit metadata: null sichtbar. Dieses kleine Beispiel lädt die Ergebnisse in den Speicher; Verwenden Sie das Streaming-Audit in der Bulk-Dateiverarbeitung für einen großen Datensatz.
# Save as bulk-enrichment/export.py. Local files only; no API calls.
import csv
import hashlib
import json
import os
import re
import sys
from pathlib import Path
ROOT = Path(__file__).resolve().parent
try:
os.umask(0o077)
directory = (ROOT / "ready.txt").read_text(encoding="utf-8").strip()
if not re.fullmatch(r"attempts/run-[A-Za-z0-9_-]+", directory):
raise ValueError("Use the ready.txt written by process.py or process.sh.")
directory = ROOT / directory
def read_json(path):
return json.loads(path.read_text(encoding="utf-8"))
plan = read_json(ROOT / "prepared/plan.json")
raw = (ROOT / "prepared/video-ids.txt").read_bytes()
ids = raw.decode("utf-8").splitlines()
saved = read_json(directory / "run.json")
run = saved["data"]
digest = hashlib.sha256(raw).hexdigest()
if (not saved.get("ok") or run.get("status") != "succeeded" or run.get("kind") != "bulk:run"
or run.get("id") != plan["run_id"] or run.get("source") != "youtube_metadata"
or run.get("inputFileHash") != digest or plan["input_sha256"] != digest
or plan["input_count"] != len(ids) or not run.get("remoteId")):
raise ValueError("The saved run does not match this input file.")
# This recipe loads a small file into memory to validate it before writing exports.
records = {}
with (directory / "bulk-results.ndjson").open(encoding="utf-8") as source:
for line in source:
row = json.loads(line)
index = row.get("index")
if (type(index) is not int or not 0 <= index < len(ids) or index in records
or row.get("video_id") != ids[index] or row.get("source") != "youtube_metadata"
or row.get("status") not in ("completed", "failed")):
raise ValueError("Unknown, duplicate or mismatched result row.")
metadata = None
if row["status"] == "completed":
results = row.get("results")
if (not isinstance(results, list) or len(results) != 1
or not isinstance(results[0], dict) or results[0].get("videoId") != ids[index]):
raise ValueError("Completed metadata does not match its video.")
metadata = results[0]
records[index] = {
"index": index, "video_id": ids[index], "status": row["status"],
"metadata": metadata, "error": row.get("error"), "usage": row.get("usage"),
}
if len(records) != len(ids):
raise ValueError("Missing result rows. Recover the same run before exporting.")
videos = [records[index] for index in range(len(ids))]
failed = [v["video_id"] for v in videos if v["status"] == "failed"]
output = ROOT / "export"
output.mkdir(mode=0o700) # Never overwrite an earlier export.
(output / "videos.json").write_text(json.dumps(videos, ensure_ascii=False, indent=2), encoding="utf-8")
def cell(value):
if value is None:
return ""
if not isinstance(value, str):
value = json.dumps(value, ensure_ascii=False, separators=(",", ":"))
# Keep remote text from being interpreted as a spreadsheet formula.
return "'" + value if re.match(r"^[ \t\r\n]*[=+@-]|^[\t\r\n]", value) else value
with (output / "videos.csv").open("x", encoding="utf-8", newline="") as target:
writer = csv.writer(target)
writer.writerow(["index", "video_id", "status", "title", "duration", "error"])
for video in videos:
metadata = video["metadata"] or {}
writer.writerow([cell(v) for v in (video["index"], video["video_id"], video["status"],
metadata.get("title"), metadata.get("duration"), video["error"])])
(output / "failed-video-ids.txt").write_bytes("".join(v + "\n" for v in failed).encode("utf-8"))
summary = {"run_id": plan["run_id"], "bulk_id": run["remoteId"], "input_count": len(ids),
"completed": len(ids) - len(failed), "failed": len(failed), "coverage_complete": True}
(output / "summary.json").write_text(json.dumps(summary, indent=2), encoding="utf-8")
print(json.dumps(summary, indent=2))
print("Saved export/videos.json, videos.csv and failed-video-ids.txt")
sys.exit(2 if failed else 0)
except (OSError, ValueError, KeyError, TypeError) as error:
print(str(error), file=sys.stderr)
sys.exit(1)python export.py#!/usr/bin/env bash
# Save as bulk-enrichment/export.sh. Local files only; no API calls.
set -euo pipefail
trap 'exit 1' ERR
umask 077
cd -- "$(dirname -- "$0")"
case "$(uname -s)" in
MINGW*|MSYS*|CYGWIN*) jq() { command jq --binary "$@"; } ;;
esac
directory=$(cat ready.txt)
[[ "$directory" =~ ^attempts/run-[A-Za-z0-9_-]+$ ]] || exit 1
hash=$(openssl dgst -sha256 prepared/video-ids.txt | awk '{print $NF}')
jq -e --slurpfile plan prepared/plan.json --arg hash "$hash" '
.ok and .data.status == "succeeded" and .data.kind == "bulk:run"
and .data.id == $plan[0].run_id and .data.source == "youtube_metadata"
and .data.inputFileHash == $hash and $plan[0].input_sha256 == $hash
and (.data.remoteId | type == "string" and length > 0)
' "$directory/run.json" >/dev/null
# Validate the complete small-sample result before creating export/.
videos=$(jq -sc --rawfile input prepared/video-ids.txt --slurpfile plan prepared/plan.json '
($input | split("\n") | .[:-1]) as $ids
| if $plan[0].input_count != ($ids | length) or length != ($ids | length)
or any(.[]; (.index | type != "number" or . != floor)
or .source != "youtube_metadata" or (.status != "completed" and .status != "failed"))
then error("Missing rows or unexpected source/status/index.")
else sort_by(.index) end
| if map(.index) != [range(0; $ids | length)]
or any(.[]; .video_id != $ids[.index])
then error("Unknown, duplicate or mismatched rows.")
elif any(.[]; .status == "completed" and
((.results | type != "array" or length != 1) or .results[0].videoId != .video_id))
then error("Completed metadata does not match its video.")
else map({index, video_id, status,
metadata:(if .status == "completed" then .results[0] else null end), error, usage}) end
' "$directory/bulk-results.ndjson")
mkdir export
printf '%s\n' "$videos" | jq . > export/videos.json
jq -r '
def cell: if . == null then ""
else (if type == "string" then . else tojson end)
| if test("^[ \\t\\r\\n]*[=+@-]|^[\\t\\r\\n]") then "'"'"'" + . else . end end;
(["index","video_id","status","title","duration","error"],
(.[] | [.index,.video_id,.status,.metadata.title,.metadata.duration,.error] | map(cell)))
| @csv
' export/videos.json > export/videos.csv
jq -r '.[] | select(.status == "failed") | .video_id' export/videos.json > export/failed-video-ids.txt
jq --slurpfile plan prepared/plan.json --slurpfile run "$directory/run.json" '
{run_id:$plan[0].run_id, bulk_id:$run[0].data.remoteId, input_count:length,
completed:([.[] | select(.status == "completed")] | length),
failed:([.[] | select(.status == "failed")] | length), coverage_complete:true}
' export/videos.json > export/summary.json
cat export/summary.json
echo 'Saved export/videos.json, videos.csv and failed-video-ids.txt'
jq -e '.failed == 0' export/summary.json >/dev/null || exit 2bash export.shVerwenden Sie die exportierten Dateien
Success druckt die Zusammenfassung und die gespeicherten Dateinamen. Exportieren Sie 0, wenn jedes Video erfolgreich war, 2, wenn einige fehlgeschlagen sind, oder 1, wenn die Validierung oder das Schreiben fehlgeschlagen ist. Ein bestehender Export / bleibt erhalten; lesen Sie ihn lokal, anstatt die Einreichung erneut auszuführen.
| Datei unter Export/ | Verwenden Sie es für |
|---|---|
| videos.json | Importieren Sie in Ihre App oder Agent Workflow. Zeilen behalten Eingabereihenfolge, Metadaten, Fehler und Nutzung. |
| videos.csv | Überprüfen Sie Titel, Dauer und Fehler in einer Tabelle. Formelähnlicher Text wird mit einem Apostroph vorangestellt; JSON behält den Originaltext bei. |
| summary.json | Überprüfen Sie die Abdeckung und die completed/failed-Zählung, die mit dem Lauf ID und Bulk ID verknüpft ist. |
| failed-video-ids.txt | Die Überprüfung bestätigte nur fehlgeschlagene Videos, bevor sie sich für eine andere bezahlte Anfrage entschied. Leere, wenn alles gelungen ist. |
python -m json.tool export/summary.json
python -m json.tool export/videos.jsonjq . export/summary.json
jq . export/videos.jsonBeispielergebnis mit einem fehlgeschlagenen Video
Beispielhafter videos.json-Auszug. Ein abgeschlossener Bulk-Job kann fehlgeschlagene Videos enthalten. Behandeln Sie ein fehlgeschlagenes Video nicht als leeres erfolgreiches Ergebnis oder lassen Sie es stillschweigend aus Ihrem Datensatz fallen.
[
{
"index": 0,
"video_id": "jNQXAC9IVRw",
"status": "completed",
"metadata": {
"videoId": "jNQXAC9IVRw",
"title": "Example video",
"duration": 19
},
"error": null,
"usage": null
},
{
"index": 1,
"video_id": "dQw4w9WgXcQ",
"status": "failed",
"metadata": null,
"error": {
"code": "example_video_unavailable"
},
"usage": null
}
]Den gleichen Job wiederherstellen
Wenn das Warten gestoppt wurde oder ein Ergebnisteil nicht gelesen werden konnte, führen Sie die Wiederherstellung aus. Es sammelt den vorhandenen Job in einem neuen Versuchsordner und aktualisiert ready.txt erst nach vollständigem Abruf. Es werden keine Ersatzarbeiten hochgeladen oder eingereicht. Führen Sie dann den Exporteur aus, wenn der Export / noch nicht erstellt wurde.
| Gespeichertes Ergebnis | Nächste Maßnahme |
|---|---|
| bulk_item_failures | Exportieren und überprüfen Sie failed-video-ids.txt. Nicht alle erfolgreichen Videos erneut einreichen. |
| partial_result | Bewahren Sie die Teildatei. Stellen Sie den gleichen Lauf wieder her, um alle Teile vor dem Export abzurufen. |
| running / finalizing | Wiederherstellen Sie später mit dem gleichen Lauf ID, Profil und Zustandsverzeichnis. |
| paused | Lesen Sie pauseReason im Status, beheben Sie die Ursache und setzen Sie dann Bulk ID mithilfe des Steuerhandbuchs explizit fort. |
| awaiting_upload / bulk_input_required | Überprüfen Sie den gespeicherten Entwurf. Laden Sie die ursprünglich vorbereitete Datei hoch und starten Sie die vorhandene Bulk ID; die Wiederherstellung wiederholt diese Aktionen nicht. |
| Unsichere Übermittlung oder keine Remote-ID | Halten Sie den Lauf und überprüfen Sie den gespeicherten Fehler und Bulk Jobs, bevor Sie erneut versuchen. Ein neuer Lauf ID kann einen anderen Job erstellen. |
| Falsche Quelle, fehlende Zeilen oder Input-Hash-Mismatch | Es wird kein Export akzeptiert. Überprüfen Sie die vorbereitete Snapshot-, gespeicherte Run- und Ergebnisdatei; erfinden Sie keine fehlenden Metadaten. |
python process.py status
python process.py recoverbash process.sh status
bash process.sh recoverSpeichern Sie diesen Snapshot oder aktualisieren Sie ihn absichtlich
Speichern Sie abgeschlossene Ergebnisse innerhalb des 24-Stunden-Retentionsfensters. Ihre Exporte bleiben lokale Dateien zur Wiederverwendung. Um Metadaten später zu aktualisieren, verwenden Sie einen neuen Arbeitsordner und führen Sie ID aus, und überprüfen Sie zuerst die Kosten für die neue Anforderung.