Python projekts 30 koda rindiņās: kā iestatīt SMS paziņojumu, kad jūsu iecienītākais Twitcher straumē

Sveiki visiem :) Šodien es sāku jaunu ierakstu sēriju, kas īpaši paredzēta Python iesācējiem. Koncepcija ir diezgan vienkārša: es izpildīšu jautru projektu pēc iespējas mazāk koda rindiņās un izmēģināšu pēc iespējas vairāk jaunu rīku.

Piemēram, šodien mēs iemācīsimies izmantot Twilio API, Twitch API un redzēsim, kā projektu izvietot Heroku. Es jums parādīšu, kā jums var būt savs "Twitch Live" īsziņu paziņotājs 30 kodu rindiņās un par 12 centiem mēnesī.

Priekšnosacījums : jums jāzina tikai tas, kā darbināt Python savā datorā, un dažas pamata komandas git (izdarīt un virzīt). Ja jums nepieciešama palīdzība, es jums varu ieteikt šos 2 rakstus:

Python 3 instalēšanas un iestatīšanas rokasgrāmata

Adriana Hadina galīgā Git komandu apmācība iesācējiem.

Ko jūs uzzināsiet :

  • Twitch API
  • Twilio API
  • Izvietojot Heroku
  • Plānotāja iestatīšana Heroku

Ko jūs veidosiet:

Specifikācijas ir vienkāršas: mēs vēlamies saņemt īsziņu, tiklīdz konkrēts Twitcher straumē tiešraidē. Mēs vēlamies uzzināt, kad šī persona dzīvo tiešraidē un kad aiziet no straumēšanas. Mēs vēlamies, lai visa šī lieta visu dienu darbotos pati no sevis.

Mēs sadalīsim projektu 3 daļās. Pirmkārt, mēs redzēsim, kā programmatiski uzzināt, vai konkrētais Twitcher ir tiešsaistē. Tad mēs redzēsim, kā saņemt SMS, kad tas notiks. Mēs pabeigsim, redzot, kā padarīt šo koda fragmentu palaist ik pēc X minūtēm, tāpēc mēs nekad nepalaidīsim garām nevienu mirkli no mūsu iecienītākās straumētāja dzīves.

Vai šis Twitcher dzīvo?

Lai uzzinātu, vai Twitcher darbojas tiešsaistē, mēs varam darīt divas lietas: mēs varam pāriet uz Twitcher URL un mēģināt noskaidrot, vai tur ir emblēma "Live".

Šis process ir saistīts ar nokasīšanu un nav viegli izpildāms Python ar mazāk nekā 20 koda rindiņām. Twitch palaiž daudz JS koda un nepietiek ar vienkāršu request.get ().

Lai nokasīšana darbotos, šajā gadījumā mums vajadzētu nokasīt šo lapu pārlūkā Chrome, lai iegūtu tādu pašu saturu kā ekrānuzņēmumā redzamais. Tas ir izdarāms, taču tas prasīs daudz vairāk nekā 30 koda rindas. Ja vēlaties uzzināt vairāk, nevilcinieties pārbaudīt manu neseno tīmekļa nokasīšanu, nesaņemot bloķētu ceļvedi. (Nesen es palaidu tīmekļa skrāpēšanas rīku ScrapingBee, tāpēc manas zināšanas šajā jomā;))

Tāpēc tā vietā, lai mēģinātu nokasīt Twitch, mēs izmantosim viņu API. Tiem, kas šo terminu nepārzina, API ir programmatiska saskarne, kas ļauj vietnēm atklāt savas funkcijas un datus ikvienam, galvenokārt izstrādātājiem. Twitch gadījumā viņu API tiek pakļauta, izmantojot HTTP, ragana nozīmē, ka mums var būt daudz informācijas un paveikt daudzas lietas, vienkārši veicot vienkāršu HTTP pieprasījumu.

Iegūstiet savu API atslēgu

Lai to izdarītu, vispirms jāizveido Twitch API atslēga. Daudzi pakalpojumi nodrošina savu API autentifikāciju, lai nodrošinātu, ka neviens tos ļaunprātīgi neizmanto, vai ierobežotu noteiktu cilvēku piekļuvi noteiktām funkcijām.

