En tant que pratique de Google App Engine / Python, nous allons créer un service BOT qui publie automatiquement les résultats du jeu appelé League of Legends sur Twitter. L'authentification Twitter utilise Tweepy qui prend en charge OAuth pour en faire un service que tout le monde peut enregistrer. L'enregistrement du jeu est obtenu à partir de l'API officielle RIOT. Le code source est exploité sur GitBucket, et le produit fini est exploité sur ici.
Les paramètres de l'application GAE / P sont écrits dans le langage yaml. app.yaml est un fichier qui décrit les paramètres de l'ensemble de l'application, comme AndroidManifest.xml sous Android. Décrivez également les paramètres de routage d'URL tels que urls.py dans Django. Étant donné que la version de l'application qui s'exécute réellement sur le serveur peut être facilement changée, si vous augmentez fréquemment la version lors du déploiement, vous n'aurez pas à paniquer en cas de problème.
app.yaml
application: example_app #Nom de l'application
version: 1
runtime: python27 #Python2.Utiliser 7
api_version: 1
threadsafe: true
handlers: #Décrire le routage des URL
- url: /hell
script: hell.app #hell.Appelez l'application de variable py
Cette fois, nous allons implémenter l'application en Python en utilisant webapp2.
hell.py
#! -*- coding: utf-8 -*-
import webapp2
class hellHandler(webapp2.RequestHandler): #Gestionnaire auquel le traitement est passé
def get(self): #Traitement de la méthode GET
self.response.out.write('Hell World!')
def post(self): #Traitement de la méthode POST
self.response.out.write('Postes Hell World!')
app = webapp2.WSGIApplication([ ('/hell', hellHandler) ]) #handlers:Appelez le gestionnaire à partir du chemin / de la variable spécifié dans
Allez sur `` http: // example_app.appspot.com / hell '' et vous devriez voir Hell World.
Pour utiliser Tweepy avec GAE, vous devez préparer votre propre environnement. Tout d'abord, téléchargez le dossier tweepy entier depuis GitHub et placez-le dans votre dossier de projet. Ensuite, puisque Tweepy utilise ssl, ajoutez la bibliothèque à utiliser dans app.yaml. Spécifiez également l'adresse de rappel et forcez la communication HTTPS pour assurer la sécurité.
app.yaml
application: example_app
version: 1
runtime: python27
api_version: 1
threadsafe: true
libraries: #Spécifiez la bibliothèque à utiliser
- name: ssl
version: latest
handlers:
- url: /
script: main.app
- url: /callback #Adresse de rappel
script: main.app
secure: always #Forcer la communication HTTPS
Ensuite, implémentons une application de test qui permet à l'utilisateur d'effectuer l'authentification OAuth et stocke la clé de jeton d'accès et la clé de jeton secret d'accès dans le magasin de données (base de données GAE). La conception du magasin de données est différente de celle d'un SGBDR général, mais comme il a un mappeur O / R de type Django, il n'a pas beaucoup de mal à utiliser le modèle d'une manière ou d'une autre.
main.py
#! -*- coding: utf-8 -*-
from google.appengine.ext import db
import webapp2, tweepy
#Clé client Twitter
CONSUMER_KEY = '********************'
CONSUMER_SECRET = '**************************************'
class modelUser(db.Model): #Définition de modèle pour stocker les informations de compte Twitter
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):
#Bouton de démarrage de l'authentification de sortie
self.response.out.write('<form method="POST" action="./"><button type="submit">Authentification</button></form>')
def post(self):
#Définir la clé du consommateur sur Tweepy
auth = tweepy.OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)
try:
redirect_url = auth.get_authorization_url() #Obtenir l'URL pour l'authentification OAuth
self.redirect(redirect_url) #Redirection vers l'URL pour l'authentification OAuth
except Exception as e:
self.response.out.write('Ella')
class callbackHandler(webapp2.RequestHandler):
def get(self):
auth = tweepy.OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)
try:
#Laissez Tweepy authentifier divers paramètres reçus
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) #Après cela, diverses informations peuvent être obtenues à partir de cet objet.
modeluser = modelUser().get_or_insert(str(api.me().id)) #Définir la clé de modèle sur l'ID interne Twitter
modeluser.twitter_name = api.me().screen_name #Twitter Id
modeluser.access_key = access_key #Clé de jeton d'accès
modeluser.access_secret = access_secret #Accéder à la clé de jeton secrète
modeluser.put() #Reflété dans la base de données
self.response.out.write('Achèvement de l'inscription')
except Exception as e:
self.response.out.write('Ella')
app = webapp2.WSGIApplication([ ('/', mainHandler), ('/callback', callbackHandler) ])
Le magasin de données a un attribut appelé clé, et il est pratique de définir la clé en utilisant get_or_insert ('unique value') '' lors de la création d'une entrée avec une valeur unique. De plus, la clé avec une valeur unique est récupérée avec key (). Name () '', et si aucune clé n'est spécifiée, un ID aléatoire est automatiquement attribué et key (). Obtenez l'ID avec id ().
RIOT API
Pour utiliser l'API RIOT, connectez-vous d'abord au Site des développeurs avec votre compte LoL. La limite du nombre de requêtes API y est spécifiée comme indiqué ci-dessous (à partir de février 2014).
―― 10 requêtes / 10 secondes --500 requêtes / 10 minutes
En d'autres termes, si l'intervalle de demande tombe en dessous de 1,2 seconde en moyenne, vous courez le risque d'être soumis à des limites de demande. Le temps le plus court pour un jeu de LoL est de 20 minutes qui peuvent être abandonnées (bien que cela puisse être plus rapide), et en théorie, 1000 utilisateurs sont le maximum pour orbiter le BOT sans délai. C'est assez.
Ensuite, utilisons réellement / api / lol / {region} /v1.3/summoner/by-name/ {summonerNames} pour obtenir les informations d'invocateur. Vous pouvez vérifier l'opération en entrant le nom de l'invocateur sur la page API sur le site des développeurs. Les données extraites de l'API sont renvoyées au format JSON. Cette fois, nous utiliserons le simplejson de django pour analyser le JSON, donc spécifiez d'abord django dans la bibliothèque.
app.yaml
application: example_app
version: 7
runtime: python27
api_version: 1
threadsafe: true
libraries:
- name: django
version: "1.4" #Spécifiez la version que vous connaissez
handlers:
- url: /registration
script: main.app
secure: always
Implémentez une application Web en Python qui renvoie un ID d'invocateur lorsque l'utilisateur entre un nom d'invocateur.
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): #Fonction d'acquisition d'identifiant d'invocateur
#Obtenir des informations sur l'invocateur de l'API
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:
#Passer à l'analyseur JSON et renvoyer l'ID et le nom
j = loads(result.content)[summoner_name.lower().replace(' ', '')]
return j['id'], j['name']
else:
return -1, None
class registrationHandler(webapp2.RequestHandler):
def get(self):
#Bouton de démarrage de l'acquisition de sortie
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">Avoir</button></form>')
def post(self):
try:
#Obtenez le nom et la région saisis
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'
#Appelez la fonction d'acquisition d'identifiant d'invocateur
summoner_id, summoner_name = getId(resion, summoner_name)
#Sortir le résultat
if summoner_id > 0:
self.response.out.write('ID d'invocateur:'+summoner_id+'Nom d'invocateur:'+summoner_name)
else:
self.response.out.write('Il n'y a pas d'invocateur, mais c'est')
return
except Exception as e:
self.response.out.write('Ella')
app = webapp2.WSGIApplication([ ('/registration', registrationHandler) ])
Ça va être long, je vais donc terminer la première partie ici. Dans la deuxième partie, je voudrais aborder la façon de transformer réellement le BOT en utilisant Queue, Backend, Cron et Memchache. → Partie 2 Je l'ai écrit!