CSV | 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 - Daten mit OpenRefine exportieren

Fri, 01 Apr 2022 00:00:00 +0000

Wir exportieren Daten mit OpenRefine in unterschiedliche Formate.

Daten exportieren in der OpenRefine Dokumentation.

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

Hintergrund

OpenRefine bietet sowohl verschiedene fertige Exportmöglichkeiten an als auch die Möglichkeit, eigene Formate (JSON, XML) zu erstellen. Wir konzentrieren uns in diesem Workshop auf tabellenartige Formate.

Aufgabe 1: Daten als Excel exportieren

Wir verwenden das Projekt “Kretschmann Kabinett III”, das wir in Projekte in OpenRefine laden und verwalten erstellt haben.

Dort erstellen wir ein “Text Facet” auf der Spalte “Geschlecht” und wählen darüber alle weiblichen Kabinettsmitglieder aus.

Über “Export" "Excel 2007+ (.xlsx)” erzeugen wir eine Excel Datei.

Aufgabe 2: Daten als CSV exportieren

Wir verwenden das gleiche Setup wie in Aufgabe 1.

Über “Export" "Comma-separated value” erzeugen wir eine CSV Datei.

Aufgabe 3: Datenexport spezifizieren

Wir verwenden das gleiche Setup wie in Aufgabe 1.

Über “Export" "Custom tabular exporter…” erzeugen wir eine spezielle Datei.

Die Einstellungen sind mit Bildschirmfotos in Abbildung 1 und 2 dokumentiert.

Bildschirmfoto von OpenRefine Export Einstellungen 1.

Bildschirmfoto von OpenRefine Export Einstellungen 2.

Die Dateiendung der heruntergeladenen Datei ändern wir anschließend von .txt nach .csv.

Aufgabe 4: Datenexporte vergleichen

Wir öffnen die drei exportierten Dateien mit Excel.

Was sind die Unterschiede zwischen den Dateien?

Welcher Export eignet sich für welchen Anwendungsfall?

Hinweise/Lösungen:

Der normale Export berücksichtigt die momentan aktiven “Facets” und Filter.
Excel erwartet bei CSV ein Semikolon ; als Trennzeichen und windows-1252 als Kodierung. Daher sieht die erste CSV-Datei in Excel “seltsam” aus. ¹
Der normale CSV Export von OpenRefine ist mit Komma , getrennt und verwendet utf-8 als Kodierung, wie es von den meisten Anwendungen erwartet wird.
Beim spezifischen Datenexport hat man die Kontrolle darüber, was exportiert wird und kann Trennzeichen, Kodierungen, … beeinflussen.
Im FDMLab verwenden wir xlsx, wenn die Daten in Excel weiter bearbeitet werden sollen, und csv, wenn wir die Daten mit anderen Anwendungen weiter bearbeiten.

Microsoft Excel hat einen Textimport-Assistenten, mit dem auch andere Formate importiert werden können. ↩︎

Fazit

OpenRefine kann die Projekte in gängige Formate exportieren. Das ist schnell und bequem. Komplexer wird es bei verschachtelten Formaten wie XML. Das behandeln wir in unserem Workshop für Fortgeschrittene.

Im nächsten Teil beschäftigen wir uns mit den Mechanismen zum Clustering in OpenRefine.

05 Daten mit OpenRefine clustern

Workshop - Projekte in OpenRefine laden und verwalten

Fri, 01 Apr 2022 00:00:00 +0000

Wir laden mehrere Dateien in OpenRefine Projekte und bearbeiten deren Metadaten.

Projekte in der OpenRefine Dokumentation.

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

Hintergrund

OpenRefine kann unterschiedliche Dateiformate über verschiedene Quellen in das interne Projektformat importieren. Der “übliche” Weg ist der Import von einer oder mehreren Dateien, weshalb wir uns vorerst darauf beschränken.

Aufgabe 1: Eine Datei laden

Wir werden im Laufe des Workshops häufiger mit einem Ausschnitt der Gurs-Deportationsliste arbeiten, die vom Generallandesarchiv Karlsruhe recherchiert und im FDMLab bereinigt und mit weiteren Normdaten ergänzt wurde.

Für diesen Workshop wurde die Liste nachträglich mit einigen “Problemen” versehen, die wir in den nachfolgenden Aufgaben bereinigen werden. Für diese Aufgabe wollen wir erst einmal nur die Datei 01_gurs.csv in das Projekt “Gurs” laden.

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

Gurs als CSV

Beim Projektimport verwenden wir die folgenden Einstellungen:

Project name: Gurs
Tags: Gurs, GND, Workshop, 2024

Die Optionen für das Format sind als Bildschirmfoto hinterlegt.

Bildschirmfoto von OpenRefine Parsing Options.

Die Gurs-Daten wurden zur Veröffentlichung im Blog aufbereitet, indem Zeilen und Spalten gelöscht sowie die restlichen Spalten zufällig sortiert wurden. Für die Verwendung in den Aufgaben des Workshops ist die Datei nach wie vor geeignet, jedoch nicht für Recherche und Forschungszwecke!

Aufgabe 2: Mehrere Dateien gleichzeitig laden

Wir haben die Beteiligten des Kabinetts Kretschmann III getrennt nach Frauen und Männern in zwei CSV Dateien gespeichert (01_kretschmann-kabinett-frauen.csv und 01_kretschmann-kabinett-maenner.csv).

💾 Wir benötigen die folgenden zwei Dateien (Rechtsklick und “Ziel speichern unter…”):

Kretschmann Kabinett Frauen als CSV

Kretschmann Kabinett Maenner als CSV

Diese Dateien laden wir gemeinsam in ein OpenRefine Projekt.

Beim Projektimport verwenden wir die folgenden Einstellungen:

Project name: Kretschmann Kabinett III
Tags: GND, Workshop, 2024

Die Optionen für das Format sind als Bildschirmfoto hinterlegt.

Bildschirmfoto von OpenRefine Parsing Options.

Aufgabe 3: Projektdaten anpassen

OpenRefine bietet noch mehr Einstellungen für Projekte, als die die wir beim Erstellen angeben. Dazu gehören zum Beispiel der Name des Erstellers, ein Vorschaubild, die Lizenz, …

Bildschirmfoto von OpenRefine Projekt Metadaten.

Um diese anzupassen, verwendet man den Link “About” in der Projektübersicht wie in Abbildung 3 und fügt die Informationen via “Edit” ein. Um dies einmal durchzuführen, ergänzen wir bei dem Gurs-Projekt im Feld Homepage die URL des LABW, wie in Abbildung 4 gezeigt.

https://www.landesarchiv-bw.de

Bildschirmfoto von dem Bearbeitungsdialog der OpenRefine Projekt Metadaten.

Aufgabe 4: Aktionsverlauf

OpenRefine speichert Änderungen automatisch und erstellt einen Verlauf aller auf ein Projekt angewendeter Aktionen. Diese können im Tab “Undo/Redo” angesehen, rückgängig gemacht oder importiert werden.

Um das besser kennen zu lernen laden wir ein OpenRefine Projekt und übertragen die Änderungshistorie auf ein Projekt von uns.

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

Kretschmann Kabinett (Vorlage) als OpenRefine Projektdatei

Wir laden die OpenRefine Projektdatei über das in Abbildung 5 gezeigte Formular zum Importieren von OpenRefine Projekten.

Bildschirmfoto vom Formular zum Importieren von OpenRefine Projekten.

