# Збагатити файл відео IDs

Увімкніть файл YouTube ID у метадані JSON та CSV з одним результатом за відео. Використовуйте Python або Bash з FlashData CLI.

Канонічне посилання: https://flashdata.dev/uk/docs/guides/bulk-metadata-recipe
Переглянуто: 2026-11-05 від FlashData

<a id="prepare"></a>

## Перед тим, як початися

Використовуйте FlashData CLI v1.2.1 на PATH, плюс Python 3.10+ (тільки стандартна бібліотека), або Bash з jq і OpenSSL. Обидві версії використовують CLI для завантаження, відновлення роботи та ретривального результату. На Windows використовується Git Bash для версії Bash.

Вам потрібно власник API ключ з дозволом youtube_metadata і доступним кредитом. Зробіть свій збережений логін власника, або запустіть auth login один раз і введіть ключ на його приховану підказку. Агенти можуть поставляти FLASHDATA_API_KEY з свого секретного магазину.

Ці приклади використовують профіль CLI і каталог стану. Зберігати цей самий обліковий запис і збережений стан для відновлення. Якщо auth status показує тимчасовий доступ, перед тим як розпочати Bulk.

### Тільки якщо ви не втрачили логін власника

```bash
flashdata auth login
```

### Перевірити доступ і вартість цього двовідео прикладу

```bash
flashdata --version
flashdata auth status --json
flashdata account balance --json
flashdata account pricing --source youtube_metadata --request-count 2 --json
flashdata account limits --json
```

