Howto on Søren's Blog

Run Hugo Blog on uberspace

Sun, 11 Jan 2026 06:00:00 +0000

Back in 2019, I wrote an article on how to run a hugo blog on uberspace (🇩🇪). The magic is not to bring the static files on a webhoster, that’s easy, but that uberspace allows building and publishing the blog for you on your domain. Like GitHub or Netlify, but with a small German hoster.

I use this setup ever since. Although I struggle every now and then.

Robert reached out, because he was facing error messages when trying to implement the same. I couldn’t help him directly, because that article is five years old and I was not sure if things have changed in the meantime.

Luckily, the holidays came with a bit of spare time to test this myself and to provide an updated version.

I was very careful to collect all commands I sent to the terminal and am thus very sure that this works on an U7 uberspace.

Prepare your machine

You need to have the git and hugo available on your machine. Please follow their installation guides.

git
hugo

You also need access to a terminal. That’s standard if you’re on Linux or Mac. You may want to checkout Putty if you’re using Windows.

Create a new asteroid

Now let’s create a new asteroid (= account) on uberspace. Surf to https://dashboard.uberspace.de/register and fill out the form. It has 3 fields. Should take less than a minute.

Let me say it again: I am super happy with uberspace as a hoster. They provide all you need, have a great service and company values. If you don’t know them yet, check out their about-us page.

Once the account is created, nagivate to Dashboard –> Login and set a new password for the SSH access.

Remember the host name on which your asteroid is created. You can find that in the email they write you, or on the Datasheet.

The nerdy stuff

So far, so fancy. From now on, no more UI, but terminal commands only.

First, we connect to your new Asteroid using SSH. Please replace batman with your user name and helium with your host name. You need the SSH password you defined in the previous step to log in.

ssh batman@helium.uberspace.de

Next, we install Hugo. We download the latest release. Check GitHub and replace the url in the wget if necessary.

Wondering what the commands do? wget will download the compressed hugo release, tar will unzip it, mv moves the extracted directory, and rm deletes the file we downloaded.

cd ~

wget https://github.com/gohugoio/hugo/releases/download/v0.154.4/hugo_0.154.4_Linux-64bit.tar.gz

tar -xvf hugo_0.154.4_Linux-64bit.tar.gz hugo

mv hugo ~/bin

rm hugo_0.154.4_Linux-64bit.tar.gz

With mkdir we create a directory that holds our repository. This is where we will push to. Within the folder, we initialize an empty repository (--bare) and create the main branch.

cd ~

mkdir batblog.git

cd batblog.git

git init --bare

git branch -m main

Brace yourself, because now we add the magic 🧚

We tell git to run a few commands every time an update is made on the repository, e.g. when we push a commit holding a new blog post. This is done by changing the content of the post-update hook.

Run these commands to open the file in the nano editor

cd ~/batblog.git

nano hooks/post-update

Copy the following script into the file, change GIT_REPO to match your repository.

What the script does:

define path to the repository we created before (GIT_REPO)
define path to a temporary directory to clone into (TMP_GIT)
define path to your public folder, where the built blog shall be moved to (PUBLIC_WWW)
clone the repository to the temporary folder
change into that temporary folder
build the blog and move the output to the public folder
delete the temporary folder

#!/bin/sh

echo "Start hook magic"

# path to repository
GIT_REPO=$HOME/batblog.git

# path to tmp
TMP_GIT_CLONE=$(mktemp -d)

# path to publich URL
PUBLIC_WWW=/var/www/virtual/$USER/html

# clone repository
git clone $GIT_REPO $TMP_GIT_CLONE
cd $TMP_GIT_CLONE

# build
~/bin/hugo --cleanDestinationDir --destination $PUBLIC_WWW

# clean
rm -Rf $TMP_GIT_CLONE

Save the changes with control + o and exit the editor with control + x.

It’s important to run one more command, letting the machine know that this script is executable.

cd ~/batblog.git

chmod +x hooks/post-update

We’re done on the server. The rest happens on your local machine.

Create and publish your blog

On your machine, we clone the repository that we created on uberspace. Adjust the path to your needs, by replacing batman with your user name, helium with your host name, and batblog.git with whatever you called the repository. You need the SSH password that you defined above.

git clone ssh://batman@helium.uberspace.de/home/batman/batblog.git

This will create a directory called batblog. We open this directory, create a new blog in there, commit the changes and push them to the server.

cd batblog

hugo new site . --force

git add .
git commit -m "initial"
git push origin main

Wait a few seconds and then open your uberspace URL. If you want to make your blog available at your own domain - you just need to add the domain to your uberspace and adjust the DNS records (A, AAAA). A guide how to do this is here: https://manual.uberspace.de/web-domains/

Enjoy your new blog 👏

Update: We can include a repeated execution of the script to allow for scheduled posts.

This week I wanted to tinker on the blog machinery. Scheduled posts have been on the agenda for a while - not because it’s complicated, but because I barely needed it.

With the above setup, this is very simple. Add one row to the crontab.

Assuming you‘re logged in the server (ssh batman@helium.uberspace.de), run

crontab -e

And in the editor, add

@hourly /home/batman/batblog.git/hooks/post-update

Save the changes with control + o and exit the editor with control + x.

This will run the script on an hourly basis and publish scheduled jobs the latest 60min after the planned release.

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.

Publish to Blog from iPad

Mon, 28 Dec 2020 12:00:00 +0100

Unfortunately, ideas for new blog posts often fizzle out because I find it too much of an effort to boot up my laptop in the evening and organize my thoughts. I am therefore always on the lookout for ways to lower the inhibition threshold as much as possible.