Anschließend öffnen wir den Reiter für die Änderungshistorie in OpenRefine. Dort werden automatisch alle automatisch gespeicherten Arbeitsschritte gezeigt. Frühere Zustände des Projektes können durch Anklicken des entsprechenden Eintrages in der Änderungshistorie wiederhergestellt oder überschrieben werden. Geht man in der Änderungshistorie zum Beispiel zu Schritt 2 zurück und fügt dann eine neue Änderung ein, dann werden die nachfolgenden Schritte (3-4) überschrieben.

Wie in Abbildung 6 gezeigt können die Arbeitsschritte eines Projektes auch extrahiert werden.

Bildschirmfoto des Reiters für die Änderungshistorie in OpenRefine.

Der in Abbildung 7 gezeigte Dialog zum Extrahieren erlaubt es auch einzelne Schritte zum Export aus- oder abzuwählen. Wir extrahieren den kompletten Text und kopieren ihn in die Zwischenablage.

Bildschirmfoto des Dialogs zum Extrahieren von Änderungen.

Der kopierte Text sieht in etwa wie folgt aus, wobei die Beschreibung (description) nachträglich mit einer deutschsprachigen Erklärung versehen wurde.

[
 {
 "op": "core/column-split",
 "engineConfig": {
 "facets": [],
 "mode": "row-based"
 },
 "columnName": "Bevorzugter Name",
 "guessCellType": true,
 "removeOriginalColumn": true,
 "mode": "separator",
 "separator": ",",
 "regex": false,
 "maxColumns": 2,
 "description": "Spalte nach Vorname und Nachname auftrennen."
 },
 {
 "op": "core/column-rename",
 "oldColumnName": "Bevorzugter Name 1",
 "newColumnName": "Nachname",
 "description": "Spalte Bevorzugter Name 1 in Nachname umbenennen."
 },
 {
 "op": "core/column-rename",
 "oldColumnName": "Bevorzugter Name 2",
 "newColumnName": "Vorname",
 "description": "Spalte Bevorzugter Name 2 in Vorname umbenennen."
 },
 {
 "op": "core/text-transform",
 "engineConfig": {
 "facets": [],
 "mode": "row-based"
 },
 "columnName": "Geschlecht",
 "expression": "grel:if(value == \"Weiblich\", \"w\", \"m\")",
 "onError": "keep-original",
 "repeat": false,
 "repeatCount": 10,
 "description": "Männlich und Weiblich als m und w kodieren."
 }
]

Um die Änderungen in unserem eigenen Projekt anzuwenden öffnen wir das Projekt “Kretschmann Kabinett III”, öffnen dort den Tab “Undo/Redo”, drücken auf “Apply” und kopieren wie in Abbildung 8 den Text in den Dialog.

Anwenden von Aktionen über die History Funktion von OpenRefine.

Da wir in unserem Projekt die gleichen Spaltennamen haben, wie im Vorlagenprojekt, konnten wir die Änderungen direkt übernehmen und haben nun den gleichen Stand.

Fazit

OpenRefine öffnet viele unterschiedliche Dateitypen, extrahiert Archive, rät die Einstellungen für den Import und bietet mit der Vorschau eine tolle Möglichkeit die Einstellungen anzupassen. Das Metadatenmanagement der Projekte ist etwas lieblos implementiert. Die Möglichkeit (fast) jeden Bearbeitungsschritt wieder rückgängig zu machen gibt die Sicherheit, auch mal Datenbearbeitungen ausprobieren zu können, ohne sich in verschiedenen Versionen einer “Datei” zu verlaufen. Beim Verlauf der Bearbeitungsschritte wäre es noch praktisch, wenn man verschiedene Stände markieren könnte, um schneller dorthin zurückzuspringen.

Im nächsten Teil lernen wir, wie wir Daten in OpenRefine filtern und sortieren können.

02 Daten mit OpenRefine filtern und sortieren

Gemeinsam an OpenRefine-Projekten arbeiten

Tue, 07 Dec 2021 00:00:00 +0000

Im FDMLab testeten wir verschiedene Möglichkeiten mit OpenRefine gemeinsam an Projekten zu arbeiten. Dieser Artikel fasst unsere Erfahrungen beim kollaborativen Arbeiten mit OpenRefine 3.5.0 zusammen.

Wir hatten in Fünf Dinge, die wir an OpenRefine mögen schon darüber berichtet, dass uns die Architektur von OpenRefine gefällt, da sie es ermöglicht OpenRefine sowohl auf einem Client (Laptop, Rechner), als auch auf einem Server laufen zu lassen. Die Bedienung erfolgt anschließend über den Browser.

--- title: OpenRefine Setup config: look: handDrawn theme: neutral --- flowchart LR subgraph server[fas:fa-server Server] server_or[fas:fa-gem OpenRefine] end subgraph laptop[fas:fa-laptop Laptop] browser[far:fa-window-maximize Browser] laptop_or[fas:fa-gem OpenRefine] end browser -.-> laptop_or & server_or

Da läge es nahe, dass OpenRefine auch eine Benutzerverwaltung und eine Möglichkeit zum Kollaborativen Arbeiten an Projekten anbietet. Dafür gab es Pläne ein Broker Protokoll für OpenRefine einzuführen, die bisher aber weder umgesetzt noch eingeplant wurden.

In der Dokumentation von OpenRefine wird folgendes Vorgehen empfohlen:

Die beste Art, mit einer anderen Person zusammenzuarbeiten, ist, Projekte zu exportieren und zu importieren, wobei alle Änderungen gespeichert werden, so dass Sie an der Stelle weiterarbeiten können, wo die andere Person aufgehört hat.

Übersetzt von Starting a project: Import a project, aufgerufen am 01.12.2021.

--- title: Gemeinsam arbeiten - Strategie 1 config: look: handDrawn theme: neutral --- flowchart TD subgraph a["fa:fa-user Alice"] vaa["fa:fa-table Version A"] vab["fa:fa-table Version B"] vac["fa:fa-table Version C"] vad["fa:fa-table Version D"] end subgraph b["fa:fa-user Bob"] vba["fa:fa-table Version A"] vbb["fa:fa-table Version B"] end subgraph c["fa:fa-user Charly"] vcb["fa:fa-table Version B"] vcc["fa:fa-table Version C"] end vaa -.Übergabe.-> vba --Arbeiten--> vbb -.Übergabe.-> vab -.Übergabe.-> vcb --Arbeiten--> vcc -.Übergabe.-> vac --Arbeiten--> vad

Konkret bedeutet das, dass bei einer Kooperation von Alice, Bob und Charly zwar alle an dem gleichen Projekt arbeiten können, jedoch nicht gleichzeitig. Nachdem Alice das Projekt an Bob übergeben hat, arbeitet Bob daran. Nachdem Bob fertig ist, übergibt er das Projekt an Alice zurück, die es an Charly übergibt. Nachdem Charly fertig ist, übergibt er das Projekt an Alice zurück, die dann erst daran weiterarbeiten kann. Das war für uns im FDMLab ein eher unbefriedigender Zustand, weshalb wir zu einer anderen Strategie gewechselt haben.

--- title: Gemeinsam Arbeiten - Strategie 2 config: look: handDrawn theme: neutral --- flowchart LR subgraph a["fa:fa-user Alice"] va["fa:fa-table Version A"] vb["fa:fa-table Version B"] vc["fa:fa-table Version C"] vd["fa:fa-table Version D"] end subgraph b["fa:fa-user Bob"] pa["fa:fa-table Part A"] end subgraph c["fa:fa-user Charly"] pb["fa:fa-table Part B"] end va -.-> pa vb -.-> pb pa -.-> vc pb -.-> vd va --Arbeiten--> vb --Arbeiten--> vc --Arbeiten--> vd

