GREL | FDMLab@LABW

Workshop - Python in OpenRefine

Wed, 14 May 2025 00:00:00 +0000

Wir verwenden Python zusammen mit OpenRefine.

Jython in der OpenRefine Dokumentation.
Einsteiger Workshop 19 Daten mit OpenRefine clustern.
Blogbeitrag Named Entity Recognition mit OpenRefine und spaCy.

Dieser Workshop wurde erstellt mit OpenRefine Version 3.5.0.
Dieser Workshop wurde zuletzt getestet mit OpenRefine Version 3.9.3.

Die in diesem Tutorial behandelten Funktionen sind teilweise erst verfügbar seit der Version OpenRefine 3.9.3.

Jython

Quasi überall, wo man in OpenRefine GREL-Expressions schreiben kann, kann man stattdessen auch auf Jython umstellen. Also beispielsweise für den Transformations-Dialog, Facets oder neu auch für eigene Clustering Methoden.

Bildschirmfoto des Transformations Dialogs mit Jython.

Praktisch wird das Jython-Snippet, welches man wie in Abbildung 1 gezeigt im Dialog eingibt, in eine Python-Funktion gepackt und dann von Jython ausgeführt. Daher benötigt man im Unterschied zu GREL ein return Statement, um anzugeben, welcher Wert zurückgegeben wird.

def some_fun_name(value, cell, cells, row, rowIndex, value1, value2):
 ...

Das eingegebene Snippet wird quasi anstelle von ... eingesetzt.

Zu den in GREL zur Verfügung stehenden Variablen haben wir schon einiges geschrieben. Diese stehen mit Ausnahmen in Jython unter OpenRefine ebenfalls zur Verfügung. Beispielsweise fehlt die Variable columnName mit dem aktuellen Spaltennamen.

Jython selbst ist eine Java Implementierung von Python. Das bedeutet, dass es innerhalb von Java interpretiert wird und man auch von Jython Code aus auf verfügbare Java Methoden zugreifen kann.

Leider hat das Projekt den Sprung auf Python 3 nicht geschafft und unterstützt daher nur die Funktionalität von Python 2.7. Das macht auch die Verwendung von externen Python Bibliotheken innerhalb von Jython deutlich komplexer.

Es gibt nur noch selten Python Bibliotheken, die Python 2.7 unterstützen. Und es können auch nur Python Bibliotheken verwendet werden, die komplett in Python geschrieben wurden. Einige gerade sehr beliebte Python Projekte verwenden aus Performance Gründen unter der Haube kompilierte Programmiersprachen wie C, Fortran oder Rust. Diese können unter Jython nicht direkt verwendet werden.

Praktisch ist die Ausführung von Jython Code in OpenRefine auch deutlich langsamer, als z.B. GREL oder Clojure Code. Das macht es eher schwierig komplexere Algorithmen z.B. für das Clustering direkt zu hinterlegen.

Alternativ kann von OpenRefine aus, via Jython auf externen Python Code zugegriffen werden, was im folgenden Teil vertieft wird.

Python

Standard Setup

Wir verfolgen die Idee von OpenRefine aus auf Python Code zuzugreifen, der nicht innerhalb von Jython ausgeführt wird. Dafür benötigen wir einen Blick in das Python Projekt Setup.

--- title: Python Setup config: look: handDrawn theme: neutral --- flowchart LR subgraph web[fas:fa-globe Web] subgraph python[fab:fa-python Python] python_3_12[fab:fa-python 3.12] python_3_13[fab:fa-python 3.13] end subgraph packages[fas:fa-folder-tree Packages] typer_0_15[Typer 0.15] fastapi_0_115[FastAPI 0.115] spacy_3_8[spaCy 3.8] my_project_0_1[My Project 0.1] end end subgraph laptop[fas:fa-laptop Laptop] subgraph local_python[fab:fa-python Python] local_python_3_12[fab:fa-python 3.12] local_python_3_13[fab:fa-python 3.13] end subgraph local_packages[fas:fa-folder-tree Packages] local_typer_0_15[Typer 0.15] local_fastapi_0_115[FastAPI 0.115] subgraph local_spacy_3_8[spaCy 3.8] c_code[fab:fa-c Code] compiled_c_code[fab:fa-c compiled] end end subgraph my_project[My Project] subgraph venv[fas:fa-folder-open venv] venv_python_3_12[fab:fa-python 3.12] venv_typer_0_15[Typer 0.15] venv_fastapi_0_115[FastAPI 0.115] venv_spacy_3_8[spaCy 3.8] end package_my_project[My Project] end end python --(1)--> local_python python_3_12 ~~~ local_python_3_12 python_3_13 ~~~ local_python_3_13 packages --(2)--> local_packages typer_0_15 ~~~ local_typer_0_15 fastapi_0_115 ~~~ local_fastapi_0_115 spacy_3_8 ~~~ local_spacy_3_8 c_code --(3)--> compiled_c_code local_python_3_12 --(4)--> venv_python_3_12 local_typer_0_15 --(4)--> venv_typer_0_15 local_fastapi_0_115 --(4)--> venv_fastapi_0_115 local_spacy_3_8 --(4)--> venv_spacy_3_8 my_project_0_1 ~~~ package_my_project package_my_project --(5)--> my_project_0_1

Für ein typisches Python Projekt benötigt man fünf Schritte, die durch verschiedene Tools in unterschiedlichem Ausmaß unterstützt werden.

Schritt 1: Python Interpreter

Zuerst benötigt man einen Python Interpreter, der es ermöglicht Python Code auf dem eigenen Rechner auszuführen. Zur Verwaltung verschiedener Python Versionen auf dem Rechner gibt es zum Beispiel das Projekt pyenv.

Schritt 2: Dependency Management

Üblicherweise werden verschiedene externe Bibliotheken benötigt. Diese stehen zum Beispiel im Python Package Index (PyPI) zur Verfügung und können mit pip verwaltet werden.

Alternativen zur Verwaltung der Abhängigkeiten sind Poetry, pip-tools und pipx.

Schritt 3: Compiler

Wie schon angesprochen beinhalten manche Python Projekte nicht nur Python Code, sondern auch Code in kompilierten Sprachen. Wenn für die von euch verwendete Kombination aus CPU und Betriebssystem (noch) kein kompiliertes Binärpaket für die Bibliothek zur Verfügung steht, dann muss das Paket ggf. auf eurem Rechner kompiliert werden. Dafür werden entsprechende Compiler und Entwicklungspakete auf dem Rechner benötigt.

Alternativ gibt es auf conda-forge eine Sammlung schon kompilierter Pakete.

Schritt 4: Virtuelle Umgebung

Erfahrungsgemäß bleibt es nicht bei einem Python Projekt auf dem eigenen Rechner. Um Konflikte zwischen den Python Versionen und/oder Abhängigkeiten zu vermeiden, ist es üblich für jedes Projekt eine eigene virtuelle Umgebung anzulegen.

Dafür gibt es das Werkzeug venv, welches früher ein separates Paket war, und seit Python 3.3 in den Standard übernommen wurde.

Schritt 5: Package und Release Management