A good approach would be to remove the laptop from the equation and blog from a device that I have in my hand all the time anyway: Smartphone or tablet, for example. But because the cell phone display is perhaps a bit small, I’m going to see if I can blog well from an iPad today. And yes, this article was written entirely on the iPad.

I use Hugo as the foundation for my blog, which I run (as described here) on a uberspace. This has the advantage that I can outsource some of the magic to the server. Specifically, I have set up a post-update hook in the Git repository on the server. This automatically creates the static files after each commit.

So I don’t need to have Hugo installed on the i-Device, I just need a Git client and a text editor. I found both in Working Copy.

The app costs a bit, but in my opinion it’s worth every penny. Especially because it is perfectly integrated into iOS. For example, the repository can be accessed via the Files app - so I can edit the content with many different apps.

My workflow is now as follows:

within Working Copy, I duplicate an existing Markdown file as the basis for the new article and adapt the YAML header.
open the new file in the integrated text editor and write the article. For a little more syntax highlighting, you can also open the file in an external editor (e.g. Textastic).
if I want to include screenshots or other files, I save them directly to the static folder of the repository via the iOS Files app.
when I’m done, I use Working Copy to commit the changes and then push them to the repository. The uberspace then automatically updates the blog.

It could hardly be easier.

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.

Etwas coolere ggplots erstellen

Tue, 08 Oct 2019 00:00:00 +0000

Leider muss ich zugeben, dass meine bisherige Beteiligung am TidyTuesday weit hinter meinen Erwartungen zurück geblieben ist. Bisher habe ich lediglich einmal mitgemacht und das ist auch schon Monate her.

Natürlich überfliege ich trotzdem jede Woche unzählige Tweets und erfreue mich an tollen Grafiken zu verschiedenen Themen. So wie beispielsweise an dieser super-coole Visualisierung, die wirklich Lust darauf gemacht hat, mal wieder was mit Karten zu machen.

Und da ich mit ein bisschen Glück demnächst wieder Vollzeit-Baden-Württemberger werde, werden wir uns nicht Pizza-Restaurants in NYC sondern was aus dem lokaleren Datenbestand anschauen.

In diesem Blog-Post möchte ich zeigen, wie sich Visualisierungen in meinem Workflow entwickeln, wie ich von ggplot() + geom_point() zu etwas halbwegs ansehnlichem komme. Dass manche Schritte dabei ein Fall für @accidential aRt sind, versteht sich vermutlich von selbst 😅

Daten sammeln

Lange Rede - kurzer Sinn. Ich habe also auf die Webseite des Statistischen Landesamtes aufgerufen und mir einfach den erstbesten Datensatz runtergeladen, der Informationen auf Kreis-Ebene zur Verfügung stellt. Wir werden heute also etwas zur Bevölkerungsdichte in Baden-Württemberg lernen.

Damit wir die Daten auch hübsch visualisieren könne, habe ich mir darüber hinaus vom Landesamt für Geoinformation und Landentwicklung das entsprechende Shapefile heruntergeladen.

Da die Daten sauber vorbereitet sind, können wir sie mit wenigen Zeilen einlesen und in das gewünschte Format bringen.

 1# --------------------------------
 2# notwendige Packete laden
 3# --------------------------------
 4library(tidyverse)
 5library(sf)
 6
 7# --------------------------------
 8# Dateipfade definieren
 9# --------------------------------
10file_bevoelkerung <- "link/to/Bevoelk_I_Flaeche_j.csv"
11file_shapes <- "link/to/AX_Gebiet_Kreis.shp"
12
13# --------------------------------
14# Daten einlesen und aufbereiten
15# --------------------------------
16EINWOHNER.Kreise <- 
17  read_delim(
18    file = file_bevoelkerung, 
19    locale = locale(encoding = readr::guess_encoding(file_bevoelkerung) %>% select(encoding) %>% unlist()),
20    delim = ";", 
21    skip = 20,
22    col_names = c(
23      "ID.Regionaleinheit",
24      "AmtlicherGemeindeschluessel",
25      "PLZ",
26      "Regionalname",
27      "Stichtag",
28      "Bevoelkerung_insgesamt",
29      "Gemeindegebiet_ha",
30      "Bevoelkerungsdichte_EW_km2"
31    )
32  ) %>% 
33  filter(
34    Stichtag == "31.12.2018",
35    ID.Regionaleinheit == "KR"
36  ) %>% 
37  left_join(
38    y = read_sf(file_shapes),
39    by = c("AmtlicherGemeindeschluessel" = "Schlüssel")
40  )

Basis-Plot erstellen

Nachdem wir die Daten eingelesen und aufbereitet haben, sollten wir uns anschauen was ggplot() vorschlägt. Ein klarer Vorteil ist, dass selbst dieser erste Versuch schon relativ ansehnlich ist. Aber da geht natürlich noch mehr …

1# --------------------------------
2# Basisplot erstellen
3# --------------------------------
4p <- ggplot(data = EINWOHNER.Kreise) + 
5  geom_sf(aes(fill = Bevoelkerungsdichte_EW_km2))
6p

All hail the Spätzle!

Theoretisch könnten wir hier aufhören. Wir haben eine Karte auf der die Landkreise entsprechend ihrer Bevölkerungsdichte eingefärbt sind. Es wird auf einen Blick deutlich, dass in Stuttgart sehr viele Menschen auf wenig Raum wohnen, während es im Nord- und Südosten eher ruhig zugeht.