Wir haben angefangen Teile eines Projektes in OpenRefine auszulagern und nach erfolgreicher Bearbeitung wieder in das Originalprojekt einzupflegen. So kann in unserem Beispiel Alice weiter an dem Projekt arbeiten, während Bob und Charly sie durch die Bearbeitung einzelner Teile unterstützen. Diese Teile werden anschließend von Alice wieder in das Originalprojekt eingepflegt. Wie das funktioniert besprechen wir in den folgenden Unterpunkten.

Zeilenweise zusammenführen

Manchmal ist es möglich, ein Projekt zeilenweise aufzuteilen. Also dass Alice die ersten 100 Zeilen, Bob die nächsten 100 und Charly die letzten 75 Zeilen bearbeitet.

Die Ergebnisse können nach der Bearbeitung als CSV-Dateien exportiert und daraus anschließend ein neues OpenRefine-Projekt erstellt werden.

Bildschirmfoto der Dateiauswahl Oberfläche von OpenRefine.

Wie in Abbildung 1 gezeigt, kann OpenRefine ein Projekt aus mehreren Dateien erstellen. Das kann auch ein Dateiarchiv sein, dessen Dateien in ein neues Projekt importiert werden.

Bildschirmfoto des Dateifilter Oberfläche von OpenRefine.

Bevor das Projekt konfiguriert wird, gibt es wie in Abbildung 2 gezeigt, die Möglichkeit einzelne Dateien aus- oder abzuwählen. Im Idealfall haben die einzelnen Dateien schon die gleichen Spaltenüberschriften in der richtigen Reihenfolge. Ansonsten bietet OpenRefine mit der Möglichkeit Spalten zu verbinden und Spalten zu verschieben die Möglichkeit das nachträglich zu bereinigen.

Spaltenweise zusammenführen

Ein häufiger Anwendungsfall im FDMLab ist, dass das Aufräumen und Transformieren der Daten von einer Person erledigt wird, die zum Beispiel beim Reconciling oder dem Abgleich mit weiteren Datenquellen von weiteren Personen unterstützt wird. Dafür werden einzelne Spalten als CSV (oder Excel) exportiert, von der unterstützenden Person bearbeitet und die Ergebnisse dann wieder in das Originalprojekt übernommen.

Ein anderer Fall kann sein, dass es schon einen anderen Datensatz gibt, dessen Daten komplett oder teilweise übernommen werden sollen. Das haben wir in Findbuchdaten mit OpenRefine wiederverwenden teilweise besprochen.

Beispiel

In unserem fiktiven Beispiel arbeitet Alice mit einem Datensatz der 16 Bundesländer, wie er in Abbildung 3 gezeigt ist. Diesen gibt sie an Bob und Charly weiter.

Bildschirmfoto der Oberfläche von OpenRefine mit den 16 Bundesländern.

Bob unterstützt Alice, indem er für die 16 Bundesländer das “Motto” recherchiert, er kann jedoch nicht für alle Bundesländer ein Motto finden und liefert den in Abbildung 4 gezeigten Datensatz zurück. ¹

Bildschirmfoto der Oberfläche von OpenRefine mit dem Motto einiger Bundesländer.

Charly hat die Aufgabe die Hauptstädte der einzelnen Bundesländer zu recherchieren, und liefert den in Abbildung 5 gezeigten Datensatz zurück. Dabei wurden jedoch die Namen der Bundesländer teilweise geändert, also zum Beispiel der Begriff “Freistaat” aus dem Namen wegoptimiert.

Bildschirmfoto der Oberfläche von OpenRefine mit den Hauptstädten der 16 Bundesländer.

Datensätze herunterladen

Die drei beschriebenen Datensätze können hier heruntergeladen werden, um die vorgestellten Methoden zum Zusammenführen von Daten beim gemeinsamen Arbeiten in OpenRefine selbst auszuprobieren

💾 Wir benötigen drei Dateien (Rechtsklick und “Ziel speichern unter…”):

Bundesländer als CSV

Bundesländer Motto als CSV

Bundesländer Hauptstädte als CSV

ID Spalte erstellen

Wir werden die Daten auf drei Arten abgleichen:

Via einer dedizierten ID-Spalte
Mit einer improvisierten ID-Spalte (Name des Bundeslandes)
Via Reconciling

Idealerweise haben alle Datensätze eine einheitliche ID-Spalte zum Abgleichen. Diese lässt sich in OpenRefine über “Spaltenmenü" "Edit column" "Add column based on this column…” mit dem folgenden GREL Ausdruck anlegen:

row.index + 1

Wie in Abbildung 6 gezeigt, wird so eine ID-Spalte erzeugt, deren Nummerierung analog zur Nummerierung der Zeilen in OpenRefine verläuft.

Bildschirmfoto des Spalten hinzufügen Dialogs in OpenRefine.

Alternativ lassen sich manchmal auch ID-Spalten improvisieren, indem zum Beispiel bei Personen die Namen und Vornamen in eine ID-Spalte übernommen werden.

Zusammenführen mit cross()

Alice hat von Bob und Charly zwei CSV-Dateien bekommen, die sie in ihr OpenRefine-Projekt übernehmen möchte. Eine Möglichkeit, das innerhalb von OpenRefine zu erledigen, ist die Funktion cross().

Im OpenRefine-Wiki gibt es einige Beispiele zur Anwendung von cross(). Außerdem gibt es eine OpenRefine-Erweiterung für cross() um die Funktion über Dialoge in der Oberfläche von OpenRefine zu verwenden.

Wir verwenden die Funktion cross() ohne Erweiterung. Dafür erstellen wir für die drei Datensätze jeweils ein Projekt.

Projekt “Bundesländer” aus bundeslaender.csv
Projekt “Bundesländer Motto” aus bundeslaender-motto.csv
Projekt “Bundesländer Hauptstadt” aus bundeslaender-hauptstadt.csv

Wir verwenden absichtlich Umlaute und Leerzeichen im Projektnamen, um zu testen, ob OpenRefine beim Auflösen mit cross() damit klarkommt!

Zusammenführen via ID

Idealerweise haben wir eine eindeutige ID-Spalte, um die Projekte miteinander abzugleichen. Mit cross() können wir über die ID-Spalte Daten aus einem anderen OpenRefine-Projekt nachladen. Das funktioniert aber nur, wenn die IDs eindeutig sind.

Nachladen des Mottos

Zum Nachladen des Mottos der Bundesländer gehen wir im “Bundesländer”-Projekt über das Spaltenmenü “ID" "Edit column" "Add column based on this column…” und verwenden den folgenden GREL Ausdruck.

cell.cross("Bundesländer Motto", "ID").cells["Mottotext"].value[0]

Dabei ist “Bundesländer Motto” der Name des Projektes aus dem wir die Daten holen wollen, und “ID” die ID-Spalte im Projekt “Bundesländer Motto”.

Bildschirmfoto des Spalten hinzufügen Dialogs mit cross() für den Mottotext in OpenRefine.

Wie in Abbildung 7 gezeigt, werden die Daten (also der Mottotext) aus dem anderen Projekt nachgeladen. Es haben nicht alle Bundesländer einen Mottotext hinterlegt, was den Abgleich nicht weiter stört.

