Corona on Søren's Blog

I went to winter wonderland, and all I got was ...

Sun, 17 Dec 2023 11:00:00 +0100

… heavy snow fall, a week spent in the apartment, a Corona infection, but still nice family time.

I was really looking forward to this type. We went to the alps for a week (read here about the adventures train journey) with the intention to spend some quality time surrounded by snow.

I was so full of anticipation that I prepared a few paragraphs in advance that I wanted to use in the type. How we hiked through the snowy forest, how we went sledging, how we enjoyed the breathtaking views, and overall how beautiful everything was. But …

On the day we arrived, I got cold symptoms but didn’t think too much about it, because I did a Corona test before we left. The result was negative. The first few days passed by quickly, because there was heavy snow fall, causing the danger of avalanches to be „high“ (rank 4 out of 5) - and slopes to be closed for security. Looking out of the window you couldn’t see further than 10 meters. It was not what I expected but as I was having the cold symptoms it was a good excuse to stay in the apartment, drink a hot beverage and just relax.

Then one night, the baby got a fever. I tested again and this time, the result was positive. I brought the plague to my family ☹️ Luckily, the fever went down after one day and her mood increased - but this definitely was not how I imagined our first “skiing trip” to be. We thought about going back early, but since we came by train, this was not an option. My conscience wouldn’t allow to sit on a full train - knowing that you could spread viruses. We stayed …

… and were rewarded, at least a bit. On the last day, we were feeling much better, the sun came out and we could enjoy winter wonderland. Nevertheless, I hope that next time we will have more sun and less viruses around 🌞

Thank you for subscribing to this RSS feed. https://soeren.one/ is søren's personal blog. If you want to get in touch, please reply to this post via email.

Corona-Daten des RKI mit Python an Telegram-Kanal senden

Sun, 27 Dec 2020 17:00:00 +0100

Dritter und letzter Teil der Reihe in der ich beschreibe wie ich Daten vom RKI mit Python abziehe, diese mit Plotly grafisch aufbereite und schließlich jeden Morgen in einen Telegram-Kanal sende.

In diesem Artikel schauen wir uns gemeinsam an, wie man einen Telegram-Bot erstellt, diesen einem Kanal hinzufügt und schließlich mit Python Nachrichten verschicken lässt.

Telegram Bot erstellen

Im Gegensatz zu anderen Messengern ist es bei Telegram überaus leicht, eigene Bots zu erstellen. Der BotFather kümmert sich um die technischen Details, ihr müsst ihm lediglich mitteilen wie eurer Bot heißen soll. Beginnt also zunächst einen Chat mit dem Account @BotFather - ihr findet ihn ganz einfach über die Suche.

Mit dem Befehl /newbot kündigt ihr dem BotFather an, dass ihr einen neuen Bot erstellen wollt. Er fragt euch daraufhin, wie euer Bot heißen soll - einmal sprechend, einmal technisch. Der technische Name muss auf bot enden. Wir könnten den Bot also beispielsweise “CoronaBotStuttgart” und “CoronaBotStuttgart_bot” nennen.

Der BotFather nennt euch daraufhin euren API access token. Dieser ist quasi Benutzername und Passwort für euren Bot in einem. Diese Information solltet ihr also unter keinen Umständen aus den Händen geben. Ihr braucht diesen Token gleich, um den Bot von Python aus zu steuern.

Telegram Bot einem Kanal hinzufügen

Jetzt solltet ihr einen neuen Kanal erstellen und euren Bot als Admin hinzufügen. Dazu geht ihr wie folgt vor:

In Telegram klickt auf “New Channel”
Gebt eurem Kanal einen Namen
Entscheidet ob der Kanal öffentlich oder privat sein soll und unter welcher URL er erreichbar sein soll
Fügt euren Bot dem Kanal hinzu (sucht nach dem “sprechenden Namen”)

Der Kanal ist nun erstellt.