- [Встановити CLI](https://flashdata.dev/uk/docs/guides/flashdata-cli/reference.md#install)
- [Отримайте API-ключ](https://flashdata.dev/app/api-keys)
- [Пробний доступ агента й прив’язування облікового запису](https://flashdata.dev/uk/docs/guides/agent-onboarding/reference.md)

<a id="input"></a>

## 1. Приготувати відео IDs

Створюйте папку-опитування та зберігайте video-ids.txt. Відкрийте термінал в цій папці. Використовуйте один 11-character ID за лінію, без заголовка, порожні лінії або повний YouTube URLs.

Виберіть один скрипт підготовки і зберегти його біля video-ids.txt. Відхилено недійсним і дублікатом IDs, потім зберігає нормалізовану вводну знімку, параметри метаданих і запуск ID під prepared/. Збережено порядок введення.

### bulk-enrichment/video-ids.txt

```text
jNQXAC9IVRw
dQw4w9WgXcQ
```

### Python

#### bulk-enrichment/prepare.py

```python
# 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)
```

#### Запуск з об'ємної обробки /

```bash
python prepare.py videos-001
```


### Bash

#### Перевірити локальні інструменти

```bash
jq --version
openssl version
```

#### bulk-enrichment/prepare.sh

```bash
#!/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.json
```

#### Запуск з об'ємної обробки /

```bash
bash prepare.sh videos-001
```



<a id="plan"></a>

### Що готується

Expect Приготований 2 унікальний відео для відео-001. Зберігати готовий/змінити. Метадані використовує include_formats: false і include_chapters: false. Кожен прийнятий відео є окремим вексельним елементом; дублікати рядків будуть оброблятися окремо, тому цей рецепт зупиняється перед їх поданням.

Використовуйте запуск ID, який ви не використовували для іншого завдання. Зберігати відео-001 для цього завдання речення і відновлення. Новий запуск ID призначений для навмисного нового набору даних або оновлення.

- [Виберіть поля метаданих](https://flashdata.dev/uk/docs/guides/video-metadata-recipe/reference.md#fields)

<a id="submit"></a>

## 2. Відправити і збирати результати

Заощаджуйте process.py або process.sh в об'ємному об'ємі до його запуску. CLI створює одну з завдань Bulk, що додає підготовлену IDs, запускає обробку і зберігає кожен результат в bulk-results.ndjson. Займається локальна очікування після протоколу 30; триває робота сервера.

Кожна спроба отримує власну папку за спробами /, з чеком CLI, помилкою та збереженою працею. ready.txt вказує на останній результат. Exit 2 означає повне результати включають невдалі відео; продовжувати експортувати і перевіряти ці рядки.

### Python

#### bulk-enrichment/process.py

```python
# 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)
```

#### Процес підготовленого файлу

```bash
python process.py submit
```


### Bash

#### bulk-enrichment/process.sh

```bash
#!/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
bash process.sh submit
```



<a id="status"></a>

### Перевірити прогрес з іншого терміналу

Запуск з об'ємної обробки з таким же обліковим записом CLI. Стан показує збережену роботу і прочитає її віддалену роботу Bulk, коли доступний ID. Це не створює або відновлює роботу.

#### Python

##### Читання поточного прогресу

```bash
python process.py status
```


#### Bash

##### Читання поточного прогресу

```bash
bash process.sh status
```



<a id="output"></a>

## 3. Консультування та експорт

Заощаджуйте export.py або export.sh біля інших скриптів, потім запустіть його. Він перевіряє збережений хід і вхідний хеш, потім відповідає кожному результаті нульового індексу і video_id. З замовлень можна приїхати з замовлення. Випробування, дублікати або незрівняні рядки зупиняють експорт.

Експортер зберігає об'єкт повного метаданих, помилки та використання даних для кожного рядка. Непроблемні відео, що залишаються видимими з metadata: null. Цей невеликий приклад завантажує результати в пам'ять; використовувати аудит потокового передавання в файлах Bulk для великого набору даних.

### Python

#### bulk-enrichment/export.py

```python
# 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)
```

#### Експорт локально · немає API

```bash
python export.py
```


### Bash

#### bulk-enrichment/export.sh

```bash
#!/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 2
```

#### Експорт локально · немає API

```bash
bash export.sh
```


- [Аудит великого файлу з обмеженою пам'яттю](https://flashdata.dev/uk/docs/guides/bulk/reference.md#audit)

<a id="files"></a>

### Використовуйте експортовані файли

Успіх друкує резюме і збережені імена файлів. Експорт виходів 0, коли кожен відео вдалося, 2, коли хтось не вдалося, або 1 при виконанні перевірки або запису не вдалося. Збережено існуючий експорт/збереження; читати його локально замість перевипуску.

| Файл під експорт/ | Використовуйте його для |
| --- | --- |
| videos.json | Імпорт у ваш процес роботи або агента. Пороги зберігають порядок введення, метадані, помилки та використання. |
| videos.csv | Перегляд заголовків, тривалостей і збоїв у таблиці. Формула-подібний текст прописується апотрофією; JSON зберігає оригінальний текст. |
| summary.json | Перевірити покриття і кількість completed/failed, пов'язаних з запуском ID і Bulk ID. |
| failed-video-ids.txt | Огляд тільки підтверджено невдалі відео перед відмовою на іншому платному запиті. Помилки, коли все вдалося. |

#### Python

##### Читати збережені резюме та метадані

```bash
python -m json.tool export/summary.json
python -m json.tool export/videos.json
```


#### Bash

##### Читати збережені резюме та метадані

```bash
jq . export/summary.json
jq . export/videos.json
```



<a id="expected"></a>

### Приклад результату з невдалим відео

Ілюстрація videos.json Вирізка. Закінчена робота Bulk може містити незрівняні відео. Не лікуйте відео, як порожній результат, так і безшумно опустіть його з вашого набору даних.

#### export/videos.json

```json
[
  {
    "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
  }
]
```


<a id="recover"></a>

## Відновити те ж саме роботу

Якщо очікування припинили або результат, не можна прочитати, запустіть відновлення. Збирає існуючу роботу в папку свіжої спроби та оновлення ready.txt тільки після завершення ретривального. Не завантажуйте або подайте заміну роботи. Після чого експортер не був створений, якщо експортувати / ще не був створений.

| Збережений результат | Попередня дія |
| --- | --- |
| bulk_item_failures | Експорт та огляд failed-video-ids.txt. Не відшкодувати всі успішні відео. |
| partial_result | Збережіть частковий файл. Відновити той самий курс, щоб отримати всі частини до експорту. |
| running / finalizing | За допомогою одного запуску ID, профілю та державного каталогу. |
| paused | Читайте pauseReason в статусі, зафіксуйте причину, потім явно відновіть, що Bulk ID за допомогою керівництва управління. |
| awaiting_upload / bulk_input_required | Оглянути збережений проект. Завантажте оригінальний підготовлений файл і запустіть існуючий Bulk ID; відновлення не повторює ці дії. |
| Неперевірити подання або відсутність віддаленого ID | Зберігайте роботу і перевірте збережену помилку і Bulk Новий запуск ID може створити ще одну роботу. |
| Wrong джерело, відсутні ряди або вхід має неправильний | Не прийнято експорт. Перевірити підготовлений знімок, збережений файл запуску та результат; не впускати відсутні метадані. |

### Python

#### Інспекція, після чого відновити існуючу роботу

```bash
python process.py status
python process.py recover
```


### Bash

#### Інспекція, після чого відновити існуючу роботу

```bash
bash process.sh status
bash process.sh recover
```


- [Завантаження, пауза та контроль за відновленням](https://flashdata.dev/uk/docs/guides/bulk/reference.md#controls)
- [Bulk Вакансії](https://flashdata.dev/app/bulk-jobs)
- [Bulk кінцева точка посилання](https://flashdata.dev/uk/docs/reference/bulk-processing/reference.md)

<a id="next"></a>

## Заощаджуйте цей знімок або освіжайте його навмисно

Заощаджуйте завершені результати у вікні затримки 24-години. Ваші експорти залишаються локальними файлами для повторного використання. Щоб оновити метадані пізніше, скористайтеся новою папкою та запустіть ID, а також спочатку переглядайте вартість запиту.

- [Приєднати метадані назад до власних записів](https://flashdata.dev/uk/docs/guides/enrich-youtube-videos/reference.md)
- [Зберігати часові підписи](https://flashdata.dev/uk/docs/guides/timestamped-captions-recipe/reference.md)