Nachladen der Hauptstadt

Zum Nachladen der Hauptstadt der Bundesländer gehen wir im “Bundesländer”-Projekt über das Spaltenmenü “ID" "Edit column" "Add column based on this column…” und verwenden den folgenden GREL Ausdruck.

cell.cross("Bundesländer Hauptstadt", "ID").cells["Hauptstadt"].value[0]

Dabei ist “Bundesländer Hauptstadt” der Name des Projektes aus dem wir die Daten holen wollen, und “ID” die ID-Spalte im Projekt “Bundesländer Hauptstadt”.

Bildschirmfoto des Spalten hinzufügen Dialogs mit cross() für die Hauptstadt in OpenRefine.

Wie in Abbildung 8 gezeigt, werden die Daten (hier die Hauptstadt) aus dem anderen Projekt nachgeladen. Es haben alle Bundesländer eine Hauptstadt, so dass der Abgleich hier für jeden Eintrag ein Ergebnis produziert.

Außerdem ist zu erwähnen, dass sich OpenRefine hier auch nicht daran stört, dass die ID-Spalte bei uns im Projekt “Bundesländer” als Zahl, im Projekt “Bundesländer Motto” jedoch als Typ Text gespeichert ist.

Zusammenführen via Werte

Es ist nicht immer eine eindeutige ID-Spalte vorhanden. Das kommt zum Beispiel vor, wenn die Daten aus verschiedenen Projekten stammen. Man kann auch ID-Spalten improvisieren, was aber nicht immer zum gewünschten Ergebnis führt. Wir werden den Abgleich mit cross() diesmal über die Spalte “Bundesland” durchführen.

Nachladen des Mottos

Zum Nachladen des Mottos der Bundesländer gehen wir im “Bundesländer”-Projekt diesmal über das Spaltenmenü “Bundesland“ "Edit column" "Add column based on this column…” und verwenden den folgenden GREL Ausdruck.

cell.cross("Bundesländer Motto", "Bundesland").cells["Mottotext"].value[0]

Wie in Abbildung 9 zu sehen ist, hat der Abgleich zwischen diesen beiden Projekten kein Problem, da die Bundesländer hier einheitlich geschrieben sind.

Bildschirmfoto des Spalten hinzufügen Dialogs mit cross() für den Mottotext in OpenRefine.

Nachladen der Hauptstadt

Zum Nachladen der Hauptstädte der Bundesländer gehen wir im “Bundesländer”-Projekt diesmal über das Spaltenmenü “Bundesland“ "Edit column" "Add column based on this column…” und verwenden den folgenden GREL Ausdruck.

cell.cross("Bundesländer Hauptstadt", "Bundesland").cells["Hauptstadt"].value[0]

Wie in Abbildung 10 zu sehen ist, hat der Abgleich hier Probleme, da die Bundesländer teilweise unterschiedlich geschrieben sind. Es fehlen Ergänzungen wie “Freistaat”. Daher können die Daten für diese Bundesländer nicht nachgeladen werden.

Bildschirmfoto des Spalten hinzufügen Dialogs mit cross() für die Hauptstadt in OpenRefine.

Ergebnis

Bildschirmfoto von OpenRefine mit den Bundesländern und den zusätzlichen Spalten aus anderen Projekten.

Der Abgleich mit cross() innerhalb von OpenRefine funktioniert recht einfach, solange es eine Spalte mit eindeutigen Werten gibt. Der Abgleich stört sich auch nicht an Sonderzeichen, Leerzeichen oder fehlenden Werten.

Problematisch wird es, wenn die Werte der Spalten, die abgeglichen werden, nicht komplett übereinstimmen. Diese sind in Abbildung 11 farblich hervorgehoben. In solchen Fällen empfiehlt sich das im nächsten Abschnitt besprochene lokale Reconciling.

Zusammenführen mit lokalem Reconciling

Wir hatten in Fünf Dinge, die wir an OpenRefine mögen schon die Architektur von OpenRefine gelobt, da diese so gestaltet ist, dass OpenRefine auch mit anderen APIs kommunizieren kann. Besonders unterstützt ist dabei das Reconciliation Service API Protokoll. Damit können Daten in einem OpenRefine-Projekt nicht nur gegen Wikidata oder die GND abgeglichen werden, sondern mit Werkzeugen wie csv-reconcile auch mit lokalen CSV-Dateien.

--- title: OpenRefine Setup config: look: handDrawn theme: neutral --- flowchart LR subgraph server[fas:fa-server Server] server_or[fas:fa-gem OpenRefine] server_api[fas:fa-code Reconciliation Service API] end subgraph laptop[fas:fa-laptop Laptop] browser[far:fa-window-maximize Browser] laptop_or[fas:fa-gem OpenRefine] laptop_api[fas:fa-code Reconciliation Service API] end browser -.-> laptop_or & server_or laptop_or -.-> laptop_api & server_api server_or -.-> server_api

Für die Verwendung von csv-reconcile benötigt man Python auf seinem System. Ist Python vorhanden, dann kann csv-reconcile einfach via Shell (PowerShell, Git Bash, …) installiert werden. Wir erstellen dafür erst eine virtuelle Umgebung in unserem Arbeitsordner, um csv-reconcile ausschließlich dort zu installieren.

Der Arbeitsordner ist der Ordner, in dem wir unsere CSV-Dateien liegen haben, mit denen wir hier arbeiten.

Die virtuelle Umgebung für Python ermöglicht es uns, Python Bibliotheken nur für dieses Projekt zu installieren, so dass sie nicht mit Bibliotheken oder Python Versionen in anderen Projekten in Konflikt kommen.

> python -m venv venv # virtuelle Umgebung erstellen
> .\venv\Scripts\activate # virtuelle Umgebung aktivieren (Windows!)
(venv) > pip install csv-reconcile # csv-reconcile in virtuelle Umgebung installieren

Da csv-reconcile in Version 0.3.0 den Vorschaudienst optional anbietet und keine automatische Erkennung von Encoding und Trennzeichen in CSV-Dateien hat, erstellen wir in unserem Arbeitsordner zusätzlich eine Datei config.py mit dem folgenden Inhalt.

CSVKWARGS={'delimiter': ',', 'quotechar': '"'}
CSVENCODING='UTF-8'
MANIFEST = {
 "preview": {
 "url": "http://localhost:5000/preview/{{id}}",
 "width": 400,
 "height": 300
 }
}

Anschließend können wir mit aktivierter virtueller Umgebung in unserem Arbeitsordner den lokalen Reconciling Service für die “Bundesländer Motto” CSV-Datei initiieren und starten.

(venv) > csv-reconcile init --config config.py bundeslaender-motto.csv ID Bundesland
(venv) > csv-reconcile serve

Wenn wir mit dieser Datei fertig sind, können wir den lokalen Reconciling Service für die “Bundesländer Hauptstadt” CSV-Datei initiieren und starten.

Ob die virtuelle Umgebung aktiv ist, sieht man an der Ergänzung (venv) in der Shell. Ansonnsten lässt sie sich mit .\venv\Scripts\activate wieder aktivieren.

(venv) > csv-reconcile init --config config.py bundeslaender-hauptstadt.csv ID Bundesland
(venv) > csv-reconcile serve

Wir könnten die beiden lokalen Reconciling Services auch parallel laufen lassen, indem wir sie in unterschiedliche Ordner schieben und wie unter csv-reconcile: Common configuration beschrieben über die Variable SERVER_NAME in der config.py jeweils einen anderen Port setzen.

