OWLAPY: Python Framework for OWL Ontologies

• OWLAPY is a comprehensive native Python framework for engineering OWL 2 ontologies with robust reasoning and conversion capabilities.
• It integrates both native embedding-based reasoning and Java-backed sync reasoning, enabling efficient DL tasks and fast instance retrieval.
• Its modular architecture supports seamless interoperability, formal syntax mapping, and extensible workflows, including LLM-powered ontology generation.

OWLAPY is a comprehensive native Python framework for engineering ontologies conforming to the Web Ontology Language (OWL) 2 standard. Designed for both flexibility and rigorous specification adherence, OWLAPY streamlines the creation, manipulation, reasoning, and serialization of OWL ontologies in Python. Its architecture supports multiple reasoning paradigms, robust bidirectional conversion between ontology representations, seamless interoperability with Java-based systems via the OWLAPI, and extensible workflows for ontology generation employing LLMs.

1. Core Architecture and Modules

OWLAPY's architecture is organized around four principal modules:

• Ontology Module: Encapsulates OWL classes (OWLClass, OWLObjectProperty, OWLDataProperty, OWLNamedIndividual, OWLLiteral) and axiom types (OWLSubClassOfAxiom, OWLClassAssertionAxiom, OWLObjectPropertyAssertionAxiom, etc.). Functionalities include loading ontologies, adding/removing axioms, saving ontologies, and accessing the ontology signature through dedicated accessors (ontology.classes, ontology.properties, ontology.individuals). This module forms the basis for API-driven ontology creation, modification, and serialization in Python.
• Reasoner Module: Provides diverse reasoning capabilities:
  • SyncReasoner: Facilitates integration with major Java-based reasoners (HermiT, Pellet, ELK) using JPype, supporting open-world Description Logic (DL) tasks (classification, consistency checking, subsumption, instance retrieval).
  • EmbeddingBasedReasoner (EBR): Implements native approximate reasoning using knowledge graph embeddings and scoring functions, targeting tasks such as instance retrieval.
  • NativeCloseWorldReasoner: A simple, in-memory reasoner operating under a local closed-world assumption.
• Transformers / Converters: Comprises DLTransformer, ManchesterTransformer, SPARQLTransformer, and SWRLParser, supporting bidirectional conversions between Python OWLAPY objects and logical Description Logic syntax, Manchester Syntax, and SPARQL graph patterns.
• OWLAPIMapper: Enables seamless, bidirectional mapping between OWLAPY objects and their Java OWLAPI counterparts via JPype, supporting workflows that require features exclusively available in Java environments.

2. Reasoning Paradigms and Performance

OWLAPY integrates both native and Java-backed reasoning backends:

• Native Embedding-Based Reasoner: Utilizes pretrained embedding models with configurable scoring functions (e.g., distmult). Enables fast, approximate instance retrieval for DL expressions, such as $\exists$hasChild.Person, with empirical retrieval of 100 instances completing in approximately 0.1 seconds on typical hardware, contingent on the model configuration.
• Java-Backed SyncReasoner: Connects to OWLAPI-based reasoners through JPype, allowing for the execution of DL reasoning tasks directly from Python. Classification of ontologies with roughly 1,000 axioms generally completes in 2–3 seconds using HermiT on modern 8-core CPUs.

A plausible implication is that OWLAPY can flexibly accommodate either research prototyping using native embedding-based inference or production-level logic-based reasoning via established Java frameworks.

3. Formal Constructs and Syntax Mappings

OWLAPY faithfully implements the OWL 2 Structural Specification and Functional-Style Syntax through one-to-one mappings:

• Core Classes:
  • OWLClass(IRI)
  • OWLObjectProperty(IRI)
  • OWLDataProperty(IRI)
  • OWLNamedIndividual(IRI)
  • OWLLiteral(value, datatype)
• Axioms:
  • OWLSubClassOfAxiom(sub_class, super_class)
  • OWLClassAssertionAxiom(individual, class_expr)
  • OWLObjectPropertyAssertionAxiom(subject, property, object)
