In der Praxis von Google App Engine / Python erstellen wir einen BOT-Dienst, der die Ergebnisse des Spiels League of Legends automatisch auf Twitter veröffentlicht. Die Twitter-Authentifizierung verwendet Tweepy, das OAuth unterstützt, um es zu einem Dienst zu machen, den jeder registrieren kann. Die Spielaufzeichnung wird von der offiziellen RIOT-API abgerufen. Der Quellcode wird unter GitBucket und das fertige Produkt unter hier betrieben.
Die GAE / P-Anwendungseinstellungen sind in der Sprache yaml geschrieben. app.yaml ist eine Datei, die die Einstellungen der gesamten Anwendung beschreibt, z. B. AndroidManifest.xml in Android. Außerdem werden URL-Routing-Einstellungen wie urls.py in Django beschrieben. Da die Version der Anwendung, die tatsächlich auf dem Server ausgeführt wird, leicht gewechselt werden kann, müssen Sie bei Problemen nicht in Panik geraten, wenn Sie die Version bei der Bereitstellung häufig erhöhen.
app.yaml
application: example_app #Anwendungsname
version: 1
runtime: python27 #Python2.Verwenden Sie 7
api_version: 1
threadsafe: true
handlers: #Beschreiben des URL-Routings
- url: /hell
script: hell.app #hell.Rufen Sie die py variable App auf
Dieses Mal werden wir die Anwendung mit webapp2 in Python implementieren.
hell.py
#! -*- coding: utf-8 -*-
import webapp2
class hellHandler(webapp2.RequestHandler): #Handler, an den die Verarbeitung übergeben wird
def get(self): #Verarbeitung der GET-Methode
self.response.out.write('Hell World!')
def post(self): #Verarbeitung der POST-Methode
self.response.out.write('Postes Hell World!')
app = webapp2.WSGIApplication([ ('/hell', hellHandler) ]) #handlers:Rufen Sie den Handler über den in / angegebenen Pfad / die Variable auf
Gehen Sie zu `` `http: // example_app.appspot.com / hell``` und Sie sollten Hell World sehen.
Um Tweepy mit GAE verwenden zu können, müssen Sie Ihre eigene Umgebung vorbereiten. Laden Sie zunächst den gesamten Tweepy-Ordner von GitHub herunter und legen Sie ihn in Ihrem Projektordner ab. Da Tweepy ssl verwendet, fügen Sie als Nächstes die Bibliothek hinzu, die in app.yaml verwendet werden soll. Geben Sie außerdem die Rückrufadresse an und erzwingen Sie die HTTPS-Kommunikation, um die Sicherheit zu gewährleisten.
app.yaml
application: example_app
version: 1
runtime: python27
api_version: 1
threadsafe: true
libraries: #Geben Sie die zu verwendende Bibliothek an
- name: ssl
version: latest
handlers:
- url: /
script: main.app
- url: /callback #Rückrufadresse
script: main.app
secure: always #HTTPS-Kommunikation erzwingen
Als Nächstes implementieren wir eine Test-App, mit der der Benutzer die OAuth-Authentifizierung durchführen und den Zugriffstokenschlüssel und den geheimen Zugriffstokenschlüssel im Datenspeicher (GAE-Datenbank) speichern kann. Das Design des Datenspeichers unterscheidet sich von dem eines allgemeinen RDBMS, aber da es einen Django-ähnlichen O / R-Mapper hat, ist es nicht so schwierig, das Modell irgendwie zu verwenden.
main.py
#! -*- coding: utf-8 -*-
from google.appengine.ext import db
import webapp2, tweepy
#Twitter Consumer Key
CONSUMER_KEY = '********************'
CONSUMER_SECRET = '**************************************'
class modelUser(db.Model): #Modelldefinition zum Speichern von Twitter-Kontoinformationen
twitter_name = db.StringProperty()
access_key = db.StringProperty()
access_secret = db.StringProperty()
date = db.DateTimeProperty(auto_now_add=True)
class mainHandler(webapp2.RequestHandler):
def get(self):
#Startschaltfläche für die Ausgabeauthentifizierung
self.response.out.write('<form method="POST" action="./"><button type="submit">Authentifizierung</button></form>')
def post(self):
#Setzen Sie den Consumer-Schlüssel auf Tweepy
auth = tweepy.OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)
try:
redirect_url = auth.get_authorization_url() #URL für OAuth-Authentifizierung abrufen
self.redirect(redirect_url) #Zur OAuth-Authentifizierung zur URL umleiten
except Exception as e:
self.response.out.write('Ella')
class callbackHandler(webapp2.RequestHandler):
def get(self):
auth = tweepy.OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)
try:
#Lassen Sie Tweepy verschiedene empfangene Parameter authentifizieren
auth.set_request_token(self.request.get('oauth_token'), self.request.get('oauth_verifier'))
auth.get_access_token(self.request.get('oauth_verifier'))
access_key = auth.access_token.key
access_secret = auth.access_token.secret
auth.set_access_token(access_key, access_secret)
api = tweepy.API(auth) #Danach können verschiedene Informationen von diesem Objekt erhalten werden.
modeluser = modelUser().get_or_insert(str(api.me().id)) #Setzen Sie den Modellschlüssel auf die interne ID von Twitter
modeluser.twitter_name = api.me().screen_name #Twitter Id
modeluser.access_key = access_key #Zugriff auf Token-Schlüssel
modeluser.access_secret = access_secret #Greifen Sie auf den geheimen Token-Schlüssel zu
modeluser.put() #Reflektiert in der Datenbank
self.response.out.write('Abschluss der Registrierung')
except Exception as e:
self.response.out.write('Ella')
app = webapp2.WSGIApplication([ ('/', mainHandler), ('/callback', callbackHandler) ])
Der Datenspeicher verfügt über ein Attribut, das als Schlüssel bezeichnet wird, und es ist zweckmäßig, den Schlüssel mit get_or_insert (eindeutiger Wert) festzulegen, wenn ein Eintrag mit einem eindeutigen Wert erstellt wird. Außerdem wird der Schlüssel mit einem eindeutigen Wert mit `key (). Name ()` abgerufen. Wenn kein Schlüssel angegeben wird, wird automatisch eine zufällige ID und `key () zugewiesen. Holen Sie sich die ID mit id () `.
RIOT API
Um die RIOT-API zu verwenden, melden Sie sich zuerst mit Ihrem LoL-Konto bei der Developers Site an. Das Limit für die Anzahl der API-Anforderungen wird dort wie unten gezeigt angegeben (Stand Februar 2014).
―― 10 Anfragen / 10 Sekunden
Mit anderen Worten, wenn das Anforderungsintervall im Durchschnitt unter 1,2 Sekunden fällt, besteht das Risiko, dass Sie Anforderungslimits unterliegen. Die kürzeste Zeit für ein LoL-Spiel beträgt 20 Minuten, die aufgegeben werden können (obwohl sie möglicherweise schneller sind), und theoretisch können 1000 Benutzer den BOT ohne Verzögerung umkreisen. Das ist genug.
Als nächstes verwenden wir tatsächlich `/ api / lol / {region} /v1.3/summoner/by-name/ {summonerNames}`, um die Beschwörerinformationen abzurufen. Sie können den Vorgang überprüfen, indem Sie den Namen des Beschwörers auf der API-Seite der Entwicklerseite eingeben. Die von der API abgerufenen Daten werden im JSON-Format zurückgegeben. Dieses Mal verwenden wir djangos simplejson, um den JSON zu analysieren. Geben Sie also zuerst django in der Bibliothek an.
app.yaml
application: example_app
version: 7
runtime: python27
api_version: 1
threadsafe: true
libraries:
- name: django
version: "1.4" #Geben Sie die Version an, mit der Sie vertraut sind
handlers:
- url: /registration
script: main.app
secure: always
Implementieren Sie eine Web-App in Python, die eine Beschwörer-ID zurückgibt, wenn der Benutzer einen Beschwörernamen eingibt.
main.py
#! -*- coding: utf-8 -*-
from google.appengine.api.urlfetch import fetch
from django.utils.simplejson import loads
import webapp2
from urllib import quote
from time import mktime
from cgi import escape
from datetime import datetime
RIOT_KEY = '***********************************'
def getId(resion, summoner_name): #Funktion zur Erfassung der Beschwörer-ID
#Beschwörerinformationen von der API abrufen
result = fetch('https://prod.api.pvp.net/api/lol/'+resion+'/v1.3/summoner/by-name/'+quote(summoner_name)+'?api_key='+RIOT_KEY)
if result.status_code == 200:
#Übergeben Sie es an den JSON-Parser und geben Sie ID und Name zurück
j = loads(result.content)[summoner_name.lower().replace(' ', '')]
return j['id'], j['name']
else:
return -1, None
class registrationHandler(webapp2.RequestHandler):
def get(self):
#Starttaste für die Ausgabeerfassung
self.response.out.write('<form method="POST" action="./registration"><input type="radio" name="resion" value="1" checked="checked" />NA<input type="radio" name="resion" value="2" />EUW<input type="radio" name="resion" value="3" />EUNE<input type="text" name="summoner_name" /><button type="submit">Erhalten</button></form>')
def post(self):
try:
#Holen Sie sich den eingegebenen Namen und die Region
summoner_name = escape(self.request.get('summoner_name'))
if escape(self.request.get('resion')) == '1':
resion = 'na'
elif escape(self.request.get('resion')) == '2':
resion = 'euw'
elif escape(self.request.get('resion')) == '3':
resion = 'eune'
#Rufen Sie die Funktion zur Erfassung der Beschwörer-ID auf
summoner_id, summoner_name = getId(resion, summoner_name)
#Das Ergebnis ausgeben
if summoner_id > 0:
self.response.out.write('Beschwörer-ID:'+summoner_id+'Name des Beschwörers:'+summoner_name)
else:
self.response.out.write('Es gibt keinen Beschwörer, aber das ist')
return
except Exception as e:
self.response.out.write('Ella')
app = webapp2.WSGIApplication([ ('/registration', registrationHandler) ])
Es wird lange dauern, also werde ich den ersten Teil hier beenden. Im zweiten Teil möchte ich darauf eingehen, wie der BOT mithilfe von Queue, Backend, Cron und Memchache tatsächlich gedreht wird. → Teil 2 Ich habe es geschrieben!
Recommended Posts