Möchte man das Projekt anschließend für andere z.B. im Python Package Index zur Verfügung stellen, dann muss es davor noch in das passende Paketformat umgewandelt werden. Da das für die Benutzung mit OpenRefine nicht relevant ist, wird dieser Schritt hier nicht vertieft.

uv

Das oben beschriebene Setup klingt recht kompliziert und daher abschreckend gerade für kleinere Experimente. Spätestens seit 2025 setzt sich bei Python Entwicklern hier das Projekt uv durch, welches die Schritte 1, 2, 4 und 5 in einem Werkzeug vereint und das Python Setup dadurch deutlich vereinfacht.

Für die Installation von uv werden mehrere einfache und direkte Wege beschrieben.

Sollte man mit dem Windows-Subsystem for Linux (WSL) arbeiten, dann benötigt man die Installationsanleitung für Linux, auch wenn man Windows als Betriebssystem hat.

uv hat (quasi) drei für uns relevante Modi:

uvx zum Ausführen von Tools.
uv run zum Ausführen von Skripten.
uv zum Arbeiten mit Projekten
(mehrere abhängige Python Dateien, separates Dependency Management).

Wir konzentrieren uns in dieser Anleitung auf die ersten beiden.

Reconciliation Service

Um die Verwendung von uvx zum Ausführen von externen Python Werkzeugen zu demonstrieren, erstellen wir einen eigenen Reconciliation Service basierend auf einer CSV-Datei mit uvx und csv-reconcile. Zum Herunterladen der CSV-Datei von 12 Daten zwischen Projekten abgleichen verwenden wir uvx mit httpie.

In einem Terminal wie iTerm, xTerm, Bash oder Powershell führen wir den folgenden Befehl aus.

uvx --from httpie http --download GET https://fdmlab.landesarchiv-bw.de/data/openrefine-workshop/12_staedte-in-bw-geokoordinaten.csv

Dieses kompakte Snippet lädt die zu diesem Zeitpunkt standardmäßige Python Version und die aktuellste Version von httpie herunter, erstellt damit eine virtuelle Umgebung (venv) und führt darin den Befehl http --download GET ... aus.

Den Reconciliation Service basierend auf der im letzten Schritt heruntergeladenen Datei erstellen wir in zwei Schritten:

Datenbank für Reconcilation Service erstellen
Reconciliation Service starten

uvx csv-reconcile init 12_staedte-in-bw-geokoordinaten.csv "GND ID" "Name"

Mit diesem Snippet erstellen wir die Datenbank für den Reconciliation Service und legen die Spalte “GND ID” als ID-Spalte fest und die Spalte “Name” als Standardspalte für den Abgleich. Den Reconciliation Service selbst starten wir mit dem folgenden Befehl.

uvx csv-reconcile serve

In OpenRefine können wir den Reconciliation Service anschließend hinzufügen mit: http://127.0.0.1:5000/reconcile.

Datenbank mit eigener Konfiguration

Der oben erstelle Reconciliation Service ist recht generisch und es fehlt z.B. noch die Vorschaufunktion für die einzelnen Elemente. Um den Service nach unseren Anforderungen zu konfigurieren, erstellen wir eine Datei config.py mit dem folgenden Inhalt.

SERVER_NAME="localhost:5000"
CSVKWARGS={'delimiter': ',', 'quotechar': '"'}
CSVENCODING='UTF-8'
MANIFEST = {
 "name": "Städte in BW Reconciliation Service",
 "identifierSpace": "https://normdaten.landesarchiv-bw.de/ids",
 "schemaSpace": "https://normdaten.landesarchiv-bw.de/schema",
 "extend": {
 "propose_properties": {
 "service_url": "http://localhost:5000",
 "service_path": "/properties"
 }
 },
 "preview": {
 "url": "http://localhost:5000/preview/{{id}}",
 "width": 500,
 "height": 300
 }
}

Anschließend erstellen wir die Reconciliation Datenbank mit der neuen Konfiguration.

uvx csv-reconcile init --config config.py 12_staedte-in-bw-geokoordinaten.csv "GND ID" "Name"

Der neue Service ist nach dem Starten unter http://localhost:5000/reconcile erreichbar.

uvx csv-reconcile serve

In OpenRefine müssen wir den CSV Reconciliation Service aktuell bei jeder Änderung der Konfiguration neu hinzufügen.

Der Reconciliation Service kann jetzt wie in Abbildung 2 mit dem Beispiel aus 12 Daten zwischen Projekten abgleichen getestet werden.

Screencast zum Reconciling mit OpenRefine und CSV-Datei.

Eigene Skripte

Um Command Line Interfaces (CLIs) zu erstellen, gibt es in Python die Standardbibliothek argparse. Meistens möchte man aber “nur mal schnell” aus einer Python Funktion ein Werkzeug erstellen, welches von der Kommandozeile aufgerufen werden kann. Ein nützliches Python Projekt dafür ist typer.

Typer Hello World Beispiel

Ein einfaches “Hello World” Beispiel mit uv und Typer ist im folgenden Quellcode aus hello_world.py abgebildet.

# /// script
# requires-python = ">=3.12"
# dependencies = [
# "typer",
# ]
# ///
import typer

def hello_world():
 print("Hello World")

if __name__ == "__main__":
 typer.run(hello_world)

Zu Beginn wird über Inline Metadaten definiert, dass das Skript mit Python 3.12 oder neuer ausgeführt werden soll und das Skript zusätzlich die externe Abhängigkeit typer benötigt.

Das Werkzeug uv unterstützt diese inline Metadaten, so dass zum Ausführen dieses Skriptes in einem Terminal lediglich uv run hello_world.py ausgeführt werden muss.

Das Werkzeug Typer übersetzt den CLI-Aufruf für die Python Funktion, und validiert und konvertiert dabei die Eingabedaten.

Typer Beispiel mit Parametern

Wir beginnen mit einem einfachen Beispiel.

# /// script
# requires-python = ">=3.12"
# dependencies = [
# "typer",
# ]
# ///
import typer

def add(a, b):
 print(a + b)

if __name__ == "__main__":
 typer.run(add)

Die Funktion add soll zwei Parameter a und b miteinander addieren und dann ausgeben. Zum Ausgeben des Ergebnisses verwenden wir die Funktion print. Das Werkzeug typer erkennt automatisch die beiden Parameter a und b und meldet, wenn diese nicht gesetzt sind. Unter uv run add.py --help erhalten wir einen Informationstext zur Benutzung unseres CLI-Tools.

Standardmäßig werden die Parameter als Text interpretiert. Mit so genannten Type Hints können wir Typer mitteilen, dass wir hier Zahlen erwarten.

def add(a: int, b: int):
 print(a + b)

Es ist auch möglich, optionale Parameter wie c mit anzugeben.

def add(a: int, b: int, c: int = 0):
 print(a + b + c)

Individuelle Konfigurationen können mit Type Annotations hinterlegt werden.

def add(a, b, c: Annotated[int, typer.Argument()] = 0):
 print(a + b + c)

Mit den Annotationen lässt sich bei Bedarf der Text für die Hilfe weiter spezifizieren. Hier das fertige Skript mit ausführlicherem Hilfstext.

