# Video IDs'un bir dosyası

Bir YouTube ID dosyası metadata JSON ve CSV, video başına bir sonuçla. Python veya Bash ile FlashData CLI.

Canonical referans: https://flashdata.dev/tr/docs/guides/bulk-metadata-recipe
İnceleme: 2026-11-05 Tarafından FlashData

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

## Başlamadan önce başlamadan önce

Use Use Use FlashData CLI v1.2.1 Onda PATH, artı Python 3.10+ (standart kütüphane sadece), veya Bash with with with ile jq ve OpenSSL. Her iki versiyon da CLI'u yükleme, iş kurtarma ve sonuç bölüm retrieval için kullanır. Onda Windows, kullanımı Git Bash Çünkü, Bash Versiyon.

API anahtarı ile youtube_metadata izni ve mevcut kredilere ihtiyacınız var. Kurtarılan sahibinin girişini yeniden kullanın veya auth login'u bir kez çalıştırın ve gizli bir şekilde anahtara girin. Ajanlar FLASHDATA_API_KEY'u gizli mağazalarından tedarik edebilir.

Bu örnekler varsayılan CLI profili ve eyalet rehberi kullanır. Aynı hesabı tut ve kurtarma için devlet kurtar. auth status geçici erişimi gösterirse, Bulk'ye başlamadan önce bunu iddia edin.

### Sadece kurtarılmamış bir sahibiniz varsa

```bash
flashdata auth login
```

### İki videoluk bu örneğin erişimini ve maliyetini kontrol edin

```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
```

