Próbuję pobrać plik z dysku Google w skrypcie i mam z tym trochę problemów. Pliki, które próbuję pobrać, są tutaj .

Rozglądałem się szeroko i wreszcie udało mi się zdobyć jednego z nich do pobrania. Mam identyfikatory UID plików, a mniejszy (1,6 MB) pobiera dobrze, jednak większy plik (3,7 GB) zawsze przekierowuje na stronę, która pyta mnie, czy chcę kontynuować pobieranie bez skanowania antywirusowego. Czy ktoś może mi pomóc ominąć ten ekran?

Oto jak uruchomiłem pierwszy plik -

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

Kiedy uruchomię to samo w innym pliku,

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

Otrzymuję następujące dane wyjściowe -

Zauważyłem w wierszu od trzeciego do ostatniego w linku, &confirm=JwkKktóry jest losowym ciągiem 4 znaków, ale sugeruje, że istnieje sposób na dodanie potwierdzenia do mojego adresu URL. Jeden z linków, które odwiedziłem, sugeruje, &confirm=no_antivirusale to nie działa.

Mam nadzieję, że ktoś tutaj może w tym pomóc!

OSTRZEŻENIE : Ta funkcja jest przestarzała. Zobacz ostrzeżenie poniżej w komentarzach.

Spójrz na to pytanie: Bezpośrednie pobieranie z Dysku Google za pomocą interfejsu API Dysku Google

Zasadniczo musisz utworzyć katalog publiczny i uzyskać dostęp do swoich plików poprzez odniesienie względne za pomocą czegoś takiego

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

Alternatywnie możesz użyć tego skryptu: https://github.com/circulosmeos/gdown.pl

Czerwiec 2020 r

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

The file_idPowinien wyglądać mniej więcej tak 0Bz8a_Dbh9QhbNU3SGlFaDg

Możesz go uzyskać, klikając plik prawym przyciskiem myszy, a następnie Uzyskaj link do udostępniania. Działa tylko na plikach o otwartym dostępie (każdy, kto ma link, może wyświetlać). Nie działa w przypadku katalogów. Testowane na Google Colab. Działa najlepiej przy pobieraniu plików. Użyj tar / zip, aby uczynić go jednym plikiem.

Przykład: aby pobrać plik readme z tego katalogu

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

Napisałem fragment kodu w języku Python, który pobiera plik z Dysku Google, podając link do udostępnienia . Działa od sierpnia 2017 r .

Snipped nie korzysta z gdrive ani interfejsu API Dysku Google. Korzysta z modułu żądań .

Podczas pobierania dużych plików z Dysku Google pojedyncze żądanie GET nie jest wystarczające. Potrzebny jest drugi, a ten ma dodatkowy parametr adresu URL o nazwie potwierdź , którego wartość powinna być równa wartości określonego pliku 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)

Możesz użyć narzędzia wiersza poleceń Linux / Unix typu open source gdrive.

Aby zainstalować:

1. Pobierz plik binarny. Wybierz na przykład ten, który pasuje do Twojej architekturygdrive-linux-x64.

2. Skopiuj go na swoją ścieżkę.

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

Aby go użyć:

1. Określ identyfikator pliku Dysku Google. W tym celu kliknij prawym przyciskiem myszy żądany plik na stronie Dysku Google i wybierz „Uzyskaj link…”. Zwróci coś takiego https://drive.google.com/open?id=0B7_OwkDsUIgFWXA1B2FPQfV5S8H. Uzyskaj ciąg za ?id=i skopiuj go do schowka. To jest identyfikator pliku.

2. Pobierz plik. Oczywiście zamiast tego użyj identyfikatora pliku w następującym poleceniu.

   gdrive download 0B7_OwkDsUIgFWXA1B2FPQfV5S8H
   

