Diese Seite wurde von der Cloud Translation API übersetzt.

Entwicklerleitfaden: Python

Mit der Blogger Data API können Clientanwendungen Blogger-Inhalte in Form von Google Data API-Feeds abrufen und aktualisieren.

Ihre Clientanwendung kann die Blogger Data API verwenden, um neue Blogposts zu erstellen, vorhandene Blogposts zu bearbeiten oder zu löschen und nach Blogposts zu suchen, die bestimmten Kriterien entsprechen.

Neben Informationen zu den Möglichkeiten der Blogger Data API enthält dieses Dokument auch Beispiele für grundlegende Data API-Interaktionen mit der Python-Clientbibliothek. Weitere Informationen zum zugrunde liegenden Protokoll, das in der Bibliothek verwendet wird, finden Sie im Abschnitt zum Protokoll in diesem Entwicklerleitfaden.

Inhalt

Zielgruppe

Dieses Dokument richtet sich an Programmierer, die Python-Clientanwendungen schreiben möchten, die mit Blogger interagieren können.

In diesem Dokument wird davon ausgegangen, dass Sie mit den allgemeinen Ideen hinter dem Google Data APIs-Protokoll vertraut sind.

Allgemeine Informationen zur Blogger Data API finden Sie im Referenzhandbuch zum Protokoll.

Erste Schritte

Hilfe zum Einrichten der Clientbibliothek finden Sie im Startleitfaden.

Für die Python-Clientbibliothek ist Python 2.2 oder höher erforderlich. Nachdem du die Clientbibliothek heruntergeladen hast, musst du auch das Paket ElementTree herunterladen und installieren.

Blogger-Konto erstellen

Du kannst dich auch für ein Blogger-Konto registrieren. Blogger verwendet Google-Konten. Wenn Sie also bereits ein Google-Konto haben, müssen Sie nichts weiter tun.

Beispielcode ausführen

Ein voll funktionsfähiger Beispielclient, der den gesamten in diesem Dokument gezeigten Beispielcode enthält, ist in der Datei BloggerExample.py im Verzeichnis gdata-python-client/samples/blogger/ verfügbar.

Der Beispielclient führt im angegebenen Blog mehrere Vorgänge aus, um die Verwendung der Blogger Data API zu demonstrieren.

Sie können das Beispiel mit den folgenden Argumenten ausführen:

python BloggerExample.py --email [email_address] --password [password]

Wenn Sie die Beispiele in diesem Dokument in Ihrem eigenen Code verwenden möchten, benötigen Sie die folgenden import-Anweisungen:

from gdata import service
import gdata
import atom

Authentifizierung beim Blogger-Dienst

Mit der Blogger Data API können Sie sowohl auf öffentliche als auch auf private Feeds zugreifen. Für öffentliche Feeds ist keine Authentifizierung erforderlich, sie sind aber schreibgeschützt. Wenn du Blogs ändern möchtest, muss sich dein Client authentifizieren, bevor du private Feeds anfordern kannst. Für die Authentifizierung gibt es drei Möglichkeiten: die OAuth-Authentifizierung, die AuthSub-Proxyauthentifizierung oder die ClientLogin-Authentifizierung für Nutzernamen und Passwörter.

Weitere Informationen zur Authentifizierung mit Google Data APIs im Allgemeinen finden Sie in der Authentifizierungsdokumentation.

Bei den meisten Beispielen in den nachfolgenden Abschnitten dieses Dokuments wird davon ausgegangen, dass Sie eine authentifizierte GDataService-Instanz haben.

OAuth-Authentifizierung

Informationen zur OAuth-Authentifizierung mit der Python GData-Bibliothek finden Sie unter OAuth in den Google Data Protocol-Clientbibliotheken.

AuthSub-Proxy-Authentifizierung

Die AuthSub-Proxy-Authentifizierung wird von Webanwendungen verwendet, die ihre Nutzer bei Google-Konten authentifizieren müssen. Der Websitebetreiber und der Clientcode haben keinen Zugriff auf den Nutzernamen und das Passwort für den Blogger-Nutzer. Stattdessen erhält der Client spezielle AuthSub-Tokens, die es dem Client ermöglichen, im Namen eines bestimmten Nutzers zu handeln. Weitere Informationen finden Sie in der AuthSub-Dokumentation.