Nun wollten wir ja aber einen etwas cooleren Plot erstellen. Dazu ändern wir als erstes die Farben. Und weil die Landesfarbe halt spätzle-gelb ist, nehmen wir das als Basis. Von coolors.co lasse ich mir einen dazu passenden Rot-Ton erzeugen und definiere so die beiden Extremwerte meiner Farbskala.

 1# --------------------------------
 2# Farben definieren
 3# --------------------------------
 4colour_spaetzlegelb <- "#FFFEF9"
 5colour_rangemax <- "#AA4465"
 6
 7# --------------------------------
 8# Plot aktualisieren
 9# --------------------------------
10p <- p + 
11  scale_fill_gradient(low = colour_spaetzlegelb, high = colour_rangemax)
12p

Make the theme great again!

Das sieht schon besser (aber noch nicht gut) aus. Als nächstes passen wir das Theme an, entfernen die Legende, den grauen Hintergrund und die Achsen, deren Zahlenwerte aktuell eher verwirrend als hilfreich sind.

 1# --------------------------------
 2# Plot aktualisieren
 3# --------------------------------
 4p <- p + 
 5  theme(
 6    
 7    # Achsen entfernen -----------
 8    axis.line = element_blank(), 
 9    axis.title = element_blank(),
10    axis.ticks = element_blank(),
11    axis.text = element_blank(),
12
13    # Hintergrund anpassen -------
14    panel.background = element_rect(fill = colour_spaetzlegelb),
15    plot.background = element_rect(fill = colour_spaetzlegelb),
16    
17    # Legende entfernen ----------
18    legend.position = "none"
19  )
20p

Reden ist Silber, Annotierung ist Gold!

So langsam wird es doch. Es fehlt aber noch ein bisschen Kontext. Also fügen wir neben der eigentlich Grafik einen Titel und eine kurze Zusammenfassung der Ergebnisse ein. Das hilft die Hauptaussage der Visualisierung noch einmal (in prosa) hervorzuheben.

 1# --------------------------------
 2# Untertitel verfassen
 3# --------------------------------
 4plot_subtitle <- str_c(
 5  "Die Karte zeigt die Bevölkerungsdichte nach Kreisen in Baden-Württemberg.",
 6  "Am dünnsten besiedelt ist der Main-Tauber-Kreis. Hier wohnen 101 Personen pro km².",
 7  "Mehr als 30x mehr Personen pro Quadratkilomenter wohnen in der Landeshauptstadt.",
 8  sep = " "
 9)
10
11# --------------------------------
12# Quellen definieren
13# --------------------------------
14plot_caption <- str_c(
15  "Daten: Statistisches Landesamt Baden-Württemberg;",
16  "Karten: Landesamt für Geoinformation und Landentwicklung",
17  "Grafik: https://gluecko.se",
18  sep = " "
19)
20
21# --------------------------------
22# Notwendige Koordinaten speichern
23# --------------------------------
24coord_xmin <- sf::st_bbox(EINWOHNER.Kreise$geometry)$xmin
25coord_xmax <- sf::st_bbox(EINWOHNER.Kreise$geometry)$xmax
26coord_ymin <- sf::st_bbox(EINWOHNER.Kreise$geometry)$ymin
27coord_ymax <- sf::st_bbox(EINWOHNER.Kreise$geometry)$ymax
28
29# --------------------------------
30# Plot aktualisieren
31# --------------------------------
32p <- p + 
33  annotate("text", label = "Bevölkerungsdichte nach Kreisen", x = .7 * coord_xmin, y = 1.01 * coord_ymax, size = 6, hjust = 0) +
34  annotate("text", label = str_wrap(plot_subtitle, 40), x = .7 * coord_xmin, y = coord_ymax, size = 3, hjust = 0) +
35  annotate("text", label = str_wrap(plot_caption, 40), x = .7 * coord_xmin, y = coord_ymax, size = 3, hjust = 0, vjust = 2.5)
36p

Look here!

