Escribí un fragmento de Python que descarga un archivo de Google Drive, dado un enlace compartible. Funciona, a partir de agosto de 2017.

El snipped no usa gdrive, ni la API de Google Drive. Utiliza el módulo requests .

Al descargar archivos grandes desde Google Drive, una sola solicitud GET no es suficiente. Se necesita un segundo, y este tiene un parámetro de URL adicional llamado confirm , cuyo valor debe ser igual al valor de un cierta galleta.

import requests

def download_file_from_google_drive(id, destination):
    def get_confirm_token(response):
        for key, value in response.cookies.items():
            if key.startswith('download_warning'):
                return value

        return None

    def save_response_content(response, destination):
        CHUNK_SIZE = 32768

        with open(destination, "wb") as f:
            for chunk in response.iter_content(CHUNK_SIZE):
                if chunk: # filter out keep-alive new chunks
                    f.write(chunk)

    URL = "https://docs.google.com/uc?export=download"

    session = requests.Session()

    response = session.get(URL, params = { 'id' : id }, stream = True)
    token = get_confirm_token(response)

    if token:
        params = { 'id' : id, 'confirm' : token }
        response = session.get(URL, params = params, stream = True)

    save_response_content(response, destination)    


if __name__ == "__main__":
    import sys
    if len(sys.argv) is not 3:
        print "Usage: python google_drive.py drive_file_id destination_file_path"
    else:
        # TAKE ID FROM SHAREABLE LINK
        file_id = sys.argv[1]
        # DESTINATION FILE ON YOUR DISK
        destination = sys.argv[2]
        download_file_from_google_drive(file_id, destination)

Puede utilizar la herramienta de línea de comandos Linux / Unix de código abiertogdrive.

Para instalarlo:

1. Descarga el binario. Elija el que se ajuste a su arquitectura, por ejemplo gdrive-linux-x64.

2. Cópialo a tu ruta.

   sudo cp gdrive-linux-x64 /usr/local/bin/gdrive;
   sudo chmod a+x /usr/local/bin/gdrive;
   

Para usarlo:

1. Determine el ID de archivo de Google Drive. Para eso, haga clic con el botón derecho en el archivo deseado en Google Conduzca el sitio web y elija "Obtener enlace Link". Devolverá algo como https://drive.google.com/open?id=0B7_OwkDsUIgFWXA1B2FPQfV5S8H. Obtenga la cadena detrás de ?id= y cópiela a su portapapeles. Esa es la identificación del archivo.

2. Descarga el archivo. Por supuesto, use el ID de su archivo en su lugar en el siguiente comando.

   gdrive download 0B7_OwkDsUIgFWXA1B2FPQfV5S8H
   

Al primer uso, la herramienta necesitará obtener permisos de acceso a la API de Google Drive. Para ello, te mostrará un enlace que tienes que visitar en un navegador, y entonces obtenga un código de verificación para copiar y pegar en la herramienta. La descarga se inicia automáticamente. No hay indicador de progreso, pero puede observar el progreso en un administrador de archivos o en un segundo terminal.

Fuente: Un comentario de Tobi sobre otra respuesta aquí.

Truco adicional: limitación de velocidad. Para descargar con gdrive a una velocidad máxima limitada (para no inundar la red)), puede usar un comando como este (usando PipeViewer):

gdrive download --stdout 0B7_OwkDsUIgFWXA1B2FPQfV5S8H | \
  pv -br -L 90k | \
  cat > file.ext

Esto mostrará la cantidad de datos descargados (-b) y la velocidad de descarga (-r) y limitará esa velocidad a 90 KiB/s (-L 90k).

ggID='put_googleID_here'  
ggURL='https://drive.google.com/uc?export=download'  
filename="$(curl -sc /tmp/gcokie "${ggURL}&id=${ggID}" | grep -o '="uc-name.*</span>' | sed 's/.*">//;s/<.a> .*//')"  
getcode="$(awk '/_warning_/ {print $NF}' /tmp/gcokie)"  
curl -Lb /tmp/gcokie "${ggURL}&confirm=${getcode}&id=${ggID}" -o "${filename}"  

