Diese Seite wurde von der Cloud Translation API übersetzt.

Entwicklerhandbuch: Python

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

Mit der Blogger Data API können Sie in Ihrer Clientanwendung neue Blogbeiträge erstellen, vorhandene Blogbeiträge bearbeiten oder löschen und nach Blogbeiträgen suchen, die bestimmten Kriterien entsprechen.

Dieses Dokument enthält nicht nur einige Hintergrundinformationen zu den Funktionen der Blogger Data API, sondern auch Beispiele für grundlegende Data API-Interaktionen mit der Python-Clientbibliothek. Weitere Informationen zum zugrunde liegenden Protokoll, das von der Bibliothek verwendet wird, finden Sie im Abschnitt zum Protokoll dieses Entwicklerhandbuchs.

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 Konzepten des Google Data APIs-Protokolls vertraut sind.

Allgemeine Informationen zur Blogger Data API finden Sie im Referenzhandbuch für Protokolle.

Erste Schritte

Informationen zum Einrichten der Clientbibliothek finden Sie im Leitfaden für den Einstieg.

Für die Python-Clientbibliothek ist Python 2.2 oder höher erforderlich. Nachdem Sie die Clientbibliothek heruntergeladen haben, müssen Sie auch das ElementTree-Paket herunterladen und installieren.

Blogger-Konto erstellen

Sie können sich für Testzwecke für ein Blogger-Konto registrieren. Für Blogger werden Google-Konten verwendet. Wenn Sie also bereits ein Google-Konto haben, können Sie sofort loslegen.

Codebeispiel ausführen

Ein vollständiger, funktionierender Beispielclient mit dem gesamten in diesem Dokument gezeigten Beispielcode ist in der Datei BloggerExample.py im Verzeichnis gdata-python-client/samples/blogger/ verfügbar.

Der Beispielclient führt mehrere Vorgänge am angegebenen Blog 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

Beim Blogger-Dienst authentifizieren

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 nur lesbar. Wenn du Blogs ändern möchtest, muss sich dein Client authentifizieren, bevor er private Feeds anfordert. Es kann mit einem der drei folgenden Ansätze authentifiziert werden:OAuth-Authentifizierung, AuthSub-Proxy-Authentifizierung oder ClientLogin-Nutzername/Passwort-Authentifizierung.

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

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

Authentifizierung mit OAuth

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

AuthSub-Proxy-Authentifizierung

Die AuthSub-Proxy-Authentifizierung wird von Webanwendungen verwendet, die ihre Nutzer in Google-Konten authentifizieren müssen. Der Website-Betreiber und der Clientcode haben keinen Zugriff auf den Nutzernamen und das Passwort des Blogger-Nutzers. Stattdessen erhält der Client spezielle AuthSub-Tokens, mit denen er im Namen eines bestimmten Nutzers handeln kann. Weitere Informationen finden Sie in der AuthSub-Dokumentation.

Wenn ein Nutzer Ihre Anwendung zum ersten Mal besucht, wurde er noch nicht authentifiziert. In diesem Fall müssen Sie einige Informationen und einen Link anzeigen, über den der Nutzer zu einer Google-Seite weitergeleitet wird, um Ihre Anfrage auf Zugriff auf seine Blogs zu authentifizieren. Die Python-Clientbibliothek bietet eine Funktion zum Generieren der URL der Google-Seite. Im folgenden Code wird die URL der Seite „AuthSubRequest“ 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).
sicher: Gibt an, ob der Client ein sicheres Token anfordert.
Sitzung: Gibt an, ob das zurückgegebene Token gegen ein wiederverwendbares Sitzungstoken eingetauscht werden kann.

