Un projet Python en 30 lignes de code: comment mettre en place une notification SMS lorsque votre Twitcher préféré est en streaming

Salut à tous :) Aujourd'hui, je commence une nouvelle série d'articles destinés spécifiquement aux débutants en Python. Le concept est assez simple: je vais faire un projet amusant, en aussi peu de lignes de code que possible, et essayer autant de nouveaux outils que possible.

Par exemple, aujourd'hui, nous allons apprendre à utiliser l'API Twilio, l'API Twitch, et nous verrons comment déployer le projet sur Heroku. Je vais vous montrer comment vous pouvez avoir votre propre notification SMS "Twitch Live", en 30 lignes de codes et pour 12 cents par mois.

Prérequis : il vous suffit de savoir comment exécuter Python sur votre machine et quelques commandes de base dans git (commit & push). Si vous avez besoin d'aide, je peux vous recommander ces 2 articles:

Guide d'installation et de configuration de Python 3

Le didacticiel ultime de la commande Git pour les débutants d'Adrian Hajdin.

Ce que vous apprendrez :

  • API Twitch
  • API Twilio
  • Déploiement sur Heroku
  • Configurer un planificateur sur Heroku

Ce que vous allez construire:

Les spécifications sont simples: nous souhaitons recevoir un SMS dès qu'un Twitcher spécifique est diffusé en direct. Nous voulons savoir quand cette personne sera mise en ligne et quand elle quittera le streaming. Nous voulons que tout cela fonctionne par lui-même, toute la journée.

Nous allons diviser le projet en 3 parties. Tout d'abord, nous verrons comment savoir par programmation si un Twitcher particulier est en ligne. Ensuite, nous verrons comment recevoir un SMS lorsque cela se produit. Nous finirons par voir comment faire fonctionner ce morceau de code toutes les X minutes, pour ne jamais manquer un autre moment de la vie de notre streamer préféré.

Est-ce Twitcher en direct?

Pour savoir si un Twitcher est en direct, on peut faire deux choses: on peut aller sur l'URL de Twitcher et essayer de voir si le badge "Live" est là.

Ce processus implique du scraping et n'est pas facilement réalisable en Python en moins de 20 lignes de code. Twitch exécute beaucoup de code JS et un simple request.get () ne suffira pas.

Pour que le scraping fonctionne, dans ce cas, nous aurions besoin de gratter cette page dans Chrome pour obtenir le même contenu que celui que vous voyez dans la capture d'écran. C'est faisable, mais cela prendra bien plus de 30 lignes de code. Si vous souhaitez en savoir plus, n'hésitez pas à consulter mon récent scraping Web sans bloquer le guide. (J'ai récemment lancé ScrapingBee, un outil de web-scraping d'où mes connaissances dans le domaine;))

Donc, au lieu d'essayer de gratter Twitch, nous utiliserons leur API. Pour ceux qui ne connaissent pas le terme, une API est une interface programmatique qui permet aux sites Web d'exposer leurs fonctionnalités et leurs données à n'importe qui, principalement aux développeurs. Dans le cas de Twitch, leur API est exposée via HTTP, ce qui signifie que nous pouvons avoir beaucoup d'informations et faire beaucoup de choses en faisant simplement une simple requête HTTP.

Obtenez votre clé API

Pour ce faire, vous devez d'abord créer une clé API Twitch. De nombreux services appliquent l'authentification pour leurs API pour s'assurer que personne n'en abuse ou pour restreindre l'accès à certaines fonctionnalités par certaines personnes.

Veuillez suivre ces étapes pour obtenir votre clé API:

  • Créez un compte Twitch
  • Créez maintenant un compte de développement Twitch -> «S'inscrire avec Twitch» en haut à droite
  • Accédez à votre "tableau de bord" une fois connecté
  • "Enregistrez votre candidature"
  • Nom -> Quoi qu'il en soit, URL de redirection Oauth -> // localhost, Catégorie -> Quoi qu'il en soit

Vous devriez maintenant voir, en bas de votre écran, votre identifiant client. Gardez ceci pour plus tard.

Est-ce que Twitcher est en streaming maintenant?

Avec votre clé API en main, nous pouvons maintenant interroger l'API Twitch pour avoir les informations que nous voulons, alors commençons à coder. L'extrait suivant utilise simplement l'API Twitch avec les paramètres corrects et imprime la réponse.