Wenn ein Nutzer Ihre Anwendung zum ersten Mal aufruft, wurde er noch nicht authentifiziert. In diesem Fall musst du einige Informationen und einen Link anzeigen, der den Nutzer zu einer Google-Seite weiterleitet, damit deine Zugriffsanfrage für seine Blogs authentifiziert werden kann. Die Python-Clientbibliothek bietet eine Funktion zum Generieren der Google-Seite. Mit dem folgenden Code wird die URL der AuthSubRequest-Seite abgerufen:

def GetAuthSubUrl():
  next = 'http://www.example.com/welcome.pyc'
  scope = 'http://www.blogger.com/feeds/'
  secure = False
  session = True
  blogger_service = service.GDataService()
  return blogger_service.GenerateAuthSubURL(next, scope, secure, session);

authSubUrl = GetAuthSubUrl();
print '<a href="%s">Login to your Google account</a>' % authSubUrl

Die Methode GenerateAuthSubURL verwendet die folgenden Parameter (entsprechend den Abfrageparametern, die vom AuthSubRequest-Handler verwendet werden):

Weiter: Die URL der Seite, auf die Google den Nutzer nach der Authentifizierung weiterleiten soll.
Bereich: Gibt an, dass die Anwendung ein Token für den Zugriff auf Blogger-Feeds anfordert. Der zu verwendende Bereichsstring ist http://www.blogger.com/feeds/ (natürlich URL-codiert).
geschützt?: Gibt an, ob der Client ein sicheres Token anfordert.
session: Gibt an, ob das zurückgegebene Token gegen ein Mehrzwecktoken (Sitzungsversion) eingetauscht werden kann.

Das obige Beispiel zeigt einen Aufruf, der kein sicheres Token anfordert (der Wert von secure ist False). Die resultierende Anfrage-URL könnte so aussehen:

https://www.google.com/accounts/AuthSubRequest?scope=http%3A%2F%2Fwww.blogger.com%2Ffeeds%2F&session=1&secure=0&next=http%3A%2F%2Fwww.example.com%2Fwelcome.pyc

Der Nutzer folgt dem Link zur Google-Website und authentifiziert sich für sein Google-Konto.

Nach der Authentifizierung des Nutzers werden sie vom AuthSub-System an die URL weitergeleitet, die Sie im Abfrageparameter next der AuthSubRequest-URL angegeben haben. Das AuthSub-System hängt als Wert des Abfrageparameters token ein Authentifizierungstoken an diese URL an. Beispiel:

http://www.example.com/welcome.pyc?token=yourAuthToken

Es gibt mehrere Möglichkeiten, den Tokenwert von der URL abzurufen. Beispiel:

import cgi

parameters = cgi.FieldStorage()
authsub_token = parameters['token']

Dieser Tokenwert stellt ein Einweg-Token für die einmalige Verwendung dar. Da in diesem Beispiel session = True angegeben wurde, kann dieses Token mit der Methode UpgradeToSessionToken, die den Dienst AuthSubSessionToken aufruft, gegen ein AuthSub-Sitzungstoken eingetauscht werden:

blogger_service = service.GDataService()
blogger_service.auth_token = authsub_token
blogger_service.UpgradeToSessionToken()

Das heißt, Sie übergeben Ihr einmaliges Token an die Methode UpgradeToSessionToken und die AuthSub-Schnittstelle gibt ein Sitzungstoken zurück.

Ihre Anwendung kann dann den Wert des Sitzungstokens bei nachfolgenden Interaktionen mit Blogger verwenden. Die Clientbibliothek sendet das Token automatisch zusammen mit Anfragen.

Authentifizierung mit Nutzername/Passwort für ClientLogin

Verwenden Sie die ClientLogin-Authentifizierung, wenn Ihr Client ein eigenständiger, einzelner Nutzerclient ist, z. B. eine Desktopanwendung. Rufen Sie einfach die Methode ProgrammaticLogin() auf Ihrer GDataService-Instanz auf. Alle nachfolgenden Interaktionen mit Blogger werden authentifiziert:

blogger_service = service.GDataService('user@example.com', 'secretPassword')
blogger_service.source = 'exampleCo-exampleApp-1.0'
blogger_service.service = 'blogger'
blogger_service.account_type = 'GOOGLE'
blogger_service.server = 'www.blogger.com'
blogger_service.ProgrammaticLogin()

