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

गाइड

उपाय API विलंबता और थ्रूपुट डाउनलोड

एक मापा खोज चलायें, सहेजे गए नमूनों को सारांशित करें, या समय मीडिया वितरण अपने भंडारण के लिए।

इस पेज पर

माप चुनें

मीट्रिकप्रारंभ करें → finish
प्रतिक्रिया समयप्रारंभ करें HTTP अनुरोध → पूरा शरीर पढ़ा। नीचे दिए गए चरणों 1–3 का उपयोग करें।
मीडिया वितरण थ्रूपुटवितरित मीडिया बाइट्स ÷ CLI स्टार्ट-टू-रेसल्ट सेकंड। इसमें एक्सेस चेक, सबमिशन, मतदान और परिणाम निर्यात शामिल हैं।
Async API समयरिकॉर्ड स्वीकृति (रीक्वेस्ट → जॉब ID) अलग से पूरा होने (रीक्वेस्ट → पूरा स्टेटस) से। Async वर्कफ़्लो का उपयोग करें और अपने मतदान अंतराल को बनाए रखें।

1. एक खोज नमूना तैयार करना

Python 3.10+ का उपयोग करें और google_search अनुमति के साथ एक कुंजी FLASHDATA_API_KEY में। कोई अतिरिक्त Python पैकेज की आवश्यकता नहीं है। यदि आपके अनुवादक का नाम है तो पाइथन के बजाय पाइथन 3 का उपयोग करें।

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

टर्मिनल · काम करने वाले फ़ोल्डर का निर्माण
mkdir flashdata-benchmark
cd flashdata-benchmark
python --version

अनुरोध सहेजें

इसे request.json के अंदर flashdata-benchmark/. के रूप में सहेजें

request.json
{
  "source": "google_search",
  "query": "battery recycling research",
  "params": {
    "num": 5
  }
}

2. पूर्ण प्रतिक्रिया समय

measure.py को request.json के बगल में सहेजें। यह अनुरोध को एक नए नमूना फ़ोल्डर में कॉपी करता है, फिर पूर्ण प्रतिक्रिया समय, HTTP स्थिति रिकॉर्ड करता है, जब लौटाया जाता है तो ID और Retry-After का अनुरोध करता है। सॉकेट ऑपरेशन एक 120-दूसरे टाइमआउट का उपयोग करते हैं। एक मौजूदा नमूना फ़ोल्डर एक अनुरोध भेजने से पहले निष्पादन बंद कर देता है।

measure.py
import hashlib
import json
import os
import platform
import sys
import time
from datetime import datetime, timezone
from http.client import HTTPException
from pathlib import Path
from urllib.error import HTTPError, URLError
from urllib.request import HTTPRedirectHandler, Request, build_opener

class NoRedirect(HTTPRedirectHandler):
    def redirect_request(self, req, fp, code, msg, headers, newurl):
        return None

if len(sys.argv) != 4:
    raise SystemExit("Usage: python measure.py request.json NEW_DIRECTORY CLIENT_REGION")
key = os.environ.get("FLASHDATA_API_KEY")
if not key:
    raise SystemExit("Set FLASHDATA_API_KEY first")
payload = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8-sig"))
if not isinstance(payload, dict) or payload.get("source") != "google_search" \
        or set(payload) - {"source", "query", "params"} \
        or not isinstance(payload.get("query"), str) or not payload["query"].strip() \
        or not isinstance(payload.get("params", {}), dict):
    raise SystemExit("This example measures one realtime google_search request")
body = json.dumps(payload, sort_keys=True, allow_nan=False).encode()
settings = json.dumps({"source": payload["source"], "params": payload.get("params", {})},
    sort_keys=True, allow_nan=False).encode()
folder = Path(sys.argv[2])
try:
    folder.mkdir(mode=0o700)
except FileExistsError:
    raise SystemExit("Sample directory already exists; no request sent. Inspect its saved files.")
