Retour au blog
Articles

Télécharger des fichiers Google Drive avec Python

Gérer la confirmation et le téléchargement en flux, puis choisir l’API officielle si nécessaire.

Un téléchargement Python d'un fichier Google Drive partagé publiquement peut parfois enregistrer une page de confirmation de balayage de virus en HTML. Cet article explique le flux de deux demandes utilisé sur le site original et comment vérifier que la réponse finale est un fichier.

Pourquoi n'obtenons-nous que du HTML?

Une demande à l'URL de téléchargement Web peut renvoyer le fichier directement, ou il peut retourner une page de confirmation en premier. Le déclencheur et le format de la page sont contrôlés par Google; un seuil de taille de fichier fixe n'est pas fiable.

Un navigateur peut suivre le bouton de confirmation. Un script doit gérer cette réponse et vérifier l'état HTTP final et télécharger l'en-tête avant d'écrire le fichier cible.

Solution : Demande en deux étapes

Le téléchargement comporte quatre étapes:

  1. Première demande: Envoyer une demande GET à https://docs.google.com/uc?export=download avec l'identifiant du fichier.
  2. Vérifier la réponse: A Content-Disposition sinon, vérifiez si la réponse est une page de confirmation; ne l'enregistrez pas en tant que fichier cible.
  3. Extrait le jeton de confirmation:
    • Des cookies: Google peut placer un download_warning_xxxxx clé dans les cookies, qui contient le jeton. Par exemple: token = session.cookies.get('download_warning_xxxxx')
    • À partir de HTML: Parfois, Google peut ne pas placer le jeton dans les cookies, mais dans le formulaire HTML. Par exemple:
      html
      <form
        id="download-form"
        action="https://drive.usercontent.google.com/download"
        method="get"
      >
        <input type="hidden" name="confirm" value="t" />
        ...
      </form>
      
      BeautifulSoup lit les champs cachés, notamment confirm et uuid.
  4. Envoyer la demande de confirmation: Passez le jeton ou les champs de formulaire, puis vérifiez l'état HTTP et téléchargez à nouveau l'en-tête. Ce workflow HTML s'applique aux fichiers accessibles au public et peut changer.](https://developers.google.com/workspace/drive/api/guides/manage-downloads) avec autorisation.

Mise en œuvre du code

Tout d'abord, installez les paquets nécessaires:

bash
pip install requests tqdm beautifulsoup4

Ensuite, utilisez la fonction Python suivante, fournissant l'ID du fichier, le nom que vous voulez enregistrer le fichier comme, et le répertoire cible pour déterminer automatiquement si une deuxième requête est nécessaire et télécharger le fichier avec succès:

python
import os
import re
from urllib.parse import urljoin, urlparse
import requests
from tqdm import tqdm
from bs4 import BeautifulSoup