Na das sieht doch jetzt echt nach was aus! Wir sollten allerdings noch ein paar Kreise explizit hervorheben. Extremfälle bieten sich an - fügen wir also noch Hinweise auf die Kreise mit der höchsten bzw. niedrigsten Bevölkerungsdichte ein.

 1# --------------------------------
 2# Centroid berechnen
 3# --------------------------------
 4get_centroid <- function(name){
 5  coords <- 
 6    EINWOHNER.Kreise %>% 
 7    filter(Name %in% name) %>% 
 8    select(geometry) %>% 
 9    st_as_sf() %>% 
10    st_centroid() %>% 
11    unlist()
12  
13  if(length(coords)>2){
14    warning("More than one centroid found!")
15  }
16  
17  returnData <- 
18    tribble(
19      ~"Name", ~"x", ~"y",
20      name, coords[1], coords[2]
21    )
22  
23  return(returnData)
24}
25
26# --------------------------------
27# Notwendige Koordinaten speichern
28# --------------------------------
29coord_Stuttgart_xlabel <- 1.05 * coord_xmin
30coord_Stuttgart_ylabel <- 1.0045 * get_centroid("Stuttgart")$y
31coord_Mannheim_xlabel <- 1.1 * coord_xmin
32coord_Mannheim_ylabel <- 1.005 * get_centroid("Mannheim")$y
33coord_Karlsruhe_xlabel <- 1.1 * coord_xmin
34coord_Karlsruhe_ylabel <- 1.005 * get_centroid("Karlsruhe")$y
35coord_MainTauberKreis_xlabel <- 0.95 * coord_xmax
36coord_MainTauberKreis_ylabel <- 1.005 * get_centroid("Main-Tauber-Kreis")$y
37coord_Sigmaringen_xlabel <- 0.98 * coord_xmax
38coord_Sigmaringen_ylabel <- 1.005 * get_centroid("Sigmaringen")$y
39coord_NeckarOdenwaldKreis_xlabel <- 0.82 * coord_xmax
40coord_NeckarOdenwaldKreis_ylabel <- 1.0115 * get_centroid("Neckar-Odenwald-Kreis")$y
41
42# --------------------------------
43# Plot aktualisieren
44# --------------------------------
45p <- p + 
46  # Top 1: Stuttgart -------------  
47  annotate("segment", x = coord_Stuttgart_xlabel, y = coord_Stuttgart_ylabel, xend = get_centroid("Stuttgart")$x,  yend = get_centroid("Stuttgart")$y) + 
48  annotate("label", label = "Stuttgart\n3.062 EW/km²", x = coord_Stuttgart_xlabel, y = coord_Stuttgart_ylabel) + 
49  
50  # Top 2: Mannheim --------------
51  annotate("segment", x = coord_Mannheim_xlabel, y = coord_Mannheim_ylabel, xend = get_centroid("Mannheim")$x, yend = get_centroid("Mannheim")$y) + 
52  annotate("label", label = "Mannheim\n2.134 EW/km²", x = coord_Mannheim_xlabel, y = coord_Mannheim_ylabel) + 
53  
54  # Top 3: Karlsruhe -------------
55  annotate("segment", x = coord_Karlsruhe_xlabel, y = coord_Karlsruhe_ylabel, xend = get_centroid("Karlsruhe")$x, yend = get_centroid("Karlsruhe")$y) + 
56  annotate("label", label = "Karlsruhe\n1.805 EW/km²", x = coord_Karlsruhe_xlabel, y = coord_Karlsruhe_ylabel) + 
57
58  # Bottom 1: Main-Tauber-Kreis --
59  annotate("segment", x = coord_MainTauberKreis_xlabel, y = coord_MainTauberKreis_ylabel, xend = get_centroid("Main-Tauber-Kreis")$x, yend = get_centroid("Main-Tauber-Kreis")$y) +
60  annotate("label", label = "Main-Tauber-Kreis\n101 EW/km²", x = coord_MainTauberKreis_xlabel, y = coord_MainTauberKreis_ylabel) + 
61
62  # Bottom 2: Sigmaringen --------
63  annotate("segment", x = coord_Sigmaringen_xlabel, y = coord_Sigmaringen_ylabel, xend = get_centroid("Sigmaringen")$x, yend = get_centroid("Sigmaringen")$y) +
64  annotate("label", label = "Sigmaringen\n109 EW/km²", x = coord_Sigmaringen_xlabel, y = coord_Sigmaringen_ylabel) +
65
66  # bottom 3: Neckar-Odenwald-Kreis --
67  annotate("segment", x = coord_NeckarOdenwaldKreis_xlabel, y = coord_NeckarOdenwaldKreis_ylabel, xend = get_centroid("Neckar-Odenwald-Kreis")$x, yend = get_centroid("Neckar-Odenwald-Kreis")$y) +
68  annotate("label", label = "Neckar-Odenwald-Kreis\n127 EW/km²", x = coord_NeckarOdenwaldKreis_xlabel, y = coord_NeckarOdenwaldKreis_ylabel)
69p

Eine große Version der Grafik und den vollständigen Code am Stück gibt es - wie immer - bei GitHub.

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.

OSM Daten als SVG exportieren

Mon, 09 Sep 2019 00:00:00 +0000

Ich möchte euch heute ein cooles Projekt vorstellen. Der Hase nutzt die Zeit während seines Spezialprojektes sehr effektiv und hat am Wochenende ein Python-Projekt auf GitHub geladen.

Mit dem Skript könnt ihr Daten aus OpenStreetMaps als XML oder SVG exportieren. Das ist super-nützlich, wenn ihr eine skalierbare Grafik vom “Grundriss” eurer Heimatstadt, eures Lieblingsbundeslandes, eurer Lieblingsinsel, Bielefeld oder Trinidad und Tobago braucht.

Das bietet sich auch super für ein Ratespiel an. Wer weiß welche Stadt das ist?

Los geht’s!

Als erstes solltet ihr die einzige Voraussetzung auf eurem System installieren: Python 3. Ich empfehle (vor allem unter Windows) das mittels Anaconda zu tun. Ladet euch die neuste Version herunter und folgt den Anweisungen des Installers: https://www.anaconda.com/distribution/.

Ob alles geklappt hat, könnt ihr in der Windows Eingabeaufforderung testen. Wenn ihr python eingebt, solltet ihr einen Hinweis zur installierten Version erhalten.

C:\Users\Batman>python
Python 3.7.0 (default, Jun 28 2018, 08:04:48) [MSC v.1912 64 bit (AMD64)] :: Anaconda, Inc. on win32
Type "help", "copyright", "credits" or "license" for more information.

Als nächstes ladet ihr euch aus dem Repository das Skript herunter: https://github.com/mhaseneyer/osmxml/blob/master/src/osm2svg.py

Und als letztes sucht ihr noch den passenden OSM-Link für das Objekt eurer Wahl heraus. Um das Rätsel von oben aufzulösen, nehmen wir mal an ihr interessiert euch für die Umrisse von Stuttgart: https://www.openstreetmap.org/relation/2793104.

Die sehen in OSM wie folgt aus.

Die Wundermaschine anwerfen

Mit nur einem Befehl lassen wir Python jetzt das Objekt von OSM herunterladen und in eine SVG umwandeln. Dafür übergebt ihr dem Skript einfach den Link zu OSM und einen Namen für das SVG-File.

C:\Users\Batman>python link/to/osm2svg.py https://www.openstreetmap.org/relation/2793104 stuttgart.svg

So einfach ist das. Richtig geiler Scheiß, Danke! 👍

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.

Hugo mit Git auf dem uberspace nutzen

Fri, 06 Sep 2019 00:00:00 +0000

Vorgeschichte