(folder / "request.json").write_bytes(body)
request = Request("https://data.flashdata.dev/v1/queries/realtime", data=body,
    headers={"X-API-Key": key, "Content-Type": "application/json", "Accept": "application/json"})
report = {"started_at": datetime.now(timezone.utc).isoformat(),
    "region": sys.argv[3], "source": payload["source"], "mode": "realtime",
    "input_sha256": hashlib.sha256(body).hexdigest(),
    "settings_sha256": hashlib.sha256(settings).hexdigest(), "concurrency": 1,
    "python_version": platform.python_version(), "timeout_seconds": 120,
    "http_status": None, "request_id": None, "retry_after": None,
    "elapsed_ms": None, "outcome": "unknown"}
(folder / "timing.json").write_text(json.dumps(report, indent=2), encoding="utf-8")
raw = b""
start = time.perf_counter()
try:
    try:
        response = build_opener(NoRedirect()).open(request, timeout=120)
    except HTTPError as error:
        response = error
    with response:
        report["http_status"] = response.status
        report["request_id"] = response.headers.get("X-Request-Id")
        report["retry_after"] = response.headers.get("Retry-After")
        raw = response.read()
except (URLError, OSError, HTTPException):
    report["error"] = "transport_error_or_timeout"
report["elapsed_ms"] = round((time.perf_counter() - start) * 1000, 3)
try:
    result = json.loads(raw)
except (ValueError, UnicodeDecodeError):
    result = {}
if report["http_status"] is not None and "error" not in report:
    complete = report["http_status"] == 200 and isinstance(result, dict) \
        and result.get("status") == "done" and isinstance(result.get("results"), list)
    report["outcome"] = "completed" if complete else "failed"
(folder / "response.json").write_bytes(raw)
(folder / "timing.json").write_text(json.dumps(report, indent=2), encoding="utf-8")
print(json.dumps(report, indent=2))
raise SystemExit(0 if report["outcome"] == "completed" else 1)

रन और निरीक्षण

अपने क्लाइंट मशीन के क्षेत्र के साथ क्लाइंट-क्षेत्र बदलें, जैसे कि यू-वेस्ट-1। एक बार पहले कमांड चलाएं; दूसरा कमांड केवल सहेजे गए समय को पढ़ता है।

एक खोज, फिर एक स्थानीय पढ़ा
python measure.py request.json sample-01 client-region
python -m json.tool sample-01/timing.json

सहेजी गई फ़ाइलों की जाँच करें

कोड 0 और रिकॉर्ड http_status: 200 और outcome: completed के साथ सफलता निकास। प्रतिक्रिया निकाय में status: done और एक परिणाम सारणी है। कोड 1 के साथ असफल या अज्ञात निकास; किसी अन्य क्वेरी पर निर्णय लेने से पहले फ़ाइलों का निरीक्षण करें।

फ़ाइलक्या जांचें
sample-01/request.jsonसही इनपुट जमा करने से पहले बचाया।
sample-01/response.jsonरॉ रिस्पांस बॉडी; एक HTTP त्रुटि गैर-JSON सामग्री को वापस कर सकती है।
sample-01/timing.jsonelapsed_ms, परिणाम, http_status, request_id और retry_after. एक null elapsed_ms का मतलब है कि प्रक्रिया finish रिकॉर्डिंग नहीं थी।

3. सहेजे गए नमूनों को समरूपीकृत करें

summarize.py को measure.py के बगल में सहेजें। यह स्थानीय नमूनों को पढ़ता है और डुप्लिकेट फ़ोल्डर्स, अपूर्ण समय और गलत अनुरोध सेटिंग्स, क्लाइंट क्षेत्र या Python संस्करण को अस्वीकार करता है।

p50/p95 पूर्ण प्रतिक्रियाओं के निकटतम रैंक प्रतिशत का उपयोग करते हैं। असफल और अज्ञात प्रयास कुलों में रहते हैं। एक सफल नमूना एक ही p50 और p95 देता है; कोई सफल नमूने दोनों के लिए null देता है।

summarize.py
import json
import math
import sys
from pathlib import Path