def download_from_google(file_id: str, file_name: str, target: str = "."):
    """
    Downloads a file from Google Drive, handling potential confirmation tokens for large files.

    Args:
        file_id (str):
            The ID of the file to download from Google Drive.
        file_name (str):
            The name to save the downloaded file as.
        target (str, optional):
            The directory to save the file in. Defaults to the current directory (".").

    Raises:
        Exception: If the download fails or the file cannot be created.

    Notes:
        This function handles both small and large files. For large files, it automatically processes
        Google's confirmation token to bypass warnings about virus scans or file size limits.

    Example:
        Download a file to the current directory:
            download_from_google(
                file_id="xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
                file_name="example_file.txt"
            )

        Download a file to a specific directory:
            download_from_google(
                file_id="xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
                file_name="example_file.txt",
                target="./downloads"
            )
    """
    # First try: docs.google.com/uc?export=download&id=FileID
    base_url = "https://docs.google.com/uc"
    session = requests.Session()
    params = {
        "export": "download",
        "id": file_id
    }
    response = session.get(base_url, params=params, stream=True, timeout=(10, 60))

    # If Content-Disposition is present, the file is directly available
    if "content-disposition" not in response.headers:
        # Try to get the token from cookies
        token = None
        for k, v in response.cookies.items():
            if k.startswith("download_warning"):
                token = v
                break

        # If no token in cookies, extract it from the HTML
        if not token:
            soup = BeautifulSoup(response.text, "html.parser")
            # Common case: HTML contains a form with id="download-form"
            download_form = soup.find("form", {"id": "download-form"})
            if download_form and download_form.get("action"):
                # Extract action URL, which might be drive.usercontent.google.com/download
                download_url = urljoin(response.url, download_form["action"])
                if urlparse(download_url).hostname not in {
                    "docs.google.com", "drive.google.com", "drive.usercontent.google.com"
                }:
                    raise RuntimeError("Unexpected Google Drive download host")
                # Collect all hidden inputs
                hidden_inputs = download_form.find_all("input", {"type": "hidden"})
                form_params = {}
                for inp in hidden_inputs:
                    if inp.get("name") and inp.get("value") is not None:
                        form_params[inp["name"]] = inp["value"]

                # Re-send the GET request with these parameters
                response = session.get(download_url, params=form_params, stream=True, timeout=(10, 60))
            else:
                # Otherwise, search for confirm=xxx in HTML
                match = re.search(r'confirm=([0-9A-Za-z-_]+)', response.text)
                if match:
                    token = match.group(1)
                    # Include the confirm token in the request
                    params["confirm"] = token
                    response = session.get(base_url, params=params, stream=True, timeout=(10, 60))
                else:
                    raise Exception("Unable to find the download link or confirmation token in the response. Download failed.")

        else:
            # Use the token obtained from cookies and resend the request
            params["confirm"] = token
            response = session.get(base_url, params=params, stream=True, timeout=(10, 60))

    # Ensure the download directory exists
    response.raise_for_status()
    if "content-disposition" not in response.headers:
        raise RuntimeError("Google Drive did not return a downloadable file")
    if not file_name or file_name in {".", ".."} or os.path.basename(file_name) != file_name:
        raise ValueError("file_name must be a filename, not a path")

    os.makedirs(target, exist_ok=True)
    file_path = os.path.join(target, file_name)

    # Start downloading the file in chunks, with a progress bar
    try:
        total_size = int(response.headers.get('content-length', 0))
        with open(file_path, "wb") as f, tqdm(
            desc=file_name,
            total=total_size,
            unit="B",
            unit_scale=True,
            unit_divisor=1024,
        ) as bar:
            for chunk in response.iter_content(chunk_size=32768):
                if chunk:
                    f.write(chunk)
                    bar.update(len(chunk))

        print(f"File successfully downloaded to: {file_path}")

    except Exception as e:
        raise Exception(f"File download failed: {e}")

Comment utiliser

Supposons que vous ayez un ID de fichier : YOUR_FILE_ID, vous voulez le télécharger comme big_model.onnx et de le stocker dans le ./models répertoire, appelez-le comme ceci:

python
download_from_google(
    file_id="YOUR_FILE_ID",
    file_name="big_model.onnx",
    target="./models"
)

Une fois terminé, vous trouverez le téléchargé avec succès big_model.onnx dans le ./models dossier, et vous verrez l'avancement du téléchargement dans le terminal.

Outil en ligne de commande

La même fonction peut être appelée à partir d'un wrapper en ligne de commande :

python
from download_from_google import download_from_google
import argparse

def main():
    parser = argparse.ArgumentParser(description="Download files from Google Drive.")
    parser.add_argument("--file-id", required=True, help="Google Drive file ID.")
    parser.add_argument("--file-name", required=True, help="Output file name.")
    parser.add_argument("--target", default=".", help="Output directory. Defaults to current folder.")
    args = parser.parse_args()

    download_from_google(file_id=args.file_id, file_name=args.file_name, target=args.target)

if __name__ == "__main__":
    main()

Enregistrer le code ci-dessus comme download_from_google_cli.py, puis lancez-le à partir de la ligne de commande:

bash
python download_from_google_cli.py \
 --file-id YOUR_FILE_ID \
 --file-name big_model.onnx \
 --target ./models

Le script doit échouer si la réponse finale est toujours une page HTML ou d'erreur. Le site original a testé des fichiers publics de 70 Mo et 900 Mo; ces observations ne garantissent pas le même comportement pour d'autres permissions, types de fichiers ou versions de pages ultérieures.