Un proyecto de Python en 30 líneas de código: cómo configurar una notificación por SMS cuando tu Twitcher favorito está transmitiendo

Hola a todos :) Hoy comienzo una nueva serie de publicaciones dirigidas específicamente a los principiantes de Python. El concepto es bastante simple: haré un proyecto divertido, en la menor cantidad de líneas de código posible, y probaré tantas herramientas nuevas como sea posible.

Por ejemplo, hoy aprenderemos a usar la API de Twilio, la API de Twitch y veremos cómo implementar el proyecto en Heroku. Te mostraré cómo puedes tener tu propio notificador de SMS "Twitch Live", en 30 líneas de códigos y por 12 centavos al mes.

Requisito previo : solo necesita saber cómo ejecutar Python en su máquina y algunos comandos básicos en git (commit & push). Si necesita ayuda con estos, puedo recomendarle estos 2 artículos:

Guía de instalación y configuración de Python 3

El último tutorial de comandos de Git para principiantes de Adrian Hajdin.

Qué aprenderás :

  • API de Twitch
  • API de Twilio
  • Implementar en Heroku
  • Configurar un programador en Heroku

Qué vas a construir:

Las especificaciones son simples: queremos recibir un SMS tan pronto como un Twitcher específico esté transmitiendo en vivo. Queremos saber cuándo esta persona se transmitirá en vivo y cuándo dejará de transmitir. Queremos que todo esto funcione solo durante todo el día.

Dividiremos el proyecto en 3 partes. Primero, veremos cómo saber mediante programación si un Twitcher en particular está en línea. Luego veremos cómo recibir un SMS cuando esto suceda. Terminaremos viendo cómo hacer que este fragmento de código se ejecute cada X minutos, para que nunca nos perdamos un momento más de la vida de nuestro streamer favorito.

¿Este Twitcher está en vivo?

Para saber si un Twitcher está activo, podemos hacer dos cosas: podemos ir a la URL de Twitcher e intentar ver si la insignia "Live" está ahí.

Este proceso implica raspado y no es fácil de realizar en Python en menos de 20 líneas de código. Twitch ejecuta una gran cantidad de código JS y una simple request.get () no será suficiente.

Para que el scraping funcione, en este caso, necesitaríamos raspar esta página dentro de Chrome para obtener el mismo contenido que se ve en la captura de pantalla. Esto es factible, pero tomará mucho más de 30 líneas de código. Si desea obtener más información, no dude en consultar mi raspado web reciente sin que se bloquee la guía. (Recientemente lancé ScrapingBee, una herramienta de raspado web de ahí mi conocimiento en el campo;))

Entonces, en lugar de intentar eliminar Twitch, usaremos su API. Para aquellos que no estén familiarizados con el término, una API es una interfaz programática que permite a los sitios web exponer sus características y datos a cualquier persona, principalmente a los desarrolladores. En el caso de Twitch, su API está expuesta a través de HTTP, lo que significa que podemos tener mucha información y hacer muchas cosas con solo hacer una simple solicitud HTTP.

Obtenga su clave API

Para hacer esto, primero debe crear una clave API de Twitch. Muchos servicios imponen la autenticación de sus API para garantizar que nadie abuse de ellas o para restringir el acceso a determinadas funciones por parte de determinadas personas.

Siga estos pasos para obtener su clave API:

  • Crea una cuenta de Twitch
  • Ahora crea una cuenta de desarrollo de Twitch -> "Registrarse con Twitch" arriba a la derecha
  • Ve a tu "panel" una vez que hayas iniciado sesión
  • "Registre su solicitud"
  • Nombre -> Lo que sea, URL de redirección de Oauth -> // localhost, Categoría -> Lo que sea

Ahora debería ver, en la parte inferior de su pantalla, su identificación de cliente. Guárdelo para más tarde.

¿Ese Twitcher está transmitiendo ahora?

Con su clave API en la mano, ahora podemos consultar la API de Twitch para tener la información que queremos, así que comencemos a codificar. El siguiente fragmento solo consume la API de Twitch con los parámetros correctos e imprime la respuesta.

# 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 salida debería verse así:

{ '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' } }

Este formato de datos se llama JSON y es de fácil lectura. El dataobjeto es una matriz que contiene todos los flujos activos actualmente. La clave typeasegura que la transmisión esté actualmente live. De lo contrario, esta clave estará vacía (en caso de error, por ejemplo).

Entonces, si queremos crear una variable booleana en Python que almacene si el usuario actual está transmitiendo, todo lo que tenemos que agregar a nuestro código es:

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)

En este punto, at_least_one_stream_activees Verdadero cuando su Twitcher favorito está en vivo.

Veamos ahora cómo recibir notificaciones por SMS.

Envíame un mensaje de texto, ¡AHORA!

Entonces, para enviarnos un mensaje de texto, usaremos la API de Twilio. Simplemente vaya allí y cree una cuenta. Cuando se le solicite que confirme su número de teléfono, utilice el número de teléfono que desea utilizar en este proyecto. De esta forma podrá utilizar los $ 15 de crédito gratuito que Twilio ofrece a los nuevos usuarios. A alrededor de 1 centavo el texto, debería ser suficiente para que su bot se ejecute durante un año.

Si vas a la consola, verás tu Account SIDy tu Auth Token, guárdalos para más tarde. También haga clic en el botón rojo grande "Obtener mi número de prueba", siga el paso y guárdelo para más adelante.

Enviar un texto con la API de Twilio Python es muy fácil, ya que proporcionan un paquete que hace las cosas molestas por usted. Instale el paquete con pip install Twilioy simplemente haga:

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

Y eso es todo lo que necesitas para enviarte un mensaje de texto, ¿verdad?

Poniendo todo junto

Ahora juntaremos todo y acortaremos un poco el código para que podamos decir menos de 30 líneas de código 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=)

Evitando notificaciones dobles

Este fragmento funciona muy bien, pero si ese fragmento se ejecuta cada minuto en un servidor, tan pronto como nuestro Twitcher favorito se active, recibiremos un SMS cada minuto.

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.