Im Snippet oben haben wir drei Attribute für die Instanz GDataService festgelegt. Der erste ist der Name unserer Anwendung im Format companyName-applicationName-versionID. Der zweite ist der Name des Dienstes, mit dem wir interagieren möchten. Der dritte ist die Adresse des Servers.

Beachten Sie, dass account_type explizit auf GOOGLE gesetzt ist. Wenn Sie diesen Parameter nicht festlegen, können G Suite-Nutzer die Blogger API nicht verwenden.

Weitere Informationen zur ClientLogin-Authentifizierung, einschließlich Beispielanfragen und -antworten, finden Sie in der Dokumentation Authentifizierung für installierte Anwendungen.

Hinweis: Verwenden Sie für alle Anfragen in einer bestimmten Sitzung dasselbe Token. Erhalten Sie nicht für jede Blogger-Anfrage ein neues Token.

Hinweis: Wie in der ClientLogin-Dokumentation beschrieben, schlägt die Authentifizierungsanfrage möglicherweise fehl und fordert ein CAPTCHA an. Wenn Google die CAPTCHA-Abfrage ausstellen und verarbeiten soll, leite den Nutzer an https://www.google.com/accounts/DisplayUnlockCaptcha?service=blogger weiter anstatt zur in der ClientLogin-Dokumentation angegebenen CAPTCHA-Verarbeitungs-URL.

Liste von Blogs abrufen

Die Blogger Data API bietet einen Feed, in dem die Blogs eines bestimmten Nutzers aufgelistet werden. Dieser Feed wird als Metametafeed bezeichnet.

Im folgenden Beispielcode wird eine authentifizierte GDataService-Instanz verwendet, um den Metafeed abzurufen. Anschließend wird der Titel jedes Blogs ausgegeben.

def PrintUserBlogTitles(blogger_service):
  query = service.Query()
  query.feed = '/feeds/default/blogs'
  feed = blogger_service.Get(query.ToUri())

  print feed.title.text
  for entry in feed.entry:
    print "\t" + entry.title.text

Notieren Sie sich die von der Methode Get verwendete URL. Dies ist die Standard-Metafeed-URL. Sie gibt eine Liste von Blogs für den aktuell authentifizierten Nutzer zurück. Um auf einen Feed für einen anderen Nutzer zuzugreifen, können Sie die ID des Nutzers anstelle von default in der Meta-Feed-URL angeben. Die ID des Nutzers ist die Ziffernfolge am Ende der Profil-URL des Nutzers.

Das folgende Code-Snippet zeigt, wie eine Blog-ID aus dem Feed extrahiert wird. Zum Erstellen, Aktualisieren und Löschen von Beiträgen und Kommentaren benötigen Sie die Blog-ID. Mit dem folgenden Snippet wird der erste für einen Nutzer abgerufene Blog ausgewählt.

blog_id = feed.entry[0].GetSelfLink().href.split("/")[-1]

Im Beispiel BloggerExample.py wird die Klasse BloggerExample erstellt und die Blog-ID wird im Konstruktor für den einfachen Zugriff später festgelegt. Für die meisten der folgenden Beispiele in diesem Dokument wird blog_id als Variable übergeben.

Beiträge erstellen

Mit der Blogger Data API können Sie sowohl neue Blogeinträge als auch Entwürfe erstellen und veröffentlichen.

Hinweis: Das Festlegen eines benutzerdefinierten Autors für Beiträge wird derzeit nicht unterstützt. Alle neuen Beiträge sehen so aus, als wären sie vom derzeit authentifizierten Nutzer erstellt worden.

Blogpost veröffentlichen

Sie können die Python-Clientbibliothek verwenden, um neue Blogeinträge zu veröffentlichen.

Erstellen Sie zuerst eine GDataEntry-Instanz für den Blogpost. Anschließend können Sie den Titel, den Inhalt und andere Attribute des Blogposts festlegen. Verwenden Sie schließlich die Instanz GDataService, um den Beitrag einzufügen. Hier ein Beispiel für die Veröffentlichung eines neuen Blogposts:

def CreatePublicPost(blogger_service, blog_id, title, content):
  entry = gdata.GDataEntry()
  entry.title = atom.Title('xhtml', title)
  entry.content = atom.Content(content_type='html', text=content)
  return blogger_service.Post(entry, '/feeds/%s/posts/default' % blog_id)

blogEntry = CreatePublicPost(blogger_service, blog_id,
    title='I have the answer', content='Eureka! It is 42!')

Blogpostentwurf erstellen

Entwürfe werden auf die gleiche Weise wie öffentliche Beiträge erstellt. Sie müssen jedoch das Erweiterungselement draft in der Instanz GDataEntry festlegen. Der obige Blogpost könnte durch Hinzufügen der hervorgehobenen Zeilen als Entwurf erstellt werden:

def CreateDraftPost(blogger_service, blog_id, title, content):
  entry = gdata.GDataEntry()
  entry.title = atom.Title('xhtml', title)
  entry.content = atom.Content(content_type='html', text=content)

  control = atom.Control()
  control.draft = atom.Draft(text='yes')
  entry.control = control

  return blogger_service.Post(entry, '/feeds/%s/posts/default' % blog_id)

draftEntry = CreateDraftPost(blogger_service, blog_id,
    title='I have the question',
    content='What do you get if you multiply six by nine?')

Du kannst einen vorhandenen Blogpost in einen veröffentlichten Beitrag umwandeln. Rufe dazu den Entwurfsbeitrag ab, setze das Entwurfsattribut auf no und aktualisiere dann den Beitrag. In den nächsten beiden Abschnitten geht es um das Abrufen und Aktualisieren von Beiträgen.

Beiträge werden abgerufen

In den folgenden Abschnitten wird beschrieben, wie Sie eine Liste von Blogposts mit und ohne Suchparameter abrufen.

Sie können einen öffentlichen Blogger-Feed ohne Authentifizierung abfragen. Sie müssen daher vor dem Abrufen von Beiträgen aus einem öffentlichen Blog keine Anmeldedaten festlegen oder eine AuthSub-Authentifizierung durchführen.

Alle Blogposts werden abgerufen

Um die Beiträge des Nutzers abzurufen, rufen Sie die Methode GetFeed mit der Blogpost-Feed-URL auf:

def PrintAllPosts(blogger_service, blog_id):
  feed = blogger_service.GetFeed('/feeds/' + blog_id + '/posts/default')

  print feed.title.text
  for entry in feed.entry:
    print "\t" + entry.title.text
    print "\t" + entry.content.text
    print "\t" + entry.updated.text
  print

Beiträge mit Suchparametern abrufen

Mit der Blogger Data API können Sie eine Reihe von Einträgen anfordern, die bestimmten Kriterien entsprechen, z. B. das Anfordern von Blogposts, die in einem bestimmten Zeitraum veröffentlicht oder aktualisiert wurden. Dazu erstellen Sie eine Query-Instanz und rufen dann die Methode Get() auf.

Wenn Sie beispielsweise eine Zeitraumabfrage senden möchten, legen Sie die Attribute published_min und published_min der Instanz Query fest. Das folgende Code-Snippet gibt den Titel und Inhalt jedes Blogposts aus, der zwischen dem angegebenen Start- und Enddatum veröffentlicht wurde:

def PrintPostsInDateRange(blogger_service, blog_id, start_time='2007-04-01', end_time='2007-04-25'):
  query = service.Query()
  query.feed = '/feeds/' + blog_id + '/posts/default'
  query.published_min = start_time
  query.published_max = end_time
  feed = blogger_service.Get(query.ToUri())

  print feed.title.text + " posts between " + start_time + " and " + end_time
  for entry in feed.entry:
    print "\t" + entry.title.text
    print "\t" + entry.content.text
    print "\t" + entry.updated.text
  print

Das Objekt Query wird mit derselben Postfeed-URL erstellt, die zum Abrufen von Beiträgen verwendet wurde.

Die Blogger Data API unterstützt die folgenden Query-Properties:

Kategorien: Gibt Kategorien an (auch Labels genannt), um die Feedergebnisse zu filtern. http://www.blogger.com/feeds/blogID/posts/default/-/Fritz/Laurie gibt beispielsweise Einträge mit den Labels Fritz und Laurie zurück. Wenn Sie diese Kategorieabfrage in der Python-Clientbibliothek angeben möchten, können Sie query.categories = ['Fritz','Laurie',] verwenden
max_results: Die maximale Anzahl der Einträge, die zurückgegeben werden sollen.
Veröffentlicht_min, veröffentlicht_max: Die Grenzen des Veröffentlichungsdatums des Eintrags.
start_index: Der 1-basierte Index des ersten abzurufenden Ergebnisses (für die Seitenordnung).
aktualisiert_min, aktualisiert_max: Die Grenzen für die Datumsaktualisierung. Diese Suchparameter werden ignoriert, sofern der Parameter orderby nicht auf updated gesetzt ist.

Weitere Informationen zu Suchparametern findest du im Referenzleitfaden für die Blogger Data API und im Referenzhandbuch für Google Data APIs.

Beiträge werden aktualisiert

Zum Aktualisieren eines vorhandenen Blogposts rufen Sie zuerst den Eintrag ab, den Sie aktualisieren möchten. Dann ändern Sie ihn und senden ihn dann mithilfe der Methode Put an Blogger. Das folgende Code-Snippet ändert den Titel eines Blogeintrags unter der Annahme, dass du den Eintrag bereits vom Server abgerufen hast.

def UpdatePostTitle(blogger_service, entry_to_update, new_title='The REAL answer'):
  entry_to_update.title = atom.Title('xhtml', new_title)
  return blogger_service.Put(entry_to_update, entry_to_update.GetEditLink().href)

Der obige Code gibt ein GDataEntry zurück, das den gesamten aktualisierten Beitrag enthält. Wenn Sie andere Attribute aktualisieren möchten, legen Sie diese einfach in der Instanz GDataEntry fest, bevor Sie Put aufrufen.

Hinweis: Das Ändern von mit Beiträgen verknüpften Autorendaten wird derzeit nicht unterstützt.

Beiträge löschen

Wenn Sie einen Beitrag löschen möchten, übergeben Sie die Bearbeitungs-URL des Beitrags an die Methode Delete Ihres GDataService-Objekts. Das sieht dann so aus:

def DeletePost(blogger_service, edit_link_href):
  blogger_service.Delete(edit_link_href)

Kommentare

Mit der Blogger Data API können Sie Kommentare erstellen, abrufen und löschen. Das Aktualisieren von Kommentaren wird weder unterstützt noch in der Weboberfläche verfügbar.

Kommentare erstellen

Wenn Sie einen Kommentar posten möchten, erstellen Sie ein GDataEntry-Objekt und fügen Sie es so ein:

def CreateComment(blogger_service, blog_id, post_id, comment_text='Mostly harmless'):
  feed_uri = '/feeds/' + blog_id + '/' + post_id + '/comments/default'

  entry = gdata.GDataEntry()
  entry.content = atom.Content(content_type='xhtml', text=comment_text)
  return blogger_service.Post(entry, feed_uri)

Hinweis: Derzeit können Sie in einem Blog nur Kommentare veröffentlichen, deren Inhaber der authentifizierte Nutzer ist.

Hinweis: Das Festlegen eines benutzerdefinierten Autors für Kommentare wird derzeit nicht unterstützt. Alle neuen Kommentare werden so angezeigt, als wären sie vom derzeit authentifizierten Nutzer erstellt worden.

Kommentare werden abgerufen

So kannst du die Kommentare für einen bestimmten Beitrag über die Feed-URL des Beitrags abrufen:

def PrintAllComments(blogger_service, blog_id, post_id):
  feed_url = '/feeds/' + blog_id + '/' + post_id + '/comments/default'
  feed = blogger_service.Get(feed_url)

  print feed.title.text
  for entry in feed.entry:
    print "\t" + entry.title.text
    print "\t" + entry.updated.text
  print

Du kannst auch die Kommentare zu allen Beiträgen über die Kommentar-Feed-URL des Blogs abrufen:

http://www.blogger.com/feeds/blogID/comments/default

Kommentare löschen

Übergib den Bearbeitungs-URL des Kommentars an die Methode Delete deines GDataService-Objekts, um einen Kommentar zu löschen:

def DeleteComment(blogger_service, post_id, comment_id):
  feed_url = '/feeds/' + post_id + '/comments/default/' + comment_id
  blogger_service.Delete(feed_url)

Nach oben