¿Cómo funciona?
Obtenga el archivo cookie y el código html con curl.
Canalice html a grep y sed y busque el nombre del archivo.
Obtenga el código de confirmación del archivo de cookies con awk.
Finalmente descargue el archivo con la cookie habilitada, confirme el código y el nombre del archivo.

curl -Lb /tmp/gcokie "https://drive.google.com/uc?export=download&confirm=Uq6r&id=0B5IRsLTwEO6CVXFURmpQZ1Jxc0U" -o "SomeBigFile.zip"

Si no necesita nombre de archivo variable curl puede adivinarlo
- L Seguir redirecciones
- O Remote-name
- J Remote-header-name

curl -sc /tmp/gcokie "${ggURL}&id=${ggID}" >/dev/null  
getcode="$(awk '/_warning_/ {print $NF}' /tmp/gcokie)"  
curl -LOJb /tmp/gcokie "${ggURL}&confirm=${getcode}&id=${ggID}" 

Para extraer el ID de archivo de Google de la URL, puede usar:

echo "gURL" | egrep -o '(\w|-){26,}'  
# match more than 26 word characters  

O

echo "gURL" | sed 's/[^A-Za-z0-9_-]/\n/g' | sed -rn '/.{26}/p'  
# replace non-word characters with new line,   
# print only line with more than 26 word characters 

El comportamiento predeterminado de Google drive es escanear archivos en busca de virus si el archivo es demasiado grande, le pedirá al usuario y le notificará que el archivo no se pudo escanear.

Por el momento, la única solución que encontré es compartir el archivo con la web y crear un recurso web.

Cita de la página de ayuda de Google drive:

Con Drive, puede hacer que los recursos web, como HTML, CSS y archivos Javascript, se puedan ver como un sitio web.

Para alojar una página web con Unidad:

1. Abra la unidad en drive.google.com y seleccione un archivo.
2. Haga clic en el botón Compartir en la parte superior de la página.
3. Haga clic en Avanzado en la esquina inferior derecha del cuadro compartir.
4. Haga clic en Cambiar....
5. Elija On - Public on the weby haga clic en Save.
6. Antes de cerrar el cuadro compartir, copie el ID del documento de la URL en el campo de abajo "Enlace para compartir". El ID del documento es una cadena de letras mayúsculas y minúsculas y números entre barras en la URL.
7. Comparte la URL que se parece a "www.googledrive.com/host / [doc id] donde [doc id] se sustituye por el ID del documento que copió en el paso 6.
   Ahora cualquiera puede ver tu página web.

Se encuentra aquí: https://support.google.com/drive/answer/2881970?hl=en

Así que, por ejemplo, cuando compartes un archivo en Google drive públicamente, sharelink se ve así:

https://drive.google.com/file/d/0B5IRsLTwEO6CVXFURmpQZ1Jxc0U/view?usp=sharing

Luego copia el id del archivo y crea un googledrive.com linke que se ven así:

https://www.googledrive.com/host/0B5IRsLTwEO6CVXFURmpQZ1Jxc0U

Aquí hay una forma rápida de hacer esto.

Asegúrese de que el enlace sea compartido, y se verá algo como esto:

Https://drive.google.com/open?id=FILEID&authuser=0

Luego, copie ese FILEID y utilícelo así

wget --no-check-certificate 'https://docs.google.com/uc?export=download&id=FILEID' -O FILENAME

Actualización a partir de marzo de 2018.

Probé varias técnicas dadas en otras respuestas para descargar mi archivo (6 GB) directamente desde Google drive a mi instancia AWS ec2, pero ninguna de ellas funciona (podría ser porque son viejas).

Así que, para información de otros, he aquí cómo lo hice con éxito:

1. Haga clic con el botón derecho en el archivo que desea descargar, haga clic en compartir, en la sección compartir enlaces, seleccione "cualquier persona con este enlace puede editar".
2. Copie el enlace. Debería estar en este formato: https://drive.google.com/file/d/FILEIDENTIFIER/view?usp=sharing
3. Copie la porción FILEIDENTIFIER del enlace (Esto parece algunos caracteres aleatorios).

4. Copie el siguiente script en un archivo. Utiliza curl y procesa la cookie para automatizar la descarga del archivo.

   #!/bin/bash fileid="FILEIDENTIFIER" filename="FILENAME" curl -c ./cookie -s -L "https://drive.google.com/uc?export=download&id=${fileid}" > /dev/null curl -Lb ./cookie "https://drive.google.com/uc?export=download&confirm=`awk '/download/ {print $NF}' ./cookie`&id=${fileid}" -o ${filename}

