Estoy tratando de descargar un archivo de Google Drive en un script, y tengo algunos problemas para hacerlo. Los archivos que intento descargar están aquí .

He buscado mucho en línea y finalmente logré descargar uno de ellos. Obtuve los UID de los archivos y el más pequeño (1,6 MB) se descarga bien, sin embargo, el archivo más grande (3,7 GB) siempre redirige a una página que me pregunta si quiero continuar con la descarga sin un análisis de virus. ¿Podría alguien ayudarme a pasar esa pantalla?

Así es como conseguí el primer archivo funcionando:

curl -L "https://docs.google.com/uc?export=download&id=0Bz-w5tutuZIYeDU0VDRFWG9IVUE" > phlat-1.0.tar.gz

Cuando ejecuto lo mismo en el otro archivo,

curl -L "https://docs.google.com/uc?export=download&id=0Bz-w5tutuZIYY3h5YlMzTjhnbGM" > index4phlat.tar.gz

Me sale el siguiente resultado:

Noto en la penúltima línea del enlace, hay una &confirm=JwkKcadena aleatoria de 4 caracteres pero sugiere que hay una manera de agregar una confirmación a mi URL. Uno de los enlaces que visité sugirió &confirm=no_antiviruspero eso no funciona.

¡Espero que alguien aquí pueda ayudar con esto!

ADVERTENCIA : esta funcionalidad está en desuso. Vea la advertencia a continuación en los comentarios.

Eche un vistazo a esta pregunta: descarga directa desde Google Drive utilizando la API de Google Drive

Básicamente, debe crear un directorio público y acceder a sus archivos por referencia relativa con algo como

wget https://googledrive.com/host/LARGEPUBLICFOLDERID/index4phlat.tar.gz

Alternativamente, puede usar este script: https://github.com/circulosmeos/gdown.pl

Junio ​​2020

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

El file_iddebería verse como 0Bz8a_Dbh9QhbNU3SGlFaDg

Puede obtenerlo haciendo clic derecho en el archivo y luego en Obtener enlace para compartir. Solo funciona en archivos de acceso abierto (cualquier persona que tenga un enlace puede Ver). No funciona para directorios. Probado en Google Colab. Funciona mejor en la descarga de archivos. Use tar / zip para convertirlo en un solo archivo.

Ejemplo: para descargar el archivo Léame de este directorio

gdown https://drive.google.com/uc?id=0B7EVK8r0v71pOXBhSUdJWU1MYUk

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

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

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

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 usar la herramienta de línea de comandos de código abierto Linux / Unix gdrive.

Para instalarlo:

1. Descargar el binario. Elija el que se adapte a su arquitectura, por ejemplogdrive-linux-x64.

2. Cópialo a tu camino.

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

Para usarlo:

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

2. Descargar el archivo. Por supuesto, use la ID de su archivo en el siguiente comando.

   gdrive download 0B7_OwkDsUIgFWXA1B2FPQfV5S8H
   

En el primer uso, la herramienta necesitará obtener permisos de acceso a la API de Google Drive. Para eso, le mostrará un enlace que debe visitar en un navegador, y luego obtendrá un código de verificación para copiar y pegar en la herramienta. La descarga se inicia automáticamente. No hay un 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 gdrivea una velocidad máxima limitada (para no saturar la red ...), puede usar un comando como este ( pves 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}"  

¿Como 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 cookie 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 variable de nombre de archivo, la curvatura puede adivinarlo
-L Seguir redirecciones
-O Nombre
remoto -J Nombre -encabezado remoto

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 la ID del 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 

Actualización a partir de marzo de 2018.

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

Entonces, para información de otros, así es como lo hice con éxito:

1. Haga clic derecho en el archivo que desea descargar, haga clic en compartir, en la sección de compartir enlaces, seleccione "cualquiera con este enlace puede editar".
2. Copia el enlace. Debe estar en este formato:https://drive.google.com/file/d/FILEIDENTIFIER/view?usp=sharing
3. Copie la parte FILEIDENTIFIER del enlace.

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 IDENTIFICADOR DE ARCHIVO en el script. ¡Recuerde mantener las comillas dobles!