Przy pierwszym użyciu narzędzie będzie musiało uzyskać uprawnienia dostępu do interfejsu API Dysku Google. W tym celu pokaże Ci link, który musisz odwiedzić w przeglądarce, a następnie otrzymasz kod weryfikacyjny, aby skopiować i wkleić z powrotem do narzędzia. Pobieranie rozpocznie się automatycznie. Nie ma wskaźnika postępu, ale można obserwować postęp w menedżerze plików lub drugim terminalu.

Źródło: Komentarz Tobiego do innej odpowiedzi tutaj.

Dodatkowa sztuczka: ograniczenie prędkości. Aby pobierać z gdriveograniczoną maksymalną szybkością (aby nie zalać sieci…), możesz użyć takiego polecenia ( pvto PipeViewer ):

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

To pokaże ilość pobranych danych ( -b) i szybkość pobierania ( -r) i ograniczy tę szybkość do 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}"  

Jak to działa?
Pobierz plik cookie i kod HTML z curl.
Przeciągnij html do grep i sed i wyszukaj nazwę pliku.
Uzyskaj kod potwierdzający z pliku cookie za pomocą awk.
Na koniec pobierz plik z włączoną obsługą plików cookie, potwierdź kod i nazwę pliku.

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

Jeśli nie potrzebujesz nazwy pliku, zmienne curl może zgadnąć
-L Śledź przekierowania
-O Nazwa
zdalna -J Nazwa zdalna nagłówka

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}" 

Aby wyodrębnić identyfikator pliku Google z adresu URL, możesz użyć:

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

LUB

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 

Aktualizacja od marca 2018 r.

Próbowałem różnych technik podanych w innych odpowiedziach, aby pobrać mój plik (6 GB) bezpośrednio z dysku Google do mojej instancji AWS ec2, ale żadna z nich nie działa (może dlatego, że są stare).

Tak więc, dla informacji innych, oto jak to zrobiłem z powodzeniem:

1. Kliknij prawym przyciskiem myszy plik, który chcesz pobrać, kliknij udostępnij, w sekcji udostępniania linków wybierz „każdy, kto ma ten link, może edytować”.
2. Skopiuj link. Powinien być w tym formacie:https://drive.google.com/file/d/FILEIDENTIFIER/view?usp=sharing
3. Skopiuj część FILEIDENTIFIER z linku.

4. Skopiuj poniższy skrypt do pliku. Wykorzystuje curl i przetwarza plik cookie, aby zautomatyzować pobieranie pliku.

   #!/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. Jak pokazano powyżej, wklej FILEIDENTIFIER w skrypcie. Pamiętaj, aby zachować podwójne cytaty!