5. Como se muestra arriba, pegue el FILEIDENTIFIER en el script. Recuerde mantener comillas dobles.

6. Dar un nombre para su archivo de salida en lugar de FICHERO. Recuerde mantener las comillas dobles y también incluir la extensión en FILENAME (por ejemplo, "myfile.Postal").
7. Ahora, guarde el archivo y haga que el archivo sea ejecutable ejecutando este comando en la terminal "sudo chmod + x download-script.sh". Sustitúyase "download-script.sh" con el nombre de archivo de tu script.
8. Ejecute el script usando ". /download-script.sh". Una vez más, reemplace la "download-script.sh" con el nombre de archivo de tu script.

PS: Aquí está el gist Github para el por encima de la secuencia de comandos dada: https://gist.github.com/amit-chahar/db49ce64f46367325293e4cce13d2424

Junio de 2018 La forma más fácil que funciona para mí

• pip install gdown
• gdown https://drive.google.com/uc?id=file_id

El file_id debería ser algo así como 0Bz8a_Dbh9QhbNU3SGlFaDg

Puede obtenerlo haciendo clic derecho en el archivo y luego Obtener un enlace compartible. Probado en archivos de acceso abierto. No estoy seguro de si funciona para el directorio.

Ninguna respuesta propone lo que funciona para mí a partir de diciembre 2016 (fuente):

curl -L https://drive.google.com/uc?id={FileID}

Siempre que el archivo de Google Drive se haya compartido con aquellos que tienen el enlace y {FileID} sea la cadena detrás de ?id= en la URL compartida.

Aunque no comprobé con archivos enormes, creo que podría ser útil saberlo.

El camino fácil:

^{(si solo lo necesita para una descarga única)}

1. Vaya a la página web de Google Drive que tiene el enlace de descarga
2. Abra la consola del navegador y vaya a la pestaña "red"
3. Haga clic en el enlace de descarga
4. Espere a que el archivo comience a descargarse, y encuentre la solicitud correspondiente (debe ser la última en la lista), luego puede cancelar la descarga
5. Haga clic derecho en la solicitud y haga clic en "Copiar como cURL" (o similar)

Deberías terminar con algo como:

curl 'https://doc-0s-80-docs.googleusercontent.com/docs/securesc/aa51s66fhf9273i....................blah blah blah...............gEIqZ3KAQ==' --compressed

Pasado en su consola, agregue > my-file-name.extension al final (de lo contrario, escribirá el archivo en su consola), luego presione enter:)

Hay un cliente multiplataforma de código abierto, escrito en Go: drive. Es bastante agradable y con todas las funciones, y también está en desarrollo activo.

$ drive help pull
Name
        pull - pulls remote changes from Google Drive
Description
        Downloads content from the remote drive or modifies
         local content to match that on your Google Drive

Note: You can skip checksum verification by passing in flag `-ignore-checksum`

* For usage flags: `drive pull -h`

No pude conseguir que el script perl de Nanoix funcionara, u otros ejemplos curl que había visto, así que empecé a buscar en la api yo mismo en python. Esto funcionó bien para archivos pequeños, pero los archivos grandes se atragantaron más allá de la ram disponible, así que encontré otro código de chunking agradable que utiliza la capacidad de la api para descargar parcialmente. Gist aquí: https://gist.github.com/csik/c4c90987224150e4a0b2

Tenga en cuenta el bit acerca de la descarga del archivo json client_secret desde la interfaz API a su local directorio.

$ cat gdrive_dl.py
from pydrive.auth import GoogleAuth  
from pydrive.drive import GoogleDrive    

"""API calls to download a very large google drive file.  The drive API only allows downloading to ram 
   (unlike, say, the Requests library's streaming option) so the files has to be partially downloaded
   and chunked.  Authentication requires a google api key, and a local download of client_secrets.json
   Thanks to Radek for the key functions: http://stackoverflow.com/questions/27617258/memoryerror-how-to-download-large-file-via-google-drive-sdk-using-python
"""