In OpenRefine fügen wir den lokalen Reconciliation Service hinzu, indem wir in einem Projekt über ein beliebiges “Spaltenmenü" "Reconcile" "Start reconciling” aufrufen und dort via “Add Standard Service…” die Adresse http://localhost:5000/reconcile eingeben. Der Port 5000 muss entsprechend angepasst werden, wenn er in der config.py geändert wurde.

Siehe auch die OpenRefine-Dokumentation zu Reconciling: Getting started.

Zusammenführen via ID

Idealerweise haben wir eine eindeutige ID-Spalte, um die Projekte miteinander abzugleichen. Dann ist der lokale Reconciliation Service fast schon etwas zu mächtig, und wird von uns eher eingesetzt, wenn wir es vermeiden wollen, zu viele OpenRefine-Projekte zu jonglieren.

Nachladen des Mottos

Wir haben den lokalen Reconciling Service für das “Bundesländer Motto”-Projekt, wie im oberen Abschnitt beschrieben, am laufen.

Zum Nachladen des Mottos der Bundesländer gehen wir im “Bundesländer”-Projekt über das Spaltenmenü “ID" "Reconcile" "Use values as identifiers” und wählen unseren CSV Reconciliation Service aus.

Die IDs werden nun alle zu Links. Wie im Maus-Hover in Abbildung 12 sehen wir, dass nicht alle IDs aufgelöst werden, sondern manchmal eine “Nicht gefunden” Meldung angezeigt wird. Zur Erinnerung: es gibt nicht für alle Bundesländer ein Motto in unseren Daten!

Bildschirmfoto des Maus-Hover ‘Not Found’ in OpenRefine.

Den Mottotext können wir über “ID" "Edit column" "Add columns from reconciled values…” nachladen. Wie in Abbildung 13 zu sehen ist, kann der Dienst auch mit nicht auflösbaren IDs umgehen und ignoriert diese einfach.

Bildschirmfoto des Reconciliation Dialogs mit dem Mottotext in OpenRefine.

Nachladen der Hauptstadt

Wir haben den lokalen Reconciling Service für das “Bundesländer Hauptstadt”-Projekt, wie im oberen Abschnitt beschrieben, am laufen.

Zum Nachladen der Hauptstädte der Bundesländer gehen wir wieder im “Bundesländer”-Projekt über das Spaltenmenü “ID" "Reconcile" "Use values as identifiers” und wählen unseren CSV Reconciliation Service aus.

Die IDs werden nun alle wieder zu Links. Bei diesem Abgleich können alle IDs aufgelöst werden und wir sehen wie in Abbildung 14 überall Maus-Hover mit den entsprechenden Werten des gematchten Eintrags in der CSV-Datei.

Bildschirmfoto des Maus-Hover mit CSV Werten in OpenRefine.

Zusammenführen via Werte

Es ist nicht immer eine eindeutige ID-Spalte vorhanden. In so einem Fall spielt der lokale Reconciliation Service seine Stärke aus, da wir mit ihm auch “ungenaue” Werte finden und matchen können.

Nachladen des Mottos

Wir haben den lokalen Reconciling Service für das “Bundesländer Motto”-Projekt, wie im oberen Abschnitt beschrieben, am laufen.

Zum Nachladen der Mottos der Bundesländer über die Wertespalte gehen wir zu “Bundesland" "Reconcile" "Start reconciling” und wählen den “CSV Reconciling Service” aus.

Wie in Abbildung 15 markiert, ist das automatische Matching etwas zu großzügig, so dass Bundesländer gematcht werden, weil sie zum Beispiel beide den Begriff “Freistaat” im Namen haben. Das kann manuell und bei größeren Datenmengen mit der Unterstützung von Facets auf den Konfidenzwerten (Wert wie gut das Matching passt) nachgearbeitet werden.

Bildschirmfoto des Ergebnis des automatischen Reconciling in OpenRefine.

Den Mottotext können wir dann wieder über “Bundesland" "Edit column" "Add columns from reconciled values…” nachladen. Wie in Abbildung 16 zu sehen ist, kann der Dienst auch in diesem Fall mit nicht auflösbaren IDs umgehen und ignoriert diese einfach.

Bildschirmfoto des Reconciliation Dialogs mit dem Mottotext in OpenRefine.

Nachladen der Hauptstadt

Wir haben den lokalen Reconciling Service für das “Bundesländer Hauptstadt”-Projekt, wie im oberen Abschnitt beschrieben, am laufen.

Zum Nachladen der Hauptstädte der Bundesländer über die Wertespalte gehen wir zu “Bundesland" "Reconcile" "Start reconciling” und wählen den “CSV Reconciliation Service” aus.

Da wir in diesem Datensatz passende Einträge für alle Bundesländer haben, funktioniert das Matching, wie in Abbildung 17 zu sehen ist, recht gut, obwohl die Bundesländer teilweise anders geschrieben sind.

Bildschirmfoto der Oberfläche von OpenRefine mit den Reconciliation Ergebnissen für die Bundesländer.

Ergebnis

Der Abgleich mit dem lokalen Reconciling Service hat initial einen höherne Aufwand, da sowohl Python auf dem System als auch der CSV Reconciling Service in OpenRefine eingerichtet werden müssen. Dann ist das Verfahren jedoch deutlich flexibler als das Zusammenführen mit cross(), da darüber sowohl ein exaktes ID Matching und Nachladen von Spalten durchgeführt werden kann, als auch ein so genanntes Fuzzy-Matching, bei dem die Werte in den Spalten nicht exakt übereinstimmen.

In Abbildung 18 sind nochmal alle nachgeladenen Spalten abgebildet, wobei

via cross() auf der ID-Spalte
via cross() auf der Werte-Spalte (Namen Bundesland)
via lokalem Reconciling Service auf der ID-Spalte
via lokalem Reconciling Service auf der Werte-Spalte (Namen Bundesland)

nachgeladen wurde.

Bildschirmfoto von OpenRefine mit den Bundesländern und den zusätzlichen Spalten aus anderen Projekten.

Ausblick auf weitere Methoden

Für das Zusammenführen von Datensätzen mit OpenRefine gibt es noch weitere Möglichkeiten, die sich aktuell in der Planung und Entwicklung befinden.

Zum einen gibt es Überlegungen für Projekte in OpenRefine automatisch einen Reconciliation Service zu erstellen, so dass analog zu cross() direkt innerhalb von OpenRefine ein Reconciling gegen andere Projekte durchgeführt werden kann. Also Reconciling innerhalb von OpenRefine ohne separaten lokalen Reconciling Service.

Zum anderen gibt es mit Datasette ein komplettes Ökosystem um Daten in SQLite einzulesen und anschließend via unterschiedlicher APIs zur Verfügung zu stellen. Es wird gerade auch ein Reconciliation Plugin für Datasette entwickelt.

Gibt es in Arbeitsgruppen Datensätze, die intern oder extern veröffentlicht und auch für Reconciliation genutzt werden sollen, dann lohnt sich ein Blick auf dieses Werkzeug.

Fazit

OpenRefine bietet mit seiner Architektur das Potential zukünftig kollaboratives Arbeiten zu ermöglichen. Bis dahin können wir uns selbst helfen und mit wenig Extraaufwand Aufgaben aufteilen und die Ergebnisse wieder zusammenführen. Mit der cross() Funktion können wir direkt Daten aus anderen OpenRefine-Projekten über ID-Spalten übernehmen. Mit einem lokalem Reconciling Service können wir auch Daten aus unterschiedlichen Projekten verbinden.

