OWL-RL

Warnings

• breaking OWL-RL version 7.x, following RDFLib's dependency updates, now requires Python 3.9 or higher. Older projects using Python 2.7 or earlier Python 3 versions (e.g., 3.5, 3.6) will need to upgrade their Python environment or use an older `owlrl` version.
  Fix: Upgrade Python to 3.9+ or pin `owlrl` to an older version compatible with your Python environment (e.g., `owlrl<7.0.0` for Python 3.5-3.8, or `owlrl<5.0.0` for Python 2.7).
• breaking In version 5.1.0, the primary module for the library was renamed from `RDFClosure` to `owlrl`. If you are migrating an older codebase, import statements like `from RDFClosure import DeductiveClosure` must be updated to `from owlrl import DeductiveClosure`.
  Fix: Update your import statements to use `from owlrl import ...` instead of `from RDFClosure import ...`.
• gotcha The `DeductiveClosure` class does not automatically interpret `owl:imports` statements. Any imported ontologies must be explicitly loaded and merged into the graph (e.g., using `owlrl.interpret_owl_imports`) before calling `expand()` for the inference process to consider them.
  Fix: Pre-process your graph to interpret `owl:imports` statements, for example: ```python from rdflib import Graph from owlrl import interpret_owl_imports g = Graph().parse('my_ontology_with_imports.owl') interpret_owl_imports('auto', g) # Now proceed with DeductiveClosure().expand(g) ```
• gotcha RDFLib's default datatype handling may not meet the stricter requirements of OWL 2 RL, potentially leading to incorrect inferences for complex datatypes. `owlrl` provides improved datatype conversion routines, which can be explicitly enabled.
  Fix: To use the stricter datatype conversions, call `DeductiveClosure.use_improved_datatypes_conversions()` before expanding graphs, or initialize `DeductiveClosure(improved_datatypes=True)`. ```python from owlrl import DeductiveClosure, OWLRL_Semantics DeductiveClosure.use_improved_datatypes_conversions() # Apply globally # or: closure = DeductiveClosure(OWLRL_Semantics, improved_datatypes=True) ```
• gotcha A known bug in RDFLib's Turtle parser can cause exceptions when parsing abbreviated double datatypes (e.g., `1.234E56`). It's advisable to avoid this specific literal syntax in your Turtle files if you encounter parsing errors.
  Fix: Represent double datatypes in their full lexical form (e.g., `"1.234E56"^^xsd:double`) or use a different serialization format if this issue is critical.
• gotcha On Windows systems, if both the `owlrl` package and an `owlrl.py` command-line script are present and accessible in `PYTHON_PATH`, attempting to `from owlrl import convert_graph` (an older entry point) could lead to an import collision, as Python might incorrectly try to import from the script file.
  Fix: Avoid using the `convert_graph` entry point if encountering this issue. Ensure your Python environment's `PYTHON_PATH` doesn't lead to ambiguity, or consider upgrading `owlrl` which has renamed scripts to avoid `.py` extensions.

Install

• pip install owlrl Install stable version

Imports

• DeductiveClosure
  wrong:

  from RDFClosure import DeductiveClosure

  correct:

  from owlrl import DeductiveClosure

  The module was renamed from RDFClosure to owlrl in version 5.1.0. Ensure you're using the correct module name for newer versions.
• RDFS_Semantics

  from owlrl import RDFS_Semantics

• OWLRL_Semantics

  from owlrl import OWLRL_Semantics

• Graph

  from rdflib import Graph

Quickstart

This quickstart demonstrates how to create an RDFLib graph, populate it with some triples, and then use `owlrl.DeductiveClosure` with `OWLRL_Semantics` or `RDFS_Semantics` to infer new triples based on the respective OWL 2 RL or RDFS rules. The `expand` method modifies the graph in place, adding all possible derived triples. It shows how to check for an inferred triple after expansion.

from rdflib import Graph, Literal, Namespace, RDF, RDFS
from owlrl import DeductiveClosure, OWLRL_Semantics

# Define a simple namespace for demonstration
ex = Namespace("http://example.org/ontology#")

# Create an RDFLib graph
graph = Graph()
graph.bind("ex", ex)

# Add some initial triples (asserted facts)
graph.add((ex.Person, RDF.type, RDFS.Class))
graph.add((ex.Student, RDFS.subClassOf, ex.Person))
graph.add((ex.John, RDF.type, ex.Student))

# Add a rule that says if someone is a Person, they are also an Agent
graph.add((ex.Agent, RDF.type, RDFS.Class))
graph.add((ex.Person, RDFS.subClassOf, ex.Agent))

print(f"Graph size before OWL RL expansion: {len(graph)}")

# Initialize and run the OWL 2 RL deductive closure
closure = DeductiveClosure(OWLRL_Semantics)
closure.expand(graph)

# The graph now contains inferred triples, e.g., John is a Person, and also an Agent
print(f"Graph size after OWL RL expansion: {len(graph)}")

# Check for an inferred triple
if (ex.John, RDF.type, ex.Agent) in graph:
    print("Inferred: John is an Agent.")

# You can also run RDFS inference separately
rdfs_graph = Graph()
rdfs_graph.bind("ex", ex)
rdfs_graph.add((ex.Teacher, RDFS.subClassOf, ex.Person))
rdfs_graph.add((ex.Jane, RDF.type, ex.Teacher))

print(f"\nGraph size before RDFS expansion: {len(rdfs_graph)}")
from owlrl import RDFS_Semantics
rdfs_closure = DeductiveClosure(RDFS_Semantics)
rdfs_closure.expand(rdfs_graph)
print(f"Graph size after RDFS expansion: {len(rdfs_graph)}")
if (ex.Jane, RDF.type, ex.Person) in rdfs_graph:
    print("Inferred: Jane is a Person.")