# /// script
# requires-python = ">=3.12"
# dependencies = [
# "typer",
# ]
# ///
import typer
from typing_extensions import Annotated

def add(
 a: Annotated[int, typer.Argument(help="The first number to add.")],
 b: Annotated[int, typer.Argument(help="The second number to add.")],
 c: Annotated[int, typer.Argument(help="The optionally third number to add.")] = 0,
):
 """
 Add the numbers in `a` and `b` and optionally `c` if `c` is provided.
 """
 print(a + b + c)

if __name__ == "__main__":
 typer.run(add)

Das Praktische an Typer ist, dass man “nur zum Ausprobieren” lediglich die type hints und den Aufruf von Typer im Skript ergänzen muss. Bei Bedarf können ausführlichere Hilfstexte oder Validierungen hinterlegt werden, deren Ergebnis in Abbildung 3 gezeigt ist.

Screenshot Terminal mit von Typer generierten Hilfstext.

Zugriff von OpenRefine auf Python Skript

Von OpenRefine heraus, lässt sich mit Jython recht unkompliziert auf das externe Python Skripte zugreifen. Es muss lediglich der Pfad des Skriptes in dem Jython Snippet unten angepasst werden. Ggf. müssen auch noch Parameter für das Skript ergänzt werden.

import subprocess
script = "C:\\...\\python_script.py"
res = subprocess.check_output(
 ["uv", "run", script, "\""+value+"\""],
 shell=True,
)
return res

Probleme beim Zugriff von OpenRefine auf Python Skripte

Der direkte Zugriff auf ein Skript ist erst einmal relativ performant, hat in der Praxis aber mehrere Probleme.

Die korrekte Übergabe von Daten an das Skript via Parametern ist nicht ganz so einfach. Besonders, wenn die Daten größer sind ggf. Sonderzeichen enthalten, …
Man ist selbst für die Fehlerbehandlung verantwortlich. Also dass die Skripte auch irgendwann beendet werden, bei zu langer Laufzeit abgebrochen werden, usw.
Es wird lediglich Text zurückgegeben. Die Interpretation in ein bestimmtes Format muss dann in Jython oder in einem Nachbearbeitungsschritt erfolgen.
Manche Skripte oder Tools müssen initial erst einmal Daten in den Arbeitsspeicher laden. Insbesondere bei Machine Learning Anwendungen kann das mehrere Sekunden dauern. Dies erfolgt bei jedem Skriptaufruf wieder erneut.

Daher ist es wesentlich stabiler stattdessen mit eigenen Web-APIs zu arbeiten.

Eigene Web-APIs mit FastAPI

--- title: Script vs Web-API config: look: handDrawn theme: neutral --- flowchart LR subgraph openrefine["OpenRefine"] subgraph jython["Jython"] jython_code["Jython Code"] end end subgraph venv script["fab:fa-python Skript"] end subgraph uvicorn["Uvicorn"] subgraph fastapi["FastAPI"] python_code["fab:fa-python Code"] end end jython_code -.-> script jython_code -.-> script jython_code -.-> script jython_code -.-> script jython_code -.-> script jython_code -.-> script jython_code -.-> script jython_code -.-> script jython_code -.-> script jython_code <--HTTP--> python_code

Für Web-APIs gibt es etablierte und stabile Protokolle zum Austausch von Daten. Ähnlich wie mit Typer können wir mit FastAPI unsere Python-Funktionen als Web-API zur Verfügung stellen. Mit einem Server wie uvicorn sorgen wir dabei für eine Stabilität der angestoßenen Prozesse für die Abfragen.

Beispielcode für spaCy

Das folgende Skript lädt ein deutschsprachiges Modell von spaCy und berechnet über Word Embeddings die Ähnlichkeit bzw. hier die Distanz der beiden übergebenen Texte.

# /// script
# requires-python = ">=3.12,<3.13"
# dependencies = [
# "spacy",
# "typer",
# "de_core_news_lg @ https://github.com/explosion/spacy-models/releases/download/de_core_news_lg-3.8.0/de_core_news_lg-3.8.0.tar.gz",
# ]
# ///

import typer
import de_core_news_lg as model


def spacy_distance(a: str, b: str):
 nlp = model.load()
 doc_a = nlp(a)
 doc_b = nlp(b)
 dist = 1 - doc_a.similarity(doc_b)
 print(dist)


if __name__ == "__main__":
 typer.run(spacy_distance)

Das Skript hat den eindeutigen Nachteil, dass es bei jedem Aufruf das “große” Sprachmodell laden muss, was mehrere Sekunden dauert. Hier im Vergleich das Skript spacy_distance_fastapi.py, welches die Funktionalität via FastAPI zur Verfügung stellt.

# /// script
# requires-python = ">=3.12,<3.13"
# dependencies = [
# "spacy",
# "fastapi",
# "uvicorn",
# "de_core_news_lg @ https://github.com/explosion/spacy-models/releases/download/de_core_news_lg-3.8.0/de_core_news_lg-3.8.0.tar.gz",
# ]
# ///

import de_core_news_lg as model
import uvicorn
from fastapi import FastAPI

app = FastAPI()
nlp = model.load()


@app.get("/distance")
def spacy_distance(a: str, b: str) -> float:
 doc_a = nlp(a)
 doc_b = nlp(b)
 dist = 1 - doc_a.similarity(doc_b)
 return dist


if __name__ == "__main__":
 uvicorn.run("spacy_distance_fastapi:app", host="127.0.0.1", port=5000)

Die Verarbeitungspipeline für die Texte mit dem “großen” Sprachmodell wird außerhalb der Python Methode definiert, weshalb das Modell pro Aufruf nur einmal aufgerufen werden muss. Im Vergleich zum direkten Skriptaufruf, ist der Zugriff auf unsere lokale Web-API zwar etwas langsamer. Wir profitieren aber von der Müglichkeit ladeintensive Prozesse nur einmal beim Starten auszuführen, sowie von dem zusätzlichen Protokoll im Bereich Fehlerbehandlung, Validierung von Eingaben und Antworten.

Ähnlich wie bei Typer übernimmt FastAPI hier das Mapping der Benutzeranfrage auf die entsprechende Python Funktion. Gleich wie bei Typer werden Type Hints für das Mapping, die Dokumentation und die Validierung verwendet. Auch bei FastAPI kann die Dokumentation mit weiteren Annotationen erweitert und personalisiert werden.

Somit lassen sich mit FastAPI eigene Web-APIs ähnlich leicht erstellen, wie einfache Python Skripte mit Typer. Ausführliche Beispiele stehen im Anhang bzw. als GitHub Gist unter spacy_fastapi.py und rapidfuzz_fastapi.py zur Verfügung.

Von OpenRefine heraus kann man via Jython auf die (lokalen) Web-APIs zugreifen.

Zugriff via GET

Web-APIs unterscheiden für den Abruf von Daten zwischen GET- und POST-Requests (Anfragen). Für GET-Requests gibt es in OpenRefine die Möglichkeit den Dialog Add column by fetching URLs zum Nachladen von Daten zu verwenden.