Bisher klappt das beschriebene Vorgehen im FDMLab ganz gut und wir beobachten weiterhin gespannt die Entwicklung sowohl von OpenRefine, als auch von anderen Werkzeugen wie csv-reconcile und Datasette, die es hervorragend ergänzen.

Die Mottotexte wurden aus Wikidata geladen und sind daher genauso (un)vollständig, wie die Daten dort. ↩︎

Erfahrungsbericht - Extraktion und Abgleich von Prokuratoren mit OpenRefine

Tue, 21 Sep 2021 00:00:00 +0000

In diesem Beitrag beschreiben wir unsere Erfahrungen bei der Textextraktion, der Deduplikation und dem Abgleich mit der GND von Indizes aus zehn Findbüchern.

Wir haben bisher in Tutorials gezeigt, wie wir einen Findbuch Index mit OpenRefine aufbereiten und wie wir diese Findbuch Daten mit OpenRefine wiederverwenden können.

Die dabei gesammelten Erfahrungen haben wir anschließend praktisch angewendet und die Indizes der Prokuratoren aus den Findbüchern zu den Akten des Reichskammergerichts in den Staatsarchiven Wertheim und Sigmaringen, sowie die Bände 1 - 8 im Hauptstaatsarchiv Stuttgart mit OpenRefine aufgearbeitet und mit der GND abgeglichen.

Generelle Daten

Text:

10 Bände
10.339 Textzeilen

CSV:

2.912 Indexeinträge
Davon 100 Aliase

Deduplikation:

472 Prokuratoren

Abgleich mit GND:

275 ohne GND Eintrag
197 mit GND Eintrag (ca. 42 Prozent)

Anwenden mehrerer Teilschritte

--- title: Extraktionsprozess config: look: handDrawn theme: neutral --- flowchart LR subgraph books[fas:fa-book Bände] band1[Band 46/1.txt] bandn[Band 46/...] band8[Band 46/8.txt] band9[Band 46/57.txt] band10[Band 57/Wertheim.txt] end subgraph csvs[fas:fa-file-csv CSV] csv1[CSV Band 46/1.csv] csvn[CSV Band 46/...] csv8[CSV Band 46/8.csv] csv9[CSV Band 57.csv] csv10[CSV Band 57/Wertheim.csv] end db[fas:fa-file-csv Prokuratoren.csv] gnd[fas:fa-database GND] result[fas:fa-project-diagram Prokuratoren] band1 --fas:fa-gem--> csv1 --fas:fa-magic--> db bandn --fas:fa-gem--> csvn --fas:fa-magic--> db band8 --fas:fa-gem--> csv8 --fas:fa-magic--> db band9 --fas:fa-gem--> csv9 --fas:fa-magic--> db band10 --fas:fa-gem--> csv10 --fas:fa-magic--> db db & gnd --fas:fa-gem--> result

Wir haben uns dazu entschieden, aus jeder Findbuch(text)datei mit OpenRefine eine CSV Datei mit den Informationen zu den Prokuratoren zu extrahieren und die zehn CSV Dateien anschließend zusammenzufassen.

--- title: Extraktionsprozess config: look: handDrawn theme: neutral --- flowchart LR subgraph books[fas:fa-book Bände] band1[Band 46/1.txt] bandn[Band 46/...] band8[Band 46/8.txt] band9[Band 46/57.txt] band10[Band 57/Wertheim.txt] end txt[fas:fa-file-txt Bände.txt] db[fas:fa-file-csv Prokuratoren.csv] gnd[fas:fa-database GND] result[fas:fa-project-diagram Prokuratoren] band1 & bandn & band9 & band10 --fas:fa-magic--> txt --fas:fa-gem--> db db & gnd --fas:fa-gem--> result

Es wäre auch denkbar gewesen, die zehn Textdateien in einer Textdatei zusammenzufassen und daraus mit OpenRefine in einem Projekt eine CSV Datei zu erstellen. Das Layout der einzelnen Findbücher unterschied sich jedoch so, dass wir uns anders entschieden. Im Nachhinein wäre die Lösung mit einer Textdatei als Grundlage einfacher zu handhaben gewesen, da wir bei unserem Vorgehen systematische Fehler in allen zehn Projekten nachzukorrigieren hatten.

Um die einzelnen Operationen zwischen den Projekten besser austauschen zu können, haben wir die groben Schritte, wie zum Beispiel “zweispaltiges Layout in einspaltiges Layout umwandeln”, als Sammlung von mehreren Operationen in separaten .json Dateien vorgehalten. Diese haben wir dann über die “History” Funktion von OpenRefine auf das aktuelle Projekt angewendet. Darüber haben wir auch schon in Findbuch Daten mit OpenRefine wiederverwenden geschrieben.

So konnten wir iterativ mehrere Operationen gleichzeitig anwenden, das Ergebnis überprüfen und bei Bedarf die Operationen wieder rückgängig machen, sie anpassen und neu anwenden. Hierbei wäre es praktisch gewesen, wenn man sich einzelne Versionen in der History von OpenRefine hätte markieren können, um einfacher dorthin zurückspringen zu können.

Nachdem wir die CSV Dateien zusammengefasst hatten und in einem neuen Projekt die Deduplikation mit OpenRefine begannen, stellten wir fest, dass es trotz sorgfältiger manueller Prüfung nach wie vor Extraktionsfehler in den Einzelprojekten gab.

Daher geben wir hier als Tipp weiter, die Projekte und Zwischenschritte automatisch zu validieren. Dafür kann zum Beispiel in OpenRefine mit Textfiltern und regulären Ausdrücken überprüft werden, ob es noch Zahlen oder andere unerwartete Zeichen in den Namen gibt, die Jahreszahlen und Verweise richtig formatiert sind, …

Deduplikation mit Clusterverfahren

Zur Deduplikation verwendeten wir die in OpenRefine integrierten Cluster Verfahren. Da wir unterschiedliche Arten von Duplizierungen hatten, verwendeten wir mehrere der angebotenen Verfahren nacheinander, bis wir keine Cluster mehr automatisiert finden konnten.

Probleme machten hierbei alternative Schreibweisen, die in unseren Findbüchern durch Klammerung kompakt zusammengefasst wurden. Beispielsweise gab es für Re(c)hlinger, Johann in den Findbüchern auch die Schreibweise Rehlinger, Johann und Rechlinger Johann.

Dies konnte durch die Clusterverfahren gut erkannt und zusammengeführt werden.

Schwieriger wurde es bei der automatischen Zusammenführung von Brandt, (Johann) Ferdinand Wilhelm von, mit Brandt, Ferdinand Wilhelm, da hier der geklammerte Ausdruck relativ zum Namen recht lang ist.

Wenn der Anteil des geklammerten Namens zu groß wird, dann finden die verfügbaren automatischen Clustermethoden keine (sinnvolle) Ähnlichkeit mehr. Dies war beispielsweise bei Müller (Mulher), Christoph und Müller, Christoph der Fall.

Abgleich mit der GND

Der Abgleich der Daten mit der GND via lobid nahm die meiste Zeit in Anspruch. Um die Sortierung der Suchtreffer zu verbessern, haben wir eine zusätzliche Spalte “Beruf” mit dem Wert “Jurist” eingefügt und mit der Eigenschaft professionOrOccupation abgeglichen.

