Napisałem fragment Pythona, który pobiera plik z Dysku Google, biorąc pod uwagę shareable link . Działa, od sierpnia 2017 .

Podczas pobierania dużych plików z Dysku Google jedno żądanie GET nie jest wystarczające. Potrzebny jest drugi, a ten ma dodatkowy parametr URL o nazwie confirm , którego wartość powinna być równa wartości pewne ciasteczko.

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ń open source Linux / Unix gdrive.

Aby go zainstalować:

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

2. Skopiuj to 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 w Google Prowadź stronę internetową i wybierz " Pobierz Link ...". Zwróci coś w rodzaju https://drive.google.com/open?id=0B7_OwkDsUIgFWXA1B2FPQfV5S8H. Uzyskaj ciąg znaków ?id= i skopiuj go do schowka. To identyfikator akt.

2. Pobierz plik. oczywiście użyj identyfikatora pliku w następującej komendzie.

   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 Uzyskaj kod weryfikacyjny, aby skopiować i wkleić go 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 Tobi na inną odpowiedź tutaj.

Dodatkowy trik: ograniczenie szybkości. aby pobierać z gdrive z ograniczoną maksymalną szybkością (aby nie bagatelizować sieci ...), możesz użyć komendy takiej jak ta (używając PipeViewer):

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

Pokazuje ilość pobranych danych (-b) i szybkość pobierania (-r) i ogranicza 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}"  

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

Jeśli nie potrzebujesz pliku zmienna curl może go odgadnąć
-L Follow redirects
- 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}" 

Aby wyodrębnić google file ID z URL można 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 

Domyślnym zachowaniem Dysku google jest skanowanie plików w poszukiwaniu wirusów jeśli plik jest duży, poprosi użytkownika i powiadomi go, że plik nie może zostać zeskanowany.

W tej chwili jedynym obejściem, jakie znalazłem, jest udostępnienie pliku sieci web i utworzenie zasobu sieciowego.

Cytat ze strony pomocy Dysku google:

Za pomocą Dysku możesz sprawić, że zasoby internetowe - takie jak pliki HTML, CSS i Javascript - będą widoczne jako strona internetowa.

Do hostowania strony internetowej z Napęd:

1. Open Drive at drive.google.com i wybierz plik.
2. kliknij przycisk Udostępnij u góry strony.
3. kliknij zaawansowane w prawym dolnym rogu okna udostępniania.
4. Kliknij Zmień....
5. Wybierz ON-Public w sieci i kliknij Zapisz .
6. przed zamknięciem okna udostępniania skopiuj identyfikator dokumentu z adresu URL w polu poniżej "Link do udostępniania". ID dokumentu jest ciągiem wielkich i małych liter i cyfr pomię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ępowany przez identyfikator dokumentu skopiowany w kroku 6.
   Każdy może teraz przeglądać Twoją stronę internetową.

Znaleziono tutaj: https://support.google.com/drive/answer/2881970?hl=en

Więc na przykład, gdy udostępniasz plik na Dysku google publicznie sharelink wygląda TAK:

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

Następnie kopiujesz ID pliku i tworzysz googledrive.com linke to wyglada tak:

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

Oto szybki sposób na to.

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

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

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

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

Aktualizacja z marca 2018.

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

Więc, dla informacji innych, oto jak zrobiłem to pomyślnie:

1. Kliknij prawym przyciskiem myszy plik, który chcesz pobrać, kliknij Udostępnij, w sekcji Udostępnianie linków wybierz "każdy z tym linkiem może edytować".
2. Skopiuj link. Powinno być w tym format: https://drive.google.com/file/d/FILEIDENTIFIER/view?usp=sharing
3. skopiuj fragment FILEIDENTIFIER z linku(wygląda to jak losowe znaki).

4. Skopiuj poniższy skrypt do pliku. Wykorzystuje curl i przetwarza plik cookie w celu automatyzacji pobierania 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 wyjściowego zamiast Nazwa pliku. Pamiętaj, aby zachować podwójne cudzysłowy i również włączyć rozszerzenie w nazwie pliku (na przykład, " myfile.zip").
7. Teraz zapisz plik i utwórz plik wykonywalny, uruchamiając to polecenie w terminalu "sudo chmod +x download-script.sh". Zastąp "download-script.sh" z nazwą pliku skryptu.
8. Uruchom skrypt używając "./download-script.sh". ponownie zastąp "download-script.sh" z nazwą pliku skryptu.

PS: Oto GitHub gist dla powyżej podany skrypt: https://gist.github.com/amit-chahar/db49ce64f46367325293e4cce13d2424

Czerwiec 2018 Najprostszy sposób, który działa dla mnie

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

file_id powinien wyglądać jak 0Bz8a_Dbh9QhbNU3SGlFaDg

Można go uzyskać klikając prawym przyciskiem myszy na pliku, a następnie uzyskać łącze udostępniane . Testowane na plikach open access. Nie jestem pewien, czy to działa dla directory.

Brak odpowiedzi na to, co u mnie działa od Grudzień 2016 (źródło):

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

Pod warunkiem, że plik Dysku Google został udostępniony osobom posiadającym link, a {FileID} jest ciągiem znaków ?id= w udostępnionym adresie URL.

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

The easy way:

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

1. przejdź do strony Dysku Google z linkiem do pobrania
2. Otwórz konsolę przeglądarki i przejdź do zakładki "sieć"
3. Kliknij link do pobrania
4. poczekaj, aż plik rozpocznie pobieranie i znajdź odpowiednie żądanie( powinno być Ostatnie na liście), a następnie możesz anulować pobieranie
5. Kliknij prawym przyciskiem myszy na żądanie i kliknij "Kopiuj jako cURL" (lub podobne)