Lūdzu, rīkojieties šādi, lai iegūtu API atslēgu:

  • Izveidojiet Twitch kontu
  • Tagad izveidojiet Twitch dev kontu -> augšējā labajā stūrī "Pierakstīšanās ar Twitch"
  • Kad esat pieteicies, dodieties uz savu "informācijas paneli"
  • "Reģistrējiet savu pieteikumu"
  • Nosaukums -> Neatkarīgi, Oauth novirzīšanas URL -> // localhost, Category -> Whatever

Tagad ekrāna apakšdaļā jums vajadzētu redzēt savu klienta ID. Saglabājiet to vēlāk.

Vai tas Twitcher straumē tagad?

Ar jūsu API atslēgu rokā mēs tagad varam pieprasīt Twitch API, lai mums būtu vēlamā informācija, tāpēc sāksim kodēt. Šis fragments vienkārši patērē Twitch API ar pareizajiem parametriem un izdrukā atbildi.

# 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())

Izejai vajadzētu izskatīties šādi:

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

Šo datu formātu sauc par JSON un tas ir viegli lasāms. dataObjekts ir masīvs, kas satur visus šobrīd aktīvos plūsmas. Atslēga typenodrošina, ka straume pašlaik ir live. Pretējā gadījumā šī atslēga būs tukša (piemēram, kļūdas gadījumā).

Tātad, ja mēs vēlamies Python izveidot būla mainīgo, kas saglabā, vai pašreizējais lietotājs straumē, viss, kas mums jāpievieno mūsu kodam, ir:

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)

Šajā brīdī tā at_least_one_stream_activeir taisnība, kad jūsu mīļākais Twitcher ir tiešraidē.

Tagad redzēsim, kā saņemt paziņojumus ar īsziņu.

Sūti man īsziņu, TAGAD!

Tātad, lai nosūtītu tekstu sev, mēs izmantosim Twilio API. Vienkārši dodieties turp un izveidojiet kontu. Kad jums tiek lūgts apstiprināt savu tālruņa numuru, lūdzu, izmantojiet tālruņa numuru, kuru vēlaties izmantot šajā projektā. Tādā veidā jūs varēsiet izmantot Twilio piedāvāto bezmaksas kredītu 15 USD apmērā jauniem lietotājiem. Ar aptuveni 1 centu teksta vajadzētu būt pietiekamam, lai robots darbotos vienu gadu.

Ja dodaties uz konsoli, redzēsiet savu Account SIDun savējo Auth Token, saglabājiet tos vēlākam laikam. Noklikšķiniet arī uz lielās sarkanās pogas "Saņemt izmēģinājuma numuru", izpildiet norādīto darbību un saglabājiet šo arī vēlāk.

Teksta nosūtīšana, izmantojot Twilio Python API, ir ļoti vienkārša, jo tie nodrošina paketi, kas jums dara kaitinošas lietas. Instalējiet pakotni ar pip install Twilioun vienkārši rīkojieties šādi:

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

Un tas ir viss, kas jums nepieciešams, lai nosūtītu sev tekstu, vai ne?

Saliekot visu kopā

Tagad mēs visu saliksim un nedaudz saīsināsim kodu, lai mums izdotos pateikt zem 30 Python koda rindiņām.

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=)

Izvairīšanās no divkāršiem paziņojumiem

Šis fragments darbojas lieliski, bet, ja šis fragments palaist katru minūti serverī, tiklīdz mūsu iecienītākais Twitcher tiks publicēts, mēs katru minūti saņemsim īsziņu.

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

Es ceru, ka jums patika šis ieraksts un jūs uzzinājāt lietas, lasot to. Es patiesi uzskatu, ka šāda veida projekts ir viens no labākajiem veidiem, kā apgūt jaunus rīkus un koncepcijas, es nesen uzsāku tīmekļa skrāpēšanas API, kur daudz uzzināju, to darot.

Lūdzu, pastāstiet man komentāros, vai jums patika šis formāts un vai vēlaties darīt vairāk.

Man ir daudz citu ideju, un es ceru, ka jums tās patiks. Nevilcinieties dalīties ar to, ko vēl jūs veidojat ar šo fragmentu, iespējas ir bezgalīgas.

Laimīgu kodēšanu.

Pjērs

Nevēlos palaist garām manu nākamo ziņu:

Šeit jūs varat abonēt manu biļetenu.