ontologos 1.0.1

Python bindings for the OntoLogos OWL reasoner — RDFS, OWL RL, and OWL EL classification

ontologos

Python bindings for OntoLogos — a Rust-native OWL reasoner for RDFS, OWL RL, OWL EL, OWL 2 DL, and SWRL on PyPI 1.0.0.

Install: pip install ontologos (v1.0.0). Production profiles: rdfs, rl, el, auto, dl, swrl. Preview: alc, dl-preview. See Profile stability.

Load .owl / .ttl files or build ontologies in memory, run the same profile engines as the CLI, and export taxonomies to pandas or Polars. Powered by PyO3 and the stable Python ABI (abi3).

Full guide: ontologos.readthedocs.io — Python

Features

• File or in-memory — Reasoner(path=...) or Ontology / OntologyBuilder
• Profiles — "rdfs", "rl", "el", "auto", "dl", "swrl" on PyPI 1.0.0; "dl-preview", "alc" are preview
• Classify — RDFS/RL materialization reports or EL taxonomy dicts
• Explain — proof graph dicts with IRI-resolved conclusions (EL full traces)
• Incremental — multi-pass add_subclass_of / remove_subclass_of with incremental=True
• Export — optional subsumptions_to_pandas / subsumptions_to_polars

Install

Requires Python 3.10+.

pip install ontologos

Optional DataFrame helpers:

pip install 'ontologos[pandas]'
pip install 'ontologos[polars]'

Pre-built wheels are published for:

OS	Architectures
Linux	x86_64, aarch64 (manylinux)
macOS	x86_64, aarch64
Windows	x64, aarch64

One abi3 wheel per platform covers Python 3.10–3.13+. If no wheel matches, build from source (Rust + maturin).

Quick start

Download Pizza for EL examples (from a clone: ./benchmarks/scripts/download.sh at repo root):

# From repository clone only:
./benchmarks/scripts/download.sh

Classify an OWL file

import ontologos

# OWL EL taxonomy
reasoner = ontologos.Reasoner(path="pizza.owl", profile="el")
taxonomy = reasoner.classify()
print(taxonomy["subsumption_count"], taxonomy["subsumptions"][:3])

# RDFS materialization
reasoner = ontologos.Reasoner(path="ontology.owl", profile="rdfs")
report = reasoner.classify()
print(report["inferred_axioms"])

# Auto-detect profile (EL or RL)
reasoner = ontologos.Reasoner(path="ontology.owl", profile="auto")
result = reasoner.classify()

Build in memory

from ontologos import OntologyBuilder, Reasoner

builder = OntologyBuilder()
builder.add_class("http://example.org/A")
builder.add_class("http://example.org/B")
builder.subclass_of("http://example.org/A", "http://example.org/B")
ontology = builder.build()

reasoner = Reasoner(ontology=ontology, profile="el")
taxonomy = reasoner.classify()

Load from JSON dict instead of the builder (v2 or v3; writers on workspace 1.0.0 emit v3):

from ontologos import Ontology, Reasoner

ontology = Ontology.from_dict({
    "format_version": 2,
    "entities": [
        {"iri": "http://example.org/A", "kind": "Class"},
        {"iri": "http://example.org/B", "kind": "Class"},
    ],
    "axioms": [
        {"SubClassOf": {
            "subclass": "http://example.org/A",
            "superclass": "http://example.org/B",
        }}
    ],
})
reasoner = Reasoner(ontology=ontology, profile="el")
reasoner.classify()

Incremental edits

reasoner = Reasoner(ontology=ontology, profile="el", incremental=True)
reasoner.classify()

reasoner.add_subclass_of("http://example.org/B", "http://example.org/C")
reasoner.classify()  # re-classify with warm session

reasoner.remove_subclass_of("http://example.org/A", "http://example.org/B")
reasoner.classify()

Explain inferences

graph = reasoner.explain()
print(graph["node_count"])
for node in graph["nodes"][:5]:
    print(node["rule"], node.get("conclusion_sub"))

Profile	Explain coverage
EL	Full inference traces
RL / RDFS	Asserted axioms seeded; inferred steps lack per-rule premises until upstream exposes traces
auto	Routes like classify

Export to DataFrame

from ontologos import subsumptions_to_pandas

df = subsumptions_to_pandas(taxonomy)
# columns: subclass, superclass

API overview

Type / method	Description
Reasoner(path=..., profile=..., incremental=False)	Load OWL file and classify
Reasoner(ontology=..., ...)	Classify in-memory ontology
reasoner.classify()	Run engine; returns taxonomy or materialization dict
reasoner.explain()	Proof graph dict (node_count, nodes, parse_meta)
reasoner.taxonomy	Last EL taxonomy (after classify)
reasoner.parse_meta	Parser warnings and axiom counts
reasoner.add_subclass_of / remove_subclass_of	Incremental axiom edits
reasoner.add_axiom_json	Add axiom via JSON object (v2/v3 shape)
Ontology.from_json / from_dict	Load JSON snapshot (v2 or v3)
OntologyBuilder	Fluent builder → build()
subsumptions_to_pandas / subsumptions_to_polars	Optional taxonomy export

Invalid profiles and unsupported constructs raise RuntimeError with a message string.

Reasoner is not thread-safe — do not mutate from multiple threads.

Development

From a repository clone:

cd crates/ontologos-py
python -m venv .venv
source .venv/bin/activate   # Windows: .venv\Scripts\activate
pip install 'maturin>=1.7,<2.0' pytest '.[pandas]'
maturin develop --release
pytest tests/ -q

Pizza EL golden test (requires corpus):

./benchmarks/scripts/download.sh   # from repo root
pytest tests/test_pizza_golden.py -q

What OntoLogos is (and is not)

OntoLogos is an orchestration layer: profile detection, a unified ontology model, CLI, Python wheels, and security limits on top of in-house EL, ontologos-dl for OWL 2 DL, and reasonable for RL/RDFS. It maps a subset of OWL — validate on your corpus before production cutover.

For engine-only workflows, consider reasonable, whelk-rs, or horned-owl directly.

Links

Resource	URL
Python guide	readthedocs — Python
Getting started	readthedocs
Migration v0.9 → v1.0	migration guide
Repository	github.com/eddiethedean/ontologos
Rust crates	crates.io — ontologos-core
Changelog	CHANGELOG.md

License

Licensed under either of Apache-2.0 or MIT.