"http://localhost:5000/ner?text=" + escape(value, "url")

Hier kann man mit einfachem GREL die benötigte URL zusammen bauen. Man sollte jedoch daran denken, die Parameter mit escape für die URL kompatibel aufzubereiten.

In Abbildung 4 ist der Dialog aus 18 Nachladen von Geokoordinaten gezeigt.

Bildschirmfoto des Dialogs zum Nachladen von URLs für GeoNames.

Möchte man eine Web-API z.B. von einem Facet oder einem Clustering-Dialog heraus aufrufen, benötigt man dafür das folgende Jython-Snippet um einen validen GET-Request zu erstellen.

import json, urllib, urllib2
url = "http://localhost:5000/ner"
request_data = urllib.urlencode({
 "text": value.encode("utf-8"),
})
response = urllib2.urlopen(url + "?" + request_data)
return json.dumps(json.load(response), ensure_ascii=False)

Zur Erinnerung: Es gibt Python Bibliotheken wie requests, die das Erstellen und Verarbeiten von Web-Requests deutlich vereinfachen. Wir arbeiten in OpenRefine aber mit Jython und können daher nicht einfach auf externe Bibliotheken zugreifen.

Zugriff via GET und Form

Manche Web-APIs erwarten einen GET-Request mit zusätzlichem Nutzdaten z.B. aus einem Formular. Das lässt sich in Jython / Python 2.7 mit folgendem Snippet umsetzen.

import json, urllib, urllib2
url = "http://localhost:5000/ner"
request_data = urllib.urlencode({
 "text": value.encode("utf-8"),
})
response = urllib2.urlopen(url, request_data)
return json.dumps(json.load(response), ensure_ascii=False)

Der Unterschied zum letzten Beispiel ist, dass request_data als zusätzliche Nutzdaten mit einem Komma getrennt an urllib2 übergeben werden, anstatt sie mit an die URL zu kodieren.

Zugriff via POST

Der in den Beispielen im Anhang verwende Use-Case ist das Verwenden von POST-Requests. Hier werden die Nutzdaten als JSON kodiert an den Request angehängt. Das macht die Kodierung der Daten in der Anfrage komplexer, gleichzeitig aber die Übermittlung stabiler.

import json, urllib, urllib2
url = "http://localhost:5000/ner"
request_data = json.dumps({
 "text": value.encode("utf-8"),
})
request = urllib2.Request(
 url,
 request_data,
 {"Content-Type": "application/json"},
)
response = urllib2.urlopen(request)
return json.dumps(json.load(response), ensure_ascii=False)

Der komplette Workflow vom Starten des Web-Service, bis zur Verwendung von RapidFuzz als eigene Clustering Methode in OpenRefine ist in dem Screencast in Abbildung 5 gezeigt.

Screencast zur Verwendung von uv, FastAPI und RapidFuzz als eigene Clustering Methode bei OpenRefine.

Fazit

Kleinere Skripte mit Jython / Python 2.7 in OpenRefine sind möglich, jedoch gerade beim Clustering oder bei der Nachnutzung von externen Python Projekten problematisch.

Mit Typer und FastAPI lassen sich aus Python Funktionen heraus schnell CLI-Tools oder Web-APIs erstellen. Die beiden Werkzeuge ermöglichen es sowohl mit wenig Aufwand Prototypen zu erstellen, als auch diese zu dokumentierten praktischen Tools zu erweitern.

Mit uv sind die Hürden für das Erstellen von indivduellen Python Umgebungen für einzelne Skripte sehr stark gesenkt worden. Das reduziert nicht nur den Entwicklungsaufwand, sondern erleichtert auch die Nachnutzung von Skripten für Nutzerinnen und Nutzer.

Mit der Kombination aus Jython, uv und wahlweise Typer oder FastAPI lassen sich dadurch modernste Python Anwendungen direkt mit OpenRefine verbinden.

Anhang

FastAPI Wrapper für spaCy

FastAPI Wrapper für RapidFuzz

Workshop - Erweitertes Clustering

Mon, 05 May 2025 00:00:00 +0000

Wir verwenden eigene Clustering Methoden in OpenRefine, um Schreibweisen zu vereinheitlichen.

Clustering in der OpenRefine Dokumentation.
Clustering im OpenRefine Wiki.
Einsteiger Workshop 05 Daten mit OpenRefine clustern.

Dieser Workshop wurde erstellt mit OpenRefine Version 3.5.0.
Dieser Workshop wurde zuletzt getestet mit OpenRefine Version 3.9.3.

Die in diesem Tutorial behandelte Funktionalität ist verfügbar seit OpenRefine 3.9.3.

Daten

Wir benötigen die folgenden Dateien als OpenRefine Projekt:

💾 Wir benötigen die folgende Datei (Rechtsklick und “Ziel speichern unter…”):

Erweitertes Clustering

In der nachfolgenden Tabelle sind typische Probleme dargestellt, die mit den Standard Clusteringverfahren von OpenRefine nicht direkt zu lösen sind.

Ort	Name	Name 2
XY, Ort in Bayern	Hans Meier	Hans Meier
XY (Bayern)	Maier, Hans	Hans Peter Meier
XY in Bayern	Hans Peter Meyer	Hans P. Meier
XY; Bayern	Hans (Peter) Maier	Hans (Peter) Meier
XY \| Bayern	Hans P. Mayer	Hans Müller
XY, liegt in Bayern	Meier, Hans (Peter)	Hans Peter Müller

In der Spalte Ort gibt es unterschiedliche Ansetzungen für einen Ort in Bayern. Die Spalte Name enthält unterschiedliche Schreibweisen für den Namen Hans Peter Meier. Und die Spalte Name 2 enthält Hans Peter Meier und Hans Peter Müller jeweils mit und ohne Zweitnamen.

Keying Functions

Eine von OpenRefine unterstützte Art des Clusterings sind so genannte key collision Verfahren.

Die Idee dahinter ist, dass ein Eingabetext nach einheitlichen Regeln umgewandelt wird. Die Ergebnisse der Umwandlungen werden dann verglichen und die gleichen Ergebnisse zusammengefasst.

Typische Beispiele für Umwandlungsregein sind:

Wörter sortieren
Sonderzeichen entfernen oder umwandeln
Wörter auf Normalformen bringen
Synonyme auflösen
n-Gramme erstellen
…

Einige dieser Methoden sind in OpenRefine implementiert. Dennoch sind sie häufig nicht ausreichend für spezifischere Probleme. Seit OpenRefine 3.9.3 ist es möglich eigene Clustering Algorithmen in den von OpenRefine unterstützten Programmiersprachen zu hinterlegen.

Im Folgenden stellen werden zwei Algorithmen für das Keying vorstellt.

OrtFingerprint

Das Problem bei den Werten in der Spalte Ort ist, dass wir unterschiedliche Sonderzeichen, als auch “überflüssige” Wörter haben, die eine Zusammenführung via Clustering erschweren.

Der Screencast in Abbildung 1 zeigt, wie im Clustering Dialog unter Manage clustering functions eigene Clustering Funktionen hinterlegt werden. In dem Beispiel ist das ein GREL-Ausdruck, der die Fingerprint Methode von OpenRefine mit unserem domänenspezifischem Wissen kombiniert.