• Mappings:
  • $$C \sqcap D \longleftrightarrow \text{OWLObjectIntersectionOf}(C,D)$$
  • $$\exists R.C \longleftrightarrow \text{OWLObjectSomeValuesFrom}(R,C)$$
  • $$\forall R.C \longleftrightarrow \text{OWLObjectAllValuesFrom}(R,C)$$
  • $$C \sqsubseteq D \longleftrightarrow \text{OWLSubClassOfAxiom}(C,D)$$

Manchester syntax is provided in parallel:

• $C \sqcap D$ corresponds to "C and D" (API: OWLObjectIntersectionOf)
• $\exists R.C$ corresponds to "R some C" (API: OWLObjectSomeValuesFrom)

4. Transformation and Interoperability Workflows

OWLAPY supports robust conversion pipelines:

• Class Expression Transformation: Enables progression from an OWLAPY object to DL syntax, Manchester syntax, and SPARQL patterns. For example, the expression $$(\text{Person} \sqcap \text{Student}) \sqcap \exists\text{hasAdvisor}.\text{Professor}$$ can be serialized as:
  • Description Logic: "((Person ⊓ Student) ⊓ ∃hasAdvisor.Professor)"
  • Manchester: "Person and Student and hasAdvisor some Professor"
  • SPARQL Query fragment.
• OWLAPI Interoperability: Through OWLAPIMapper, users can convert ontologies between Java OWLAPI and OWLAPY representations, enabling Pythonic editing and subsequent serialization in either environment.

The modularity and conversion capacity facilitate advanced ontology engineering workflows, including cross-platform development and data-science integration.

5. Extensible Workflows Using LLMs

OWLAPY provides an “OntologyGenerator” that can incorporate LLMs for automated extraction of entities, relations, and types from natural language:

• Workflow components include LLM configuration (e.g., Mistral-7B, Llama2), instantiation with predefined types, text input, ontology generation, inspection of resulting axioms, and serialization (e.g., in Turtle syntax).
• Hypothetical output exemplifies triples such as:
  • ClassAssertion(:Person :Alice)
  • ClassAssertion(:Organization :AcmeCorp)
  • ObjectPropertyAssertion(:worksAt :Alice :AcmeCorp)
  • DataPropertyAssertion(:publicationYear :Paper123 "2023"^^xsd:gYear)

This suggests that OWLAPY is positioned for contemporary ontology development settings leveraging advanced NLP techniques.

6. Installation, Dependencies, and Documentation

OWLAPY requires Python $\geq$ 3.8 and is distributed via PyPI (pip install owlapy) or GitHub. Dependencies are handled automatically and include owlready2 (Java bridge and base OWL object model), rdflib (RDF support), JPype1 (JVM bridge), and numpy, torch for the embedding-based reasoner.

Comprehensive documentation is provided at https://dice-group.github.io/owlapy/index.html.

Distribution	Location	Downloads (at writing)
PyPI	https://pypi.org/project/owlapy/	> 50,000
GitHub	https://github.com/dice-group/owlapy	–

7. Application Contexts and Metrics

OWLAPY forms the foundational layer for several systems including Ontolearn (JMLR 2025), OntoSample (CIKM 2023), Drill (IJCAI 2023), EvoLearner (WWW 2022), and CLIP (ESWC 2022), supporting tasks such as large-scale OWL class expression learning, efficient ontology sampling, and concept learning pipelines in Description Logics.

In academic contexts, OWLAPY is employed in curriculum at Paderborn University and TU Dresden for ontology engineering education. The software comprises approximately 15,000 lines of code, with 165 unit tests, and anecdotally receives positive feedback for ease of transitioning from Java OWLAPI, flexibility for data-science and machine-learning integrations, and extensibility for custom reasoners and LLM-powered workflows.

Summary

OWLAPY delivers a technically rigorous, modular, and extensible platform for OWL 2 ontology engineering in Python. It integrates native and Java-backed reasoning, formal syntax conversions, LLM-based ontology generation, and cross-platform workflows, facilitating both production and research requirements in advanced ontology engineering (Baci et al., 11 Nov 2025).