if len(sys.argv) < 2:
    raise SystemExit("Usage: python summarize.py SAMPLE_DIRECTORY [SAMPLE_DIRECTORY ...]")
folders = [Path(value).resolve() for value in sys.argv[1:]]
if len(set(folders)) != len(folders):
    raise SystemExit("Pass each sample directory only once")
rows = [json.loads((folder / "timing.json").read_text(encoding="utf-8")) for folder in folders]
fields = ("source", "mode", "region", "concurrency", "timeout_seconds", "settings_sha256", "python_version")
for row in rows:
    if not isinstance(row, dict) or any(field not in row for field in (*fields, "input_sha256")):
        raise SystemExit("Use timing.json files written by this measure.py")
    elapsed = row.get("elapsed_ms")
    if row.get("outcome") not in ("completed", "failed", "unknown") \
            or type(elapsed) not in (int, float) or not math.isfinite(elapsed) or elapsed < 0:
        raise SystemExit("Incomplete or invalid timing record; inspect it before summarizing")
if len({json.dumps([row[field] for field in fields], sort_keys=True) for row in rows}) != 1:
    raise SystemExit("Compare runs separately when source, mode, region or settings differ")
times = sorted(row["elapsed_ms"] for row in rows if row["outcome"] == "completed")
inputs = len({row["input_sha256"] for row in rows})
def percentile(percent):
    return times[math.ceil(len(times) * percent / 100) - 1] if times else None
print(json.dumps({"context": {field: rows[0][field] for field in fields},
    "attempted": len(rows), "completed": len(times),
    "failed": sum(row["outcome"] == "failed" for row in rows),
    "unknown": sum(row["outcome"] == "unknown" for row in rows),
    "success_rate": len(times) / len(rows), "distinct_inputs": inputs,
    "input_pattern": "repeated_input" if inputs == 1 else "varied_inputs",
    "successful_latency_ms": {"p50": percentile(50), "p95": percentile(95)}}, indent=2))
पहला नमूना पढ़ें
python summarize.py sample-01

जानबूझकर नमूने जोड़ें

नीचे दिए गए प्रथम कमांड एक और खोज भेजता है। एक ही ग्राहक पंजीकरण मान और अनुरोध सेटिंग रखें। विभिन्न इनपुट को मापने के लिए, इसे चलाने से पहले केवल request.json में क्वेरी को बदल दें। रिपोर्ट इनपुट पैटर्न को लेबल करती है और अलग-अलग इनपुट की गणना करती है।

एक एजेंट-रन मूल्यांकन के लिए, पहले नमूना गिनती और क्रेडिट बजट पर सहमत होते हैं। क्रमिक रूप से नमूने चलाएं; इस उदाहरण के लिए परिणामी रिकॉर्ड: 1. नमूना फ़ोल्डर्स के साथ सारांश सहेजें।

एक अतिरिक्त खोज
python measure.py request.json sample-02 client-region
सहेजे गए नमूनों को मिलाएं · कोई नया अनुरोध नहीं है
python summarize.py sample-01 sample-02 > summary.json
python -m json.tool summary.json

CLI के साथ मीडिया वितरण को मापें

यह अलग-अलग उदाहरण आपके भंडारण के लिए एक MP3 प्रदान करता है। CLI स्थापित करें, youtube_download अनुमति के साथ एक बचाया मालिक प्रोफ़ाइल का उपयोग करें, और इसकी राज्य निर्देशिका उपलब्ध रखें। टाइमर उस प्रोफ़ाइल का पुन: उपयोग करता है और FLASHDATA_API_KEY को अनदेखा करता है। सामान्य डाउनलोड मूल्य निर्धारण लागू होता है।

flashdata-benchmark/ में, अपने गंतव्य को एक निजी storage.json के रूप में सहेजते हैं। इस S3 उदाहरण को आपकी बाल्टी, क्षेत्र और भंडारण क्रेडेंशियल की जरूरत है; यदि आपके पास पहले से ही एक है तो अपनी मौजूदा निजी फ़ाइल का उपयोग करें।