Screencast zum Anlegen und Anwenden eigener Clustering Funktionen.

In dem nachfolgenden GREL-Ausdruck werden vor der Anwendung der Fingerprint Methode von Openrefine die folgenden Schritte durchgeführt:

Sonderzeichen entfernen, die die Fingerprint Methode nicht berücksichtigt ("|").
Stoppworte entfernen ("Ort").
Klein geschriebene Wörter entfernen (/\b[a-z]+\b/).

fingerprint(value.replace("|", "").replace("Ort", "").replace(/\b[a-z]+\b/, ""))

Das Ergebnis ist eine spezifische Fingerprintmethode, die wie in Abbildung 1 gezeigt, unterschiedliche Ansetzungen bei Orten berücksichtigen kann.

CologneFingerprint

Die in OpenRefine implementierten Clustering-Methoden lassen sich nachnutzen und kombinieren. Der folgende GREL-Ausdruck wendet zuerst das Fingerprinting und dann die Normalisierung bzgl. der deutschen Aussprache mit Cologne Phonetic an.

fingerprint(value).phonetic("cologne-phonetic")

Auf diese Weise können die Werte in der Spalte Name wie in Abbildung 2 gezeigt (größtenteils) zusammengeführt werden.

Bildschirmfoto des Clustering Dialogs mit kombiniertem Fingerprinting und Cologne Phonetic Algorithmus.

Distance Functions

Bei den Distanzfunktionen werden die Texte nicht umgewandelt, sondern mit unterschiedlichen Metriken berechnet, wie “weit” sie voneinander entfernt sind. Dafür erhält man Zugriff auf die Variablen value1 und value2 und gibt eine Zahl zurück, die die Distanz zwischen den beiden Werten repräsentiert. Je größer die Zahl, desto “unähnlicher” sind die Texte.

Manche Algorithmen betrachten auch positiv die Ähnlichkeit (Similarity) von Texten. Dabei sind die beiden Metriken einfach umzurechnen: $distance = 1 - similarity$.

Manche Algorithmen betrachten die Ähnlichkeit bzw. die Distanz auch nicht als Wert zwischen 0 und 1.0, sondern zwischen 0 und 100.

FingerprintDistance

Ein typisches Problem ist, dass man sowohl unterschiedliche Ansetzungen, als auch leichte Abweichungen hat. Hier lässt sich zum Beispiel das Fingerprinting in OpenRefine mit der Implementierung der Levenshtein-Distanz kombinieren.

levenshteinDistance(fingerprint(value1), fingerprint(value2))

In Abbildung 3 sind die Ergebnisse der kombinierten Algorithmen auf der Spalte Name gezeigt.

Bildschirmfoto des Clustering Dialogs mit kombiniertem Fingerprinting und Levenshtein-Algorithmus.

AbsoluteDistance

In der Spalte Name 2 ist das Problem mit Extrabegriffen wie Zweitnamen etwas deutlicher gezeigt. Hier könnte man Methoden anwenden, die Distanzen auf Wortebene berechnen.

Im Folgenden Code Beispiel ist ein Jython-Algorithmus, der die Datenstruktur Counter verwendet um eine Art Bag-of-words Model zu erstellen.

Die Distanz ist hier, die Anzahl an unterschiedlichen Worten zwischen den beiden Texten.

import re
from collections import Counter

splitter = re.compile(r"\W+")
words = Counter(splitter.split(value1.strip()))
words.subtract(Counter(splitter.split(value2.strip())))
dist = sum(abs(count) for count in words.values())

return dist

Wie in Abbildung 4 gezeigt, hilft diese Methode bei dem Problem von einzelnen Extrabegriffen, die den auf Buchstabenebene arbeitenden Levenshtein-Algorithmus “überfordern”.

Bildschirmfoto des Clustering Dialogs mit AbsoluteDistance Funktion.

CosineDistance

Eine wichtige Distanzmetrik zur Berechnung der Ähnlichkeit (oder in dem Fall der Distanz) zwischen Vektoren ist die Kosinus-Ähnlichkeit. Dies ist exemplarisch in dem folgenden Jython-Code umgesetzt.

import re
from collections import Counter

splitter = re.compile(r"\W+")
a = Counter(splitter.split(value1.strip()))
b = Counter(splitter.split(value2.strip()))
words = list(set(a) | set(b))

a_vec = [a.get(word, 0) for word in words]
b_vec = [b.get(word, 0) for word in words]

v_len = lambda v: sum(x * x for x in v) ** 0.5
v_dot = lambda v1, v2: sum(x * y for x, y in zip(v1, v2))
dist = 1 - v_dot(a_vec, b_vec) / (v_len(a_vec) * v_len(b_vec))

return dist

Ähnlich wie bei der AbsoluteDistance zählen wir, wie oft ein Wort im Text vorkommt. Diesmal berücksichtigen wir (vereinfacht ausgedrückt) zusätzlich die Länge der Texte. Dadurch ist der Rückgabewert eine Zahl zwischen 0 und 1. Wie in Abbildung 5 gezeigt, erhält man mit dem in OpenRefine voreingestellten Standardradius von 1.0 dadurch alle möglichen Cluster. Für sinnvolle Ergebnisse sollte man den Radius bei Verwendung der Kosinus-Ähnlichkeit also auf Werte zwischen 0.1 und 0.3 reduzieren.

Bildschirmfoto des Clustering Dialogs mit CosineDistance Funktion.

Weitere Ideen

Mit Jython lassen sich auch Skripte auf dem eigenen Rechner ausführen oder Web-APIs ansprechen. Damit kann man komplexere und effizientere Algorithmen implementieren und/oder auf andere Python Pakete zurückgreifen.

Hier ist eine kleine Sammlung von weiteren Ideen:

Keying
- Liste mit Synonymen einlesen und Synonym-Cluster-ID zurückgeben.
- Lemma, Normalform oder Lexem berechnen z.B. mit spaCy.
- …
Distance
- Texte z.B. mit spaCy in Wortvektoren umwandeln und Abstand berechnen.
- Levenshtein-Distanz mit mehr Einstellmöglichkeiten via RapidFuzz.
- …

Fazit

Eigene Clustering-Funktionen hinterlegen zu können ermöglicht komplett andere Arbeitsabläufe und reduziert regelmäßige manuelle Nacharbeiten.

In Kombination mit der Möglichkeit z.B. über Jython Web-APIs anzusprechen, können zusätzlich Funktionalitäten von externen Werkzeugen für das Clustering genutzt werden.

Im nächsten Teil beschäftigen wir uns Python mit OpenRefine zu verwenden.

20 Python mit OpenRefine

Workshop - Arbeiten mit GREL

Sun, 01 May 2022 00:00:00 +0000

In diesem Tutorial beschäftigen wir uns mit der “General Refine Expression Language” (GREL).

Einführung

GREL in der OpenRefine Dokumentation.
GREL Rezepte im OpenRefine Wiki.

Dieser Workshop wurde erstellt mit OpenRefine Version 3.5.0.
Dieser Workshop wurde zuletzt getestet mit OpenRefine Version 3.9.3.