6. Podaj nazwę pliku zamiast FILENAME. Pamiętaj, aby zachować podwójne cudzysłowy, a także dołączyć rozszerzenie do FILENAME (na przykład myfile.zip).
7. Teraz zapisz plik i uczyń go wykonywalnym, uruchamiając to polecenie w terminalu sudo chmod +x download-gdrive.sh.
8. Uruchom skrypt za pomocą `./download-gdrive.sh".

PS: Oto lista Github dla powyższego skryptu: https://gist.github.com/amit-chahar/db49ce64f46367325293e4cce13d2424

Oto szybki sposób, aby to zrobić.

Upewnij się, że link jest udostępniony i będzie wyglądał mniej więcej tak:

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

Następnie skopiuj ten FILEID i użyj go w ten sposób

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

Domyślne zachowanie dysku google polega na skanowaniu plików w poszukiwaniu wirusów, jeśli plik jest zbyt duży, wyświetli monit dla użytkownika i powiadomi go, że pliku nie można przeskanować.

W tej chwili jedynym obejściem, jakie znalazłem, jest udostępnienie pliku w Internecie i utworzenie zasobu internetowego.

Cytat ze strony pomocy Google Drive:

Za pomocą Dysku możesz udostępniać zasoby internetowe - takie jak pliki HTML, CSS i JavaScript - jako witryny sieci Web.

Aby hostować stronę internetową za pomocą Dysku:

1. Otwórz Dysk na drive.google.com i wybierz plik.
2. Kliknij przycisk Udostępnij u góry strony.
3. Kliknij Zaawansowane w prawym dolnym rogu pola udostępniania.
4. Kliknij Zmień ....
5. Wybierz Włącz - Publiczny w Internecie i kliknij Zapisz .
6. Przed zamknięciem pola udostępniania skopiuj identyfikator dokumentu z adresu URL w polu poniżej „Link do udostępniania”. Identyfikator dokumentu to ciąg wielkich i małych liter oraz cyfr między ukośnikami w adresie URL.
7. Udostępnij adres URL, który wygląda jak „www.googledrive.com/host/[doc id], gdzie [doc id] jest zastąpione identyfikatorem dokumentu skopiowanym w kroku 6.
   Każdy może teraz przeglądać twoją stronę internetową.

Znalezione tutaj: https://support.google.com/drive/answer/2881970?hl=pl

Na przykład publicznie udostępniając plik na dysku Google, link udostępniania wygląda następująco:

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

Następnie skopiuj identyfikator pliku i utwórz link googledrive.com, który wygląda następująco:

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

Łatwa droga:

^{(jeśli potrzebujesz go tylko do jednorazowego pobrania)}

1. Przejdź do strony Dysku Google, która zawiera link do pobrania
2. Otwórz konsolę przeglądarki i przejdź do zakładki „sieć”
3. Kliknij link do pobrania
4. Zaczekaj, aż plik zacznie się pobierać, i znajdź odpowiednie żądanie (powinno być ostatnim na liście), a następnie możesz anulować pobieranie
5. Kliknij żądanie prawym przyciskiem myszy i kliknij „Kopiuj jako cURL” (lub podobny)

Powinieneś skończyć z czymś takim jak:

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

Wklej go w konsoli, dodaj > my-file-name.extensionna końcu (w przeciwnym razie zapisze plik w konsoli), a następnie naciśnij klawisz Enter :)

Na podstawie odpowiedzi Roshana Sethi

Maja 2018 r

Korzystanie z WGET :

1. Utwórz skrypt powłoki o nazwie wgetgdrive.sh, jak poniżej:

   #!/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. Nadaj odpowiednie uprawnienia do wykonania skryptu

3. W terminalu uruchom:

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

   na przykład:

   ./wgetgdrive.sh 1lsDPURlTNzS62xEOAIG98gsaW6x2PYd2 images.zip
   

- AKTUALIZACJA--

Aby pobrać plik, pobierz najpierw youtube-dlpython tutaj:

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

lub zainstaluj za pomocą pip:

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

AKTUALIZACJA:

Właśnie się dowiedziałem:

1. Kliknij prawym przyciskiem myszy plik, który chcesz pobrać z drive.google.com

2. Kliknij Get Sharable link

3. Włącz Link sharing on

4. Kliknij Sharing settings

5. Kliknij górne menu, aby wyświetlić opcje

6. Kliknij Więcej

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

8. Skopiuj link

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

Skopiuj identyfikator po https://drive.google.com/file/d/:

3PIY9dCoWRs-930HHvY-3-FOOPrIVoBAR

Wklej to do wiersza poleceń:

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

Wklej identyfikator za 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)

Mam nadzieję, że to pomoże

Żadna odpowiedź nie sugeruje, co działa dla mnie od grudnia 2016 r. ( Źródło ):

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

pod warunkiem, że plik Dysku Google został udostępniony osobom mającym link i {FileID}jest ciągiem ?id=w udostępnianym adresie URL.

Chociaż nie sprawdzałem dużych plików, uważam, że warto wiedzieć.

Najprostszym sposobem jest:

1. Utwórz link do pobrania i skopiuj ID pliku
2. Pobierz za pomocą 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

Powyższe odpowiedzi są nieaktualne w kwietniu 2020 r., Ponieważ dysk Google używa teraz przekierowania do faktycznej lokalizacji pliku.

Działa od kwietnia 2020 r. W systemie macOS 10.15.4 dla dokumentów publicznych:

# 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>

Miałem ten sam problem z Dyskiem Google.

Oto jak rozwiązałem problem za pomocą Links 2 .

1. Otwórz przeglądarkę na komputerze, przejdź do pliku na Dysku Google. Udostępnij plik publicznie.

2. Skopiuj publiczny link do schowka (np. Kliknij prawym przyciskiem myszy, Kopiuj adres linku)

3. Otwórz terminal. Jeśli pobierasz na inny komputer / serwer / maszynę, powinieneś SSH do niego w tym momencie

4. Zainstaluj Links 2 (metoda debian / ubuntu, użyj dystrybucji lub odpowiednika systemu operacyjnego)

   sudo apt-get install links2

5. Wklej link do terminala i otwórz go za pomocą linków:

   links2 "paste url here"

6. Przejdź do łącza pobierania w Łączach za pomocą klawiszy strzałek i naciśnij Enter

7. Wybierz nazwę pliku, a plik zostanie pobrany

Użyj youtube-dl !

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

Możesz również przejść, --get-urlaby uzyskać bezpośredni adres URL pobierania.

Używam fragmentu curl @ Amit Chahar, który opublikował dobrą odpowiedź w tym wątku. Uważam, że użyteczne jest umieszczenie go w funkcji bash zamiast w osobnym .shpliku

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
}

które mogą być uwzględnione np. ~/.bashrcpo (oczywiście, jeśli nie są pozyskiwane automatycznie) i użyte w następujący sposób

   $ curl_gdrive 153bpzybhfqDspyO_gdbcG5CMlI19ASba imagenet.tar

Istnieje wieloplatformowy klient open source, napisany w Go: drive . Jest całkiem fajny i posiada wiele funkcji, a także jest w fazie rozwoju.

$ 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`