6. Proporcione un nombre para el archivo en lugar de FILENAME. Recuerde mantener las comillas dobles y también incluir la extensión en FILENAME (por ejemplo, myfile.zip).
7. Ahora, guarde el archivo y haga que el archivo sea ejecutable ejecutando este comando en la terminal sudo chmod +x download-gdrive.sh.
8. Ejecute el script usando `./download-gdrive.sh".

PD: Aquí está la esencia de Github para el script anterior: https://gist.github.com/amit-chahar/db49ce64f46367325293e4cce13d2424

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

Asegúrese de que el enlace sea compartido, y se verá así:

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

Luego, copie ese FILEID y úselo así

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

El comportamiento predeterminado de Google Drive es escanear archivos en busca de virus si el archivo es demasiado grande, le preguntará 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 archivos HTML, CSS y Javascript, se puedan ver como un sitio web.

Para alojar una página web con Drive:

1. Abra Drive en drive.google.com y seleccione un archivo.
2. Haz 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 para compartir.
4. Haga clic en Cambiar ...
5. Elija On - Public en la web y haga clic en Guardar .
6. Antes de cerrar el cuadro para compartir, copie la ID del documento desde la URL en el campo debajo de "Enlace para compartir". La identificación del documento es una cadena de letras mayúsculas y minúsculas y números entre barras en la URL.
7. Comparta la URL que se parece a "www.googledrive.com/host/[doc id] donde [doc id] se reemplaza por la ID del documento que copió en el paso 6.
   Ahora cualquiera puede ver su página web.

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

Entonces, por ejemplo, cuando comparte un archivo en Google Drive públicamente, el enlace Sharelink se ve así:

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

Luego copia la identificación del archivo y crea un linke de googledrive.com que se ve así:

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

La manera 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 de su 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 sobre 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

Péguelo en su consola, agréguelo > my-file-name.extensional final (de lo contrario, escribirá el archivo en su consola), luego presione enter :)

Basado en la respuesta de Roshan Sethia

Mayo 2018

Usando WGET :

1. Cree un script de shell llamado wgetgdrive.sh como se muestra 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. Otorgue los permisos correctos para ejecutar el script

3. En la terminal, ejecute:

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

   por ejemplo:

   ./wgetgdrive.sh 1lsDPURlTNzS62xEOAIG98gsaW6x2PYd2 images.zip
   

--ACTUALIZADO--

Para descargar el archivo primero obtenga youtube-dlPython desde aquí:

youtube-dl: https://rg3.github.io/youtube-dl/download.html

o instalarlo con pip:

sudo python2.7 -m pip install --upgrade youtube_dl 
# or 
# sudo python3.6 -m pip install --upgrade youtube_dl

ACTUALIZAR:

Me acabo de enterar de esto:

1. Haga clic derecho en el archivo que desea descargar desde drive.google.com

2. Hacer clic Get Sharable link

3. Activar Link sharing on

4. Haga clic en Sharing settings

5. Haga clic en el menú desplegable superior para ver las opciones.

6. Haga clic en más

7. Seleccione [x] On - Anyone with a link

8. Copiar link

https://drive.google.com/file/d/3PIY9dCoWRs-930HHvY-3-FOOPrIVoBAR/view?usp=sharing       
(This is not a real file address)

Copie la identificación después de https://drive.google.com/file/d/:

3PIY9dCoWRs-930HHvY-3-FOOPrIVoBAR

Pegue esto en la línea de comando:

youtube-dl https://drive.google.com/open?id=

Pega la identificación detrás open?id=

youtube-dl https://drive.google.com/open?id=3PIY9dCoWRs-930HHvY-3-FOOPrIVoBAR

[GoogleDrive] 3PIY9dCoWRs-930HHvY-3-FOOPrIVoBAR: Downloading webpage
[GoogleDrive] 3PIY9dCoWRs-930HHvY-3-FOOPrIVoBAR: Requesting source file
[download] Destination: your_requested_filename_here-3PIY9dCoWRs-930HHvY-3-FOOPrIVoBAR
[download] 240.37MiB at  2321.53MiB/s (00:01)

Espero eso ayude

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

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

siempre que el archivo de Google Drive se haya compartido con quienes tengan el enlace y {FileID}sea ​​la cadena detrás ?id=de la URL compartida.

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

La forma más fácil es:

1. Crear enlace de descarga y copiar ID de archivo
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

Las respuestas anteriores están desactualizadas para abril de 2020, ya que Google Drive ahora usa una redirección a la ubicación real del archivo.

Trabajando a partir de abril de 2020 en macOS 10.15.4 para documentos públicos:

# this is used for drive directly downloads
function download-google(){
  echo "https://drive.google.com/uc?export=download&id=$1"
  mkdir -p .tmp
  curl -c .tmp/$1cookies "https://drive.google.com/uc?export=download&id=$1" > .tmp/$1intermezzo.html;
  curl -L -b .tmp/$1cookies "$(egrep -o "https.+download" .tmp/$1intermezzo.html)" > $2;
}

# some files are shared using an indirect download
function download-google-2(){
  echo "https://drive.google.com/uc?export=download&id=$1"
  mkdir -p .tmp
  curl -c .tmp/$1cookies "https://drive.google.com/uc?export=download&id=$1" > .tmp/$1intermezzo.html;
  code=$(egrep -o "confirm=(.+)&id=" .tmp/$1intermezzo.html | cut -d"=" -f2 | cut -d"&" -f1)
  curl -L -b .tmp/$1cookies "https://drive.google.com/uc?export=download&confirm=$code&id=$1" > $2;
}

# used like this
download-google <id> <name of item.extension>

Tuve el mismo problema con Google Drive.

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

1. Abra un navegador en su PC, navegue hasta su archivo en Google Drive. Dele a su archivo un enlace público.

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

3. Abre una terminal. Si está descargando a otra PC / servidor / máquina, debe usar SSH en este punto

4. Instale Links 2 (método debian / ubuntu, use su distribución o equivalente de SO)

   sudo apt-get install links2

5. Pegue el enlace en su terminal y ábralo con Enlaces así:

   links2 "paste url here"

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

7. Elija un nombre de archivo y descargará su archivo

Usa youtube-dl !

youtube-dl https://drive.google.com/open?id=ABCDEFG1234567890

También puede pasar --get-urlpara obtener una URL de descarga directa.

He estado usando el fragmento de rizo de @ Amit Chahar, quien publicó una buena respuesta en este hilo. Me pareció útil ponerlo en una función bash en lugar de un .sharchivo separado

function curl_gdrive {

    GDRIVE_FILE_ID=$1
    DEST_PATH=$2

    curl -c ./cookie -s -L "https://drive.google.com/uc?export=download&id=${GDRIVE_FILE_ID}" > /dev/null
    curl -Lb ./cookie "https://drive.google.com/uc?export=download&confirm=`awk '/download/ {print $NF}' ./cookie`&id=${GDRIVE_FILE_ID}" -o ${DEST_PATH}
    rm -fr cookie
}

que puede incluirse, por ejemplo, en a ~/.bashrc(después de obtenerlo, por supuesto, si no se obtiene automáticamente) y usarse de la siguiente manera

   $ curl_gdrive 153bpzybhfqDspyO_gdbcG5CMlI19ASba imagenet.tar

Hay un cliente multiplataforma de código abierto, escrito en Go: drive . Es bastante agradable y completo, 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`

