सीधे सामग्री पर जाएँ
HI
API कुंजी प्राप्त करें
दस्तावेज़ देखें

गाइड

Bulk फ़ाइल प्रसंस्करण

वीडियो IDs की एक फ़ाइल की प्रक्रिया करें, अपने आवेदन में डेटासेट आयात करने से पहले हर परिणाम भाग को पुनर्प्राप्त करें और कवरेज की जांच करें।

इस पेज पर

एक ID फ़ाइल से एक चेक डेटासेट तक

इस वर्कफ़्लो का उपयोग वीडियो कैटलॉग, अनुसंधान संग्रह या ingestion कतार के लिए किया जाता है। एक फ़ाइल प्रत्येक ID के लिए एक स्रोत और समान विकल्प का उपयोग करती है। दो वीडियो मेटाडाटा नमूना के साथ शुरू करें, फिर अपनी खुद की फ़ाइल को प्रतिस्थापित करें।

इस वर्कफ़्लो द्वारा निर्मित फ़ाइलें
video-ids.txt → Bulk कार्य → bulk-results.ndjson
  → audit/completed.ndjson आपके अनुप्रयोग के लिए परिणाम
  → audit/failed-video-ids.txt ने समीक्षा करने में विफलता की पुष्टि की
  → audit/missing.ndjson इनपुट जिसका परिणाम लापता हैं
  → audit/summary.json कवरेज और परिणाम गिनती

शुरू करने से पहले

CLI स्थापित करें और youtube_metadata अनुमति के साथ मौजूदा प्रोफ़ाइल या FLASHDATA_API_KEY का उपयोग करें। data.accessVerified: true की पुष्टि करें और उपलब्ध शेष राशि, दो अनुरोधों और वर्तमान सीमाओं के लिए मूल्य निर्धारण की समीक्षा करें। अपनी खुद की फ़ाइल के लिए, मूल्य निर्धारण की जांच करते समय अपनी ID गिनती का उपयोग करें। प्रत्येक संसाधित ID एक अलग क्वेरी है, फ़ाइल के लिए एक फ्लैट चार्ज नहीं है।

Bash का प्रयोग jq या PowerShell 7 के साथ चरणों 1–3 के लिए किया जाता है। चरण 4 में वैकल्पिक आयात लेखा परीक्षा Python 3.10+ और इसकी मानक पुस्तकालय का उपयोग करती है। CLI को स्वयं ही Node.js और Python की आवश्यकता नहीं है।

नि: शुल्क पहुँच और खाता चेक
flashdata auth status --json
flashdata account balance --json
flashdata account pricing --source youtube_metadata --request-count 2
flashdata account limits

1. IDs तैयार करें

एक नए काम करने वाले फ़ोल्डर में भाग लें। एक 11-character वीडियो ID प्रति लाइन के साथ UTF-8 टेक्स्ट का प्रयोग करें, एक YouTube URL नहीं। अधिकतम फ़ाइल का आकार 2 GiB है। खाली लाइनों और डुप्लिकेट निकालें: CLI विकृत इनपुट को अस्वीकार करता है, और बार-बार IDs को अलग से संसाधित किया जाता है।

Bash
# Run in a new working directory.
(
  set -euC
  printf '%s\n' 'jNQXAC9IVRw' 'dQw4w9WgXcQ' > video-ids.txt
)
cat video-ids.txt

2. फ़ाइल को चलाएं

CLI एक नौकरी बनाता है, फ़ाइल को अपलोड करता है, प्रत्येक परिणाम को एक NDJSON फ़ाइल में संसाधित करना शुरू कर देता है। एक नए आउटपुट पथ का प्रयोग करें। स्थानीय रन ID थोक-पहली बार वसूली के लिए दूरस्थ नौकरी रसीद रखता है।

Bash
flashdata bulk run --source youtube_metadata \
  --input video-ids.txt --run-id bulk-first \
  --output bulk-results.ndjson --timeout 30m --json

3. परिणामों का निरीक्षण करना

ओपन bulk-results.ndjson प्रत्येक लाइन इंडेक्स, video_id और स्टेटस के साथ एक JSON रिकॉर्ड है। सफल पंक्तियों में एक परिणाम सारणी होती है; असफल पंक्तियों में त्रुटि होती है। शून्य-आधारित सूचकांक द्वारा इनपुट में रिकॉर्ड में शामिल हों, फ़ाइल ऑर्डर नहीं। Bash कमांड jq का उपयोग करता है।