Wszystkie powyższe odpowiedzi wydają się zaciemniać prostotę odpowiedzi lub mają pewne niuanse, które nie zostały wyjaśnione.

Jeśli plik jest udostępniany publicznie, możesz wygenerować bezpośredni link do pobrania, po prostu znając jego identyfikator. Adres URL musi mieć postać „ https://drive.google.com/uc?id=[FILEID]&export=download ” Działa od 11-22-2019. Nie wymaga to od odbiorcy zalogowania się w Google, ale wymaga publicznego udostępnienia pliku.

1. W przeglądarce przejdź do drive.google.com.

2. Kliknij plik prawym przyciskiem myszy i kliknij „Uzyskaj link do udostępnienia”

3. Otwórz nową kartę, wybierz pasek adresu i wklej zawartość schowka, który będzie linkiem do udostępniania. Zobaczysz plik wyświetlany przez przeglądarkę Google. Identyfikator to liczba bezpośrednio przed elementem „Wyświetl” adresu URL:

4. Edytuj adres URL, aby był w następującym formacie, zastępując „[FILEID]” identyfikatorem udostępnianego pliku:

   https://drive.google.com/uc?id=[FILEID]&export=download

5. To jest twój bezpośredni link do pobrania. Jeśli klikniesz go w przeglądarce, plik zostanie „wypchnięty” do przeglądarki, otwierając okno pobierania, umożliwiając zapisanie lub otwarcie pliku. Możesz również użyć tego linku w swoich skryptach pobierania.

6. Więc równoważne polecenie curl byłoby:

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

Nie byłem w stanie uruchomić skryptu perla Nanoix ani innych przykładów curl, które widziałem, więc zacząłem szukać interfejsu API w Pythonie. Działa to dobrze w przypadku małych plików, ale duże pliki dusiły dostępną pamięć RAM, więc znalazłem inny fajny kod, który wykorzystuje zdolność API do częściowego pobrania. Gist tutaj: https://gist.github.com/csik/c4c90987224150e4a0b2

Zwróć uwagę na temat pobierania pliku json client_secret z interfejsu API do katalogu lokalnego.

$ 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) 