Powinieneś skończyć z czymś takim:

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

Dodaj go do konsoli, dodaj > my-file-name.extension na koniec (w przeciwnym razie zapisze plik do konsoli), a następnie naciśnij enter:)

Istnieje wieloplatformowy klient open source, napisany w Go: drive . Jest całkiem ładny i w pełni funkcjonalny, a także jest w aktywnym 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`

Nie udało mi się uruchomić skryptu Perla Nanoixa, ani innych przykładów curla, które widziałem, więc sam zacząłem szukać api w Pythonie. To działało dobrze w przypadku małych plików, ale duże pliki dławiły się obok dostępnej pamięci ram, więc znalazłem inny ładny kod chunking, który wykorzystuje zdolność api do częściowego pobrania. Gist tutaj: https://gist.github.com/csik/c4c90987224150e4a0b2

Zwróć uwagę na fragment dotyczący pobierania pliku client_secret json z interfejsu API do lokalnego katalog.

$ 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 mały skrypt Basha, który dziś się sprawdza. Działa na dużych plikach i może również wznowić częściowo pobrane pliki. Pobiera dwa argumenty, pierwszy to file_id, a drugi to nazwa pliku wyjściowego. Główne ulepszenia w stosunku do poprzednich odpowiedzi są takie, że działa na dużych plikach i wymaga 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

Miałem ten sam problem z Dyskiem Google.

Oto jak rozwiązałem problem używając linków 2 .

1. Otwórz przeglądarkę na komputerze, przejdź do pliku na Dysku Google. Podaj swój plik łącze publiczne.

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

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

4. Install Links 2 (metoda debian / ubuntu, użyj swojego distro lub równoważnego systemu operacyjnego)

   sudo apt-get install links2

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

   links2 "paste url here"

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

7. Wybierz nazwę pliku, a plik zostanie pobrany

To działa 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

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 publicznie i z uprawnieniami do edycji za pomocą zaawansowanego udostępniania.
2. otrzymasz link dzielący, który będzie miał identyfikator. Zobacz link:- drive.google.com/file/d/[ID] / view? usp=sharing
3. Skopiuj ten identyfikator i wklej go w następujący link:-

Googledrive.com/host/[ID]

1. powyższy link będzie naszym linkiem do pobrania.
2. Użycie wget do pobrania pliku: -

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

1. to polecenie pobierze plik o nazwie [ID] bez rozszerzenia i z tym samym rozmiarem pliku w tym samym miejscu, w którym uruchomiłeś polecenie wget.
W praktyce ściągnąłem spakowany folder. więc zmieniłem nazwę tego niezręcznego pliku używając: -

Mv [ID] 1.zip

1. Następnie użyj

Rozpakuj 1.zip

Zdobędziemy pliki.

Na podstawie odpowiedzi Roshana Sethia

Maj 2018

Using WGET :

1. Tworzenie skryptu 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. Nadaje uprawnienia do wykonywania skryptu

3. In terminal, run:

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

   Na przykład:

   ./wgetgdrive.sh 1lsDPURlTNzS62xEOAIG98gsaW6x2PYd2 images.zip
   

Znalazłem na to rozwiązanie... Po prostu użyj następującego

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 jest narzędziem 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

Maj 2018 praca

Witam na podstawie tego komentarza ... tworzę bash, aby wyeksportować listę adresów URL z pliku adresów URL.txt to a URLS_DECODED.txt jest to jeden z najbardziej popularnych akceleratorów flashget.]}

Command spider został wprowadzony, aby uniknąć pobierania i uzyskać ostateczny link (bezpośrednio)

Polecenie grep HEAD I CUT, process I get the final link, jest w języku hiszpańskim, może można być port do JĘZYK ANGIELSKI

echo -e "$URL_TO_DOWNLOAD\r" prawdopodobnie \R jest tylko cywin i musi być zastąpiony przez \N (break line)

**********user*********** jest folderem użytkownika

*******Localización*********** jest w języku hiszpańskim, Wyczyść asteryki i niech słowo w Angielskiej lokalizacji i dostosować głowę i numery cięcia do appropiate podejście.

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

Najprostszym sposobem jest:

1. Utwórz link do pobrania i skopiuj fileID
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

Maj 2018

Jeśli chcesz użyć curl do pobrania pliku z Dysku Google, oprócz identyfikatora pliku na dysku potrzebujesz również OAuth2 access_token dla interfejsu API Dysku Google. Uzyskanie tokena wymaga kilku kroków z Google API framework. Kroki rejestracji w Google są (obecnie) bezpłatne.

OAuth2 access_token potencjalnie pozwala na wszystkie rodzaje aktywności, więc bądź ostrożny z tym. Ponadto, żeton wygasa po krótkiej chwili (1 godzina?) ale nie na tyle krótki, aby zapobiegaj nadużyciom, jeśli ktoś je uchwyci.

Gdy masz access_token i identyfikator pliku, to zadziała:

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

Zobacz także: Google Drive API -- REST -- Download Files

Wystarczy użyć wget z:

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

PD. Plik musi być publiczny.

Najprostszym sposobem jest umieszczenie tego, co chcesz pobrać w folderze. Udostępnij ten folder, a następnie pobierz identyfikator folderu z paska adresu URL.

Następnie przejdź do https://googledrive.com/host/[ID] (Zamień ID na ID folderu) Powinieneś zobaczyć listę wszystkich plików w tym folderze, kliknij ten, który chcesz pobrać. Pobieranie powinno następnie odwiedzić stronę pobierania (Ctrl+J W Chrome), następnie chcesz skopiować link do pobrania, a następnie użyć wget "download link"

Enjoy :)