एक सफल पंक्ति · संक्षिप्त उदाहरण
{"index":0,"video_id":"jNQXAC9IVRw","source":"youtube_metadata","status":"completed","results":[{"videoId":"jNQXAC9IVRw","title":"Example video title"}]}
Bash
# Bash + jq: read each record without loading the whole file.
jq -c '{index, video_id, status, title: .results[0].title, error}' bulk-results.ndjson

4. आयात करने से पहले कवरेज की जाँच करें

नीचे audit-bulk.py सहेजें। इसे अपरिवर्तित इनपुट फ़ाइल और सभी पुनः प्राप्त परिणाम भागों के खिलाफ चलाएं। यह प्रत्येक सूचकांक, वीडियो ID और स्रोत की जांच करता है, डुप्लिकेट परिणाम पंक्तियों को अस्वीकार करता है, और लापता परिणामों से पुष्टि की विफलताओं को अलग करता है। एक अन्य स्रोत के लिए, --source SOURCE_ID जोड़ें।

Expect inputRows: 2, पूरा: 2, विफल: 0, लापता: 0 और allSucceeded: true सफल नमूने के लिए। केवल पूर्ण पंक्तियां आवेदन के परिणाम आयात में हैं। उनके साथ लेखा परीक्षा सारांश और असफल परिणाम रखें।

बचाओ audit-bulk.py

audit-bulk.py को video-ids.txt और bulk-results.ndjson के बगल में कार्य फ़ोल्डर में बनाया गया है। नीचे दिए गए कोड को कॉपी करें और इसे सहेजें।

स्क्रिप्ट लाइन से फ़ाइलों को लाइन पढ़ता है और मेमोरी में पूरे डेटासेट को लोड करने के बजाय स्थानीय SQLite सूचकांक का उपयोग करता है। इसके लिए वीडियो IDs की एक मान्य इनपुट फ़ाइल की आवश्यकता होती है। प्रत्येक लेखा परीक्षा एक नई आउटपुट डायरेक्टरी का उपयोग करती है; आंशिक फाइलें पार्सिंग फिनिश तक अलग रहती हैं।

audit-bulk.py
# audit-bulk.py — Python 3.10+, standard library only; no network requests.
import argparse
import json
import re
import sqlite3
import sys
from contextlib import ExitStack
from pathlib import Path

