Salta al contenuto
IT
Ottieni la chiave API
Sfoglia la documentazione

Per iniziare

Verifiche dell’account e risultati salvati con gli SDK

Controllare il costo, mantenere un record di ogni tentativo e leggere i risultati salvati senza un'altra chiamata API.

In questa pagina

Prima di iniziare

Utilizzare il progetto, installato SDK e FLASHDATA_API_KEY dal vostro avvio rapido SDK. Scegli una lingua qui sotto. Ogni nuova directory di esecuzione rappresenta una ricerca destinata; riutilizzare una directory esistente si ferma prima di effettuare qualsiasi richiesta.

1. Controllare l'accesso e il costo corrente

Salvare ed eseguire l'assegno per il tuo SDK. Legge le autorizzazioni, l'equilibrio e il prezzo di una ricerca Google. Continuare solo dopo il controllo di accesso passato; questi controlli non inviano una richiesta a pagamento o crediti di riserva.

check_access.py
import os
import sys
from flashdata import FlashData, APIError

def main():
    key = os.environ.get("FLASHDATA_API_KEY", "").strip()
    if not key:
        raise RuntimeError("Set FLASHDATA_API_KEY in this terminal.")
    with FlashData(api_key=key) as client:
        access = client.account.access()
        if "google_search" not in access["sources"]:
            raise RuntimeError("This key needs google_search permission.")
        balance = client.account.balance()
        pricing = client.account.pricing(source="google_search", request_count=1)
    price = next((p for p in pricing["prices"]
                  if p["source"] == "google_search" and p["available"]), None)
    cost = price.get("estimatedCredits") if price else None
    if cost is None:
        raise RuntimeError("No current price is available; stop here.")
    available = balance["availableCredits"]
    print(f"Available credits: {available}")
    print(f"One search: {cost} credits")
    if available < cost:
        raise RuntimeError("Insufficient credits. Review Billing.")
    print("Access check passed. No paid query submitted.")

if __name__ == "__main__":
    try:
        main()
    except APIError as error:
        print(f"HTTP {error.status_code}; code={error.code}; "
              f"request_id={error.request_id}; Retry-After={error.retry_after}",
              file=sys.stderr)
        sys.exit(1)
    except Exception as error:
        print(f"{type(error).__name__}: {error}", file=sys.stderr)
        sys.exit(1)
Linux / macOS
.venv/bin/python check_access.py
Windows PowerShell
.\.venv\Scripts\python.exe check_access.py

2. Eseguire con una nuova directory di output

Eseguire uno di questi programmi dopo i passaggi di controllo. Crea la directory prima di inviare, registra la richiesta, quindi salva la risposta. Mantenere la directory in caso di guasto: eliminarla o scegliere una nuova permette un'altra query fatturabile.

archive_search.py
import json
import os
import sys
from datetime import datetime, timezone
from pathlib import Path
from flashdata import FlashData, APIError, SubmissionUnknownError

def main():
    key = os.environ.get("FLASHDATA_API_KEY", "").strip()
    if not key:
        raise RuntimeError("Set FLASHDATA_API_KEY before running.")
    directory = Path(sys.argv[1] if len(sys.argv) > 1 else "runs/research-001")
    directory.mkdir(mode=0o700, parents=True, exist_ok=False)

    def save(name, value):
        with (directory / name).open("x", encoding="utf-8") as output:
            json.dump(value, output, ensure_ascii=False, indent=2)

    request = {"source": "google_search", "query": "battery recycling research",
               "params": {"num": 5}}
    save("request.json", request)
    save("intent.json", {"state": "dispatching",
                         "startedAt": datetime.now(timezone.utc).isoformat()})
    try:
        with FlashData(api_key=key) as client:
            response = client.google.search(request["query"], **request["params"])
    except (APIError, SubmissionUnknownError) as error:
        detail = {"kind": type(error).__name__}
        if isinstance(error, APIError):
            detail.update(code=error.code, httpStatus=error.status_code,
                          requestId=error.request_id, retryAfter=error.retry_after)
        save("error.json", detail)
        raise RuntimeError("Inspect the saved attempt and History before retrying.") from None
    save("result.json", response)
    if response.get("status") != "done":
        raise RuntimeError("Response saved; inspect its status before proceeding.")
    print("Saved:", directory / "result.json")
    print("Usage:", response.get("usage"))

if __name__ == "__main__":
    try:
        main()
    except Exception as error:
        print(f"{type(error).__name__}: {error}", file=sys.stderr)
        sys.exit(1)
Linux / macOS
.venv/bin/python archive_search.py runs/research-001
Windows PowerShell
.\.venv\Scripts\python.exe archive_search.py runs/research-001

File previsti

Stampa di successo il percorso e l'utilizzo dei risultati salvati. result.json dovrebbe avere status: done; I risultati Google sono in results[].organic[]. Un array organico vuoto è valido. Un errore di trasporto o API riportato viene salvato a error.json; intent.json rimane il record di pre-sottomissione originale.

Un tentativo di successo
runs/research-001/
  request.json # Fonte, query e parametri
  intent.json # Il tempo di inizio del tentativo
  result.json # Risposta completa, inclusi i risultati e l'utilizzo

3. Uscita di lettura salvata

Leggi result.json per la parsing, i riassunti e il lavoro UI. Questi comandi utilizzano solo i file locali. Rerunning la ricerca con la stessa directory si ferma prima di una chiamata di rete; non coordina macchine diverse o recupera una risposta del server perso.

Leggi localmente
cat runs/research-001/result.json

Decidi cosa fare dopo un fallimento

Che cosa haiProssima azione
directory esistente / EEXISTIspezionare i suoi file. Nessun nuovo query è stato inviato da questo tentativo.
result.json, status: doneLeggere ed elaborare la risposta salvata. Riutilizzare il suo utilizzo come ricevuta della carica originale.
error.json con 401 / 403 / 402Fissare l'accesso, le autorizzazioni di origine o l'equilibrio prima di pianificare un nuovo tentativo.
429 / retryAfterAttendere come istruito e ridurre il tasso di richiesta. Verificare il tentativo fallito prima di selezionare una nuova directory di esecuzione.
Non noto presentazione / intento solo / errore di scritturaIl lavoro può già essere accettato. Mantenere la directory e ispezionare History o un lavoro conosciuto ID prima di inviare un'altra query.

client Async e lavori di sfondo

NecessitàUso
Mantenere un loop di evento reattivoIl client asincastro di SDK / attendere le chiamate. Una query in tempo reale completa ancora nella sua risposta HTTP.
Riprendi dopo l'uscita del processo di chiamataInviare un lavoro di sfondo una volta, salvare il suo remoto ID, quindi leggere lo stato e i risultati.
Correre su un programmaUtilizzare l'accesso del proprietario e i record di esecuzione delle applicazioni durevoli, o la rivista di esecuzione esistente di CLI.