Télécharger une feuille de calcul à partir de Google Documents à l'aide de Python
Pouvez-vous produire un exemple Python montrant comment télécharger une feuille de calcul Google Docs à partir de la clé et de l'ID de la feuille de calcul (gid)? Je ne peux pas.
J'ai parcouru les versions 1, 2 et 3 de l'API. Je n'ai aucune chance, je n'arrive pas à comprendre leur API de flux de type ATOM compilée, la méthode privée gdata.docs.service.DocsService._DownloadFile indique que je ne suis pas autorisé et je ne veux pas écrire moi-même un système d'authentification complet. Je suis sur le point de me poignarder au visage à cause de la frustration.
J'ai quelques feuilles de calcul et je veux y accéder comme suit:
username = '[email protected]'
password = getpass.getpass()
def get_spreadsheet(key, gid=0):
... (help!) ...
for row in get_spreadsheet('5a3c7f7dcee4b4f'):
cell1, cell2, cell3 = row
...
S'il te plaît sauve ma face.
Mise à jour 1: J'ai essayé ce qui suit, mais aucune combinaison de Download() ou Export() ne semble fonctionner. (Documents pour DocsServiceici )
import gdata.docs.service
import getpass
import os
import tempfile
import csv
def get_csv(file_path):
return csv.reader(file(file_path).readlines())
def get_spreadsheet(key, gid=0):
Gd_client = gdata.docs.service.DocsService()
Gd_client.email = '[email protected]'
Gd_client.password = getpass.getpass()
Gd_client.ssl = False
Gd_client.source = "My Fancy Spreadsheet Downloader"
Gd_client.ProgrammaticLogin()
file_path = tempfile.mktemp(suffix='.csv')
uri = 'http://docs.google.com/feeds/documents/private/full/%s' % key
try:
entry = Gd_client.GetDocumentListEntry(uri)
# XXXX - The following dies with RequestError "Unauthorized"
Gd_client.Download(entry, file_path)
return get_csv(file_path)
finally:
try:
os.remove(file_path)
except OSError:
pass
Au cas où quelqu'un trouverait une solution rapide, voici une autre solution (actuellement) opérationnelle qui ne repose pas sur la bibliothèque client gdata:
#!/usr/bin/python
import re, urllib, urllib2
class Spreadsheet(object):
def __init__(self, key):
super(Spreadsheet, self).__init__()
self.key = key
class Client(object):
def __init__(self, email, password):
super(Client, self).__init__()
self.email = email
self.password = password
def _get_auth_token(self, email, password, source, service):
url = "https://www.google.com/accounts/ClientLogin"
params = {
"Email": email, "Passwd": password,
"service": service,
"accountType": "HOSTED_OR_GOOGLE",
"source": source
}
req = urllib2.Request(url, urllib.urlencode(params))
return re.findall(r"Auth=(.*)", urllib2.urlopen(req).read())[0]
def get_auth_token(self):
source = type(self).__name__
return self._get_auth_token(self.email, self.password, source, service="wise")
def download(self, spreadsheet, gid=0, format="csv"):
url_format = "https://spreadsheets.google.com/feeds/download/spreadsheets/Export?key=%s&exportFormat=%s&gid=%i"
headers = {
"Authorization": "GoogleLogin auth=" + self.get_auth_token(),
"GData-Version": "3.0"
}
req = urllib2.Request(url_format % (spreadsheet.key, format, gid), headers=headers)
return urllib2.urlopen(req)
if __== "__main__":
import getpass
import csv
email = "" # (your email here)
password = getpass.getpass()
spreadsheet_id = "" # (spreadsheet id here)
# Create client and spreadsheet objects
gs = Client(email, password)
ss = Spreadsheet(spreadsheet_id)
# Request a file-like object containing the spreadsheet's contents
csv_file = gs.download(ss)
# Parse as CSV and print the rows
for row in csv.reader(csv_file):
print ", ".join(row)
La bibliothèque https://github.com/burnash/gspread est un moyen plus simple et plus moderne d'interagir avec Google Spreadsheets, plutôt que les anciennes réponses à cette suggestion qui suggèrent la bibliothèque gdata qui n'est pas seulement de trop bas niveau, mais c'est aussi trop compliqué.
Vous devrez également créer et télécharger (au format JSON) une clé de compte de service: https://console.developers.google.com/apis/credentials/serviceaccountkey
Voici un exemple d'utilisation:
import csv
import gspread
from oauth2client.service_account import ServiceAccountCredentials
scope = ['https://spreadsheets.google.com/feeds']
credentials = ServiceAccountCredentials.from_json_keyfile_name('credentials.json', scope)
docid = "0zjVQXjJixf-SdGpLKnJtcmQhNjVUTk1hNTRpc0x5b9c"
client = gspread.authorize(credentials)
spreadsheet = client.open_by_key(docid)
for i, worksheet in enumerate(spreadsheet.worksheets()):
filename = docid + '-worksheet' + str(i) + '.csv'
with open(filename, 'wb') as f:
writer = csv.writer(f)
writer.writerows(worksheet.get_all_values())
Vous pouvez essayer d'utiliser la méthode AuthSub décrite dans la section Exporting Spreadsheets de la documentation.
Obtenez un jeton de connexion distinct pour le service de feuille de calcul et remplacez-le pour l'exportation. Ajouter ceci au code get_spreadsheet a fonctionné pour moi:
import gdata.spreadsheet.service
def get_spreadsheet(key, gid=0):
# ...
spreadsheets_client = gdata.spreadsheet.service.SpreadsheetsService()
spreadsheets_client.email = Gd_client.email
spreadsheets_client.password = Gd_client.password
spreadsheets_client.source = "My Fancy Spreadsheet Downloader"
spreadsheets_client.ProgrammaticLogin()
# ...
entry = Gd_client.GetDocumentListEntry(uri)
docs_auth_token = Gd_client.GetClientLoginToken()
Gd_client.SetClientLoginToken(spreadsheets_client.GetClientLoginToken())
Gd_client.Export(entry, file_path)
Gd_client.SetClientLoginToken(docs_auth_token) # reset the DocList auth token
Notez que j'ai aussi utilisé Export, car Download semble ne donner que des fichiers PDF.
(juillet 2016) Reformulation avec la terminologie actuelle: "Comment puis-je télécharger une feuille Google au format CSV à partir de Google Drive en utilisant Python?". (Google Docs fait désormais uniquement référence au traitement de texte/éditeur de texte basé sur un nuage qui ne donne pas accès aux feuilles de calcul Google Sheets.)
Premièrement, toutes les autres réponses sont à peu près obsolètes ou le seront, soit parce qu’elles utilisent les anciens GData (" Google Data") Protocol , ClientLogin ou AuthSub , tous dont obsolètes. Il en va de même pour tout code ou toutes les bibliothèques utilisant l'API Google Sheets version 3 ou antérieure.
L'accès aux API Google modernes s'effectue à l'aide de clés API (données publiques) ou d'autorisation OAuth2 (données autorisées), principalement avec les bibliothèques clientes Google APIs , y compris celui pour Python . (Et non, vous n'avez pas besoin de créer un système d'authentification complet pour accéder aux API ... voir l'article de blog ci-dessous.)
Pour effectuer la tâche demandée dans/par l'OP, vous devez disposer d'un accès autorisé à l'API Google Drive , éventuellement pour interroger des feuilles spécifiques à télécharger, puis pour effectuer les exportations effectives. Comme il s’agit probablement d’une opération courante, j’ai écrit un blogpost partageant un extrait de code qui le fait pour vous. Si vous souhaitez approfondir encore davantage cette question, j'ai une autre paire de posts accompagnée d'une vidéo qui explique comment importer et télécharger des fichiers depuis Google Drive.
Notez qu’il existe également une API Google Sheets v4 plus récente, mais elle s’applique principalement aux opérations orientées sur les feuilles de calcul, telles que l’insertion de données, la lecture de lignes de feuilles de calcul, la mise en forme de cellules, la création de graphiques, l’ajout de tableaux croisés dynamiques, etc., et non pas demande basée sur un fichier} comme lors de l'exportation où l'API de lecteur est celle qui convient.
Pour voir un exemple d'exportation d'une feuille Google au format CSV à partir de Drive, consultez this blog post J'ai écrit; pour en savoir plus sur l'utilisation de Google Sheets avec Python, voir cette réponse que j'ai écrite pour une question similaire.
Si vous êtes complètement nouveau dans les API Google, vous devez prendre un peu de recul et visionner d’abord ces vidéos:
- Comment utiliser les API Google et créer des projets d'API - l'interface utilisateur a changé mais les concepts sont toujours les mêmes
- Procédure pas à pas du code de passe-partout d'autorisation (Python) - vous pouvez utiliser n'importe quel langage pris en charge par pour accéder aux API Google. si vous ne faites pas Python, utilisez-le comme pseudocode pour vous aider à démarrer
- Liste de vos fichiers dans Google Drive et code Deep Dive post
Cela ne fonctionne plus à partir de gdata 2.0.1.4:
Gd_client.SetClientLoginToken(spreadsheets_client.GetClientLoginToken())
Au lieu de cela, vous devez faire:
Gd_client.SetClientLoginToken(gdata.gauth.ClientLoginToken(spreadsheets_client.GetClientLoginToken()))
Le code suivant fonctionne dans mon cas (Ubuntu 10.4, Python 2.6.5 gdata 2.0.14)
import gdata.docs.service
import gdata.spreadsheet.service
Gd_client = gdata.docs.service.DocsService()
Gd_client.ClientLogin(email,password)
spreadsheets_client = gdata.spreadsheet.service.SpreadsheetsService()
spreadsheets_client.ClientLogin(email,password)
#...
file_path = file_path.strip()+".xls"
docs_token = Gd_client.auth_token
Gd_client.SetClientLoginToken(spreadsheets_client.GetClientLoginToken())
Gd_client.Export(entry, file_path)
Gd_client.auth_token = docs_token
J'ai encore simplifié la réponse de @ Cameron en supprimant l'orientation objet inutile. Cela rend le code plus petit et plus facile à comprendre. J'ai également édité l'URL, ce qui pourrait fonctionner mieux.
#!/usr/bin/python
import re, urllib, urllib2
def get_auth_token(email, password):
url = "https://www.google.com/accounts/ClientLogin"
params = {
"Email": email, "Passwd": password,
"service": 'wise',
"accountType": "HOSTED_OR_GOOGLE",
"source": 'Client'
}
req = urllib2.Request(url, urllib.urlencode(params))
return re.findall(r"Auth=(.*)", urllib2.urlopen(req).read())[0]
def download(spreadsheet, worksheet, email, password, format="csv"):
url_format = 'https://docs.google.com/spreadsheets/d/%s/export?exportFormat=%s#gid=%s'
headers = {
"Authorization": "GoogleLogin auth=" + get_auth_token(email, password),
"GData-Version": "3.0"
}
req = urllib2.Request(url_format % (spreadsheet, format, worksheet), headers=headers)
return urllib2.urlopen(req)
if __== "__main__":
import getpass
import csv
spreadsheet_id = "" # (spreadsheet id here)
worksheet_id = '' # (gid here)
email = "" # (your email here)
password = getpass.getpass()
# Request a file-like object containing the spreadsheet's contents
csv_file = download(spreadsheet_id, worksheet_id, email, password)
# Parse as CSV and print the rows
for row in csv.reader(csv_file):
print ", ".join(row)
Gspread est en effet une grande amélioration par rapport à GoogleCL et à Gdata (que j’ai utilisés et que j’ai heureusement supprimés en faveur de Gspread). Je pense que ce code est encore plus rapide que la réponse précédente pour obtenir le contenu de la feuille:
username = '[email protected]'
password = 'sdfsdfsadfsdw'
sheetname = "Sheety Sheet"
client = gspread.login(username, password)
spreadsheet = client.open(sheetname)
worksheet = spreadsheet.sheet1
contents = []
for rows in worksheet.get_all_values():
contents.append(rows)
Ce n'est pas une réponse complète, mais Andreas Kahler a rédigé une solution de SGC intéressante utilisant Google Documents + Google App Engline + Python. N'ayant aucune expérience dans le domaine, je ne vois pas exactement quelle partie du code pourrait vous être utile, mais vérifiez-le. Je sais que l'interface s'interface avec un compte Google Documents et joue avec les fichiers. J'ai donc le sentiment que vous saurez ce qui se passe. Cela devrait au moins vous orienter dans la bonne direction.
Google AppEngine + Google Docs + Certains Python = CMS simple
(déc 16) Essayez une autre bibliothèque que j’ai écrit: pygsheets . Son semblable à gspread, mais utilise google api v4. Il dispose d'une méthode export pour exporter une feuille de calcul.
import pygsheets
gc = pygsheets.authorize()
# Open spreadsheet and then workseet
sh = gc.open('my new ssheet')
wks = sh.sheet1
#export as csv
wks.export(pygsheets.ExportType.CSV)