Todas las respuestas anteriores parecen oscurecer la simplicidad de la respuesta o tienen algunos matices que no se explican.

Si el archivo se comparte públicamente, puede generar un enlace de descarga directa con solo conocer la ID del archivo. La URL debe tener el formato " https://drive.google.com/uc?id=[FILEIDfont>&export=download " Esto funciona a partir del 22/11/2019. Esto no requiere que el receptor inicie sesión en Google, pero sí requiere que el archivo se comparta públicamente.

1. En su navegador, navegue a drive.google.com.

2. Haga clic derecho en el archivo y haga clic en "Obtener un enlace para compartir"

3. Abra una nueva pestaña, seleccione la barra de direcciones y pegue el contenido de su portapapeles, que será el enlace que se puede compartir. Verá el archivo que muestra el visor de Google. El ID es el número justo antes del componente "Ver" de la URL:

4. Edite la URL para que esté en el siguiente formato, reemplazando "[FILEID]" con la ID de su archivo compartido:

   https://drive.google.com/uc?id=[FILEIDfont>&export=download

5. Ese es tu enlace de descarga directa. Si hace clic en él en su navegador, el archivo ahora será "empujado" a su navegador, abriendo el cuadro de diálogo de descarga, permitiéndole guardar o abrir el archivo. También puede usar este enlace en sus scripts de descarga.