storage.json
{
  "storage_type": "s3",
  "storage_url": "YOUR_BUCKET",
  "access_key": "YOUR_ACCESS_KEY",
  "secret_key": "YOUR_SECRET_KEY",
  "region": "us-east-1"
}

प्रसव टाइमर सहेजें

measure-download.py को storage.json के बगल में सहेजें। यह CLI शुरू करने से पहले एक नया रन ID बचाता है, कमांड के लिए 10 मिनट तक प्रतीक्षा करता है, और परिणाम निर्यात के माध्यम से रिकॉर्ड समय समाप्त हो जाता है। CLI लॉन्च करने से पहले एक नमूना फ़ोल्डर स्टॉप का उपयोग करना।

measure-download.py
import json
import os
import shutil
import subprocess
import sys
import time
import uuid
from datetime import datetime, timezone
from pathlib import Path

if len(sys.argv) not in (6, 7):
    raise SystemExit("Usage: python measure-download.py VIDEO_ID storage.json NEW_DIRECTORY PROFILE CLIENT_REGION [STATE_DIRECTORY]")
video, storage, directory, profile, region = sys.argv[1:6]
binary = shutil.which("flashdata")
if not binary or not Path(storage).is_file():
    raise SystemExit("Install flashdata on PATH and create the private storage.json first")
folder = Path(directory)
try:
    folder.mkdir(mode=0o700)
except FileExistsError:
    raise SystemExit("Sample directory already exists; inspect timing.json and recover its run_id.")
report = {"run_id": "perf-" + uuid.uuid4().hex, "profile": profile,
    "started_at": datetime.now(timezone.utc).isoformat(),
    "source": "youtube_download", "video_id": video, "output_format": "mp3",
    "region": region, "metric": "cli_start_to_result_saved",
    "timeout_seconds": 600, "elapsed_seconds": None, "outcome": "unknown"}
timing = folder / "timing.json"
timing.write_text(json.dumps(report, indent=2), encoding="utf-8")
print("Saved run_id in " + str(timing), flush=True)
command = [binary, "youtube", "download", video, "--format", "mp3",
    "--storage-config", str(Path(storage).resolve()), "--mode", "async", "--wait",
    "--run-id", report["run_id"], "--output", str(folder / "delivery.json"),
    "--profile", profile, "--timeout", "10m", "--json", "--non-interactive"]
if len(sys.argv) == 7:
    report["state_directory"] = str(Path(sys.argv[6]).resolve())
    command.extend(["--state-dir", report["state_directory"]])
    timing.write_text(json.dumps(report, indent=2), encoding="utf-8")
environment = dict(os.environ)
environment.pop("FLASHDATA_API_KEY", None)  # Reuse the named profile's stored key.
start = time.perf_counter()
with (folder / "cli.json").open("wb") as output, (folder / "cli-error.json").open("wb") as errors:
    try:
        completed = subprocess.run(command, env=environment, stdout=output, stderr=errors,
            timeout=620, check=False)
        report["exit_code"] = completed.returncode
        report["outcome"] = "completed" if completed.returncode == 0 else "not_completed"
    except (OSError, subprocess.TimeoutExpired):
        report["error"] = "process_error_or_timeout"
report["elapsed_seconds"] = time.perf_counter() - start
timing.write_text(json.dumps(report, indent=2), encoding="utf-8")
print(json.dumps(report, indent=2))
raise SystemExit(0 if report["outcome"] == "completed" else 1)

एक डिलीवरी चलाएं

इस मशीन के क्षेत्र के साथ अपने सहेजे गए प्रोफ़ाइल नाम और ग्राहक-क्षेत्र के साथ अनुसंधान बदलें। वीडियो ID को आपके द्वारा संसाधित किए जा सकते हैं। एक पूरा रन download-01/delivery.json, timing.json और CLI आउटपुट फ़ाइलों को बचाता है।

