qlever 0.2.5__py3-none-any.whl → 0.5.41__py3-none-any.whl

qlever/Qleverfiles/Qleverfile.dblp

@@ -0,0 +1,36 @@
+# Qleverfile for DBLP, use with QLever CLI (`pip install qlever`)
+#
+# qlever get-data  # ~1 min, ~5 GB compressed, 1.3 B triples
+# qlever index     # ~30 min, ~20 GB RAM, ~25 GB index size on disk
+# qlever start     # ~3 s, adjust MEMORY_FOR_QUERIES as needed
+#
+# Measured on an AMD Ryzen 9 5950X with 128 GB RAM, and NVMe SSD (25.10.2024)
+
+[data]
+NAME         = dblp
+DATA_TARFILE = dblp_KG_with_associated_data.tar
+GET_DATA_URL = https://sparql.dblp.org/download/${DATA_TARFILE}
+GET_DATA_CMD = (curl -LROC - ${GET_DATA_URL} && tar -xf ${DATA_TARFILE}) 2>&1 | tee ${NAME}.download-log.txt && rm -f ${DATA_TARFILE}
+VERSION      = $$(date -r dblp.ttl.gz +"%d.%m.%Y %H:%M" || echo "NO_DATE")
+DESCRIPTION  = DBLP computer science bibliography + citations from OpenCitations, data from ${GET_DATA_URL}, version ${VERSION}
+FORMAT       = ttl
+
+[index]
+INPUT_FILES      = *.gz
+MULTI_INPUT_JSON = { "cmd": "zcat {}", "for-each": "*.gz" }
+SETTINGS_JSON    = { "num-triples-per-batch": 5000000 }
+STXXL_MEMORY     = 5G
+
+[server]
+PORT               = 7015
+ACCESS_TOKEN       = ${data:NAME}
+MEMORY_FOR_QUERIES = 10G
+CACHE_MAX_SIZE     = 5G
+TIMEOUT            = 300s
+
+[runtime]
+SYSTEM = docker
+IMAGE  = docker.io/adfreiburg/qlever:latest
+
+[ui]
+UI_CONFIG = dblp

qlever/Qleverfiles/Qleverfile.dblp-plus

@@ -0,0 +1,33 @@
+# Qleverfile for DBLP Plus, use with https://github.com/ad-freiburg/qlever-control
+#
+# qlever get-data    downloads .gz file of size ~3 GB (as of 31.07.2022)
+# qlever index       takes ~30 minutes and ~20 GB RAM (on an AMD Ryzen 9 5900X)
+# qlever start       starts the server
+#
+# Also builds a text index for fast kewyword search in literals.
+
+[data]
+NAME              = dblp-plus
+GET_DATA_CMD      = wget -nc -O dblp.ttl.gz https://dblp.org/rdf/dblp.ttl.gz
+DESCRIPTION       = Publication data from https://dblp.org, with affiliations from https://www.wikidata.org and citations from https://opencitations.net
+TEXT_DESCRIPTION  = All literals, search with FILTER KEYWORDS(?text, "...")
+
+[index]
+INPUT_FILES       = dblp.ttl.gz affiliations.nt affiliations.additions.nt citations.nt
+CAT_INPUT_FILES   = zcat -f ${INPUT_FILES}
+SETTINGS_JSON     = { "ascii-prefixes-only": false, "num-triples-per-batch": 1000000, "prefixes-external": [ "<https://w3id.org", "<https://doi.org", "<http://dx.doi.org" ] }
+TEXT_INDEX        = from_literals
+
+[server]
+PORT                        = 7027
+ACCESS_TOKEN                = ${data:NAME}_169238202
+MEMORY_FOR_QUERIES          = 20G
+CACHE_MAX_SIZE              = 10G
+CACHE_MAX_SIZE_SINGLE_ENTRY = 2G
+
+[runtime]
+SYSTEM = docker
+IMAGE  = docker.io/adfreiburg/qlever:latest
+
+[ui]
+UI_CONFIG = dblp-plus

qlever/Qleverfiles/Qleverfile.dbpedia