Vor gar nicht allzu langer Zeit bin ich mit diesem Blog von Ghost zu Jekyll gewechselt. Ghost hat mir eigentlich sehr gut getaugt, auch wenn ich nicht der größte Fan davon war, dass bloggen mit Markdown mit den neueren Versionen einen Klick weiter entfernt war. Außerdem war es für mich immer eine kleine Herausforderung bei neuen Versionen die Abhängigkeiten auf dem Betriebssystem auf dem neusten Stand zu halten und die Datenbank zu migrieren.

Bloggen mit einem Static-Site-Generator schien mir da der nächste logische Schritt. Ich habe also kurz Jekyll ausprobiert und bin schließlich bei Hugo gelandet. Hugo gebe ich aktuell den Vorzug, weil es sich leichter auf einem Windows-PC nutzen lässt und wesentlich schneller ist.

Der geneigte Leser wird wissen, das ich bezüglich Webhoster ein großer Fan der Jungs und Mädels von uberspace bin. Im folgenden also eine kleine Anleitung, um zu meinem aktuellen Setup zu kommen.

Dafür werden wir …

Git und Hugo lokal installieren
Einen neuen Hugo-Blog anlegen
Einen ersten Blog-Artikel schreiben
Den uberspace vorbereiten
Den Blog vom uberspace erstellen lassen
Uns über einen neuen Blog freuen :)

Git und Hugo lokal installieren

Eine Anleitung zur Installation von git findet ihr hier: https://book.git-scm.com
Wie man Hugo installiert, steht auf der Hugo-Webseite: https://gohugo.io/getting-started/installing/

Solltet ihr, wie ich aktuell, an einem Windows-PC sitzen hilft euch vielleicht auch dieses Video weiter. Gleiche Videos gibt es auch für andere Betriebssysteme.

Hugo-Blog anlegen

Ist Hugo installiert, könnt ihr mit hugo new site <sitename> einen neuen Blog anlegen. Wir erstellen das fiktive Blog hugoblog.com.

P.S. Ich nutze auch auf Windows meist die Git-Bash als Konsole. Die kennt auch Befehle wie ssh :)

[Batman@lokal ~]$ hugo new site hugoblog.com

Eine Hugo-Website kommt ohne Theme. Das müssen wir also als nächstes herunterladen. Ich mag das Base16-Theme. Falls euch das nicht zusagt, findet ihr hier aber sicher ein oder zwei Alternativen.

Das Theme müsst ihr in den Ordner themes eurer eben erstellten Seite herunterladen.

[Batman@lokal ~]$ cd hugoblog.com/themes
[Batman@lokal themes]$ git clone https://github.com/htdvisser/hugo-base16-theme.git base16

Und schließlich müssen wir Hugo noch mitteilen, dass ihr dieses Theme verwenden wollt. Dazu passen wir die Konfiguration an.

[Batman@lokal ~]$ cd ~/hugoblog.com
[Batman@lokal hugoblog.com]$ cat <<EOF>> config.toml
theme = "base16"
pygmentsuseclasses = true
EOF

Erster Artikel

Zeit für den ersten Artikel. Mittels touch erstellen wir unter content/posts/ ein neues Markdown-File und befüllen es mit ein ein bisschen Inhalt.

[Batman@lokal hugoblog.com]$ touch content/posts/cooler-artikel.md
[Batman@lokal hugoblog.com]$ cat <<EOF>> content/posts/cooler-artikel.md
+++
title = "Hello World"
date = "2019-09-06"
layout = ["article"]
author = "Batman"
tags = ["uberspace", "hugo", "blog"]
+++

# Lorem Ipsum

Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet.

EOF

Mal drauf schauen, wie der Artikel aussieht? Das geht ganz leicht mit hugo serve. Hugo erstellt dann einen lokalen Server und lässt euch eure Seite unter folgendem Link betrachten: localhost:1313.

[Batman@lokal hugoblog.com]$ hugo serve
Building sites …
                   | EN
+------------------+----+
  Pages            | 37
  Paginator pages  |  2
  Non-page files   |  0
  Static files     |  6
  Processed images |  0
  Aliases          | 14
  Sitemaps         |  1
  Cleaned          |  0
[...]
Environment: "development"
Serving pages from memory
Running in Fast Render Mode. For full rebuilds on change: hugo server --disableFastRender
Web Server is available at http://localhost:1313/ (bind address 127.0.0.1)
Press Ctrl+C to stop

Wenn alles gut aussieht, können wir auf dem uberspace weitermachen.

uberspace vorbereiten

In diesem Schritt können wir uns am Tutorial auf https://lab.uberspace.de/ orientieren. Danke an Christian, luto und Julian.

Domain anlegen

Falls ihr eine eigene Domain verwenden wollt, lest im uberspace-Wiki noch einmal nach wie das geht. Hier gehen wir davon aus, dass ihr eine Domain aufgeschaltet habt und diese auf euren Document-Root (html/) verweist.

Hugo installieren

Um Hugo auf dem uberspace zu installieren, laden wir als erstes die neuste Version von Github als tar herunter. Prüfe im Hugo Repository auf GitHub noch einmal welches die neuste Version ist und passe die Befehle entsprechend an. Anschließend entpacken, nach bin verschieben und aufräumen. Fertig.

[batman@helium ~]$ wget https://github.com/gohugoio/hugo/releases/download/v0.58.1/hugo_0.58.1_Linux-64bit.tar.gz
[batman@helium ~]$ tar -xvf hugo_0.58.1_Linux-64bit.tar.gz hugo
[batman@helium ~]$ mv hugo ~/bin
[batman@helium ~]$ rm hugo_0.58.1_Linux-64bit.tar.gz
[batman@helium ~]$ hugo version