Mit der General Refine Expression Language (GREL) werden in OpenRefine die einzelnen Operationen auf den Daten ausgeführt. Die meisten Funktionen und Dialoge in OpenRefine sind quasi nur ein Eingabeformular für GREL Ausdrücke, die in den Facets angezeigten Daten basieren auf GREL Ausdrücken und in verschiedenen Dialogen können wir auch direkt GREL Ausdrücke verwenden, um zum Beispiel Daten zu transformieren.

Die Syntax von GREL ist dabei an die Programmiersprache JavaScript angelehnt, die unterliegende Technologie basiert jedoch auf der Programmiersprache Java. Dadurch entstehen Verständnisprobleme, wenn zum Beispiel reguläre Ausdrücke im Stil von JavaScript geschrieben werden, dann jedoch in OpenRefine intern von Java ausgewertet werden und entsprechend die Funktionalität von regulären Ausdrücken in Java unterstützen.

Die Eingabe von GREL Ausdrücken erfolgt (meistens) über Dialogfenster wie in Abbildung 1. Hier sehen wir nicht nur eine Vorschau der Umwandlung, die wir gerade anstreben, sondern können auch vorherige oder gespeicherte (Starred) GREL Ausdrücke laden.

Bildschirmfoto eines Dialog Fensters zur Transformation von Daten in OpenRefine.

Werte, Variablen, Objekte

In Programmiersprachen gibt es verschiedene Konzepte um mit Daten zu arbeiten.

Ein Konzept ist die Typisierung von Daten. So wird bei Werten zum Beispiel zwischen Text und Zahlen unterschieden. Mit diesen Werten können dann verschiedene Operationen und Berechnungen durchgeführt werden.

5 > 2
> true

Diesen Werten können via Variablen auch Namen zugewiesen werden.

laenge = 5
breite = 2
laenge > breite
> true

Oder es gibt spezielle Funktionen für Werte eines bestimmten Typs:

text = "Lorem ipsum"
length(text)
> 11

Werte und Funktionen lassen sich zu Objekten zusammenfassen. Via Variable kann ein bestimmtes Objekt gespeichert und darauf zugegriffen werden.

Rechteck(laenge, breite):
 laenge = leange
 breite = breite
 flaeche()
 return laenge * breite

rechteck1 = Rechteck(5, 2)
rechteck2 = Rechteck(4, 2)

rechteck1.flaeche > rechteck2.flaeche
> true

In GREL verwenden wir hauptsächlich schon existierende Variablen, Funktionen und Objekte.

Datentypen

In der OpenRefine Oberfläche arbeiten wir mit vier Datentypen: boolean, date, number und string. In GREL gibt es noch die Datentypen array, object und regex. Texte (string) können zusätzlich in eine Repräsentation für HTML, JSON oder XML geparsed werden. Das bedeutet vereinfacht, dass die (Text-)Daten intern von OpenRefine in eine Repräsentation überführt werden, die zum Beispiel XML versteht und dafür passende Funktionen anbietet. Also zum Beispiel die Funktion über alle XML-Knoten mit einem bestimmten Namen zu iterieren.

Typ	Kürzel	GUI	Beispiel(e)
array	a		`["a", "b", "c"]`
boolean	b	Ja	`true`, `false`
date	d	Ja	`[date 2022-05-03T15:00:00Z]`
number	n	Ja	`1`, `3.1415`
object	o		`[object Cell]`
regex	p		`/\d{4}/`
string	s	Ja	`Lorem ipsum...`

Variablen

Beim Arbeiten mit GREL stehen uns zusätzlich einige Umgebungsvariablen zur Verfügung.

Variable	Alternative	Beschreibung
cell	row.cells[columnName]	Aktuelle Zelle der ausgewählten Spalte.
cell.recon		Reconciliation Daten für die Zelle.
cell.recon. …		Dokumentation zu Recon.
cell.value	value	Wert der Zelle.
cell. ….		Dokumentation zu Cell.
columnName		Name der ausgewählten Spalte.
row		Aktuelle Zeile.
row.cells	cells	Zellen in der aktuellen Zeile.
row.cells. …		Dokumentation zu Cells
row.index	rowIndex	Index der aktuellen Zeile.
row.record		Record der aktuellen Zeile.
row.record. …		Dokumentation zu Record
row. ….		Dokumentation zu Row.
value1		Neu seit OpenRefine 3.9 für Distanz basiertes Clustering.
value2		Neu seit OpenRefine 3.9 für Distanz basiertes Clustering.

Die Variablen beinhalten teilweise einfache Werte (value, rowIndex) wie einen Text oder eine Zahl. Teilweise verweisen sie auf komplexe Objekte, worin die Werte gesammelt oder verschachtelt gespeichert sind (row). Manche Variablen stellen auch Abkürzungen dar. So kann auf den Wert der aktuellen Zeile in der ausgewählten Spalte direkt mit value zugegriffen werden, anstatt dies via row.cells[columnName].value machen zu müssen.

Hier eine Übersicht der Objekte und Variablen.

--- title: Datenstruktur config: look: handDrawn theme: neutral --- flowchart LR columnName row.index[index] row.cells[cells] row.columnNames[columnNames] row.starred[starred] row.flagged[flagged] row.record[record] row.cells.cell[cell...] row.cells.cell.value[value] row.cells.cell.recon[recon] row.cells.cell.recon.properties[...] row.cells.cell.errorMessage[errorMessage] row.cells.cell.errorMessage.value[value] row.record.index[index] row.record.cells[cells] row.record.fromRowIndex[fromRowIndex] row.record.toRowIndex[toRowIndex] row.record.rowCount[rowCount] row --> row.index & row.cells & row.columnNames & row.starred & row.flagged & row.record row.cells --> row.cells.cell row.cells.cell --> row.cells.cell.value & row.cells.cell.recon & row.cells.cell.errorMessage row.cells.cell.errorMessage --> row.cells.cell.errorMessage.value row.cells.cell.recon --> row.cells.cell.recon.properties row.record --> row.record.index & row.record.cells & row.record.fromRowIndex & row.record.toRowIndex & row.record.rowCount cell -.-> row.cells.cell cells -.-> row.cells rowIndex -.-> row.index value -.-> row.cells.cell.value

Fortsetzung für Reconciliation Daten einer Zelle:

--- title: Datenstruktur - recon config: look: handDrawn theme: neutral --- flowchart LR row.cells.cell.recon[row.cells.cell....recon] row.cells.cell.recon.judgment[judgment] row.cells.cell.recon.judgmentAction[judgmentAction] row.cells.cell.recon.judgmentHistory[judgmentHistory] row.cells.cell.recon.matched[matched] row.cells.cell.recon.match[match] row.cells.cell.recon.best[best] row.cells.cell.recon.features[features] row.cells.cell.recon.candidates[candidates] row.cells.cell.recon.features.typeMatch[typeMatch] row.cells.cell.recon.features.nameMatch[nameMatch] row.cells.cell.recon.features.nameLevenshtein[nameLevenshtein] row.cells.cell.recon.features.nameWordDistance[nameWordDistance] match.id[id] match.name[name] match.type[type] match.score[score] row.cells.cell.recon --> row.cells.cell.recon.judgment & row.cells.cell.recon.judgmentAction & row.cells.cell.recon.judgmentHistory & row.cells.cell.recon.matched & row.cells.cell.recon.match & row.cells.cell.recon.best & row.cells.cell.recon.features & row.cells.cell.recon.candidates row.cells.cell.recon.match --> match.id & match.name & match.type row.cells.cell.recon.best --> match.id & match.name & match.type & match.score row.cells.cell.recon.candidates --> match.id & match.name & match.type & match.score row.cells.cell.recon.features --> row.cells.cell.recon.features.typeMatch & row.cells.cell.recon.features.nameMatch & row.cells.cell.recon.features.nameLevenshtein & row.cells.cell.recon.features.nameWordDistance

Auf Attribute eines Objekts kann punktnotiert row.cells oder via Klammern row["cells"] zugegriffen werden. Prinzipiell empfiehlt es sich aus Gründen der Lesbarkeit die Punktnotation zu verwenden und die Variante mit Klammern nur, wenn der Name in einer Variablen steht cells[columnName] oder wir mit Spaltennamen arbeiten, die potentiell “Sonderzeichen” beinhalten können cells["GND-ID"].

Aktuell kann nicht auf alle Werte einer Spalte zugegriffen werden. Man kann aber auf alle Werte einer Spalte eines Records zugreifen: row.record.cells[columnName].

Kontrollstrukturen

Etwas verwirrend ist das Definieren von eigenen Variablen in GREL. Das geschieht mit einer with Anweisung. Im folgenden Beispiel setzen wir die Variable jahr auf den Wert 1988 und berechnen dann den Ausdruck jahr < 2000.

with(1988, jahr, jahr < 2000) == true

Wir geben das erwartete Ergebnis der GREL Ausdrücke in den Beispielen zusätzlich via == ... an, so dass das Ergebnis auch abgelesen werden kann, ohne den Ausdruck in OpenRefine oder im Kopf auswerten zu müssen.

Eine der essentiellen Kontrollstrukturen in der Informatik ist die Verzweigung. In GREL wird dies mit if realisiert. Im folgenden Beispiel setzen wir wie zuvor die Variable jahr auf den Wert 1988, geben aber abhängig von dem Ergebnis einer Prüfung unterschiedliche Werte zurück. Die if-Anweisungen können auch ineinander verschachtelt werden.

with(1988, jahr, if((jahr >= 1980).and(jahr < 1990), "80er", "Sonstiges")) == "80er"

Anstatt einer Verzweigung ist es manchmal auch nötig eine komplette Liste (technisch Array) von Werten zu filtern. Dafür gibt es in GREL eine filter() Funktion. Im folgenden Beispiel erstellen wir einen Array aus einem Text indem wir ihn mit split() am Trennzeichen , trennen. Anschließend wandeln die einzelnen Elemente mit toNumber() in Zahlen um und filtern anschließend nur die geraden Zahlen via mod(number, 2) == 2. Um das Ergebnis in OpenRefine ausgeben zu können, wandeln wir die Daten im Array anschließend mit join() wieder in einen Text um, da OpenRefine in der GUI keine Arrays anzeigen kann.

filter("1,2,3,4,5,6,7,8,9,10".split(","), v, mod(v.toNumber(), 2) == 0).join(",") == "2,4,6,8,10"

Um alle Werte einer Liste (technisch Array) durchzugehen, gibt es in GREL die forEach Anweisung. Im folgenden Beispiel erstellen wir mit split() einen Array aus einem Text und fügen mit + zu jedem Element die Endung “er” hinzu. Anschließend fügen wir die Daten im Array mit join() wieder zu einen Text zusammen.

forEach("70,80,90".split(","), v, v + "er").join(",") == "70er,80er,90er"

Zusätzlich gibt es noch weitere Helfer. Um den Typ eines Wertes zu prüfen gibt es verschiedene Varianten von is…, um einen bestimmten Bereich aufzuzählen forRange oder um eine Liste (technisch Array) aufzuzählen forEachIndex.

Extra: forNonBlank

Da sie etwas verwirrend ist, geben wir der Funktion forNonBlank hier noch einen separaten Absatz. Angenommen wir wollen eine Liste (technisch Array) von Werten durchgehen und dabei nur Werte bearbeiten, die einen Inhalt haben. Also zum Beispiel die ["1", "2", "", "4", "5"] umwandeln in 1,2,0,4,5.

forNonBlank(["1", "2", "", "4", "5"], v, v, 0).join(",") == "1,2,,4,5"

Das klappt so nicht, da forNonBlank(v, ...) eine andere Schreibweise für if(isNonBlank(v), ...) ist. Der korrekte Weg ist also einer der beiden folgenden Ausdrücke.

forEach(["1", "2", "", "4", "5"], v, if(isNonBlank(v), v, 0)).join(",") == "1,2,0,4,5"
forEach(["1", "2", "", "4", "5"], v, forNonBlank(v, v, v, 0)).join(",") == "1,2,0,4,5"

Standardbibliothek

Üblicherweise haben Programmiersprachen eine Standardbibliothek von Funktionen zum Arbeiten mit den zur Verfügung gestellten Datentypen.

Diese ist bei GREL im Vergleich zu anderen Programmiersprachen zwar recht übersichtlich, kann hier aber trotzdem nicht vollständig besprochen werden. Wir empfehlen daher, die Liste der in OpenRefine verfügbaren Funktionen als Referenz verfügbar zu halten.

Wir gehen hier auf ein paar Besonderheiten von GREL ein.

Syntax für Funktionsaufrufe

Eine Besonderheit in GREL ist, dass Funktionen zur besseren Lesbarkeit auch in Punktnotation aufgerufen werden können. Also length(value) auch geschrieben werden kann als value.length().

Aliase

Es gibt Funktionen, die unter mehreren Namen verfügbar sind.

Beispielsweise sind trim() und strip() bis auf ihre Namen identisch und wurden auch gleichzeitig in OpenRefine eingeführt. Vermutlich sollte das Quereinsteigern von anderen Programmiersprachen den Einstieg vereinfachen.

Vorbereitung: Projekt erstellen

Wir laden die folgende Datei in ein OpenRefine Projekt.

💾 Wir benötigen die folgende Datei (Rechtsklick und “Ziel speichern unter…”):

Kretschmann Kabinett III

Wie in Abbildung 2 beinhaltet die Datei das Kabinett Kretschmann III mit den Berufen.

Bildschirmfoto des Projektes direkt nach dem Laden.

Aufgabe 1: GREL Variablen nutzen

Das Geburtsdatum ist in drei Spalten aufgeteilt, wir wollen das Geburtsdatum jedoch in einer Spalte haben und dabei den Monat auch noch ausgeschrieben haben. Das haben wir in 03 Transformieren: Aufgabe 5 so ähnlich schon einmal mit Funktionen in der Benutzeroberfläche gelöst. Hier wollen wir GREL Funktionen verwenden, um die Bearbeitung in einem Schritt durchzuführen.