Probleme gab es mit den schon erwähnten Namen mit Alternativen in Klammern, da geklammerte Ausdrücke Probleme bei der Verarbeitung durch die lobid API haben.

Ein wesentlicher Aufwandsfaktor war die fehlende Möglichkeit zur Einschränkung der Lebens- und Wirkungsdaten. Hier hatte lobid schon auf unseren letzten Blogpost reagiert und das Feature im März 2022 umgesetzt. ¹

Fazit

Die Umwandlung der 10.339 Textzeilen zu 472 Prokuratoren ließ sich mit OpenRefine relativ problemlos bewältigen. Durch den Abgleich der Prokuratoren über mehrere Findbücher konnten einige OCR-Fehler korrigiert oder alternative Schreibweisen aufgelöst werden. Die anschließende Zuordnung zu GND-Nummern war hingegen langwierig.

Mit 472 Juristen, die alle aus der gleichen Berufsgruppe kommen und auch an anderen Orten schriftliche Spuren (Doktorarbeiten, …) hinterlassen haben, war dieser Datensatz vergleichsweise einfach aufzuarbeiten.

In den Findbüchern zu den Akten des Reichskammergerichts gibt es noch einen gemischten Orts- und Personenindex. Dieser ist etwa 50mal so groß, wie der Index der Prokuratoren, enthält unterschiedlichste Typen von Einträgen (Adel, Berufe, Familien, Orte, …), und enthält vermutlich deutlich weniger Treffer in der GND. ²

Hier werden wir gegebenenfalls zusätzliche externe Werkzeuge bemühen, wie wir es für den Artikel Named Entity Recognition mit OpenRefine und spaCy getestet haben.

Update April 2022: Durch ein Update in dem lobid GND API für OpenRefine kann nun eine zeitliche Einschränkung beim Reconciliation vorgenommen werden. Details dazu finden sich unter Using range query parameter via OpenRefine Reconciliation auf GitHub und unter Erweiterter GND Abgleich mit lobid auf unserem Blog. ↩︎
Es kostet mehr Aufwand zu überprüfen, wenn etwas nicht da ist, als wenn es sofort ein eindeutiges Ergebnis gibt. ↩︎

Findbuchdaten mit OpenRefine wiederverwenden

Tue, 24 Aug 2021 00:00:00 +0000

In diesem Artikel behandeln wir die Frage, wie wir schon aufbereitete Daten mit OpenRefine wiederverwenden können.

Wir haben schon einen Findbuch Index mit OpenRefine aufbereitet. wenn wir nun den Prokuratoren Index von “Band 57: Akten des Reichskammergerichts im Staatsarchiv Sigmaringen - Inventar des Bestands R 7. Bearb. von Raimund J. Weber. Kohlhammer 2004” bearbeiten wollen, dann wäre zu erwarten, dass wir das Projekt nachnutzen können.

Dies ist bedingt möglich. Zum einen können wir die Operationen aus der letzten Findbuchaufbereitung wiederverwenden. Zum anderen können wir die Prokuratoren mit den Prokuratoren aus dem letzten Projekt abgleichen.

Um es vorweg zu nehmen: es hat sich gezeigt, dass wir nur einen Teil der Operationen und Prokuratoren übernehmen können. Aber gerade bei den Operationen ist das eine ziemliche Zeitersparnis.

💾 Wir benötigen drei Dateien (Rechtsklick und “Ziel speichern unter…”):

Index Prokuratoren Akten RKG Band 57

Index Prokuratoren Akten RKG Band 57 als OpenRefine Arbeitsschritte

Prokuratoren Akten RKG Band 57 - Wertheim als CSV

Wir möchten explizit dazu einladen diese Dateien zu nutzen, um die einzelnen Schritte in OpenRefine selbst auszuprobieren und damit zu experimentieren.

Operationen übertragen

Mit OpenRefine ist es möglich, die durchgeführten Operationen eines Projektes zu exportieren und in einem anderen Projekt zu importieren. Beschrieben ist das im OpenRefine Manual.

Zuerst erstellen wir das Projekt in OpenRefine mit der Datei akten-rkg-band-57-prokuratoren.txt als Grundlage. Die Einstellungen sind in Abbildung 1 gezeigt.

Bildschirmfoto der Ansicht zum Erstellen neuer Projekte in OpenRefine.

Mit der Schaltfläche “Extract…” bei “Undo/Redo” (siehe Abbildung 2) können wir die Operationen aus einem Projekt exportieren und mit der Schaltfläche “Apply..” anwenden.

Bildschirmfoto der Schaltfläche zum Anwenden von exportieren Operationen in OpenRefine.

Nach Klicken der Schaltfläche “Apply..” können wir die exportierten Operationen aus akten-rkg-band-57-openrefine-prokuratoren.json wie in Abbildung 3 gezeigt einfügen und mit “Perform Operations” die Operationen auf dem aktuellen Projekt anwenden.

Dialog zum Anwenden von exportieren Operationen in OpenRefine.

Bei unserem ersten Versuch haben wir festgestellt, dass die Operationen von unserem letzten Artikel nicht direkt auf diesen Index anwendbar sind. Beim Anwenden von Operationen aus einem anderen Projekt sind einige Dinge zu beachten.

Die .json Datei sollte mit einem Quelltexteditor wie (unter Windows) der Editor App, Notepad++ oder Visual Studio Code geöffnet (und bearbeitet) werden.
Die Spaltennamen in den beiden Projekten müssen die gleichen Namen haben.
Manuelle Editieroperationen und Filteroperationen werden nicht mit übertragen.

In unserem konkreten Fall gab es zusätzlich die folgenden Probleme

Die Extraktion der Seitenzahlen funktioniert nicht, da die Kopfzeilen sich unterscheiden.
Das zweispaltige Layout hat statt 4 einen Minimalabstand von 3 Leerzeichen.
Es gibt Zeilenumbrüche bei dem Namen der Prokuratoren und bei den Verweisen.
Die Anpassungen für das “reconciling” lassen sich nicht übertragen.

In der Datei akten-rkg-band-57-openrefine-prokuratoren.json haben wir die Operationen entsprechend bereinigt und angepasst, so dass sie direkt angewendet werden können. In Abbildung 4 ist das Ergebnis der Anwendung zu sehen.

Bildschirmfoto der Daten nach der Anwendung der Operationen in OpenRefine.

Bei “Albrecht von Lauterbach” ist eine andere Formatierung verwendet worden, die wir manuell nachkorrigiert haben. Dafür sind wir in der “History” der Operationen zurück zu Schritt 33 gegangen. Dann haben wir die fehlerhaften Einträge manuell via “inline editing” korrigiert. Anschließend haben wir die (ehemaligen) Operationen 34 und 35 erneut via “Apply…” angewendet. Die (ehemaligen) Operationen 34 und 35 haben wir hier direkt zum Kopieren in den Artikel eingefügt:

[
 {
 "op": "core/column-addition",
 "engineConfig": {
 "facets": [],
 "mode": "row-based"
 },
 "baseColumnName": "Nachname",
 "expression": "join ([coalesce(cells['Nachname'].value,''),coalesce(cells['Vorname'].value,'')],', ')",
 "onError": "keep-original",
 "newColumnName": "Name",
 "columnInsertIndex": 1,
 "description": "Create column Name at index 1 based on column Nachname using expression join ([coalesce(cells['Nachname'].value,''),coalesce(cells['Vorname'].value,'')],', ')"
 },
 {
 "op": "core/column-move",
 "columnName": "Name",
 "index": 0,
 "description": "Move column Name to position 0"
 }
]