Sollte es mal eine neuere Version von Hugo geben, wiederholt einfach diesen Schritt, um wieder up to date zu sein :)

Git-Repository für Hugo-Blog anlegen

Als nächstes legen wir uns im Home-Verzeichnis einen neuen Ordner an, in dem wir das Git-Repository für unseren neuen Hugo-Blog ablegen.

[batman@helium ~]$ mkdir hugo_websites
[batman@helium ~]$ mkdir hugo_websites/hugoblog.git
[batman@helium ~]$ cd hugo_websites/hugoblog.git
[batman@helium hugoblog.git]$ git init --bare

Git Hook anlegen

Wir möchten, das der uberspace mit jedem push in unser eben erstelltes Repository den Blog neu erstellt und auf der Domain verfügbar macht. Sagen wir ihm das. Dafür passen wir den post-update-hook wie folgt an.

[batman@helium hugoblog.git]$ touch hooks/post-update
[batman@helium hugoblog.git]$ cat <<EOF>> hooks/post-update
#!/bin/sh

# los geht's
echo "Start hook magic"

# hier definieren wir den Pfad zu unserem Git-Repository
GIT_REPO=$HOME/hugo_websites/hugoblog.git

# hier definieren wir ein temporäres Verzeichnis zum clonen des Repositorys
TMP_GIT_CLONE=$(mktemp -d)

# hier definieren wir den Pfad zu unserer öffentlichen Domain
PUBLIC_WWW=/var/www/virtual/$USER/html

# jetzt clonen wir das Repository in den temporären Ordner
git clone $GIT_REPO $TMP_GIT_CLONE
cd $TMP_GIT_CLONE

# Hugo anschmeißen
~/bin/hugo --cleanDestinationDir --destination $PUBLIC_WWW

# aufräumen
rm -Rf $TMP_GIT_CLONE
EOF

Push auf den uberspace

Damit ist alles vorbereitet. Wir sollten jetzt nur noch unser auf dem uberspace erzeugtes Git-Repository als remote zum lokalen Ordner hinzufügen, unseren Artikel committen und das ganze hochladen.

[batman@lokal ~]$ cd hugoblog.com
[batman@lokal hugoblog.com]$ git init
[batman@lokal hugoblog.com]$ git remote add origin ssh://batman@helium.uberspace.de/hugo_websites/hugoblog.git
[batman@lokal hugoblog.com]$ git add .
[batman@lokal hugoblog.com]$ git commit -m "Initial commit"
[batman@lokal hugoblog.com]$ git push origin master

Und das war’s dann auch schon. Auf den ersten Blick ist das ein bisschen länger geworden, aber diese Schritte müsst ihr ja nur einmal vornehmen.

Da ich viel von unterwegs blogge, genieße ich es, auf dem iPad zu schreiben und nur einmal git push eingeben zu müssen, um die Änderungen zu veröffentlichen. Wie ich von unterwegs blogge, werde ich vermutlich demnächst mal aufschreiben.

Und jetzt viel Spaß mit eurem neuen Blog.

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.

Komplexe CSV-Dateien einlesen

Thu, 01 Aug 2019 00:00:00 +0000

Natürlich gibt es einfachere Dinge, als Daten in R einzulesen. Und trotzdem ist es zumindest seit der Einführung des tidyverse und den damit propagierten tidy data principles sehr viel einfacher geworden saubere Daten zu laden. Leider hat nicht jeder Sensor-Hersteller das Paper von Hadley Wickem gelesen.

Dieser Tage ist eine sehr spannende Aufgabe auf meinem Schreibtisch gelandet. Es klang zunächst so einfach: Wir haben da eine Maschine. Die misst etwas und schreibt ihre Ergebnisse in eine Textdatei. Diese müsste eingelesen und weiterverarbeitet werden. Ich dachte, dass sich das relativ leicht mit read_delim() lösen lassen können müsste. Dachte ich…

Das Problem

Die Sache hatte natürlich einen Haken. Den Vorteil, dass die Maschine ihre Messwerte in eine CSV-Datei (und kein proprietäres Format) schrieb, machte sie damit zunichte, dass sie in einer Datei mehrere Header einfügte. “Wie meinen?”, denkt ihr vielleicht jetzt.

Stellen wir uns dazu vor, dass mit der Maschine die Inhaltsstoffe verschiedener Burger gemessen werden sollen. Man zielt also auf einen Burger und bekommt als Ergebnis die Anteile an Bun, Patty, Salat, etc. die in diesem Burger verwurstelt wurden. Das Problem ist nun, dass die Maschine beispielsweise bei einem vegetarischen Burger den Eintrag für Patty nicht einfach leer lässt sondern gar nicht erst notiert. Je nach Anzahl der Zutaten im Burger hat die CSV also unterschiedlich viele Spalten.

Immernoch unklar? Dann werft doch mal einen Blick auf das folgende Beispiel.

Unschön, nicht? Und obwohl ich in den vergangen Jahren wirklich einige R-Tricks gelernt habe, hat mich das einige Arbeit gekostet.

Die Lösung

Meine Lösung ist sicher nicht die beste, aber funktioniert und hilft vielleicht der ein oder anderen, die ein ähnliches Problem hat.

Zunächst speichere ich mir den String, der den Start eines neuen Headers identifiziert (erster Spaltenname im Datensatz) und lese das gesamte File mittels readLines() ein. Das setzt natürlich voraus, dass zumindest die erste Spalte immer gemessen wird.

# load packages -----------------------------------------------------------
require("tidyverse")

# define header identification --------------------------------------------
header_id <- "ID"

# read raw data -----------------------------------------------------------
RAW <- readLines(file.choose())