Öffnet ihn und klickt oben auf den Namen und wählt “Aministrators” aus.
Befördert euren Bot zum Admin des Kanals. Er braucht lediglich das Recht Nachrichten senden zu können (“Post Messages”). Alle anderen Berechtigungen könnt ihr ihm (wenn ihr wollt) entziehen.

Anschließend könnt ihr eine “Hello World”-Nachricht in den Kanal schreiben.

ChatID herausfinden

Jetzt müssen wir die ChatID eures Kanals herausfinden. Diese benötigen wir (zusammen mit dem access token), um später Nachrichten im Namen eures Bots versenden zu können.

Die ChatID erhaltet ihr, wenn ihr folgende URL öffnet: https://api.telegram.org/bot<access_token>/getUpdates. Natürlich müsst ihr <access_token> mit eurem Token ersetzen. Wichtig ist, dass /bot vor dem Token in der URL erhalten bleibt. Die Ausgabe sollte ungefähr so aussehen:

{"ok":true,"result":[{"update_id":773467236,
"message":{"message_id":550,"from":{"id":343487567,"is_bot":false,"first_name":"Bat","last_name":"Man","username":"wayne123","language_code":"de-DE"}

Die ChatID verbirgt sich in der Nachricht unter "id". Im obigen Fall also "id":343487567. Speichert euch die ChatID ebenfalls sicher ab.

Nachrichten an Telegram-Kanal senden

Nun schreiben wir uns eine Funktion, die mit Hilfe des Access Tokens und der ChatID einen bestimmten Inhalt sendet. Wir übergeben der Funktion drei Parameter:

chatid: Wenn ihr mal was testen wollt schadet es nicht, wenn der Bot auch in einen anderen Chat posten kann.
message_type: Hiermit legen wir fest, ob eine Textnachricht oder ein Bild/Foto versendet werden soll. Je nachdem unterscheidet sich der API-Aufruf.
message_content: Übergibt den Inhalt der Nachricht (Bild oder Text) an die Funktion.
Den Access Token, den ihr vom BotFather erhalten habt, tragt ihr in der ersten Zeile ein.

 1def telegram_bot_send(chatid, message_type, message_content):
 2    # define access token (received from BotFather)
 3    bot_token = '<access_token>'
 4
 5    # translate message_type in API URL
 6    if mtype == 'text':
 7        bot_mtype = '/sendMessage'
 8    elif mtype == 'photo':
 9        bot_mtype = '/sendPhoto'
10
11    # concatenate API URL
12    bot_url = 'https://api.telegram.org/bot' + bot_token + bot_mtype + '?chat_id=' + chatid
13
14    # send message
15    if mtype == 'text':
16        response = requests.get(bot_url + '&parse_mode=Markdown&text=' + content)
17    elif mtype == 'photo':
18        response = requests.post(bot_url, files={'photo': open(content, 'rb')})
19    
20    return response.json()

Damit können wir nun Inhalte über unseren Bot in den entsprechenden Telegram-Kanal senden. Den zuvor erzeugten Plot sowie eine kleine Textnachricht können wir beispielsweise mit den folgenden Befehlen absenden. Der Text muss nicht statisch sein und kann bspw. auch dynamisch aus den Daten erzeugt werden.

 1# send messages to Telegram channel
 2telegram_bot_send(
 3    chatid = '343487567'
 4    message_type = 'photo'
 5    message_content = 'link/to/exported/plot.png'
 6)
 7telegram_bot_send(
 8    chatid = '343487567'
 9    message_type = 'text'
10    message_content = 'Die Indizenz in Stuttgart ist immer noch sehr hoch'
11)

Damit sind wir am Ende dieser kleinen Serie angekommen. Ich hoffe ihr könnt daraus was für eure Projekte ableiten. Schreibt mir gern, wenn es euch weitergeholfen hat oder Probleme auftreten.

Thank you for subscribing to this RSS feed. https://soeren.one/ is søren's personal blog. If you want to get in touch, please reply to this post via email.

Corona-Daten des RKI mit Python visualisieren

Sun, 27 Dec 2020 15:00:00 +0100

Im letzten Post hatte ich bereits angekündigt, dass ich aktuell daran arbeite Daten vom RKI mit Python abzuziehen, diese mit Plotly grafisch aufzubereiten und schließlich jeden Morgen in einen Telegram-Kanal zu senden.

Heute werde ich euch zeigen, wie ich die heruntergeladenen Daten mit plotly in Python visualisiere.

Auch dafür bereiten wir zunächst das Skript vor, indem wir die notwendigen Abhängigkeiten laden. Falls euch etwas fehlt, könnt ihr es in der Regel mittels pip install <name> jederzeit installieren.

os und pandas benutzen wir erneut, um die zuvor exportierten Daten einzulesen und entsprechend aufzubereiten
mit plotly.graph_objects werden wir die Visualisierung erzeugen
und kaleido.scopes.plotly hilft uns die eigentlich interaktive Grafik von Plotly als statische Datei zu exportieren

1#imports
2import os
3import pandas as pd
4import plotly.graph_objects as go
5import requests
6
7from kaleido.scopes.plotly import PlotlyScope

Mit der Hilfe von os.path.abspath() defineren wir uns die Arbeitspfade. Gehen wir davon aus, dass sich in dem Verzeichnis, in dem unser Python-Skript liegt, auch die Unterordner data/ und img/ befinden. Aus ersterem wollen wir später die Datei rki.csv laden. In letzteres den fertigen Plot speichern.

Außerdem, sollten wir ein paar Farben festlegen.

1# define working paths
2app_dir = os.path.abspath(os.path.dirname(__file__))
3data_dir = app_dir + '/data/'
4img_dir = app_dir + '/img/'
5
6# define colors
7spaetzle_gelb_light = 'rgb(255,254,249)'
8spaetzle_gelb_dark = 'rgb(145,113,5)'
9light_grey = 'rgb(204, 204, 204)'

Laden wir die CSV-Datei und schränken sie auf den/die für uns relevanten Landkreis/e ein.

1# import as Pandas data frame and restrict to county "Stuttgart"
2rki = pd.read_csv(data_dir + "rki.csv", sep = ";")
3df_str = rki.loc[rki.GEN == "Stuttgart"]
4df_str.head()

Jeder plotly-Plot beginnt mit fig = go.Figure(). An fig werden dann weitere Elemente angefügt.

Beginnen wir damit ein Liniendiagramm hinzuzufügen (add_trace(go.Scatter()))
Dieses soll auf der x-Achse die Zeit zeigen (x = df_str.last_update)
Und auf der y-Achse die 7-Tage-Inzidenz pro 100.000 Einwohner (y = df_str.cases7_per_100k)
Die einzelnen Punkte sollen mit der (gerundeten) Inzidenz beschriftet werden (text = df_str.cases7_per_100k.round())
Angezeigt werden soll eine Linie, ein Marker und die Beschriftung (mode="lines+markers+text")
Außerdem wollen schwäbische Farben, also Spätzegelb verwenden

 1# create plot
 2fig = go.Figure()
 3fig.add_trace(go.Scatter(
 4    x = df_str.last_update,
 5    y = df_str.cases7_per_100k,
 6    text = df_str.cases7_per_100k.round(),
 7    mode="lines+markers+text",
 8    textposition="top center",
 9    textfont_color=spaetzle_gelb_dark,
10    line=dict(color = spaetzle_gelb_dark,
11))

Schon ganz nett, aber layout-technisch geht da noch was.

Geben wir dem Plot einen Titel (title = '7-Tage Inzidenz pro 100k Einwohner: Stuttgart') in der richtigen Farbe (title_font_color=spaetzle_gelb_dark)
Die x-Achse wollen wir dezent in grau zeigen (xaxis = dict())
Die y-Achse brauchen wir gar nicht (yaxis = dict())
Als Hintergrundfarbe wollen wir spätzle-gelb (plot_bgcolor, paper_bgcolor)
Und eine Legende brauchen wir auch nicht (showlegend = False)
Um Missverständnissen vorzubeugen wollen wir außerdem, dass die y-Achse nicht abgeschnitten wird (vor allem, da wir sie ausgeblendet haben). Mit update_yaxes(rangemode = 'tozero') sorgen wir dafür, dass die y-Achse immer bei null beginnt.

 1# make layout great again!
 2fig.update_layout(
 3    title = '7-Tage Inzidenz (100k EW): Stuttgart',
 4    title_font_color=spaetzle_gelb_dark,
 5    xaxis=dict(
 6        showline=True,
 7        showgrid=False,
 8        showticklabels=True,
 9        linecolor=light_grey,
10        color = light_grey,
11        linewidth=2,
12        ticks='outside', 
13    ),
14    yaxis=dict(
15        showgrid=False,
16        zeroline=False,
17        showline=False,
18        showticklabels=False,
19    ),
20    plot_bgcolor=spaetzle_gelb_light,
21    paper_bgcolor=spaetzle_gelb_light,
22    showlegend=False,
23)
24fig.update_yaxes(rangemode = 'tozero')

Diese Grafik sollten wir jetzt noch abspeichern, damit wir sie im nächsten Schritt in einen Telegram-Kanal senden können.

1# export plotly as png
2scope = PlotlyScope()
3with open(img_dir + "figure.png", "wb") as f:
4    f.write(scope.transform(fig, format="png"))

Thank you for subscribing to this RSS feed. https://soeren.one/ is søren's personal blog. If you want to get in touch, please reply to this post via email.

Corona-Daten des RKI mit Python herunterladen

Sat, 26 Dec 2020 17:57:33 +0100

Auch Ende 2020 hält uns Corona fest im Griff. Vor allem vor den Feiertagen habe ich mir die Frage gestellt, wie sinnvoll es ist, wenn Personen aus unterschiedlichen Landesteilen zusammenkommen. Ich wollte also auf einen Blick für meine Familie sehen können, wie sich die Lage in den jeweiligen Landkreisen entwickelt. Idealerweise automatisiert jeden Morgen auf meinem Handy - ohne die völlig benutzerunfreundlichen Veröffentlichungen des RKI durchstöbern zu müssen.

Die Idee war geboren. Ein Python-Skript sollte mir jede Nacht die Daten vom RKI abziehen, in einer Grafik aufbereiten und via Telegram an meine Familie verteilen. Wenn die Muse anhält, werde ich in den nächsten Tagen also kurz beschreiben, wie ich Daten vom RKI mit Python abziehe, diese mit Plotly grafisch aufbereite und schließlich in einen Telegram-Kanal jeden Morgen poste.

Beginnen wir mit dem Abziehen der Daten aus dem NPGEO Corona Hub. Das RKI veröffentlicht die Daten - aus meiner Sicht sehr dürftig dokumentiert - über arcgis.com, das mittels API von Python aus angesprochen werden kann. Wir benötigen zunächst also die URL.

Da ich mich für Daten auf Landkreisebene interessiere, öffnen wir https://npgeo-corona-npgeo-de.hub.arcgis.com/search?collection=Dataset und wählen den Landkreis-Datensatz aus. Über den API-Explorer-Tab können wir Filter setzen, die relevanten Felder auswählen und die sich ergebende URL kopieren.

Dann bereiten wir unser Python-Skript vor, indem wir die notwendigen Bibliotheken laden.

mit json und requests laden wir die Daten
pandas vereinfacht die Aufräum-Arbeit in den heruntergeladenen Daten
os und datetime helfen uns die Daten in Unterordnern und mit Datumsstempeln zu speichern

1# imports
2import json
3import os
4import pandas as pd
5import requests
6
7from datetime import datetime
8from pandas.io.json import json_normalize

Im nächsten Schritt definieren wir ein paar Variablen.

api_url ist die API-Query-URL, die wir von arcgis.com kopiert haben.
app_dir und data_dir enthalten den Dateipfad zum Verzeichnis, in dem die Python-Datei liegt, sowie einem Unterordner data. In letzterem werden wir die heruntergeladenen Daten speichern.

1# define variables
2api_url = r'https://services7.arcgis.com/mOBPykOjAyBO2ZKk/arcgis/rest/services/RKI_Landkreisdaten/FeatureServer/0/query?where=1%3D1&outFields=*&outSR=4326&f=json'
3app_dir = os.path.abspath(os.path.dirname(__file__))
4data_dir = app_dir + '/data/'

Der eigentliche Download verfolgt über eine Kombination von json.loads() mit requests.get(). Mittels json_normalize() wandeln wir das heruntergeladen JSON-File in einen Pandas-Datensatz um.

1# download and normalize
2d = json.loads(requests.get(api_url).text)
3df = json_normalize(d, record_path=['features'])

Perfekt. Mittels df.head() können wir einen Blick auf die Daten werfen. Mir persönlich gefällt das attributes.-Präfix bei den Spaltennamen nicht. Lass es uns also entfernen. Dafür erzeugen wir ein leeres Array, schleifen über die Spaltennamen, ersetzen dabei jeweils “attributes.” mit "" und überschreiben schließlich die Spaltennamen mit dem Array. Es gibt dafür sicher einen besseren Weg.

1# remove "attributes." from field names
2colnames = []
3for i in range(len(df.columns)):
4    colnames.append(df.columns[i].replace('attributes.', ''))
5
6df.columns = colnames

Das RKI veröffentlicht über die API lediglich die neusten Daten. Sofern wir einen Zeitverlauf analysieren wollen, müssen wir die Daten also abspeichern. Der Einfachheit halber sichern wir den heruntergeladenen Datensatz als CSV mittels Pandas to_csv()-Funktion. Damit wir die Dateien den einzelnen Tagen zuordnen können, extrahieren wir aus der Spalte last_update das Datum und bauen das in den Namen der exportierten CSV-Datei ein.

 1# extract last update date (for filename)
 2file_date = datetime.strptime(df['last_update'][0], '%d.%m.%Y, %H:%M Uhr').strftime("%Y%m%d_%H%M")
 3
 4# epxort CSV to data directory, using last update date for filename
 5df.to_csv(
 6    path_or_buf = data_dir + "rki_" + file_date + ".csv",
 7    sep = ";",
 8    header = True,
 9    index = False,
10    encoding = 'utf-8'
11)

Und damit sind wir eigentlich auch schon fertig. Damit ich nicht für jede Anwendung die Daten neu einlesen und zusammenfügen muss, habe ich meinem Python-Skript noch einen letzten Absatz mitgegeben. Dieser erzeugt zunächst eine Liste aller unter data/ abgespeicherten Dateien (deren Dateiname mit rki_ beginnt), liest diese anschließend der Reihe nach ein, fügt sie zu einem Datensatz zusammen und speichert diesen als zusätzliches CSV-File ab.

 1# create list of all exported CSV files
 2filepaths = [f for f in os.listdir((data_dir)) if f.startswith('rki_')]
 3filepaths
 4
 5# append exported CSV files
 6rkitmp = []
 7for f in filepaths:
 8    dftmp = pd.read_csv(data_dir + f, sep = ";", decimal=",")
 9    rkitmp.append(dftmp)
10
11# concat to Pandas data frame
12rki = pd.concat(rkitmp, axis=0, ignore_index=True, sort = True)
13rki = rki.drop_duplicates()
14
15# export combined data
16rki.to_csv(
17    path_or_buf = data_dir + "rki.csv",
18    sep = ";",
19    header = True,
20    index = False,
21    encoding = 'utf-8'
22)

Thank you for subscribing to this RSS feed. https://soeren.one/ is søren's personal blog. If you want to get in touch, please reply to this post via email.