Zwischenfazit

Die Übertragung von Verkettungen von Operationen, wie zum Beispiel das Auflösen eines zweispaltigen Layouts, ist praktisch und spart dem versierten Benutzer einiges an Zeit. Durch die automatisch generierten Beschreibungstexte für die Operationen ist es jedoch nicht leicht, die entsprechenden Blöcke von Operationen auch zu identifizieren.

Abgleich mit lokaler CSV Datei

Mit der Datei akten-rkg-band-57-wertheim-prokuratoren.csv besitzen wir eine (kleine) lokale Datenbank mit bereits aufbereiteten Prokuratoren. Diese können wir zum Abgleich mit unseren aufbereiteten Daten in OpenRefine verwenden. Dafür gibt es Werkzeuge, die eine CSV Datei als “Reconciliation Service” zur Verfügung stellen.

Abgleich mit reconcile-csv (Clojure)

Das Projekt reconcile-csv basiert auf Clojure und lässt sich daher direkt mit der gleichen Java Version ausführen, mit der wir auch OpenRefine verwenden. Dafür erstellen wir im Ordner mit der openrefine.exe einen Ordner services und kopieren die heruntergeladene reconcile-csv-0.1.2.jar hinein.

In dem Ordner öffnen wir anschließend eine PowerShell und führen mit der Java Version von OpenRefine die .jar Datei aus. Das CSV Reconciliation Service benötigt drei Parameter:

Der Pfad zu der CSV Datei.
Der Name der Spalte mit der abgeglichen werden soll.
Der Name der Spalte mit einem eindeutigen Wert (ID) für jede Zeile. ¹

.\server\target\jre\bin\java.exe -jar .\services\reconcile-csv-0.1.2.jar .\data\akten-rkg-band-57-wertheim-prokuratoren.csv Name Nr

Mit “Name" "Reconcile" "Start reconciling” können wir auf der Spalte Name den “Reconciliation” Vorgang starten und dort die Adresse http://localhost:8000/reconcile als “Reconciliation Service” hinzufügen.

Wie in Abbildung 5 gezeigt, gibt es für die einzelnen Ergebnisvorschläge auch eine Vorschau Funktion, in der die Inhalte der Tabellenzeile zum besseren Abgleich angezeigt werden.

Bildschirmfoto vom Abgleich mit ‘reconcile-csv’ in OpenRefine.

Wir konnten mit dem lokalen Abgleich 28 Prokuratoren aus unserer Liste finden.

An dieser Stelle würden wir gerne weitere Daten aus der CSV Datei laden, wie es von dem von OpenRefine unterstützen Data Extension API angeboten wird. Leider wird diese Funktionalität in diesem Service nicht unterstützt. Da das Projekt Stand August 2021 seit 2015 nicht mehr weiterentwickelt wurde, ist damit auch nicht zu rechnen.²

Abgleich mit csv-reconcile (Python)

Ein neueres Projekt zum Abgleich mit lokalen CSV Dateien ist csv-reconcile, welches auf Python basiert und sich aktiv in der Entwicklung befindet.

Wie wir schon im Artikel Named Entity Recognition mit OpenRefine und spaCy festgestellt haben, ist die Verwendung von Python Frameworks mit OpenRefine aufwendiger, da wir dafür zusätzlich eine aktuelle Python Installation benötigen.

Haben wir lokal Python installiert, dann können wir mit PowerShell im gleichen services Ordner wie im letzten Abschnitt eine virtuelle Python Umgebung anlegen (1), diese virtuelle Umgebung aktivieren (2), das Paket csv-reconcile mit pip installieren (3), und den “CSV Reconciliation Service” starten (4).

1
2
3
4


python -m venv venv
.\venv\Scripts\activate
pip install csv-reconcile
csv-reconcile --init-db --config config.py ..\data\akten-rkg-band-57-wertheim-prokuratoren.csv Nr Name

Leider konnte unsere CSV Datei auf Grund ihres Formates und Kodierung nicht auf Anhieb richtig geladen werden, so dass wir zusätzlich eine Konfigurationsdatei config.py mit dem folgenden Inhalt im Ordner services hinterlegt haben.

CSVKWARGS={'delimiter': ',', 'quotechar': '"'}
CSVENCODING='UTF-8'

Der “CSV Reconciliation Service” ist anschließend unter http://localhost:5000/reconcile erreichbar.

Das Python Projekt ist deutlich flexibler und ausführlicher zu konfigurieren, als das ältere Clojure Projekt. Es unterstützt auch die “Data Extension API”, so dass wir nach dem Abgleich weitere Spalten aus der CSV Datei nachladen können. ~~Leider fehlt noch eine Vorschau, so dass kein visueller Abgleich zum Beispiel mit den Wirkdaten der Prokuratoren möglich ist.~~ Ab Version 0.3.0 gibt es eine optionale Vorschau Funktion.

Abgleich mit der GND

Nachdem wir etwa 10 Prozent der Prokuratoren mit unseren lokalen Daten abgleichen konnten, können wir nun den Rest direkt mit der Gemeinsamen Normdatei (GND) abgleichen. Darauf sind wir in Findbuch Index mit OpenRefine aufbereiten genauer eingegangen und werden das daher hier nicht weiter vertiefen.

Fazit

--- title: Prozess config: look: handDrawn theme: neutral --- flowchart LR text[fas:fa-file-alt Text] code[fas:fa-code Code] index[fas:fa-file-csv Index] data[fas:fa-table Table] partially[fas:fa-tasks Parts] gnd[fas:fa-database GND] semantic[fas:fa-project-diagram Graph] text --> data --> partially --> semantic code --> data index --> partially gnd --> semantic

Die Möglichkeit json Schnippsel mit Verkettungen von Operationen für komplexe Aufgaben zu importieren gefällt uns, und wir werden diese Methode gegebenenfalls öfter verwenden.

Für den komfortablen Abgleich mit einer lokalen CSV Datei fehlte den beiden getesteten Bibliotheken noch Funktionalität.

Das auf Clojure basierende reconcile-csv lässt sich ohne großen Mehraufwand verwenden und bietet eine hilfreiche Vorschau Funktion. Ohne eine Unterstützung der “Data Extension API” ist es für unsere Anwendungsfälle aber nur beschränkt nutzbar.

Das auf Python basierende csv-reconcile benötigt eine lokale Python Installation und bietet noch keine Vorschau Funktion, ohne die sich der Datenabgleich teilweise mühsam gestaltet.

Die Möglichkeit eigene Datenbanken in Form von CSV Dateien zu nutzen, oder wie im Falle der Indizes zu den Akten des Reichskammergerichts schrittweise aufzubauen, ist jedoch vorhanden und hat das Potential von großer Arbeitserleichterung.

Da wir bei der Bearbeitung des Prokuratoren Index der Akten in Wertheim nicht alle Prokuratoren mit einer GND-ID verknüpfen konnten, haben wir den Daten eine Spalte Nr mit der “GREL expression” row.index + 1 hinzugefügt. ↩︎
Eine Möglichkeit das “Data Extension Problem” zu umgehen, ist aus den abgeglichenen Daten eine neue Spalte mit der “GREL expression” cell.recon.match.id zu erzeugen und die beiden Dateien anschließend mit einem anderen Werkzeug zusammenzuführen. Eine weitere Möglichkeit besteht darin, die andere CSV Datei in OpenRefine als Projekt zu laden und den Abgleich mit der Funktion cross durchzuführen. ↩︎