- [Yüklemek için CLI](https://flashdata.dev/tr/docs/guides/flashdata-cli/reference.md#install)
- [API anahtarı alın](https://flashdata.dev/app/api-keys)
- [Ajan denemesi ve hesap bağlama](https://flashdata.dev/tr/docs/guides/agent-onboarding/reference.md)

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

## 1. Videoyu Hazırlayın IDs

bulk-enrichment klasörü oluşturup video-ids.txt dosyasını oraya kaydedin. O klasörde terminal açın. Başlık, boş satır veya tam YouTube URL adresleri olmadan her satıra bir 11 karakterli ID değeri yazın.

Bir hazırlık betiği seçip video-ids.txt dosyasının yanına kaydedin. Betik geçersiz ve yinelenen ID değerlerini reddeder; normalize edilmiş girdi kopyasını, meta veri seçeneklerini ve çalıştırma ID değerini prepared/ altında saklar. Girdi sırası korunur.

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

#### Bulk-enrichment / Run from Bulk-enrichment /

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


### Bash

#### Yerel araçları kontrol edin

```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
```

#### Bulk-enrichment / Run from Bulk-enrichment /

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



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

### Hazırlanan nedir

Beklemek Hazırlandı 2 videolar için eşsiz videolar için001. Hazır / değişmeli tutun. Metadata include_formats: false ve include_chapters: false kullanır. Her kabul edilen video ayrı bir faturalanabilir bir öğedir; tekrar hatları ayrı olarak işlenecektir, bu yüzden bu tarif onları göndermeden önce durur.

Bir run ID'u farklı bir görev için kullanmadınız. Retain videoları-001 bu görevin yeniden inşası ve kurtarması için. Yeni bir koşu ID, yeni bir veri kümesi veya yenileme amaçlıdır.

- [Metadata alanlarını seçin](https://flashdata.dev/tr/docs/guides/video-metadata-recipe/reference.md#fields)

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

## 2. Gönder ve sonuçları toplamak

process.py veya process.sh dosyasını çalıştırmadan önce bulk-enrichment klasörüne kaydedin. CLI bir Bulk işi oluşturur, hazırlanmış ID değerlerini yükler, işlemi başlatır ve tüm sonuç parçalarını bulk-results.ndjson içine kaydeder. Yerel bekleme 30 dakika sonra durur; sunucunun kabul ettiği iş devam eder.

Her girişim, CLImak, hatayla kendi klasörüne girer ve çalıştırılır. ready.txt puanlarını en son tam sonuç için alır. 2, tam sonuçlar başarısız videolar içerir; bu satırları ihraç etmeye ve incelemeye devam eder.

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

#### Hazır dosyayı

```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; }
```

#### Hazır dosyayı

```bash
bash process.sh submit
```



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

### Başka bir terminalden ilerleme kontrol edin

Aynı CLI hesabı ile toplu zenginleştirmeden hareket edin. Durum eylemi, kurtarılanın yapıldığını ve uzaktan Bulk işini bir ID mevcut olduğunda okur. Bu yaratma veya özgeçmiş çalışması yaratmaz.

#### Python

##### Mevcut ilerlemeyi okuyun

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


#### Bash

##### Mevcut ilerlemeyi okuyun

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



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

## 3. Reconcile ve ihracat

export.py veya export.sh'u diğer senaryoların yanında kurtarın, sonra çalıştırın. Kurtarılan run ve girdi hash'ı kontrol eder, sonra sıfır tabanlı indeks ve video_id ile her sonucu karşılaştırır. Sonuç parçalar siparişden çıkabilir. Eksik, tekrarlanan veya yanlış sıralar ihracatı durdurur.

ihracatçı, her satır için tam metadata nesnesini, hatayı korur ve rapor eder. Başarısız videolar metadata: null ile görünür. Bu küçük örnek sonuçları hafızaya yükler; Bulk dosya işlemedeki akış denetimini büyük bir veri kümesi için kullanın.

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

#### Yerel olarak ihracat · API arama

```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
```

#### Yerel olarak ihracat · API arama

```bash
bash export.sh
```


- [Sınırlı hafıza ile büyük bir dosya Denetimi](https://flashdata.dev/tr/docs/guides/bulk/reference.md#audit)

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

### ihraç edilen dosyaları kullanın

Başarı özetini yazdırır ve dosya adı kurtarılır. İhracat çıkışları 0 Her video başarılı olduğunda, 2 Bazı başarısız olduğunda veya 1 Geçerlilik veya yazı başarısız olduğunda. Mevcut bir ihracat / korunmuştur; yeniden çalışan teslimiyet yerine yerel olarak okuyun.

| İhracat / ihracat altında Dosya | Bunu için kullanın |
| --- | --- |
| videos.json | Uygulamanıza veya acente iş akışınıza geçin. Rows giriş siparişini, metadata, hataları ve kullanımı tutar. |
| videos.csv | Listeler, bir yay sayfasındaki süreler ve başarısızlıklar. Formula benzeri metin bir apostrophe ile önceden eklenmiştir; JSON orijinal metni korur. |
| summary.json | Giriş ve kontrol kapsamı ve completed/failed Sayılar, koşma ile bağlantılı ID Ve ve Bulk ID. |
| failed-video-ids.txt | Başka bir ücretli talep üzerine karar vermeden önce sadece başarısız videoları doğruladı. Her şey başarılı olduğunda boşaltın. |

#### Python

##### Kurtarılan özet ve metadata

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


#### Bash

##### Kurtarılan özet ve metadata

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



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

### Başarısız bir video ile örnek sonuç

Illustrative videos.json alıntı. Tamamlanan Bulk işi başarısız videolar içerebilir. Boş başarılı bir sonuç olarak başarısız bir videoyu tedavi etmeyin veya sessiz bir şekilde veri setinizden çıkarın.

#### 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>

## Aynı işi yeniden keşfedin

Durmuş ya da sonuç kısmı okunamazsa, kurtarılabilir. Mevcut işi taze bir deneme klasörüne toplar ve ready.txt'u sadece tam retrieval'den sonra toplar. Bu yüklemez veya yedek iş gönderin. Sonra ihracat yapanı çalıştırın / henüz yaratılmamışsa.

| Kurtarılan sonuç | Sonraki eylem |
| --- | --- |
| bulk_item_failures | failed-video-ids.txt'u ihracat ve inceleme. Tüm başarılı videoları yeniden yayınlamayın. |
| partial_result | Kısmi dosyayı koruyun. İhracattan önce tüm parçaları almak için aynı çalışmayı yeniden keşfedin. |
| running / finalizing | Daha sonra ID, profil ve eyalet dizilerini kullanarak yeniden keşfedin. |
| paused | pauseReason'u statüde okuyun, nedeni düzeltin, o zaman açıkça Bulk ID'nun kontrol kılavuzunu kullanarak özgeçmişine devam edin. |
| awaiting_upload / bulk_input_required | Kurtarılan taslağın incelenmesi. Orijinal hazır dosyayı yükleyin ve mevcut Bulk ID'yu başlatın; kurtarma bu eylemleri yeniden oynatmıyor. |
| Uncertain gönderimi veya uzaktan ID | Takip etmeyi ve kurtarılan hatayı ve Bulk Jobs'u yeniden denemeden önce kontrol edin. Yeni bir koşu ID başka bir iş yaratabilir. |
| Yanlış kaynak, eksik satırlar veya giriş yanlış bir uyum vardır | Hiçbir ihracat kabul edilmez. Hazır snapshot'ı kontrol edin, kurtarın ve sonuç dosyasını kontrol edin; eksik metadata icat etmeyin. |

### Python

#### Inspect, o zaman mevcut işleri geri al

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


### Bash

#### Inspect, o zaman mevcut işleri geri al

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


- [Yükleme, duraklama ve özgeçmiş kontrolleri](https://flashdata.dev/tr/docs/guides/bulk/reference.md#controls)
- [Bulk Jobs](https://flashdata.dev/app/bulk-jobs)
- [Bulk endpoint referans](https://flashdata.dev/tr/docs/reference/bulk-processing/reference.md)

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

## Bu snapshot'ı kurtarın veya kasıtlı olarak yenileme

24-hour keep penceresi içinde tamamlanmış sonuçları kurtarın. İhracatınız yeniden kullanım için yerel dosyalar olarak kalır. metadata'yı daha sonra yenilemek için, yeni bir çalışma klasörü kullanın ve ID'u çalıştırın ve ilk önce yeni talebi gözden geçirin.

- [Metadata'ya kendi kayıtlarınıza katılın](https://flashdata.dev/tr/docs/guides/enrich-youtube-videos/reference.md)
- [Erişim süreleri silinmiş](https://flashdata.dev/tr/docs/guides/timestamped-captions-recipe/reference.md)