parser = argparse.ArgumentParser()
parser.add_argument('--input', required=True)
parser.add_argument('--results', required=True)
parser.add_argument('--out', required=True)
parser.add_argument('--source', default='youtube_metadata')
args = parser.parse_args()
out = Path(args.out)
try:
    out.mkdir()  # Keep any previous audit. Use a new directory for another attempt.
    with ExitStack() as stack:
        db = sqlite3.connect(out / 'index.sqlite')
        stack.callback(db.close)
        db.execute('CREATE TABLE inputs (idx INTEGER PRIMARY KEY, video_id TEXT, outcome TEXT)')
        count = 0
        with open(args.input, encoding='utf-8-sig') as inputs:
            for index, line in enumerate(inputs):
                video_id = line.strip()
                if not re.fullmatch(r'[A-Za-z0-9_-]{11}', video_id):
                    raise ValueError('Invalid ID on input line ' + str(index + 1))
                db.execute('INSERT INTO inputs VALUES (?, ?, NULL)', (index, video_id))
                count += 1
        if not count:
            raise ValueError('The input file is empty.')
        db.commit()
        files = {name: stack.enter_context(open(out / (name + '.part'), 'x', encoding='utf-8'))
                 for name in ['completed.ndjson', 'failed.ndjson', 'missing.ndjson', 'failed-video-ids.txt']}
        completed = failed = 0
        with open(args.results, encoding='utf-8-sig') as results:
            for line_number, line in enumerate(results, 1):
                if not line.strip():
                    continue
                row = json.loads(line)
                if not isinstance(row, dict) or type(row.get('index')) is not int:
                    raise ValueError('Invalid result index on line ' + str(line_number))
                expected = db.execute('SELECT video_id, outcome FROM inputs WHERE idx = ?',
                                      (row['index'],)).fetchone()
                if (not expected or row.get('video_id') != expected[0]
                        or row.get('source') != args.source or expected[1] is not None):
                    raise ValueError('Unknown, duplicate or mismatched result on line ' + str(line_number))
                status = row.get('status')
                if status not in ['completed', 'failed']:
                    raise ValueError('Unexpected item status on line ' + str(line_number))
                if status == 'completed':
                    if not isinstance(row.get('results'), list):
                        raise ValueError('Completed row is missing its results array.')
                    if args.source == 'youtube_metadata' and (len(row['results']) != 1
                            or not isinstance(row['results'][0], dict)
                            or row['results'][0].get('videoId') != expected[0]):
                        raise ValueError('Metadata does not belong to the requested video.')
                    completed += 1
                else:
                    failed += 1
                db.execute('UPDATE inputs SET outcome = ? WHERE idx = ?', (status, row['index']))
                files[status + '.ndjson'].write(json.dumps(row, ensure_ascii=False) + '\n')
        db.commit()
        missing = 0
        for index, video_id in db.execute('SELECT idx, video_id FROM inputs WHERE outcome IS NULL ORDER BY idx'):
            files['missing.ndjson'].write(json.dumps({'index': index, 'video_id': video_id,
                                                     'status': 'missing_result'}) + '\n')
            missing += 1
        for (video_id,) in db.execute("SELECT video_id FROM inputs WHERE outcome = 'failed' GROUP BY video_id ORDER BY MIN(idx)"):
            files['failed-video-ids.txt'].write(video_id + '\n')
        summary = {'source': args.source, 'inputRows': count, 'completed': completed,
                   'failed': failed, 'missing': missing, 'coverageComplete': missing == 0,
                   'allSucceeded': failed == 0 and missing == 0}
    for name in files:
        (out / (name + '.part')).rename(out / name)
    with open(out / 'summary.json', 'x', encoding='utf-8') as output:
        json.dump(summary, output, indent=2)
    print(json.dumps(summary, indent=2))
    sys.exit(0 if summary['allSucceeded'] else 2)
except Exception as error:
    print(str(error), file=sys.stderr)
    print('Audit not complete. Preserve this directory and inspect the inputs/results.', file=sys.stderr)
    sys.exit(1)

आयात लेखा परीक्षा चलायें

स्क्रिप्ट, मूल इनपुट और डाउनलोड किए गए परिणामों वाले फ़ोल्डर से भाग लें। लेखा परीक्षा केवल स्थानीय फाइलों को पढ़ती है।

Bash
python3 audit-bulk.py --input video-ids.txt --results bulk-results.ndjson --out audit

पूर्ण पंक्तियों को आयात करें और लेखा परीक्षा रखें

फ़ाइल / संकेतइसे इस तरह से इस्तेमाल करें
completed.ndjsonसूचकांक से मूल फ़ाइल में शामिल हों। एक सूची कुंजी के लिए video_id का उपयोग करें; ताज़ा इतिहास के भंडारण के दौरान job/snapshot पहचान को बनाए रखें।
failed.ndjson + failed-video-ids.txtइन IDs को जानबूझकर पुनः प्राप्त करने से पहले त्रुटियों की समीक्षा करें। सफल और लापता आइटम असफल ID सूची से बाहर रखा गया है।
missing.ndjsonमौजूदा नौकरी से सभी परिणाम भागों को पुनर्प्राप्त करें, फिर पुनर्प्राप्त फ़ाइल को एक नई डायरेक्टरी में ऑडिट करें। मिसिंग आउटपुट की पुष्टि नहीं हुई है।
summary.jsoncoverageComplete यह जाँचता है कि प्रत्येक इनपुट का परिणाम है। allSucceeded को भी कोई असफल वीडियो की आवश्यकता नहीं है। लेखा परीक्षा असफलता या लापता पंक्तियों के लिए 2 से बाहर निकलती है।
Exit 1 / No summary.jsonविकृत या गलत डेटा: सहेजी गई फ़ाइलों का निरीक्षण करें। एक पूर्ण डेटासेट के रूप में आंशिक लेखा परीक्षा को प्रकाशित न करें।