(Ich verwende file.chose(), um die Benutzung für den Endanwender so komfortabel wie möglich zu halten)

Dann baue ich einen Datensatz, der genausoviele Zeilen wie das originale CSV-File hat und ermittle (mit header_id) welche davon Header-Zeilen sind. Mittels split() fülle ich die restlichen Zeilen mit der dazugehörigen Header-Nummer auf.

# find lines to split at --------------------------------------------------
header_lines <- which(substr(RAW, 1, nchar(header_id)) == header_id)

# create a list of all datasets within the CSV file -----------------------
DATASETS <- tibble(
  Row = 1:length(RAW),
  Data = RAW,
  Split = ifelse(Row %in% header_lines, header_lines, NA)
) %>%
  fill(Split) %>% 
  split(f = .$Split)

Schließlich schleife ich einmal über die jeweiligen Headernummern und picke mir aus den Rohdaten alle Informationen zusammen.

# extract relevant data ---------------------------------------------------
BURGERS <- tibble(
  ID = character(),
  Bun = numeric(), 
  Patty = numeric(),
  Salat = numeric(),
  Tomate = numeric()
)

for(i in 1:length(DATASETS)){
  # print loop ............................................................
  print(i)
  
  # extract data ..........................................................
  tmp_str <- DATASETS[[i]] %>% select(Data) %>% unlist()
  tmp_data <- read_delim(paste(tmp_str, collapse="\n"), delim = ";", na = "<LOD") %>% 
    select(
      ID
      matches(names(BURGERS))
      ) %>%
    filter(!is.na(ID))
  
  # append to results .....................................................
  BURGERS <- BURGERS %>% bind_rows(tmp_data) 
}

Et voilà, wir haben einen Datensatz mit dem man arbeiten kann :)

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.

EXIF Daten unter Ubuntu auslesen

Wed, 10 Jul 2019 00:00:00 +0000

Heute nur ganz kurz, weil ich es gerade gesucht, gefunden und vermutlich morgen wieder vergessen habe: Mit Hilfe von imagemagick könnt ihr unter Ubuntu die exif-Daten eurer Fotos auslesen.

`imagemagick` installieren

batman@helium:~$ sudo apt-get install imagemagick

mit `identify` die Meta-Daten auslesen

 1batman@helium:~$ identify -verbose link/to/image.jpg
 2
 3Image: image.jpg
 4  Format: JPEG (Joint Photographic Experts Group JFIF format)
 5  Mime type: image/jpeg
 6  Class: DirectClass
 7  Geometry: 458x458+0+0
 8  Resolution: 72x72
 9  Print size: 6.36111x6.36111
10  Units: PixelsPerInch
11  Colorspace: sRGB
12  Type: TrueColor
13  Base type: Undefined
14  Endianess: Undefined
15  Depth: 8-bit
16  Channel depth:
17    red: 8-bit
18    green: 8-bit
19    blue: 8-bit
20  ...

Output auf die exif-Informationen einschränken

Wenn ihr beispielsweise nur an den exif-Informationen interessiert seid, könnt ihr die Ausgabe mit grep eingrenzen.

batman@helium:~$ identify -verbose link/to/image.jpg | grep "exif:"

    exif:ApertureValue: 177537/78038
    exif:BrightnessValue: 128447/18170
    exif:ColorSpace: 1
    exif:ComponentsConfiguration: 1, 2, 3, 0
    exif:ExifImageLength: 458
    exif:ExifImageWidth: 458
    exif:ExifOffset: 170
    exif:ExifVersion: 48, 50, 50, 49
    exif:ExposureBiasValue: 0/1
    exif:ExposureMode: 0
    ...

Geo-Koordinaten auslesen

Und wenn euch beispielsweise nur die Geo-Koordinaten im Foto interessieren, könnt ihr natürlich auch danach suchen.

batman@helium:~$ identify -verbose link/to/image.jpg | grep "exif:GPS"

    exif:GPSAltitude: 125791/8327
    exif:GPSAltitudeRef: 0
    exif:GPSDateStamp: 2018:10:26
    exif:GPSDestBearing: 268263/3437
    exif:GPSDestBearingRef: T
    exif:GPSImgDirection: 611324/2369
    exif:GPSImgDirectionRef: T
    exif:GPSInfo: 1670
    exif:GPSLatitude: 35/1, 43/1, 5997/100
    exif:GPSLatitudeRef: N
    exif:GPSLongitude: 139/1, 44/1, 4874/100
    ...

With Great Power …

Ich habe das heute gebraucht, weil mir ein Foto auf verschiedenen Betriebssystemen in unterschiedlichen Orientierungen angezeigt wurde (unter Windows richtig, unter Ubuntu auf dem Kopf) und ich herausfinden wollte was das Foto eigentlich dazu sagt (Spoiler: natürlich hatte Ubuntu Recht).

Es hat mir wieder einmal vor Augen geführt, wie schnell man persönliche Informationen preis gibt. Ein Foto mit dem Handy daheim aufgenommen und auf Facebook geladen? Dann brauchst du eigentlich auch keine Adresse mehr hinterlegen - wo du wohnst ist dann eh klar.

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.

Lebenslauf mit Markdown erstellen

Mon, 08 Jul 2019 00:00:00 +0000

Zum Glück müssen die meisten von uns nicht jeden Tag den eigenen Lebenslauf zu Papier bringen. Wann genau war ich nochmal bei Firma X? Wie lang dauerte das Praktikum in München? Und wie war nochmal der genaue Titel der Bachelorarbeit? …

Das eh schon aufwendige Prozedere wird noch ein bisschen aufwendiger, wenn man zusätzlich die Formatierungseigenheiten von Word verstehen muss. Richtig schön wird es, wenn sich Dateiformate geändert und einst schön formatierte Dokumente mittlerweile gruselig aussehen.