Dafür verwenden wir “Geburtsjahr" "Edit column" "Add column based on this column” und entwickeln schrittweise den in Abbildung 3 gezeigten GREL Ausdruck.

Bildschirmfoto des Dialogs zur Transformation.

Schritt 1: Geburtsmonat umwandeln

Um die Spalte “Geburtsmonat” in einen Namen umzuwandeln verwenden wir den Zugriff über row.cells["Geburtsjahr"] und die Funktionen toDate() und toString().

row.cells["Geburtsmonat"].value.toDate("M").toString("MMMM")

Schritt 2: Spalten zusammenfügen

Um die Spalten zusammenzufügen verwenden wir den Operator +.

row.cells["Geburtstag"].value + ". "
+ row.cells["Geburtsmonat"].value + " "
+ row.cells["Geburtsjahr"].value

Schritt 3: Verzweigung einbauen

Für manche Zeilen wird entweder eine Fehlermeldung oder null angezeigt. Das sind die Zeilen, wo kein Geburtstag und kein Geburtsmonat vorhanden sind.

Diese behandeln wir separat mit einer Verzweigung und passen dabei den Typ der Inhalte der Spalte “Geburtsjahr” an.

if(
 isBlank(row.cells["Geburtstag"]),
 row.cells["Geburtsjahr"].value.toString(),
 ...
)

Aufgabe 1

Fügen Sie die drei obigen GREL Ausdrücke zu einem GREL Ausdruck zusammen.

Lösung:

if(
 isBlank(row.cells["Geburtstag"]),
 row.cells["Geburtsjahr"].value.toString(),
 row.cells["Geburtstag"].value + ". "
 + row.cells["Geburtsmonat"].value.toDate("M").toString("MMMM") + " "
 + row.cells["Geburtsjahr"].value
)

Aufgabe 2: Werte aufräumen und sortieren

Die Werte in der Spalte “Beruf oder Beschäftigung” sind nicht sortiert, haben teilweise Duplikate und teilweise numerische Referenzen hinter den Berufsbezeichnungen. Diese Spalte wollen wir daher in einem Schritt mit einem GREL Ausdruck aufräumen und dabei die numerischen Referenzen entfernen, Duplikate entfernen und die Werte alphabetisch sortieren.

Dafür verwenden wir den Dialog “Beruf oder Beschäftigung" "Edit cells" "Transform” und erarbeiten uns einen GREL Ausdruck.

Schritt 1: Text in Liste umwandeln

Um die einzelnen Werte im Text in eine Liste (technisch Array) umzuwandeln, verwenden wir split() mit , als Trennzeichen.

"Politiker, Abgeordneter, Lehrer, Regierungschef, Politiker (5), Lehrer (3)".split(", ")

Schritt 2: Numerische Referenzen entfernen

Um die numerischen Referenzen zu entfernen verwenden wir replace() mit einem regulären Ausdruck und entfernen zusätzliche Leerzeichen.

"Politiker (5)".replace(/\(\d+\)/, "").trim()

Schritt 3: Funktion auf alle Elemente anwenden

Um die Ersetzung der numerischen Referenzen auf alle Elemente in der Liste (technisch Array) anzuwenden nutzen wir forEach.

forEach(
 ["Politiker, Abgeordneter, Lehrer, Regierungschef, Politiker (5), Lehrer (3)"],
 v,
 ...
)

Schritt 4: Werte vereinheitlichen und sortieren

Um die Werte zu vereinheitlichen und zu sortieren nutzen wir uniques() und sort().

["Politiker, Abgeordneter, Lehrer, Regierungschef, Politiker, Lehrer"].uniques().sort()

Schritt 5: Text aus Liste erstellen

Um aus der Liste (technisch Array) wieder einen Text zu erzeugen, verwenden wir join() mit , als Trennzeichen.

["Abgeordneter", "Lehrer", "Politiker", "Regierungschef"].join(", ")

Aufgabe 3

Fügen Sie die fünf obigen GREL Ausdrücke zu einem GREL Ausdruck zusammen. Das Ergebnis sollte in etwa wie in Abbildung 4 aussehen.

Bildschirmfoto des Projektes nach der Bearbeitung.

Lösung:

forEach(
 value.split(", "),
 v,
 v.replace(/\(\d+\)/, "").trim())
 .uniques()
 .sort()
 .join(", ")

Fazit

Viele Umwandlungen lassen sich in Einzelschritten über die graphische Oberfläche von OpenRefine ansteuern und umsetzen. So kommt man auch ohne in GREL zu programmieren in OpenRefine recht weit. Das Wissen um den Zugriff auf die Umgebungsvariablen und nützliche Funktionen wie find(), replace() oder Datumsumwandlungen ersetzt viele manuelle Schritte.

Das explizite Programmieren mit Verzweigungen und Schleifen ergänzt Arbeitsschritte oder reduziert mehrere Einzelschritte in der graphischen Oberfläche zu einem Schritt. Beim Export von XML in OpenRefine (Templating) sind die Kontrollstrukturen noch einmal relevant.

Im nächsten Teil behandeln wir das Konzept von “Records” in OpenRefine.

10 Arbeiten mit Records

Workshop für Fortgeschrittene - Warum OpenRefine?

Sun, 01 May 2022 00:00:00 +0000

In diesem Workshop für Fortgeschrittene gehen wir tiefer in die spezialisierten Funktionalitäten von OpenRefine und beschäftigen uns mit angrenzende Themen. Unter anderem betrachten wir reguläre Ausdrücke und programmieren mit der General Refine Expression Language (GREL).

Dieser Workshop wurde erstellt mit OpenRefine Version 3.5.0.
Dieser Workshop wurde zuletzt getestet mit OpenRefine Version 3.9.3.

Inhalte des Workshops

Warum eigentlich OpenRefine für Fortgeschrittene?

OpenRefine is Excel on steroids!

Oder um einen bildlichen Vergleich eines Workshop Teilnehmers wiederzuverwenden:

Mit Excel hatten wir bisher einen Trabi.
Mit OpenRefine haben wir einen Ferrari bekommen.

Der Umgang mit einem solchen Werkzeug sollte jedoch geübt und vertieft werden. Viele Funktionalitäten von OpenRefine sind über die graphische Oberfläche bedienbar. Jedoch können einige Bearbeitungsschritte vereinfacht oder automatisiert werden. Im Workshop für Einsteiger haben wir uns auf grundlegende Funktionen von OpenRefine fokussiert. Diesmal vertiefen wir einige Konzepte oder ergänzen Sie mit weiteren Technologien.

Wir werden dabei unter anderem die Programmiersprache GREL kennen lernen. Diese ist bei weitem nicht so mächtig, wie zum Beispiel Java oder Python. Jedoch können wir damit schon einige Dinge automatisieren und vereinfachen.

Außerdem werden wir uns mit regulären Ausdrücken beschäftigen. Diese helfen uns Daten zu finden, die bestimmten Mustern entsprechen.

Im ersten Teil machen wir einen Exkurs zum Arbeiten mit regulären Ausdrücken zur Erkennung und Extraktion von Mustern.

08 Arbeiten mit regulären Ausdrücken