अगर कुछ वीडियो विफल हो गए

एक पूर्ण Bulk नौकरी में विफल वीडियो हो सकते हैं। CLI उन पंक्तियों को भी बचाता है, फिर bulk_item_failures के साथ निकलता है। यह तय करने से पहले अपनी त्रुटियों का निरीक्षण करें कि व्यक्तिगत IDs को पुनः प्राप्त करना है या नहीं; पूरी फ़ाइल को स्वचालित रूप से दोहराना नहीं है।

केवल असफल रिकॉर्ड दिखाएं · jq
jq -c 'select(.status != "completed") | {index, video_id, status, error}' bulk-results.ndjson

ट्रैक प्रगति और क्षमता

जबकि मूल आदेश चलता है बचाया नौकरी पढ़ें। CLI डेटा के तहत स्थिति लपेटता है; प्रत्यक्ष HTTP इसे नौकरी के तहत लपेटता है। एक देरी और backoff के साथ जाँच करें, और 429 पर Retry-After को सम्मान दें। एक स्थानीय टाइमआउट या बंद टर्मिनल दूरस्थ काम को रद्द नहीं करता है।

फील्डइसे पढ़िए
input.scannedBytes / input.bytesफ़ाइल स्कैन की प्रगति, पूर्ण क्वेरी या अपलोड की गई मीडिया नहीं।
input.completeसभी इनपुट पढ़ा गया है; प्रश्नों और परिणाम पैकेजिंग अभी भी चल सकता है।
counts.accepted / completed / failedजमा हुआ IDs, सफल वीडियो और असफल वीडियो। बकाया = स्वीकार किए जाते हैं - पूरा हो गया।
counts.invalid / resultsअब तक पैक किए गए इनपुट लाइन / रिकॉर्ड। HTTP उन फ़ाइलों को स्वीकार कर सकता है जिनमें अवैध रेखाएं शामिल हैं; CLI अपलोड करने से पहले इनपुट को मान्य करता है।
deliveryग्राहक डेटा वितरण: uploadedParts, retryCount, storageType और customerStorage. प्रत्येक वीडियो के मीडिया अपलोड से अलग है।
Bash
(
set -eu
BULK_ID=$(flashdata runs show bulk-first --json | jq -er '.data.remoteId')
flashdata bulk get "$BULK_ID" --json
)

जब तक प्रतीक्षा या कार्य करना

Bulk धीरे-धीरे आपके खाते की maxPendingJobs क्षमता के भीतर जमा करता है, जो अन्य नौकरियों के साथ साझा होता है। अपर्याप्त क्रेडिट या निष्क्रिय सदस्यता नौकरी को रोक सकती है। Resuming से पहले pauseReason की जाँच करें।

राज्यअगली कार्रवाई
awaiting_uploadफ़ाइल को अपलोड करें, फिर मौजूदा नौकरी शुरू करें।
running / finalizingप्रतीक्षा करें अंतिम रूप देने में अधूरे प्रश्नों, पैकेजिंग और भंडारण वितरण शामिल हो सकते हैं।
pausedpauseReason को हल करें और उसी काम को फिर से शुरू करें।
completedसभी परिणाम भागों को डाउनलोड करें और असफल पंक्तियों का निरीक्षण करें।
failed / cancelledInspect job.error और बचाया रसीद। स्वीकृत कार्य अभी भी finish हो सकता है; कोई पूर्ण प्रकटन प्रकाशित नहीं किया गया है।

एक बाधित वर्कफ़्लो फिर से शुरू करें

एक स्थानीय टाइमआउट या बाधित परिणाम डाउनलोड के बाद, थोक-पहली बार पुनर्प्राप्त करें। यह मौजूदा दूरस्थ नौकरी पढ़ता है; यह फिर से डेटासेट जमा नहीं करता है। एक नया आउटपुट फ़ाइल नाम का उपयोग करें। एक partial_result त्रुटि एक आंशिक स्थानीय फ़ाइल छोड़ सकती है; इसे पुनर्प्राप्त परिणाम से अलग रखें।

उसी CLI प्रोफाइल और स्टेट डाइरेक्टरी का उपयोग करें। एक नामित प्रोफ़ाइल के लिए, प्रत्येक कमांड में --profile नाम जोड़ें।