कमांड CLI की डिफ़ॉल्ट राज्य निर्देशिका का उपयोग करता है। यदि आपकी प्रोफ़ाइल एक कस्टम निर्देशिका का उपयोग करती है, तो क्लाइंट-रेगियन के बाद अपने रास्ते को अंतिम तर्क के रूप में प्रस्तुत करें।

एक MP3 वितरण
python measure-download.py jNQXAC9IVRw storage.json download-01 research client-region
python -m json.tool download-01/timing.json

बचाया परिणामों से throughput की गणना करें

throughput.py को फ्लैशडाटा-बेंचमार्क में सहेजें/, measure-download.py के बगल में। यह अनुरोध भेजने के बिना डाउनलोड-01/ से पूरा वितरण और टाइमर पढ़ता है। थ्रूपुट मीडिया file_size मानों का योग है जिसे elapsed_seconds द्वारा विभाजित किया गया है; एमबीपीएस बाइट्स × 8 ÷ सेकंड ÷ 1,000,000 का उपयोग करता है।

throughput.py
import json
import math
import sys
from pathlib import Path

if len(sys.argv) != 2:
    raise SystemExit("Usage: python throughput.py SAMPLE_DIRECTORY")
folder = Path(sys.argv[1])
timing = json.loads((folder / "timing.json").read_text(encoding="utf-8"))
if not isinstance(timing, dict) or timing.get("outcome") != "completed" \
        or timing.get("metric") != "cli_start_to_result_saved":
    raise SystemExit("Use a completed sample from measure-download.py")
elapsed = timing.get("elapsed_seconds")
if type(elapsed) not in (int, float) or not math.isfinite(elapsed) or elapsed <= 0:
    raise SystemExit("Missing or invalid elapsed_seconds")
result = json.loads((folder / "delivery.json").read_text(encoding="utf-8-sig"))
if not isinstance(result, dict) or result.get("status") not in ("done", "completed") \
        or result.get("source") != "youtube_download":
    raise SystemExit("Use the completed download result, not a submission or job-status response")
files = result.get("results")
if not isinstance(files, list) or not files or any(not isinstance(item, dict) for item in files):
    raise SystemExit("No delivered media records")
sizes = [item.get("file_size") for item in files]
if any(type(size) not in (int, float) or not math.isfinite(size) or size <= 0 for size in sizes):
    raise SystemExit("Missing or invalid media file_size")
total = sum(sizes)
print(json.dumps({"run_id": timing["run_id"], "metric": timing["metric"],
    "delivered_media_bytes": total, "elapsed_seconds": elapsed,
    "bytes_per_second": total / elapsed, "megabits_per_second": total * 8 / elapsed / 1_000_000}, indent=2))
सहेजे गए माप पढ़ें
python throughput.py download-01

यदि वितरण finish नहीं किया गया है

पढ़िए download-01/cli-error.json और run_id में timing.json. उस ID और मूल प्रोफ़ाइल के साथ runs show और runs recover का उपयोग करें। रिकवरी स्वीकृत नौकरी को प्राप्त करती है; टाइमर को पुनः आरंभ करने या किसी अन्य डाउनलोड को जमा करने के बजाय पूर्ण-थ्रूपुट सारांशों में से इस प्रयास को बनाए रखें।

सहेजे गए प्रयास का निरीक्षण करें · स्थानीय पढ़े
python -m json.tool download-01/timing.json
python -c "from pathlib import Path; print(Path('download-01/cli-error.json').read_text(encoding='utf-8'))"

एक Bulk संग्रह की रिपोर्ट करें

पूरा मीडिया रिकॉर्ड के लिए Sum file_size और संग्रह के कुल समाप्त सेकंड से विभाजित है। इसके अलावा रिकॉर्ड स्वीकार किए जाते हैं, पूरा हो गया और विफल रहा गिनती, मतदान अंतराल और ठहराव। रिपोर्ट के साथ स्रोत IDs, आउटपुट विकल्प और गंतव्य क्षेत्र रखें। आपकी बाल्टी से मीडिया पुनर्प्राप्ति एक अलग माप है।

Markdown