# requests is the go to package in python to make http request # //2.python-requests.org/en/master/ import requests # This is one of the route where Twich expose data, # They have many more: //dev.twitch.tv/docs endpoint = "//api.twitch.tv/helix/streams?" # In order to authenticate we need to pass our api key through header headers = {"Client-ID": ""} # The previously set endpoint needs some parameter, here, the Twitcher we want to follow # Disclaimer, I don't even know who this is, but he was the first one on Twich to have a live stream so I could have nice examples params = {"user_login": "Solary"} # It is now time to make the actual request response = request.get(endpoint, params=params, headers=headers) print(response.json())

La sortie devrait ressembler à ceci:

{ 'data':[ { 'id':'35289543872', 'user_id':'174955366', 'user_name':'Solary', 'game_id':'21779', 'type':'live', 'title':"Wakz duoQ w/ Tioo - GM 400LP - On récupère le chall après les -250LP d'inactivité !", 'viewer_count':4073, 'started_at':'2019-08-14T07:01:59Z', 'language':'fr', 'thumbnail_url':'//static-cdn.jtvnw.net/previews-ttv/live_user_solary-{width}x{height}.jpg', 'tag_ids':[ '6f655045-9989-4ef7-8f85-1edcec42d648' ] } ], 'pagination':{ 'cursor':'eyJiIjpudWxsLCJhIjp7Ik9mZnNldCI6MX19' } }