स्थितिफिक्स
awaiting_uploadruns recover एक अपलोड या प्रारंभ नहीं होता है। बचाया ID, स्पष्ट रूप से जारी रहने से पहले स्थिति और मूल फ़ाइल अपलोड करें।
pausedरिपोर्ट किए गए कारण को हल करें, फिर बचाए गए ID के साथ बल्क रिज्यूमे का उपयोग करें। रिकवरी स्वचालित रूप से प्यूज्ड काम को फिर से शुरू नहीं करती है।
401 / 403जमा करने वाले खाते और स्रोत तक वैध पहुंच को पुनर्स्थापित करें। प्रमाणीकरण के बाद उसी काम को फिर से शुरू करें।
409 / 410409: परिणाम तैयार नहीं हैं। 410: संग्रहीत परिणाम समाप्त हो गए; अपनी सहेजी गई प्रतिलिपि का उपयोग करें।
Expired upload URLपुराने काम की पुष्टि करने से पहले कभी एक नया बनाने शुरू नहीं हुआ। एक अनिश्चित प्रस्तुतीकरण पहले अपने बचाया ID पढ़ने का एक कारण है।
बचाया रन को पुनर्प्राप्त करें
flashdata runs show bulk-first --json
flashdata runs recover bulk-first --output recovered-results.ndjson --timeout 30m --json

रोकें या फिर से शुरू करें नौकरी

BULK_ID को ID के साथ runs show बल्क-फ़र्स्ट से बदलें। Pause नए प्रस्तुतियों और परिणाम पैकेजिंग बंद हो जाता है; स्वीकार किए गए प्रश्नों जारी है। Resuming से पहले pauseReason को हल करें। बदल विकल्प या भंडारण क्रेडेंशियल के लिए, मौजूदा नौकरी को Bulk API के माध्यम से अद्यतन करें।

पौलुस
flashdata bulk pause BULK_ID --json
कारण को ठीक करने के बाद फिर से शुरू करें
flashdata bulk resume BULK_ID --json

स्थायी रूप से रद्द करना

जब आप नौकरी छोड़ने का इरादा रखते हैं तो केवल रद्द कर दिया जाता है। रद्द करना स्वीकार किए गए प्रश्नों को रद्द नहीं करता है या पूरा काम वापस नहीं करता है। गणना अभी भी बदल सकती है, और कोई पूर्ण प्रकट प्रकाशित नहीं होता है। प्यूस प्रतिवर्ती है।

चुने हुए काम को रद्द करना
flashdata bulk cancel BULK_ID --json

प्रत्येक परिणाम भाग को पुनर्प्राप्त करें

एक मौजूदा पूर्ण नौकरी के लिए, CLI अपने प्रकटन का अनुसरण करता है और प्रत्येक परिणाम को एक NDJSON फ़ाइल में सहेजता है। एक नए आउटपुट पथ का उपयोग करें और संयुक्त फ़ाइल पर आयात लेखा परीक्षा चलाएं। डाउनलोड परिणाम वितरित मीडिया का वर्णन करते हैं; वे एमपी 4 या ऑडियो बाइट नहीं हैं।

एक मौजूदा नौकरी से सभी भागों को आकर्षित करें
flashdata bulk results BULK_ID --output saved-results.ndjson --timeout 30m --json

अपने भंडारण के लिए वितरित करें

इस आदेश को चलाने से पहले अपने प्रदाता को कार्य फ़ोल्डर में storage.json के रूप में क्रेडेंशियल्स को कार्य करने से पहले सहेजें। नीचे जुड़े प्रदाता फ़ील्ड का उपयोग करें; फ़ाइल को निजी रखें। CLI की --storage-config ने इस JSON फ़ाइल को पढ़ा और मीडिया के लिए डेटा या स्टोरेज के लिए result_storage का चयन किया। --options एक फ़ाइल पथ भी लेता है, न कि JSON को इनलाइन करता है।

बचाया भंडारण विन्यास के साथ भागो

मेटाडाटा वर्कफ़्लो में भंडारण जोड़ें
flashdata bulk run --source youtube_metadata --input video-ids.txt --storage-config storage.json --run-id bulk-with-storage --output stored-results.ndjson --timeout 30m --json
Markdown