def partial(total_byte_len, part_size_limit):
    s = []
    for p in range(0, total_byte_len, part_size_limit):
        last = min(total_byte_len - 1, p + part_size_limit - 1)
        s.append([p, last])
    return s

def GD_download_file(service, file_id):
  drive_file = service.files().get(fileId=file_id).execute()
  download_url = drive_file.get('downloadUrl')
  total_size = int(drive_file.get('fileSize'))
  s = partial(total_size, 100000000) # I'm downloading BIG files, so 100M chunk size is fine for me
  title = drive_file.get('title')
  originalFilename = drive_file.get('originalFilename')
  filename = './' + originalFilename
  if download_url:
      with open(filename, 'wb') as file:
        print "Bytes downloaded: "
        for bytes in s:
          headers = {"Range" : 'bytes=%s-%s' % (bytes[0], bytes[1])}
          resp, content = service._http.request(download_url, headers=headers)
          if resp.status == 206 :
                file.write(content)
                file.flush()
          else:
            print 'An error occurred: %s' % resp
            return None
          print str(bytes[1])+"..."
      return title, filename
  else:
    return None          


gauth = GoogleAuth()
gauth.CommandLineAuth() #requires cut and paste from a browser 

FILE_ID = 'SOMEID' #FileID is the simple file hash, like 0B1NzlxZ5RpdKS0NOS0x0Ym9kR0U

drive = GoogleDrive(gauth)
service = gauth.service
#file = drive.CreateFile({'id':FILE_ID})    # Use this to get file metadata
GD_download_file(service, FILE_ID) 

Aquí hay un pequeño guión bash que escribí que hace el trabajo hoy. Funciona en archivos grandes y también puede reanudar los archivos parcialmente recuperados. Toma dos argumentos, el primero es el file_id y el segundo es el nombre del archivo de salida. Las principales mejoras sobre las respuestas anteriores aquí son que funciona en archivos grandes y solo necesita herramientas comúnmente disponibles: bash, curl, tr, grep, du, cut y mv.

#!/usr/bin/env bash
fileid="$1"
destination="$2"

# try to download the file
curl -c /tmp/cookie -L -o /tmp/probe.bin "https://drive.google.com/uc?export=download&id=${fileid}"
probeSize=`du -b /tmp/probe.bin | cut -f1`