6. Entonces el comando curl equivalente sería:

curl -L "https://drive.google.com/uc?id=AgOATNfjpovfFrft9QYa-P1IeF9e7GWcH&export=download" > phlat-1.0.tar.gz

No pude hacer funcionar el script perl de Nanoix, u otros ejemplos curl que había visto, así que comencé a buscar en la API yo mismo en Python. Esto funcionó bien para archivos pequeños, pero los archivos grandes se atragantaron con el RAM disponible, por lo que encontré otro buen código de fragmentación que usa la capacidad de la API para la descarga parcial. Gist aquí: https://gist.github.com/csik/c4c90987224150e4a0b2

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

$ 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 script de bash que escribí que hace el trabajo hoy. Funciona en archivos grandes y también puede reanudar archivos parcialmente recuperados. Se necesitan 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

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

Después de jugar con esta basura. He encontrado una manera de descargar mi dulce archivo usando las herramientas de desarrollo de Chrome.

1. En la pestaña de Google Docs, Ctr + Shift + J (Configuración -> Herramientas para desarrolladores)
2. Cambiar a pestañas de red
3. En su archivo de documentos, haga clic en "Descargar" -> Descargar como CSV, xlsx, ....

4. Le mostrará la solicitud en la consola "Red"

5. Haga clic derecho -> Copiar -> Copiar como Curl

6. Su comando Curl será así y se agregará -opara crear un archivo exportado. curl 'https://docs.google.com/spreadsheets/d/1Cjsryejgn29BDiInOrGZWvg/export?format=xlsx&id=1Cjsryejgn29BDiInOrGZWvg' -H 'authority: docs.google.com' -H 'upgrade-insecure-requests: 1' -H 'user-agent: Mozilla/5.0 (X..... -o server.xlsx

Resuelto!

Aquí hay una solución alternativa que se me ocurrió descargar archivos de Google Drive a mi shell de Google Cloud Linux.

1. Comparta el archivo a PÚBLICO y con permisos de edición utilizando el uso compartido avanzado.
2. Obtendrá un enlace para compartir que tendría una identificación. Vea el enlace: - drive.google.com/file/d/[IDfont>/view?usp=sharing
3. Copie esa ID y péguela en el siguiente enlace: -

googledrive.com/host/[ID]

4. El enlace de arriba sería nuestro enlace de descarga.
5. Use wget para descargar el archivo: -

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

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

mv [ID] 1.zip

8. luego usando

descomprimir 1.zip

vamos a obtener los archivos

Encontré una solución que funciona 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

Hay una manera más fácil.

Instale cliget / CURLWGET desde la extensión firefox / chrome.

Descargue el archivo del navegador. Esto crea un enlace curl / wget que recuerda las cookies y los encabezados utilizados al descargar el archivo. Use este comando desde cualquier shell para descargar

la manera fácil de bajar archivos de Google Drive también puede descargar archivos en Colab

pip install gdown

import gdown

Luego

url = 'https://drive.google.com/uc?id=0B9P1L--7Wd2vU3VUVlFnbTgtS2c'
output = 'spam.txt'
gdown.download(url, output, quiet=False)

o

fileid='0B9P1L7Wd2vU3VUVlFnbTgtS2c'

gdown https://drive.google.com/uc?id=+fileid

Documento https://pypi.org/project/gdown/

Mayo 2018 TRABAJANDO

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

Se introdujo la araña de comandos para evitar la descarga y obtener el enlace final (directamente)

Comando GREP HEAD y CUT, procese y obtenga el enlace final, está basado en el idioma español, tal vez podría ser portador a IDIOMA INGLÉS

echo -e "$URL_TO_DOWNLOAD\r" probablemente el \ r es solo cywin y debe ser reemplazado por un \ n (línea de corte)

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

*******Localización*********** está en idioma español, borra los asterianos y deja que la palabra en inglés se ubique y adapta THE HEAD y los números de CUT para un 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

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.

skicka es una herramienta cli para cargar, descargar archivos de acceso desde una unidad de google.

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