Ich hatte daher seit längerem den Wunsch, den nächsten Lebenslauf so nerdfreundlich wie möglich anzugehen. Idealerweise als leicht zu schreibendes Markdown-File, das trotzdem mit einer modernen Formatierung aufwarten kann.

Gesucht - Gefunden. Auf dem Blog von Christophe-Marie Duquesne bin ich fündig geworden. Das Design des dort vorgestellten Lebenslaufs hat mich zwar nur semi-überzeugt, aber das zugrunde liegende CSS lässt sich ja leicht anpassen.

Lass es uns ausprobieren!

Als erstes installieren wir die notwendigen Programme: Wir benötigen einen Editor. Ich mag aktuell VS Code - du kannst aber jeden beliebigen verwenden (wenn es dich glücklich macht sogar vim).
Zur Umwandlung des Markdown-Files nach HTML benötigen wir pandoc. Eine Anleitung zur Installation findest du hier: https://pandoc.org/installing.html
Und schließlich solltest du noch wkhtmltopdf installieren, das aus den erzeugten HTML-Dateien schöne PDFs macht: https://wkhtmltopdf.org/downloads.html

Lebenslauf in Markdown übersetzen

Dann übersetzen wir den Lebenslauf nach Markdown. Die Datei könnte wie folgt aussehen (cv.md). Falls euch die Markdown-Syntax entfallen ist, könnt ihr hier nochmal spicken. Für mich neu war die ":"-Notation, um Definitionen zu erstellen. Das sorgt für ein schönes Zweispalten-Layout - ideal für den Lebenslauf.

`cv.md`

# Bruce Wayne

> +1 555 123456 • ceo@wayne-enterprises.com\
> Wayne Manor, Gotham, USA

## Berufserfahrung
1939 - heute
:	**Wayne Enterprises**, Vorstandsvorsitzender

1939 - heute
:   **Fledermaus-Fanclub**, Verbrechensbekämpfer
...

Design des Lebenslaufs definieren

Als nächstes definieren wir, wie die einzelnen Bestandteile formatiert werden sollen (style.css). Als Ausgangspunkt empfehle ich euch, die Vorlage aus Christophe-Maries GitHub-Repo zu verwenden. Ich habe sie für meinen Lebenslauf aber deutlich angepasst.

`style.css`

body {
    font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
    color: #000000;
    width: 800px;
    margin: auto;
    background: #FFFFFF;
    padding: 10px 10px 10px 10px;
}

Befehle nur einmal schreiben, dank kleinem Skript

Um die Consolen-Befehle nur einmal tippen zu müssen, erstellen wir als letztes noch ein kleines Skript (create_cv.sh). Bitte denkt daran, die Dateinamen anzupassen falls ihr andere verwendet habt. Ich gehe davon aus, dass der Lebenslauf cv.md und das Stylesheet style.css heißt.

`create_cv.sh`

#!/bin/bash

# Translate MD --> HTML
pandoc --standalone -c style.css --from markdown --to html -o cv.html cv.md --metadata pagetitle="CV"

# Translate HTML --> PDF
wkhtmltopdf cv.html cv.pdf

Lebenslauf erstellen

Lassen wir es laufen! Skript ausführbar machen und los geht’s!

batman@helium:~$ chmod + x create_cv.sh
batman@helium:~$ ./create_sv.sh

Danach solltet ihr zwei neue Dateien cv.html und cv.pdf im Ordner finden.

Fertig :-)

Unser Lebenslauf von Batman sieht übrigens im ersten Entwurf wie folgt aus. Mit ein bisschen mehr Inhalt und Farbe lässt sich das schnell aufhübschen.

Code auf Github

Wie immer findet ihr den gesamten Code auf GitHub: https://github.com/s01ren/markdown_cv

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.

Howto on Søren's Blog

Run Hugo Blog on uberspace

Prepare your machine

Create a new asteroid

The nerdy stuff

Create and publish your blog

Publish to Blog from iPad

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

Telegram Bot erstellen

Telegram Bot einem Kanal hinzufügen

ChatID herausfinden

Nachrichten an Telegram-Kanal senden

Corona-Daten des RKI mit Python visualisieren

Corona-Daten des RKI mit Python herunterladen

Etwas coolere ggplots erstellen

Daten sammeln

Basis-Plot erstellen

All hail the Spätzle!

Make the theme great again!

Reden ist Silber, Annotierung ist Gold!

Look here!

OSM Daten als SVG exportieren

Los geht’s!

Die Wundermaschine anwerfen

Hugo mit Git auf dem uberspace nutzen

Vorgeschichte

Git und Hugo lokal installieren

Hugo-Blog anlegen

Erster Artikel

uberspace vorbereiten

Domain anlegen

Hugo installieren

Git-Repository für Hugo-Blog anlegen

Git Hook anlegen

Push auf den uberspace

Komplexe CSV-Dateien einlesen

Das Problem

Die Lösung

EXIF Daten unter Ubuntu auslesen

imagemagick installieren

mit identify die Meta-Daten auslesen

Output auf die exif-Informationen einschränken

Geo-Koordinaten auslesen

With Great Power …

Lebenslauf mit Markdown erstellen

Lass es uns ausprobieren!

Lebenslauf in Markdown übersetzen

cv.md

Design des Lebenslaufs definieren

style.css

Befehle nur einmal schreiben, dank kleinem Skript

create_cv.sh

Lebenslauf erstellen

Code auf Github

`imagemagick` installieren

mit `identify` die Meta-Daten auslesen

`cv.md`

`style.css`

`create_cv.sh`