# did we get a virus message?
# this will be the first line we get when trying to retrive a large file
bigFileSig='<!DOCTYPE html><html><head><title>Google Drive - Virus scan warning</title><meta http-equiv="content-type" content="text/html; charset=utf-8"/>'
sigSize=${#bigFileSig}

if (( probeSize <= sigSize )); then
  virusMessage=false
else
  firstBytes=$(head -c $sigSize /tmp/probe.bin)
  if [ "$firstBytes" = "$bigFileSig" ]; then
    virusMessage=true
  else
    virusMessage=false
  fi
fi

if [ "$virusMessage" = true ] ; then
  confirm=$(tr ';' '\n' </tmp/probe.bin | grep confirm)
  confirm=${confirm:8:4}
  curl -C - -b /tmp/cookie -L -o "$destination" "https://drive.google.com/uc?export=download&id=${fileid}&confirm=${confirm}"
else
  mv /tmp/probe.bin "$destination"
fi

Tuve el mismo problema con Google Drive.

Así es como resolví el problema usando Enlaces 2.

1. Abra un navegador en su PC, vaya a su archivo en Google Drive. Dale a tu archivo un enlace público.

2. Copie el enlace público a su portapapeles (por ejemplo, haga clic con el botón derecho, Copie la dirección del enlace)

3. Abre una Terminal. Si está descargando a otro PC / servidor / máquina debe SSH a este punto

4. Instalar Enlaces 2 (método debian / ubuntu, use su distro o equivalente del sistema operativo)

   sudo apt-get install links2

5. Pega el enlace en tu terminal y ábrelo con Enlaces como este:

   links2 "paste url here"

6. Navegue hasta el enlace de descarga dentro de los Enlaces utilizando las teclas de flecha y presione Enter

7. Elige un nombre de archivo y descargará tu archivo

Esto funciona a partir de noviembre de 2017 https://gist.github.com/ppetraki/258ea8240041e19ab258a736781f06db

#!/bin/bash

SOURCE="$1"
if [ "${SOURCE}" == "" ]; then
    echo "Must specify a source url"
    exit 1
fi

DEST="$2"
if [ "${DEST}" == "" ]; then
    echo "Must specify a destination filename"
    exit 1
fi

FILEID=$(echo $SOURCE | rev | cut -d= -f1 | rev)
COOKIES=$(mktemp)

CODE=$(wget --save-cookies $COOKIES --keep-session-cookies --no-check-certificate "https://docs.google.com/uc?export=download&id=${FILEID}" -O- | sed -rn 's/.*confirm=([0-9A-Za-z_]+).*/Code: \1\n/p')

# cleanup the code, format is 'Code: XXXX'
CODE=$(echo $CODE | rev | cut -d: -f1 | rev | xargs)

wget --load-cookies $COOKIES "https://docs.google.com/uc?export=download&confirm=${CODE}&id=${FILEID}" -O $DEST

rm -f $COOKIES

Aquí está la solución que se me ocurrió descargar archivos de Google Drive a mi shell de Google Cloud Linux.

1. Comparta el archivo en PÚBLICO y con permisos de edición usando uso compartido avanzado.
2. Obtendrá un enlace para compartir que tendría un ID. Ver el enlace:- drive.google.com/file/d/[ID] / view?usp=sharing
3. Copie ese ID y Péguelo en el siguiente enlace: -

Googledrive.com/host / [ID]

1. El enlace anterior sería nuestro enlace de descarga.
2. Uso wget para descargar el archivo: -

Wget https://googledrive.com/host / [ID]

1. Este comando descargará el archivo con el nombre como [ID] sin extensión y pero con el mismo tamaño de archivo en la misma ubicación donde ejecutó el comando wget.
2. En realidad, he descargado una carpeta comprimida en mi práctica. así que cambié el nombre de ese archivo incómodo usando: -

Mv [ID] 1.zip

1. luego usando

Descomprimir 1.zip

Obtendremos los archivos.

Basado en la respuesta de Roshan Sethia

Mayo de 2018

Usando WGET :

1. Crear un script de shell llamado wgetgdrive.sh como a continuación:

   #!/bin/bash
   
   # Get files from Google Drive
   
   # $1 = file ID
   # $2 = file name
   
   URL="https://docs.google.com/uc?export=download&id=$1"
   
   wget --load-cookies /tmp/cookies.txt "https://docs.google.com/uc?export=download&confirm=$(wget --quiet --save-cookies /tmp/cookies.txt --keep-session-cookies --no-check-certificate $URL -O- | sed -rn 's/.*confirm=([0-9A-Za-z_]+).*/\1\n/p')&id=$1" -O $2 && rm -rf /tmp/cookies.txt
   

2. Dar los permisos adecuados para ejecutar el script

3. En la terminal, ejecute:

   ./wgetgdrive.sh <file ID> <filename>
   

   Por ejemplo:

   ./wgetgdrive.sh 1lsDPURlTNzS62xEOAIG98gsaW6x2PYd2 images.zip
   

Encontré una solución de trabajo para esto... Simplemente use lo siguiente

wget --load-cookies /tmp/cookies.txt "https://docs.google.com/uc?export=download&confirm=$(wget --quiet --save-cookies /tmp/cookies.txt --keep-session-cookies --no-check-certificate 'https://docs.google.com/uc?export=download&id=1HlzTR1-YVoBPlXo0gMFJ_xY4ogMnfzDi' -O- | sed -rn 's/.*confirm=([0-9A-Za-z_]+).*/\1\n/p')&id=1HlzTR1-YVoBPlXo0gMFJ_xY4ogMnfzDi" -O besteyewear.zip && rm -rf /tmp/cookies.txt

Skicka es una herramienta cli para cargar,descargar archivos de acceso desde un google-drive.

Ejemplo -

skicka download /Pictures/2014 ~/Pictures.copy/2014
10 / 10 [=====================================================] 100.00 % 
skicka: preparation time 1s, sync time 6s
skicka: updated 0 Drive files, 10 local files
skicka: 0 B read from disk, 16.18 MiB written to disk
skicka: 0 B uploaded (0 B/s), 16.18 MiB downloaded (2.33 MiB/s)
skicka: 50.23 MiB peak memory used

Mayo DE 2018 TRABAJANDO

Hola basado en estos comentarios ... creo un bash para exportar una lista de URL desde URL de archivo .txt a un URLS_DECODED.txt un usado en algún acelerador como flashget (yo uso cygwin para combinar windows y linux)

El comando spider se introdujo para evitar la descarga y obtener el enlace final ( directamente )

Comando GREP CABEZA y CORTAR, procesar y obtener el enlace final, Se basa en el idioma español, tal vez podría ser port a IDIOMA INGLÉS

echo -e "$URL_TO_DOWNLOAD\r" probablemente la \r es solo cywin y debe ser reemplazada por una \n (línea de ruptura)

**********user*********** es la carpeta de usuario

*******Localización*********** está en lengua española, despeje las astéricas y deje que la palabra en inglés Localice y adapte LA CABEZA y los números CORTADOS al enfoque apropiado.

rm -rf /home/**********user***********/URLS_DECODED.txt
COUNTER=0
while read p; do 
    string=$p
    hash="${string#*id=}"
    hash="${hash%&*}"
    hash="${hash#*file/d/}"
    hash="${hash%/*}"
    let COUNTER=COUNTER+1
    echo "Enlace "$COUNTER" id="$hash
    URL_TO_DOWNLOAD=$(wget --spider --load-cookies /tmp/cookies.txt "https://docs.google.com/uc?export=download&confirm=$(wget --quiet --save-cookies /tmp/cookies.txt --keep-session-cookies --no-check-certificate 'https://docs.google.com/uc?export=download&id='$hash -O- | sed -rn 's/.*confirm=([0-9A-Za-z_]+).*/\1\n/p')&id="$hash 2>&1 | grep *******Localización***********: | head -c-13 | cut -c16-)
    rm -rf /tmp/cookies.txt
    echo -e "$URL_TO_DOWNLOAD\r" >> /home/**********user***********/URLS_DECODED.txt
    echo "Enlace "$COUNTER" URL="$URL_TO_DOWNLOAD
done < /home/**********user***********/URLS.txt

La forma más fácil es:

1. Crear enlace de descarga y copiar fileID
2. Descargar con WGET: wget --load-cookies /tmp/cookies.txt "https://docs.google.com/uc?export=download&confirm=$(wget --quiet --save-cookies /tmp/cookies.txt --keep-session-cookies --no-check-certificate 'https://docs.google.com/uc?export=download&id=FILEID' -O- | sed -rn 's/.*confirm=([0-9A-Za-z_]+).*/\1\n/p')&id=FILEID" -O FILENAME && rm -rf /tmp/cookies.txt

Mayo de 2018

Si desea utilizar curl para descargar un archivo de Google Drive, además del id de archivo en drive, también necesita un OAuth2 access_token para la API de Google Drive. Obtener el token implica varios pasos con el marco de la API de Google. Los pasos de registro con Google son (actualmente) gratuitos.

Un OAuth2 access_token permite potencialmente todo tipo de actividad, así que tenga cuidado con él. Además, el token se agota después de un corto tiempo (¿1 hora?) pero no lo suficientemente corto para prevenir el abuso si alguien lo captura.

Una vez que tenga un access_token y el fileid, esto funcionará:

AUTH="Authorization: Bearer the_access_token_goes_here"
FILEID="fileid_goes_here"
URL=https://www.googleapis.com/drive/v3/files/$FILEID?alt=media
curl --header "$AUTH" $URL >myfile.ext

Ver también: API de Google Drive REST REST Files Descargar archivos

Solo necesita usar wget con:

 https://drive.google.com/uc?authuser=0&id=[your ID without brackets]&export=download

PD. El archivo debe ser público.

La forma más fácil de hacerlo es poner lo que quieras descargar en una carpeta. Comparte esa carpeta y luego toma el ID de carpeta de la barra de URL.

Luego vaya a https://googledrive.com/host / [ID] (Reemplace el ID por el ID de su carpeta) Debería ver una lista de todos los archivos en esa carpeta, haga clic en el que desea descargar. Una descarga debe visitar su página de descarga (Ctrl + J en Chrome), luego desea copiar el enlace de descarga y luego usar wget "enlace de descarga"

Disfruta :)