Oto krótki skrypt napisany przeze mnie, który dziś spełnia swoje zadanie. Działa na dużych plikach i może również wznowić częściowo pobrane pliki. Wymaga dwóch argumentów, pierwszy to identyfikator_pliku, a drugi to nazwa pliku wyjściowego. Główne ulepszenia w porównaniu z poprzednimi odpowiedziami są takie, że działa na dużych plikach i potrzebuje tylko powszechnie dostępnych narzędzi: bash, curl, tr, grep, du, cut i 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

Działa to od listopada 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

Po zabawie w śmieci. Znalazłem sposób na pobranie mojego słodkiego pliku za pomocą narzędzi Chrome dla programistów.

1. Na karcie Dokumentów Google Ctr + Shift + J (Ustawienia -> Narzędzia programistyczne)
2. Przejdź do kart Sieć
3. W pliku dokumentów kliknij „Pobierz” -> Pobierz jako CSV, xlsx, ....

4. Wyświetli to żądanie w konsoli „Network”

5. Kliknij prawym przyciskiem myszy -> Kopiuj -> Kopiuj jako zawinięcie

6. Twoje polecenie Curl będzie wyglądać tak i dodaj, -oaby utworzyć wyeksportowany plik. 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

Rozwiązany!

Oto obejście, które wymyśliłem, pobierając pliki z Dysku Google do mojej powłoki Google Cloud Linux.

1. Udostępnij plik PUBLIC i z uprawnieniami do edycji za pomocą zaawansowanego udostępniania.
2. Otrzymasz link do udostępniania, który miałby identyfikator. Zobacz link: - drive.google.com/file/d/[ID]/view?usp=sharing
3. Skopiuj ten identyfikator i wklej go w następującym linku: -

googledrive.com/host/[ID]

4. Powyższy link byłby naszym linkiem do pobrania.
5. Użyj wget, aby pobrać plik: -

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

6. To polecenie pobierze plik o nazwie [ID] bez rozszerzenia i o tym samym rozmiarze pliku w tej samej lokalizacji, w której uruchomiono polecenie wget.
7. W rzeczywistości pobrałem spakowany folder w swojej praktyce. więc zmieniłem nazwę tego niezręcznego pliku, używając:

mv [ID] 1.zip

8. następnie używając

rozpakuj 1.zip

otrzymamy pliki.

Znalazłem działające rozwiązanie tego ... Po prostu skorzystaj z poniższych

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

Jest łatwiejszy sposób.

Zainstaluj cliget / CURLWGET z rozszerzenia firefox / chrome.

Pobierz plik z przeglądarki. Tworzy to link curl / wget, który zapamiętuje pliki cookie i nagłówki użyte podczas pobierania pliku. Aby pobrać, użyj tego polecenia z dowolnej powłoki

łatwym sposobem na usunięcie pliku z dysku google możesz również pobrać plik na colab

pip install gdown

import gdown

Następnie

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

lub

fileid='0B9P1L7Wd2vU3VUVlFnbTgtS2c'

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

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

PRACA W maju 2018 r

Cześć, na podstawie tych komentarzy ... tworzę bash, aby wyeksportować listę adresów URL z pliku URLS.txt do URLS_DECODED.txt używanego w niektórych akceleratorach, takich jak Flashget (używam cygwin do łączenia Windowsa i Linuksa)

Pająk poleceń został wprowadzony, aby uniknąć pobierania i uzyskania końcowego linku (bezpośrednio)

Polecenie GREP HEAD i CUT, przetwarzaj i uzyskaj ostatni link, Opiera się na języku hiszpańskim, może możesz być portem do JĘZYKA ANGIELSKIEGO

echo -e "$URL_TO_DOWNLOAD\r" prawdopodobnie \ r jest tylko cywin i musi być zastąpione przez \ n (linia przerwania)

**********user*********** to folder użytkownika

*******Localización*********** jest w języku hiszpańskim, usuń asterykę i pozwól słowu w języku angielskim Lokalizacja i dostosuj numery HEAD i CUT do odpowiedniego podejścia.

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

Wystarczy użyć wget z:

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

PD. Plik musi być publiczny.

skicka to narzędzie cli do przesyłania, pobierania plików dostępu z dysku google.

przykład -

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