@@ -0,0 +1,30 @@
+# Qleverfile for DBpedia, use with https://github.com/ad-freiburg/qlever-control
+#
+# qlever get-data  # ~14 GB, ~850 M triples (as of 30.07.2024)
+# qlever index     # ~20 min (on an AMD Ryzen 9 5900X)
+# qlever start     # ~3 sec
+
+[data]
+NAME         = dbpedia
+DATABUS_URL  = https://databus.dbpedia.org/dbpedia/collections/latest-core
+GET_DATA_CMD = curl -X POST -H "Accept: text/csv" --data-urlencode "query=$$(curl -s -H "Accept:text/sparql" https://databus.dbpedia.org/dbpedia/collections/latest-core)" https://databus.dbpedia.org/sparql | tail -n+2 | sed 's/\r$$//' | sed 's/"//g' | while read -r file; do wget -P rdf-input $$file; done
+DESCRIPTION  = RDF data from ${DATABUS_URL}
+
+[index]
+INPUT_FILES     = rdf-input/*
+CAT_INPUT_FILES = (cat rdf-input/*.nt; lbzcat -n2 rdf-input/*.bzip2 rdf-input/*.bz2)
+SETTINGS_JSON   = { "ascii-prefixes-only": true, "num-triples-per-batch": 1000000, "prefixes-external": [""] }
+WITH_TEXT_INDEX = false
+
+[server]
+PORT               = 7012
+ACCESS_TOKEN       = ${data:NAME}
+MEMORY_FOR_QUERIES = 10G
+CACHE_MAX_SIZE     = 5G
+
+[runtime]
+SYSTEM = docker
+IMAGE  = docker.io/adfreiburg/qlever:latest
+
+[ui]
+UI_CONFIG = dbpedia

qlever/Qleverfiles/Qleverfile.default

@@ -0,0 +1,51 @@
+# Default Qleverfile, use with https://github.com/ad-freiburg/qlever-control
+#
+# If you have never seen a Qleverfile before, we recommend that you first look
+# at the example Qleverfiles on http://qlever.cs.uni-freiburg.de/qlever-control/
+# src/qlever/Qleverfiles . Or execute `qlever setup-config <dataset>` on the
+# command line to obtain the example Qleverfiles for <dataset>.
+
+# As a minimum, each dataset needs a name. If you want `qlever get-data` to do
+# something meaningful, you need to define GET_DATA_CMD. Otherwise, you need to 
+# generate (or download or copy from somewhere) the input files yourself. Each
+# dataset should have a short DESCRIPTION, ideally with a date.
+[data]
+NAME         =
+GET_DATA_CMD =
+DESCRIPTION  = 
+
+# The format for INPUT_FILES should be such that `ls ${INPUT_FILES}` lists all
+# input files. CAT_INPUT_FILES should write a concatenation of all input files
+# to stdout. For example, if your input files are gzipped, you can write `zcat
+# ${INPUT_FILES}`. Regarding SETTINGS_JSON, look at the other Qleverfiles for
+# examples. Several batches of size `num-triples-per-batch` are kept in RAM at 
+# the same time; increasing this, increases the memory usage but speeds up the
+# loading process.
+[index]
+INPUT_FILES     = *.ttl
+CAT_INPUT_FILES = cat ${INPUT_FILES}
+SETTINGS_JSON   = { "num-triples-per-batch": 1000000 }
+
+# The server listens on PORT. If you want to send privileged commands to the
+# server, you need to specify an ACCESS_TOKEN, which you then have to set via a
+# URL parameter `access_token`. It should not be easily guessable, unless you
+# don't mind others to get privileged access to your server.
+[server]
+PORT         = 8888
+ACCESS_TOKEN = 
+
+# Use SYSTEM = docker to run QLever inside a docker container; the Docker image
+# will be downloaded automatically. Use SYSTEM = native to use self-compiled
+# binaries `IndexBuilderMain` and `ServerMain` (which should be in you PATH).
+[runtime]
+SYSTEM = docker
+IMAGE  = docker.io/adfreiburg/qlever:latest
+
+# UI_PORT specifies the port of the QLever UI web app, when you run `qlever ui`.
+# The UI_CONFIG must be one of the slugs from http://qlever.cs.uni-freiburg.de
+# (see the dropdown menu on the top right, the slug is the last part of the URL).
+# It determines the example queries and which SPARQL queries are launched to
+# obtain suggestions as you type a query.
+[ui]
+UI_PORT   = 8176
+UI_CONFIG = default

qlever/Qleverfiles/Qleverfile.dnb

@@ -0,0 +1,40 @@
+# Qleverfile for Olympics, use with https://github.com/ad-freiburg/qlever-control
+#
+# qlever get-data  # takes ~ 10 mins to download .nt.gz file of size ~ 8 GB
+# qlever index     # takes ~ 5 min and ~ 5 GB RAM (on an AMD Ryzen 9 5900X)
+# qlever start     # starts the server (instantaneous)
+#
+# IMPORTANT: The current files contain invalid floating point literals. To make
+# QLever ignore them, compile QLever with `invalidLiteralsAreSkipped_ = true`
+# in `src/parser/TurtleParserBase.h:55`.
+#
+# NOTE: https://data.dnb.de/opendata/ is rather confusing becase of the many
+# files. This Qleverfile downloads all the datasets named "Gesamtabzug", except
+# bib_lds.nt.gz, which contains incorrectly formatted IRIs. The file
+# dnb-all_ldsprov.nt.gz contains invalid floating point literals; to ignore
+# them, compile QLever with TurtleParserBase::invalidLiteralsAreSkipped_ = true
+
+[data]
+NAME              = dnb
+BASE_URL          = https://data.dnb.de/opendata
+GET_DATA_CMD      = curl -L -C - --remote-name-all --remote-time ${BASE_URL}/authorities-gnd_lds.nt.gz ${BASE_URL}/dnb-all_lds.nt.gz ${BASE_URL}/dnb-all_ldsprov.nt.gz ${BASE_URL}/zdb_lds.nt.gz 2>&1 | tee ${data:NAME}.getdata-log.txt
+VERSION           = $$(date -r dnb-all_lds.nt.gz +%d.%m.%Y || echo "NO_DATE")
+DESCRIPTION       = DNB data from ${BASE_URL} (authoritities-gnd_lds, dnb_all_lds, dnb-all_ldsprov, zdb_lds), version ${VERSION}
+
+[index]
+INPUT_FILES     = *.nt.gz
+CAT_INPUT_FILES = zcat ${INPUT_FILES} | sed '/"\$$R0"/d;/"0\.03013\$$D"/d'
+SETTINGS_JSON   = { "ascii-prefixes-only": false, "num-triples-per-batch": 1000000 }
+
+[server]
+PORT               = 7035
+ACCESS_TOKEN       = ${data:NAME}
+MEMORY_FOR_QUERIES = 5G
+CACHE_MAX_SIZE     = 2G
+
+[runtime]
+SYSTEM = docker
+IMAGE  = docker.io/adfreiburg/qlever:latest
+
+[ui]
+UI_CONFIG = dnb

qlever/Qleverfiles/Qleverfile.fbeasy

@@ -0,0 +1,29 @@
+# Qleverfile for Fbeasy, use with https://github.com/ad-freiburg/qlever-control
+#
+# qlever get-data  # downloads .gz file of size ~3 GB (as of 31.07.2022)
+# qlever index     # takes ~10 minutes and ~10 GB RAM (on an AMD Ryzen 7 5900X)
+# qlever start     # starts the server
+
+[data]
+NAME              = fbeasy
+DATA_URL          = https://freebase-easy.cs.uni-freiburg.de
+GET_DATA_CMD      = wget -nc ${DATA_URL}/dump/fbeasy.nt
+DESCRIPTION       = Freebase Easy, RDF NT from ${DATA_URL}, latest version from 18.07.2019
+TEXT_DESCRIPTION  = Sentences from the English Wikipedia that mention at least one Freebase entity
+
+[index]
+INPUT_FILES     = fbeasy.nt
+CAT_INPUT_FILES = cat ${INPUT_FILES}
+SETTINGS_JSON   = { "num-triples-per-batch": 10000000 }
+
+[server]
+PORT               = 7003
+ACCESS_TOKEN       = ${data:NAME}
+MEMORY_FOR_QUERIES = 5G
+
+[runtime]
+SYSTEM = docker
+IMAGE  = docker.io/adfreiburg/qlever:latest
+
+[ui]
+UI_CONFIG = fbeasy

qlever/Qleverfiles/Qleverfile.freebase

@@ -0,0 +1,28 @@
+# Qleverfile for Freebase, use with https://github.com/ad-freiburg/qlever-control
+#
+# qlever get-data  # downloads .gz file of size ~3 GB (as of 31.07.2022)
+# qlever index     # takes ~4 hours and ~20 GB RAM (on an AMD Ryzen 7 5900X)
+# qlever start     # starts the server
+
+[data]
+NAME         = freebase
+DATA_URL     = http://commondatastorage.googleapis.com/freebase-public/rdf/freebase-rdf-latest.gz
+GET_DATA_CMD = wget -nc ${DATA_URL}
+DESCRIPTION  = Freebase, RDF NT from ${DATA_URL}, latest (and final) version from 09.08.2015
+
+[index]
+INPUT_FILES     = freebase-rdf-latest.gz
+CAT_INPUT_FILES = zcat ${INPUT_FILES}
+SETTINGS_JSON   = { "languages-internal": [ "en" ], "prefixes-external": ["<"], "locale": { "language": "en", "country": "US", "ignore-punctuation": true }, "ascii-prefixes-only": false, "num-triples-per-batch": 10000000 }
+
+[server]
+PORT               = 7002
+ACCESS_TOKEN       = ${data:NAME}
+MEMORY_FOR_QUERIES = 10G
+
+[runtime]
+SYSTEM = docker
+IMAGE  = docker.io/adfreiburg/qlever:latest
+
+[ui]
+UI_CONFIG = freebase

qlever/Qleverfiles/Qleverfile.imdb

@@ -0,0 +1,36 @@
+# Qleverfile for IMDB, use with https://github.com/ad-freiburg/qlever-control
+#
+# qlever get-data  # downloads "basics" and "ratings" of size ~1 GB
+# qlever index     # takes ~5 minutes and ~5 GB RAM (on an AMD Ryzen 9 5900X)
+# qlever start     # starts the server (takes a few seconds)
+#
+# Supports fast kewyword search in literals (WITH_TEXT_INDEX = from_literals).
+
+[data]
+NAME             = imdb
+IMDB_DATA_URL    = https://datasets.imdbws.com
+GET_PREFIXES     = echo "@prefix imdb: <https://www.imdb.com/> ."
+GET_IMDB_BASICS  = FILE=title.basics.tsv.gz; curl -sLO -C - ${IMDB_DATA_URL}/$${FILE}; zcat $${FILE} | sed 1d | awk -F'\t' '{ gsub("\\\\", "\\\\", $$3); gsub("\"", "\\\"", $$3); printf "imdb:%s imdb:id \"%s\" ; imdb:type \"%s\" ; imdb:title \"%s\" .\n", $$1, $$1, $$2, $$3 }'; rm -f $${FILE}
+GET_IMDB_RATINGS = FILE=title.ratings.tsv.gz; curl -sLO -C - ${IMDB_DATA_URL}/$${FILE}; zcat $${FILE} | sed 1d | awk -F'\t' '{ printf "imdb:%s imdb:averageRating %s ; imdb:numVotes %s .\n", $$1, $$2, $$3 }'; rm -f $${FILE}
+GET_DATA_CMD     = (${GET_PREFIXES}; ${GET_IMDB_BASICS}; ${GET_IMDB_RATINGS}) > ${NAME}.ttl
+VERSION          = $$(date -r imdb.ttl +"%d.%m.%Y %H:%M" || echo "NO_DATE")
+DESCRIPTION      = IMDb, CSV from ${IMDB_DATA_URL}, converted to RDF TTL using awk, version ${VERSION}
+TEXT_DESCRIPTION = All literals, search with [ ql:contains-word "..."; ql:contains-entity ?literal ]
+
+[index]
+INPUT_FILES     = ${data:NAME}.ttl
+CAT_INPUT_FILES = cat ${INPUT_FILES}
+SETTINGS_JSON   = { "num-triples-per-batch": 1000000 }
+TEXT_INDEX      = from_literals
+
+[server]
+PORT               = 7029
+ACCESS_TOKEN       = ${data:NAME}
+MEMORY_FOR_QUERIES = 5G
+
+[runtime]
+SYSTEM = docker
+IMAGE  = docker.io/adfreiburg/qlever:latest
+
+[ui]
+UI_CONFIG = imdb

qlever/Qleverfiles/Qleverfile.ohm-planet

@@ -0,0 +1,41 @@
+# Qleverfile for OpenHistoricalMap, use with the QLever CLI (`pip install qlever`)
+#
+# qlever get-data  # ~1 hour, ~14 GB (ttl.gz), ~3.4 B triples (with osm2rdf)
+# qlever index     # ~1 hour, ~10 GB RAM, ~60 GB index size on disk
+# qlever start     # a few seconds, adjust MEMORY_FOR_QUERIES as needed
+#
+# Measured on an AMD Ryzen 9 5900X with 128 GB RAM and 1 x 4 TB NVMe (04.01.2025)
+
+[data]
+NAME           = ohm-planet
+GET_DATA_URL   = https://planet.openhistoricalmap.org/planet
+CHECK_BINARIES = osm2rdf -h > /dev/null || (echo "osm2rdf not found, make sure that it's installed and in your PATH" && exit 1)
+GET_DATA_CMD_1 = unbuffer wget -O ${NAME}.pbf $$(curl -s ${GET_DATA_URL}/state.txt) 2>&1 | tee ${NAME}.download-log.txt
+GET_DATA_CMD_2 = osm2rdf ${NAME}.pbf -o ${NAME}.ttl --source-dataset OHM --output-compression gz --store-locations=disk-dense --cache . --num-threads 12 --iri-prefix-for-untagged-nodes http://www.openhistoricalmap.org/node/ 2>&1 | tee ${NAME}.osm2rdf-log.txt
+GET_DATA_CMD   = ${CHECK_BINARIES} && ${GET_DATA_CMD_1} && echo && ${GET_DATA_CMD_2}
+VERSION        = $$(date -r ${NAME}.pbf +%d.%m.%Y || echo "NO_DATE")
+DESCRIPTION    = OHM from ${GET_DATA_URL} (with GeoSPARQL predicates ogc:sfContains and ogc:sfIntersects), version ${VERSION} 
+
+[index]
+INPUT_FILES        = ${data:NAME}.ttl.gz
+MULTI_INPUT_JSON   = { "cmd": "zcat ${INPUT_FILES}", "parallel": "true" }
+STXXL_MEMORY       = 5G
+PARSER_BUFFER_SIZE = 50M
+SETTINGS_JSON      = { "num-triples-per-batch": 5000000 }
+ENCODE_AS_ID       = https://www.openhistoricalmap.org/node/ http://www.openhistoricalmap.org/node/ https://www.openhistoricalmap.org/way/ https://www.openhistoricalmap.org/relation/ https://osm2rdf.cs.uni-freiburg.de/rdf/geom#ohmnode_tagged_ https://osm2rdf.cs.uni-freiburg.de/rdf/geom#ohmnode_untagged_ https://osm2rdf.cs.uni-freiburg.de/rdf/geom#ohmway_ https://osm2rdf.cs.uni-freiburg.de/rdf/geom#ohmrel_ https://www.openstreetmap.org/changeset/
+
+[server]
+PORT                        = 7037
+ACCESS_TOKEN                = ${data:NAME}
+MEMORY_FOR_QUERIES          = 10G
+CACHE_MAX_SIZE              = 5G
+TIMEOUT                     = 600s
+CACHE_MAX_SIZE_SINGLE_ENTRY = 4G
+WARMUP_CMD                  = curl -s https://qlever.cs.uni-freiburg.de/petrimaps/query --data-urlencode "query=PREFIX geo: <http://www.opengis.net/ont/geosparql#> PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> PREFIX osm: <https://www.openstreetmap.org/> SELECT ?osm_id ?geometry WHERE { ?osm_id geo:hasGeometry/geo:asWKT ?geometry . ?osm_id rdf:type osm:node } LIMIT 1" --data-urlencode "backend=https://qlever.cs.uni-freiburg.de/api/${data:NAME}" > /dev/null
+
+[runtime]
+SYSTEM = docker
+IMAGE  = adfreiburg/qlever:latest
+
+[ui]
+CONFIG = ohm-planet

qlever/Qleverfiles/Qleverfile.olympics

@@ -0,0 +1,31 @@
+# Qleverfile for Olympics, use with https://github.com/ad-freiburg/qlever-control
+#
+# qlever get-data  # downloads .zip file of size 13 MB, uncompressed to 323 MB 
+# qlever index     # takes ~10 seconds and ~1 GB RAM (on an AMD Ryzen 9 5900X)
+# qlever start     # starts the server (instant)
+
+[data]
+NAME              = olympics
+BASE_URL          = https://github.com/wallscope/olympics-rdf
+GET_DATA_CMD      = curl -sLo olympics.zip -C - ${BASE_URL}/raw/master/data/olympics-nt-nodup.zip && unzip -q -o olympics.zip && rm olympics.zip
+DESCRIPTION       = 120 Years of Olympics, data from ${BASE_URL}
+TEXT_DESCRIPTION  = All literals, search with FILTER CONTAINS(?var, "...")
+
+[index]
+INPUT_FILES     = olympics.nt
+CAT_INPUT_FILES = cat ${INPUT_FILES}
+SETTINGS_JSON   = { "ascii-prefixes-only": false, "num-triples-per-batch": 100000 }
+
+[server]
+PORT               = 7019
+ACCESS_TOKEN       = ${data:NAME}_7643543846
+MEMORY_FOR_QUERIES = 5G
+CACHE_MAX_SIZE     = 2G
+TIMEOUT            = 30s
+
+[runtime]
+SYSTEM = docker
+IMAGE  = docker.io/adfreiburg/qlever:latest
+
+[ui]
+UI_CONFIG = olympics

qlever/Qleverfiles/Qleverfile.orkg

@@ -0,0 +1,30 @@
+# Qleverfile for ORKG, use with the QLever CLI (`pip install qlever`)
+#
+# qlever get-data  # Get the dataset
+# qlever index     # Build index data structures
+# qlever start     # Start the server
+
+[data]
+NAME         = orkg
+GET_DATA_URL = https://orkg.org/api/rdf/dump
+GET_DATA_CMD = curl -LR -o ${NAME}.ttl ${GET_DATA_URL} 2>&1 | tee ${NAME}.download-log.txt
+VERSION      = $$(date -r ${NAME}.ttl +%d.%m.%Y || echo "NO_DATE")
+DESCRIPTION  = The Open Research Knowledge Graph (ORKG) (data from ${GET_DATA_URL}, version ${VERSION})
+
+[index]
+INPUT_FILES     = ${data:NAME}.ttl
+CAT_INPUT_FILES = cat ${INPUT_FILES}
+SETTINGS_JSON   = { "ascii-prefixes-only": false, "num-triples-per-batch": 1000000, "prefixes-external": [""] }
+
+[server]
+PORT               = 7053
+ACCESS_TOKEN       = ${data:NAME}
+MEMORY_FOR_QUERIES = 10G
+CACHE_MAX_SIZE     = 5G
+
+[runtime]
+SYSTEM = docker
+IMAGE  = docker.io/adfreiburg/qlever:latest
+
+[ui]
+UI_CONFIG = orkg

qlever/Qleverfiles/Qleverfile.osm-country

@@ -0,0 +1,39 @@
+# Qleverfile for OSM of some country, use with `qlever` CLI
+#
+# Make sure that `osm2rdf` is in your path. Set CONTINENT and COUNTRY
+# such that the link under GET_DATA_CMD exists (the names are usually
+# the canonical names).
+
+[data]
+CONTINENT    = europe
+COUNTRY      = switzerland
+NAME         = osm-${COUNTRY}
+GET_DATA_URL = https://download.geofabrik.de/${CONTINENT}/${COUNTRY}-latest.osm.pbf
+GET_DATA_CMD = wget -nc -O ${NAME}.pbf ${GET_DATA_URL}; (time osm2rdf ${NAME}.pbf -o ${NAME}.ttl --output-compression gz --cache . --iri-prefix-for-untagged-nodes http://www.openstreetmap.org/node/) 2>&1 | tee ${NAME}.osm2rdf-log.txt
+VERSION      = $$(ls -l --time-style=+%d.%m.%Y ${NAME}.pbf 2> /dev/null | cut -d' ' -f6)
+DESCRIPTION  = OSM ${COUNTRY}, PBF from ${GET_DATA_URL}, converted to RDF with osm2rdf, version ${VERSION}
+
+[index]
+INPUT_FILES      = ${data:NAME}.ttl.gz
+CAT_INPUT_FILES  = zcat ${data:NAME}.ttl.gz
+PARALLEL_PARSING = true
+VOCABULARY_TYPE  = on-disk-compressed-geo-split
+STXXL_MEMORY     = 10G
+SETTINGS_JSON    = { "num-triples-per-batch": 10000000 }
+ENCODE_AS_ID     = https://www.openstreetmap.org/node/ http://www.openstreetmap.org/node/ https://www.openstreetmap.org/way/ https://www.openstreetmap.org/relation/ https://osm2rdf.cs.uni-freiburg.de/rdf/geom#osmnode_tagged_ https://osm2rdf.cs.uni-freiburg.de/rdf/geom#osmnode_untagged_ https://osm2rdf.cs.uni-freiburg.de/rdf/geom#osmway_ https://osm2rdf.cs.uni-freiburg.de/rdf/geom#osmrel_ https://www.openstreetmap.org/changeset/
+
+[server]
+PORT                        = 7025
+ACCESS_TOKEN                = ${data:NAME}
+MEMORY_FOR_QUERIES          = 20G
+CACHE_MAX_SIZE              = 10G
+CACHE_MAX_SIZE_SINGLE_ENTRY = 5G
+TIMEOUT                     = 100s
+
+[runtime]
+SYSTEM = docker
+IMAGE = docker.io/adfreiburg/qlever:latest
+
+[ui]
+UI_PORT   = 7000
+UI_CONFIG = osm-planet

qlever/Qleverfiles/Qleverfile.osm-planet

@@ -0,0 +1,39 @@
+# Qleverfile for OSM Planet, use with the QLever CLI (`pip install qlever`)
+#
+# qlever get-data  # downloads ~400 GB (ttl.bz2), ~100 B triples
+# qlever index     # ~20 hours, ~60 GB RAM, ~1.5 TB index size on disk
+# qlever start     # a few seconds, adjust MEMORY_FOR_QUERIES as needed
+#
+# Measured on an AMD Ryzen 9 7950X with 128 GB RAM and 2 x 8 TB NVMe (04.01.2025)
+
+[data]
+NAME         = osm-planet
+GET_DATA_URL = https://osm2rdf.cs.uni-freiburg.de/ttl/planet.osm.ttl.bz2
+GET_DATA_CMD = unbuffer wget -O ${NAME}.ttl.bz2 ${GET_DATA_URL} | tee ${NAME}.download-log.txt
+VERSION      = $$(date -r ${NAME}.ttl.bz2 +"%d.%m.%Y" || echo "NO_DATE")
+DESCRIPTION  = OpenStreetMap, RDF TTL from ${GET_DATA_URL} including DE-9IM triples, version ${VERSION}
+
+[index]
+INPUT_FILES        = ${data:NAME}.ttl.bz2
+MULTI_INPUT_JSON   = { "cmd": "lbzcat -n 2 ${INPUT_FILES}", "parallel": "true" }
+VOCABULARY_TYPE    = on-disk-compressed-geo-split
+PARSER_BUFFER_SIZE = 100M
+STXXL_MEMORY       = 60G
+SETTINGS_JSON      = { "num-triples-per-batch": 10000000 }
+ULIMIT             = 50000
+ENCODE_AS_ID       = https://www.openstreetmap.org/node/ http://www.openstreetmap.org/node/ https://www.openstreetmap.org/way/ https://www.openstreetmap.org/relation/ https://osm2rdf.cs.uni-freiburg.de/rdf/geom#osmnode_ https://osm2rdf.cs.uni-freiburg.de/rdf/geom#osmway_ https://osm2rdf.cs.uni-freiburg.de/rdf/geom#osmrel_ https://www.openstreetmap.org/changeset/
+
+[server]
+PORT                        = 7007
+ACCESS_TOKEN                = ${data:NAME}
+MEMORY_FOR_QUERIES          = 40G
+CACHE_MAX_SIZE              = 20G
+CACHE_MAX_SIZE_SINGLE_ENTRY = 20G
+TIMEOUT                     = 600s
+
+[runtime]
+SYSTEM = docker
+IMAGE  = docker.io/adfreiburg/qlever:latest
+
+[ui]
+UI_CONFIG = osm-planet

qlever/Qleverfiles/Qleverfile.osm-planet-from-pbf

@@ -0,0 +1,42 @@
+# Qleverfile for OSM Planet, use with the QLever CLI (`pip install qlever`)
+#
+# qlever get-data  # download ~100 GB (pbf), convert with osm2rdf, ~200B triples
+# qlever index     # ~40 hours, ~60 GB RAM, ~2.5 TB index size on disk
+# qlever start     # a few seconds, adjust MEMORY_FOR_QUERIES as needed
+#
+# Measured on an AMD Ryzen 9 9950X with 128 GB RAM and 4 x 8 TB NVMe (02.10.2025)
+
+[data]
+NAME         = osm-planet
+PLANET_PBF   = planet-250929.osm.pbf
+GET_DATA_URL = https://planet.openstreetmap.org/pbf/${PLANET_PBF}
+GET_PBF_CMD  = unbuffer wget -O ${PLANET_PBF} ${GET_DATA_URL}
+OSM2RDF_CMD  = unbuffer osm2rdf ${PLANET_PBF} -o ${NAME}.ttl --num-threads 20 --output-compression gz --cache . --store-locations disk-dense --iri-prefix-for-untagged-nodes http://www.openstreetmap.org/node/ --split-tag-key-by-semicolon ref --split-tag-key-by-semicolon service
+GET_DATA_CMD = ${GET_PBF_CMD} && ${OSM2RDF_CMD} 2>&1 | tee ${NAME}.osm2rdf-log.txt
+VERSION      = $$(date -r ${PLANET_PBF} +%d.%m.%Y || echo "NO_DATE")
+DESCRIPTION  = OpenStreetMap, PBF from ${GET_DATA_URL}, converted to RDF TTL and enhanced by DE-9IM triples using osm2rdf
+
+[index]
+INPUT_FILES        = ${data:NAME}.ttl.gz
+MULTI_INPUT_JSON   = { "cmd": "zcat ${INPUT_FILES}", "parallel": "true" }
+VOCABULARY_TYPE    = on-disk-compressed-geo-split
+PARSER_BUFFER_SIZE = 100M
+STXXL_MEMORY       = 60G
+SETTINGS_JSON      = { "num-triples-per-batch": 10000000 }
+ULIMIT             = 50000
+ENCODE_AS_ID       = https://www.openstreetmap.org/node/ http://www.openstreetmap.org/node/ https://www.openstreetmap.org/way/ https://www.openstreetmap.org/relation/ https://osm2rdf.cs.uni-freiburg.de/rdf/geom#osmnode_tagged_ https://osm2rdf.cs.uni-freiburg.de/rdf/geom#osmnode_untagged_ https://osm2rdf.cs.uni-freiburg.de/rdf/geom#osmway_ https://osm2rdf.cs.uni-freiburg.de/rdf/geom#osmrel_ https://www.openstreetmap.org/changeset/
+
+[server]
+PORT                        = 7007
+ACCESS_TOKEN                = ${data:NAME}
+MEMORY_FOR_QUERIES          = 40G
+CACHE_MAX_SIZE              = 20G
+CACHE_MAX_SIZE_SINGLE_ENTRY = 10G
+TIMEOUT                     = 600s
+
+[runtime]
+SYSTEM = docker
+IMAGE  = docker.io/adfreiburg/qlever:latest
+
+[ui]
+UI_CONFIG = osm-planet