Das obige Beispiel zeigt einen Aufruf, bei dem kein sicheres Token angefordert wird (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 in seinem Google-Konto.

Nach der Authentifizierung des Nutzers leitet das AuthSub-System ihn an die URL weiter, die Sie im Abfrageparameter next der AuthSubRequest-URL angegeben haben. Das AuthSub-System hängt dieser URL ein Authentifizierungstoken als Wert des Abfrageparameters token an. Beispiel:

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

Es gibt mehrere Möglichkeiten, den Tokenwert aus der URL abzurufen, z. B.:

import cgi

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

Dieser Tokenwert stellt ein AuthSub-Token zur einmaligen Verwendung dar. Da in diesem Beispiel session = True angegeben wurde, kann dieses Token mit der Methode UpgradeToSessionToken gegen ein AuthSub-Sitzungstoken eingetauscht werden, wodurch der Dienst AuthSubSessionToken aufgerufen wird:

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

Sie übergeben also Ihr Einmaltoken an die UpgradeToSessionToken-Methode und die AuthSub-Schnittstelle gibt ein Sitzungstoken zurück.

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

ClientLogin-Nutzername/Passwort-Authentifizierung

Verwenden Sie die ClientLogin-Authentifizierung, wenn Ihr Client ein eigenständiger, für einen einzelnen Nutzer installierter Client ist (z. B. eine Desktopanwendung). Rufe dazu einfach die Methode ProgrammaticLogin() für deine GDataService-Instanz auf. Alle nachfolgenden Interaktionen mit Blogger werden dann 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 obigen Snippet legen wir drei Eigenschaften für die Instanz GDataService fest. 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, und der dritte ist die Adresse des Servers.

Beachten Sie, dass account_type explizit auf GOOGLE festgelegt 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 dasselbe Token für alle Anfragen in einer bestimmten Sitzung. Rufen Sie nicht für jede Blogger-Anfrage ein neues Token ab.

Hinweis: Wie in der ClientLogin-Dokumentation beschrieben, kann die Authentifizierungsanfrage fehlschlagen und ein CAPTCHA-Test angefordert werden. Wenn Google die CAPTCHA-Herausforderung stellen und verarbeiten soll, leite den Nutzer an https://www.google.com/accounts/DisplayUnlockCaptcha?service=blogger weiter (nicht an die in der ClientLogin-Dokumentation angegebene URL für die CAPTCHA-Verarbeitung).

Liste der Blogs abrufen

Die Blogger Data API stellt einen Feed bereit, in dem die Blogs eines bestimmten Nutzers aufgeführt sind. Dieser Feed wird als „Metafeed“ bezeichnet.

Im folgenden Beispielcode wird mit einer authentifizierten GDataService-Instanz der Metafeed abgerufen und dann 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 URL, die von der Methode Get verwendet wird. Das ist die Standard-Metafeed-URL. Sie gibt eine Liste der Blogs für den aktuell authentifizierten Nutzer zurück. Wenn du auf einen Feed für einen anderen Nutzer zugreifen möchtest, kannst du die ID des Nutzers anstelle von default in die Metafeed-URL einfügen. Die ID des Nutzers ist die Ziffernfolge am Ende der Profil-URL des Nutzers.

Im folgenden Code-Snippet wird gezeigt, wie eine Blog-ID aus dem Feed extrahiert wird. Sie benötigen die Blog-ID, um Beiträge und Kommentare zu erstellen, zu aktualisieren und zu löschen. Im folgenden Snippet wird der erste Blog ausgewählt, der für einen Nutzer abgerufen wird.

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

Im BloggerExample.py-Beispiel wird eine BloggerExample-Klasse erstellt und die Blog-ID wird im Konstruktor festgelegt, damit später leichter darauf zugegriffen werden kann. In den meisten der folgenden Beispiele in diesem Dokument wird blog_id als Variable übergeben.

Beiträge erstellen

Mit der Blogger Data API können Sie neue Blogbeiträge erstellen und veröffentlichen sowie Beitragsentwürfe erstellen.

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

Blogpost veröffentlichen

Mit der Python-Clientbibliothek können Sie neue Blogbeiträge veröffentlichen.

Erstellen Sie zuerst eine GDataEntry-Instanz, die den Blogpost darstellt. Anschließend können Sie den Titel, den Inhalt und andere Attribute des Blogposts festlegen. Fügen Sie den Beitrag abschließend mit der Instanz GDataService ein. 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!')

Einen Blogpost-Entwurf erstellen

Entwurfsbeiträge werden genauso erstellt wie öffentliche Beiträge. Sie müssen jedoch das Erweiterungselement draft in der Instanz GDataEntry festlegen. Der obige Blogpost könnte als Entwurf erstellt werden, indem die hervorgehobenen Zeilen hinzugefügt 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-Entwurf in einen veröffentlichten Post umwandeln, indem du den Entwurf abrufst, das Attribut „Entwurf“ auf no setzt und den Post dann aktualisierst. Im nächsten Abschnitt erfahren Sie, wie Sie Beiträge abrufen und aktualisieren.

Beiträge abrufen

In den folgenden Abschnitten wird beschrieben, wie Sie eine Liste von Blogbeiträgen mit und ohne Abfrageparameter abrufen.

Sie können einen öffentlichen Blogger-Feed ohne Authentifizierung abfragen. Daher müssen Sie keine Anmeldedaten festlegen oder eine AuthSub-Authentifizierung durchführen, bevor Sie Beiträge aus einem öffentlichen Blog abrufen.

Alle Blogbeiträge abrufen

Rufe die Methode GetFeed mit der URL des Blogpost-Feeds auf, um die Beiträge des Nutzers abzurufen:

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 mithilfe von Abfrageparametern abrufen

Mit der Blogger Data API können Sie eine Reihe von Einträgen anfordern, die bestimmten Kriterien entsprechen. So können Sie beispielsweise Blogbeiträge anfordern, die in einem bestimmten Zeitraum veröffentlicht oder aktualisiert wurden. Dazu erstellst du eine Query-Instanz und rufst dann die Methode Get() auf.

Wenn Sie beispielsweise eine Abfrage für einen bestimmten Zeitraum senden möchten, legen Sie die Attribute published_min und published_min der Instanz Query fest. Im folgenden Code-Snippet werden der Titel und der Inhalt jedes Blogposts ausgegeben, der zwischen dem angegebenen Start- und Endzeitpunkt 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 Query-Objekt wird mit derselben Postfeed-URL erstellt, die auch zum Abrufen von Beiträgen verwendet wird.

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

Kategorien: Gibt Kategorien (auch als Labels bezeichnet) an, um die Feedergebnisse zu filtern. Beispiel: http://www.blogger.com/feeds/blogID/posts/default/-/Fritz/Laurie gibt Einträge mit den Labels Fritz und Laurie zurück. Um diese Kategorieabfrage in der Python-Clientbibliothek anzugeben, können Sie query.categories = ['Fritz','Laurie',] verwenden.
max_results: Die maximale Anzahl der Einträge, die zurückgegeben werden sollen.
published_min, published_max: Die Grenzen für die Veröffentlichungsdaten von Einträgen.
start_index: Der Index (ab 1) des ersten Ergebnisses, das abgerufen werden soll (für die Paginierung).
updated_min, updated_max: Die Grenzen für die Datumsangaben der Eintragsaktualisierungen. Diese Abfrageparameter werden ignoriert, es sei denn, der Parameter orderby ist auf updated gesetzt.

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

Beiträge aktualisieren

Wenn Sie einen vorhandenen Blogpost aktualisieren möchten, rufen Sie zuerst den Eintrag ab, den Sie aktualisieren möchten, ändern ihn und senden Sie ihn dann mit der Methode Put an Blogger. Im folgenden Code-Snippet wird der Titel eines Blogposts geändert, vorausgesetzt, Sie haben den Eintrag bereits vom Server abgerufen.

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 eine GDataEntry zurück, die den gesamten neu aktualisierten Beitrag enthält. Wenn du andere Properties aktualisieren möchtest, musst du sie einfach in der GDataEntry-Instanz festlegen, bevor du Put aufrufst.

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

Beiträge löschen

Wenn du einen Beitrag löschen möchtest, übergebe die Bearbeitungs-URL des Beitrags an die Delete-Methode deines GDataService-Objekts. So gehts:

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

Kommentare

Mit der Blogger Data API können Kommentare erstellt, abgerufen und gelöscht werden. Das Aktualisieren von Kommentaren wird nicht unterstützt und ist auch nicht in der Weboberfläche verfügbar.

Kommentare erstellen

Wenn du einen Kommentar posten möchtest, erstelle ein GDataEntry-Objekt und füge 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 nur Kommentare in einem Blog posten, der dem authentifizierten Nutzer gehört.

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 aktuell authentifizierten Nutzer erstellt worden.

Kommentare abrufen

Du kannst die Kommentare zu einem bestimmten Beitrag über die URL des Kommentarfeeds 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

Alternativ können Sie die Kommentare zu allen Beiträgen über die Kommentarfeed-URL des Blogs abrufen:

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

Kommentare löschen

Wenn du einen Kommentar löschen möchtest, übergebe die Bearbeitungs-URL des Kommentars so an die Delete-Methode deines GDataService-Objekts:

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

Nach oben