Ce format de données s'appelle JSON et est facilement lisible. L' dataobjet est un tableau qui contient tous les flux actuellement actifs. La clé typegarantit que le flux est actuellement live. Cette clé sera vide dans le cas contraire (en cas d'erreur, par exemple).

Donc, si nous voulons créer une variable booléenne en Python qui stocke si l'utilisateur actuel est en streaming, tout ce que nous avons à ajouter à notre code est:

json_response = response.json() # We get only streams streams = json_response.get('data', []) # We create a small function, (a lambda), that tests if a stream is live or not is_active = lambda stream: stream.get('type') == 'live' # We filter our array of streams with this function so we only keep streams that are active streams_active = filter(is_active, streams) # any returns True if streams_active has at least one element, else False at_least_one_stream_active = any(streams_active) print(at_least_one_stream_active)

À ce stade, at_least_one_stream_activeest True lorsque votre Twitcher préféré est en direct.

Voyons maintenant comment être notifié par SMS.

Envoyez-moi un texto, MAINTENANT!

Donc, pour nous envoyer un SMS, nous utiliserons l'API Twilio. Allez-y et créez un compte. Lorsqu'on vous demande de confirmer votre numéro de téléphone, veuillez utiliser le numéro de téléphone que vous souhaitez utiliser dans ce projet. De cette façon, vous pourrez utiliser les 15 $ de crédit gratuit que Twilio offre aux nouveaux utilisateurs. À environ 1 centime par texte, cela devrait suffire à votre bot pour fonctionner pendant un an.

Si vous allez sur la console, vous verrez votre Account SIDet votre Auth Token, enregistrez-les pour plus tard. Cliquez également sur le gros bouton rouge "Obtenir mon numéro d'essai", suivez les étapes et enregistrez celui-ci pour plus tard également.

Envoyer un texte avec l'API Twilio Python est très simple, car ils fournissent un package qui fait les choses ennuyeuses pour vous. Installez le package avec pip install Twilioet faites simplement:

from twilio.rest import Client client = Client(, ) client.messages.create( body="Test MSG",from_=,to=) 

Et c'est tout ce dont vous avez besoin pour vous envoyer un SMS, incroyable non?

Tout rassembler

Nous allons maintenant tout rassembler, et raccourcir un peu le code pour que nous arrivions à dire moins de 30 lignes de code Python.

import requests from twilio.rest import Client endpoint = "//api.twitch.tv/helix/streams?" headers = {"Client-ID": ""} params = {"user_login": "Solary"} response = request.get(endpoint, params=params, headers=headers) json_response = response.json() streams = json_response.get('data', []) is_active = lambda stream:stream.get('type') == 'live' streams_active = filter(is_active, streams) at_least_one_stream_active = any(streams_active) if at_least_one_stream_active: client = Client(, ) client.messages.create(body='LIVE !!!',from_=,to=)

Éviter les doubles notifications

Cet extrait fonctionne très bien, mais si cet extrait s'exécute toutes les minutes sur un serveur, dès que notre Twitcher préféré sera mis en ligne, nous recevrons un SMS toutes les minutes.

We need a way to store the fact that we were already notified that our Twitcher is live and that we don't need to be notified anymore.

The good thing with the Twilio API is that it offers a way to retrieve our message history, so we just have to retrieve the last SMS we sent to see if we already sent a text notifying us that the twitcher is live.

Here what we are going do to in pseudocode:

if favorite_twitcher_live and last_sent_sms is not live_notification: send_live_notification() if not favorite_twitcher_live and last_sent_sms is live_notification: send_live_is_over_notification()

This way we will receive a text as soon as the stream starts, as well as when it is over. This way we won't get spammed - perfect right? Let's code it:

# reusing our Twilio client last_messages_sent = client.messages.list(limit=1) last_message_id = last_messages_sent[0].sid last_message_data = client.messages(last_message_id).fetch() last_message_content = last_message_data.body

Let's now put everything together again:

import requests from twilio.rest import Client client = Client(, ) endpoint = "//api.twitch.tv/helix/streams?" headers = {"Client-ID": ""} params = {"user_login": "Solary"} response = request.get(endpoint, params=params, headers=headers) json_response = response.json() streams = json_response.get('data', []) is_active = lambda stream:stream.get('type') == 'live' streams_active = filter(is_active, streams) at_least_one_stream_active = any(streams_active) last_messages_sent = client.messages.list(limit=1) if last_messages_sent: last_message_id = last_messages_sent[0].sid last_message_data = client.messages(last_message_id).fetch() last_message_content = last_message_data.body online_notified = "LIVE" in last_message_content offline_notified = not online_notified else: online_notified, offline_notified = False, False if at_least_one_stream_active and not online_notified: client.messages.create(body='LIVE !!!',from_=,to=) if not at_least_one_stream_active and not offline_notified: client.messages.create(body='OFFLINE !!!',from_=,to=)

And voilà!

You now have a snippet of code, in less than 30 lines of Python, that will send you a text a soon as your favourite Twitcher goes Online / Offline and without spamming you.

We just now need a way to host and run this snippet every X minutes.

The quest for a host

To host and run this snippet we will use Heroku. Heroku is honestly one of the easiest ways to host an app on the web. The downside is that it is really expensive compared to other solutions out there. Fortunately for us, they have a generous free plan that will allow us to do what we want for almost nothing.

If you don't already, you need to create a Heroku account. You also need to download and install the Heroku client.

You now have to move your Python script to its own folder, don't forget to add a requirements.txt file in it. The content of the latter begins:

requests twilio

cd into this folder and just do a `heroku create --app `.

If you go on your app dashboard you'll see your new app.

We now need to initialize a git repo and push the code on Heroku:

git init heroku git:remote -a  git add . git commit -am 'Deploy breakthrough script' git push heroku master

Your app is now on Heroku, but it is not doing anything. Since this little script can't accept HTTP requests, going to .herokuapp.com won't do anything. But that should not be a problem.

To have this script running 24/7 we need to use a simple Heroku add-on call "Heroku Scheduler". To install this add-on, click on the "Configure Add-ons" button on your app dashboard.

Then, on the search bar, look for Heroku Scheduler:

Click on the result, and click on "Provision"

If you go back to your App dashboard, you'll see the add-on:

Click on the "Heroku Scheduler" link to configure a job. Then click on "Create Job". Here select "10 minutes", and for run command select `python .py`. Click on "Save job".

While everything we used so far on Heroku is free, the Heroku Scheduler will run the job on the $25/month instance, but prorated to the second. Since this script approximately takes 3 seconds to run, for this script to run every 10 minutes you should just have to spend 12 cents a month.

Ideas for improvements

I hope you liked this project and that you had fun putting it into place. In less than 30 lines of code, we did a lot, but this whole thing is far from perfect. Here are a few ideas to improve it:

  • Send yourself more information about the current streaming (game played, number of viewers ...)
  • Send yourself the duration of the last stream once the twitcher goes offline
  • Don't send you a text, but rather an email
  • Monitor multiple twitchers at the same time

Do not hesitate to tell me in the comments if you have more ideas.

Conclusion

I hope that you liked this post and that you learned things reading it. I truly believe that this kind of project is one of the best ways to learn new tools and concepts, I recently launched a web scraping API where I learned a lot while making it.

Please tell me in the comments if you liked this format and if you want to do more.

I have many other ideas, and I hope you will like them. Do not hesitate to share what other things you build with this snippet, possibilities are endless.

Happy Coding.

Pierre

Don't want to miss my next post:

You can subscribe here to my newsletter.