rustdl 0.2.0__tar.gz → 0.2.2__tar.gz

{rustdl-0.2.0 → rustdl-0.2.2}/Cargo.lock

@@ -1037,7 +1037,7 @@ checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"
 
 [[package]]
 name = "owl-dl-bench"
-version = "0.2.0"
+version = "0.2.2"
 dependencies = [
  "anyhow",
  "clap",
@@ -1054,7 +1054,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-cli"
-version = "0.2.0"
+version = "0.2.2"
 dependencies = [
  "anyhow",
  "clap",
@@ -1066,7 +1066,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-core"
-version = "0.2.0"
+version = "0.2.2"
 dependencies = [
  "bitvec",
  "bumpalo",
@@ -1080,7 +1080,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-datatypes"
-version = "0.2.0"
+version = "0.2.2"
 dependencies = [
  "owl-dl-core",
  "proptest",
@@ -1090,7 +1090,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-py"
-version = "0.2.0"
+version = "0.2.2"
 dependencies = [
  "horned-owl",
  "owl-dl-core",
@@ -1101,7 +1101,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-reasoner"
-version = "0.2.0"
+version = "0.2.2"
 dependencies = [
  "dashmap",
  "horned-owl",
@@ -1117,7 +1117,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-saturation"
-version = "0.2.0"
+version = "0.2.2"
 dependencies = [
  "dashmap",
  "fixedbitset",
@@ -1133,7 +1133,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-tableau"
-version = "0.2.0"
+version = "0.2.2"
 dependencies = [
  "bitvec",
  "bumpalo",
@@ -1392,11 +1392,10 @@ dependencies = [
 
 [[package]]
 name = "pyo3"
-version = "0.22.6"
+version = "0.25.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f402062616ab18202ae8319da13fa4279883a2b8a9d9f83f20dbade813ce1884"
+checksum = "8970a78afe0628a3e3430376fc5fd76b6b45c4d43360ffd6cdd40bdde72b682a"
 dependencies = [
- "cfg-if",
  "indoc",
  "libc",
  "memoffset",
@@ -1410,9 +1409,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.22.6"
+version = "0.25.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b14b5775b5ff446dd1056212d778012cbe8a0fbffd368029fd9e25b514479c38"
+checksum = "458eb0c55e7ece017adeba38f2248ff3ac615e53660d7c71a238d7d2a01c7598"
 dependencies = [
  "once_cell",
  "target-lexicon",
@@ -1420,9 +1419,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.22.6"
+version = "0.25.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ab5bcf04a2cdcbb50c7d6105de943f543f9ed92af55818fd17b660390fc8636"
+checksum = "7114fe5457c61b276ab77c5055f206295b812608083644a5c5b2640c3102565c"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -1430,9 +1429,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.22.6"
+version = "0.25.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fd24d897903a9e6d80b968368a34e1525aeb719d568dba8b3d4bfa5dc67d453"
+checksum = "a8725c0a622b374d6cb051d11a0983786448f7785336139c3c94f5aa6bef7e50"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -1442,9 +1441,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.22.6"
+version = "0.25.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "36c011a03ba1e50152b4b394b479826cad97e7a21eb52df179cd91ac411cbfbe"
+checksum = "4109984c22491085343c05b0dbc54ddc405c3cf7b4374fc533f5c3313a572ccc"
 dependencies = [
  "heck",
  "proc-macro2",
@@ -1935,9 +1934,9 @@ checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
 
 [[package]]
 name = "target-lexicon"
-version = "0.12.16"
+version = "0.13.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
+checksum = "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca"
 
 [[package]]
 name = "tempfile"
@@ -2570,7 +2569,7 @@ dependencies = [
 
 [[package]]
 name = "xtask"
-version = "0.2.0"
+version = "0.2.2"
 dependencies = [
  "anyhow",
  "clap",

{rustdl-0.2.0 → rustdl-0.2.2}/Cargo.toml

@@ -3,7 +3,7 @@ resolver = "2"
 members = ["crates/owl-dl-core", "crates/owl-dl-saturation", "crates/owl-dl-tableau", "crates/owl-dl-datatypes", "crates/owl-dl-reasoner", "crates/owl-dl-py"]
 
 [workspace.package]
-version = "0.2.0"
+version = "0.2.2"
 edition = "2024"
 rust-version = "1.88"
 license = "Apache-2.0 OR MIT"
@@ -15,11 +15,11 @@ keywords = ["owl", "ontology", "reasoner", "description-logic", "semantic-web"]
 categories = ["science", "data-structures"]
 
 [workspace.dependencies]
-owl-dl-core = { path = "crates/owl-dl-core", version = "0.2.0" }
-owl-dl-saturation = { path = "crates/owl-dl-saturation", version = "0.2.0" }
-owl-dl-tableau = { path = "crates/owl-dl-tableau", version = "0.2.0" }
-owl-dl-datatypes = { path = "crates/owl-dl-datatypes", version = "0.2.0" }
-owl-dl-reasoner = { path = "crates/owl-dl-reasoner", version = "0.2.0" }
+owl-dl-core = { path = "crates/owl-dl-core", version = "0.2.2" }
+owl-dl-saturation = { path = "crates/owl-dl-saturation", version = "0.2.2" }
+owl-dl-tableau = { path = "crates/owl-dl-tableau", version = "0.2.2" }
+owl-dl-datatypes = { path = "crates/owl-dl-datatypes", version = "0.2.2" }
+owl-dl-reasoner = { path = "crates/owl-dl-reasoner", version = "0.2.2" }
 
 horned-owl = { version = "1.4", default-features = false }
 

rustdl-0.2.2/PKG-INFO

@@ -0,0 +1,161 @@
+Metadata-Version: 2.4
+Name: rustdl
+Version: 0.2.2
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Rust
+Classifier: Topic :: Scientific/Engineering
+Summary: Sound, performant OWL 2 DL (SROIQ) reasoner in Rust — Python bindings
+Keywords: owl,ontology,reasoner,description-logic,semantic-web
+Author: rustdl contributors
+License: Apache-2.0 OR MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Changelog, https://github.com/MaastrichtU-IDS/rustdl/blob/main/CHANGELOG.md
+Project-URL: Documentation, https://github.com/MaastrichtU-IDS/rustdl/blob/main/README.md
+Project-URL: Homepage, https://github.com/MaastrichtU-IDS/rustdl
+Project-URL: Repository, https://github.com/MaastrichtU-IDS/rustdl
+
+# rustdl
+
+Sound, performant **OWL 2 DL (SROIQ) reasoner** in Rust, with Python bindings.
+No JVM, no subprocess — native classification via [PyO3](https://pyo3.rs).
+
+`rustdl` beats HermiT on every measured ORE workload and wins outright against
+Konclude on Horn-fragment ontologies. See the
+[project README](https://github.com/MaastrichtU-IDS/rustdl) for the full
+benchmark table.
+
+## Install
+
+```sh
+pip install rustdl
+```
+
+Wheels are published for CPython 3.10+ on Linux (x86_64, aarch64), macOS
+(Apple Silicon), and Windows (AMD64). Other platforms build from the sdist
+(needs a Rust toolchain).
+
+## Quick start
+
+```python
+import rustdl
+
+# Classify an ontology. Format auto-detected from the extension:
+# .ofn (OWL Functional), .owx (OWL/XML), .rdf / .owl (RDF/XML).
+result = rustdl.classify("pizza.ofn")
+
+print(f"{len(result.classes)} classes, {len(result.unsatisfiable)} unsatisfiable")
+
+# Query the computed hierarchy
+result.is_subclass("http://ex.org/Margherita", "http://ex.org/Pizza")  # -> bool
+result.subclasses_of("http://ex.org/Pizza")     # -> list[str]
+result.superclasses_of("http://ex.org/Margherita")  # -> list[str]
+result.equivalent_classes("http://ex.org/Pizza")    # -> list[str]
+result.direct_subsumers("http://ex.org/Margherita") # -> list[str] (Hasse-direct parents)
+```
+
+## API
+
+### Classification
+
+```python
+result = rustdl.classify(path, *, per_pair_timeout_ms=None, saturation_only=False)
+result = rustdl.classify_bytes(data, format="ofn", *, per_pair_timeout_ms=None, saturation_only=False)
+```
+
+- `per_pair_timeout_ms` — bound each subsumption test; pairs that exceed it
+  default to "not subsumed" (a sound under-approximation — robust against
+  pathological SROIQ inputs).
+- `saturation_only` — skip the tableau entirely; EL-closure-only
+  under-approximation. Dramatically faster on mostly-EL ontologies.
+
+`classify` / `classify_bytes` return a `Classification`:
+
+| member | type | meaning |
+|---|---|---|
+| `.classes` | `list[str]` | all declared class IRIs |
+| `.unsatisfiable` | `list[str]` | classes proved `⊑ ⊥` |
+| `.inconsistent` | `bool` | whole ontology unsatisfiable |
+| `.is_subclass(sub, sup)` | `bool` | is `sub ⊑ sup` entailed? |
+| `.subclasses_of(cls)` | `list[str]` | every `D` with `D ⊑ cls` |
+| `.superclasses_of(cls)` | `list[str]` | every `D` with `cls ⊑ D` |
+| `.equivalent_classes(cls)` | `list[str]` | classes equivalent to `cls` |
+| `.direct_subsumers(cls)` | `list[str]` | Hasse-direct parents of `cls` |
+
+### One-shot queries
+
+Each parses the file, answers one question, and returns:
+
+```python
+rustdl.is_consistent(path)                        # -> bool
+rustdl.is_class_satisfiable(path, class_iri)      # -> bool
+rustdl.is_subclass_of(path, sub_iri, sup_iri)     # -> bool
+rustdl.is_instance_of(path, class_iri, indiv_iri) # -> bool
+rustdl.instances_of(path, class_iri)              # -> list[str]
+rustdl.realize(path)                              # -> dict[str, list[str]]
+```
+
+`realize` returns each individual IRI mapped to its most-specific entailed
+class IRIs.
+
+> For repeated queries over the same ontology, prefer `classify(path)` once and
+> query the returned `Classification` — each top-level function re-parses.
+
+### Inference materialization
+
+```python
+rustdl.materialize_inferred_subclass_axioms(path)   # -> list[tuple[str, str]]
+rustdl.materialize_inferred_class_assertions(path)  # -> list[tuple[str, str]]
+```
+
+`materialize_inferred_subclass_axioms` yields `(sub, sup)` pairs for every
+entailed subsumption (excluding reflexive, `owl:Thing`/`owl:Nothing`, and
+unsatisfiable classes). `materialize_inferred_class_assertions` yields
+`(class, individual)` pairs. Useful for writing an inferred ontology back to
+disk.
+
+### Errors
+
+```python
+rustdl.RustdlError            # base — catches everything from the library
+rustdl.ParseError             # the OWL file couldn't be parsed
+rustdl.UnsupportedAxiomError  # HasKey, role chains > length 2, etc.
+rustdl.UnknownClassError      # an IRI argument isn't a declared class
+```
+
+```python
+try:
+    result = rustdl.classify("ontology.ofn")
+except rustdl.ParseError as e:
+    print(f"bad input: {e}")
+except rustdl.RustdlError as e:
+    print(f"reasoning failed: {e}")
+```
+
+## Soundness & coverage
+
+`rustdl` is **sound**: every reported subsumption is a genuine entailment
+(FP=0 against Konclude on the validation corpus). Completeness is partial — the
+default classifier is empirically near-complete across the measured corpus but
+not provably complete on all of SROIQ. `saturation_only` and
+`per_pair_timeout_ms` are sound-but-incomplete by construction.
+
+Data-property and datatype axioms outside the recognized preprocessing patterns
+are silently dropped (a sound under-approximation). `HasKey` and role chains
+longer than length 2 raise `UnsupportedAxiomError`. SWRL rules are skipped.
+
+See the [project documentation](https://github.com/MaastrichtU-IDS/rustdl) for
+the full coverage matrix, soundness contract, and architecture notes.
+
+## License
+
+Apache-2.0 OR MIT.
+

rustdl-0.2.2/README.md

@@ -0,0 +1,135 @@
+# rustdl
+
+Sound, performant **OWL 2 DL (SROIQ) reasoner** in Rust, with Python bindings.
+No JVM, no subprocess — native classification via [PyO3](https://pyo3.rs).
+
+`rustdl` beats HermiT on every measured ORE workload and wins outright against
+Konclude on Horn-fragment ontologies. See the
+[project README](https://github.com/MaastrichtU-IDS/rustdl) for the full
+benchmark table.
+
+## Install
+
+```sh
+pip install rustdl
+```
+
+Wheels are published for CPython 3.10+ on Linux (x86_64, aarch64), macOS
+(Apple Silicon), and Windows (AMD64). Other platforms build from the sdist
+(needs a Rust toolchain).
+
+## Quick start
+
+```python
+import rustdl
+
+# Classify an ontology. Format auto-detected from the extension:
+# .ofn (OWL Functional), .owx (OWL/XML), .rdf / .owl (RDF/XML).
+result = rustdl.classify("pizza.ofn")
+
+print(f"{len(result.classes)} classes, {len(result.unsatisfiable)} unsatisfiable")
+
+# Query the computed hierarchy
+result.is_subclass("http://ex.org/Margherita", "http://ex.org/Pizza")  # -> bool
+result.subclasses_of("http://ex.org/Pizza")     # -> list[str]
+result.superclasses_of("http://ex.org/Margherita")  # -> list[str]
+result.equivalent_classes("http://ex.org/Pizza")    # -> list[str]
+result.direct_subsumers("http://ex.org/Margherita") # -> list[str] (Hasse-direct parents)
+```
+
+## API
+
+### Classification
+
+```python
+result = rustdl.classify(path, *, per_pair_timeout_ms=None, saturation_only=False)
+result = rustdl.classify_bytes(data, format="ofn", *, per_pair_timeout_ms=None, saturation_only=False)
+```
+
+- `per_pair_timeout_ms` — bound each subsumption test; pairs that exceed it
+  default to "not subsumed" (a sound under-approximation — robust against
+  pathological SROIQ inputs).
+- `saturation_only` — skip the tableau entirely; EL-closure-only
+  under-approximation. Dramatically faster on mostly-EL ontologies.
+
+`classify` / `classify_bytes` return a `Classification`:
+
+| member | type | meaning |
+|---|---|---|
+| `.classes` | `list[str]` | all declared class IRIs |
+| `.unsatisfiable` | `list[str]` | classes proved `⊑ ⊥` |
+| `.inconsistent` | `bool` | whole ontology unsatisfiable |
+| `.is_subclass(sub, sup)` | `bool` | is `sub ⊑ sup` entailed? |
+| `.subclasses_of(cls)` | `list[str]` | every `D` with `D ⊑ cls` |
+| `.superclasses_of(cls)` | `list[str]` | every `D` with `cls ⊑ D` |
+| `.equivalent_classes(cls)` | `list[str]` | classes equivalent to `cls` |
+| `.direct_subsumers(cls)` | `list[str]` | Hasse-direct parents of `cls` |
+
+### One-shot queries
+
+Each parses the file, answers one question, and returns:
+
+```python
+rustdl.is_consistent(path)                        # -> bool
+rustdl.is_class_satisfiable(path, class_iri)      # -> bool
+rustdl.is_subclass_of(path, sub_iri, sup_iri)     # -> bool
+rustdl.is_instance_of(path, class_iri, indiv_iri) # -> bool
+rustdl.instances_of(path, class_iri)              # -> list[str]
+rustdl.realize(path)                              # -> dict[str, list[str]]
+```
+
+`realize` returns each individual IRI mapped to its most-specific entailed
+class IRIs.
+
+> For repeated queries over the same ontology, prefer `classify(path)` once and
+> query the returned `Classification` — each top-level function re-parses.
+
+### Inference materialization
+
+```python
+rustdl.materialize_inferred_subclass_axioms(path)   # -> list[tuple[str, str]]
+rustdl.materialize_inferred_class_assertions(path)  # -> list[tuple[str, str]]
+```
+
+`materialize_inferred_subclass_axioms` yields `(sub, sup)` pairs for every
+entailed subsumption (excluding reflexive, `owl:Thing`/`owl:Nothing`, and
+unsatisfiable classes). `materialize_inferred_class_assertions` yields
+`(class, individual)` pairs. Useful for writing an inferred ontology back to
+disk.
+
+### Errors
+
+```python
+rustdl.RustdlError            # base — catches everything from the library
+rustdl.ParseError             # the OWL file couldn't be parsed
+rustdl.UnsupportedAxiomError  # HasKey, role chains > length 2, etc.
+rustdl.UnknownClassError      # an IRI argument isn't a declared class
+```
+
+```python
+try:
+    result = rustdl.classify("ontology.ofn")
+except rustdl.ParseError as e:
+    print(f"bad input: {e}")
+except rustdl.RustdlError as e:
+    print(f"reasoning failed: {e}")
+```
+
+## Soundness & coverage
+
+`rustdl` is **sound**: every reported subsumption is a genuine entailment
+(FP=0 against Konclude on the validation corpus). Completeness is partial — the
+default classifier is empirically near-complete across the measured corpus but
+not provably complete on all of SROIQ. `saturation_only` and
+`per_pair_timeout_ms` are sound-but-incomplete by construction.
+
+Data-property and datatype axioms outside the recognized preprocessing patterns
+are silently dropped (a sound under-approximation). `HasKey` and role chains
+longer than length 2 raise `UnsupportedAxiomError`. SWRL rules are skipped.
+
+See the [project documentation](https://github.com/MaastrichtU-IDS/rustdl) for
+the full coverage matrix, soundness contract, and architecture notes.
+
+## License
+
+Apache-2.0 OR MIT.

{rustdl-0.2.0 → rustdl-0.2.2}/crates/owl-dl-py/Cargo.toml

@@ -17,7 +17,7 @@ name = "rustdl"           # Python import name: `import rustdl`
 crate-type = ["cdylib"]   # Python C extension
 
 [dependencies]
-pyo3 = { version = "0.22", features = ["abi3-py310", "extension-module"] }
+pyo3 = { version = "0.25", features = ["abi3-py310", "extension-module"] }
 owl-dl-reasoner.workspace = true
 owl-dl-core.workspace = true
 horned-owl.workspace = true

rustdl-0.2.2/crates/owl-dl-py/README.md

@@ -0,0 +1,135 @@
+# rustdl
+
+Sound, performant **OWL 2 DL (SROIQ) reasoner** in Rust, with Python bindings.
+No JVM, no subprocess — native classification via [PyO3](https://pyo3.rs).
+
+`rustdl` beats HermiT on every measured ORE workload and wins outright against
+Konclude on Horn-fragment ontologies. See the
+[project README](https://github.com/MaastrichtU-IDS/rustdl) for the full
+benchmark table.
+
+## Install
+
+```sh
+pip install rustdl
+```
+
+Wheels are published for CPython 3.10+ on Linux (x86_64, aarch64), macOS
+(Apple Silicon), and Windows (AMD64). Other platforms build from the sdist
+(needs a Rust toolchain).
+
+## Quick start
+
+```python
+import rustdl
+
+# Classify an ontology. Format auto-detected from the extension:
+# .ofn (OWL Functional), .owx (OWL/XML), .rdf / .owl (RDF/XML).
+result = rustdl.classify("pizza.ofn")
+
+print(f"{len(result.classes)} classes, {len(result.unsatisfiable)} unsatisfiable")
+
+# Query the computed hierarchy
+result.is_subclass("http://ex.org/Margherita", "http://ex.org/Pizza")  # -> bool
+result.subclasses_of("http://ex.org/Pizza")     # -> list[str]
+result.superclasses_of("http://ex.org/Margherita")  # -> list[str]
+result.equivalent_classes("http://ex.org/Pizza")    # -> list[str]
+result.direct_subsumers("http://ex.org/Margherita") # -> list[str] (Hasse-direct parents)
+```
+
+## API
+
+### Classification
+
+```python
+result = rustdl.classify(path, *, per_pair_timeout_ms=None, saturation_only=False)
+result = rustdl.classify_bytes(data, format="ofn", *, per_pair_timeout_ms=None, saturation_only=False)
+```
+
+- `per_pair_timeout_ms` — bound each subsumption test; pairs that exceed it
+  default to "not subsumed" (a sound under-approximation — robust against
+  pathological SROIQ inputs).
+- `saturation_only` — skip the tableau entirely; EL-closure-only
+  under-approximation. Dramatically faster on mostly-EL ontologies.
+
+`classify` / `classify_bytes` return a `Classification`:
+
+| member | type | meaning |
+|---|---|---|
+| `.classes` | `list[str]` | all declared class IRIs |
+| `.unsatisfiable` | `list[str]` | classes proved `⊑ ⊥` |
+| `.inconsistent` | `bool` | whole ontology unsatisfiable |
+| `.is_subclass(sub, sup)` | `bool` | is `sub ⊑ sup` entailed? |
+| `.subclasses_of(cls)` | `list[str]` | every `D` with `D ⊑ cls` |
+| `.superclasses_of(cls)` | `list[str]` | every `D` with `cls ⊑ D` |
+| `.equivalent_classes(cls)` | `list[str]` | classes equivalent to `cls` |
+| `.direct_subsumers(cls)` | `list[str]` | Hasse-direct parents of `cls` |
+
+### One-shot queries
+
+Each parses the file, answers one question, and returns:
+
+```python
+rustdl.is_consistent(path)                        # -> bool
+rustdl.is_class_satisfiable(path, class_iri)      # -> bool
+rustdl.is_subclass_of(path, sub_iri, sup_iri)     # -> bool
+rustdl.is_instance_of(path, class_iri, indiv_iri) # -> bool
+rustdl.instances_of(path, class_iri)              # -> list[str]
+rustdl.realize(path)                              # -> dict[str, list[str]]
+```
+
+`realize` returns each individual IRI mapped to its most-specific entailed
+class IRIs.
+
+> For repeated queries over the same ontology, prefer `classify(path)` once and
+> query the returned `Classification` — each top-level function re-parses.
+
+### Inference materialization
+
+```python
+rustdl.materialize_inferred_subclass_axioms(path)   # -> list[tuple[str, str]]
+rustdl.materialize_inferred_class_assertions(path)  # -> list[tuple[str, str]]
+```
+
+`materialize_inferred_subclass_axioms` yields `(sub, sup)` pairs for every
+entailed subsumption (excluding reflexive, `owl:Thing`/`owl:Nothing`, and
+unsatisfiable classes). `materialize_inferred_class_assertions` yields
+`(class, individual)` pairs. Useful for writing an inferred ontology back to
+disk.
+
+### Errors
+
+```python
+rustdl.RustdlError            # base — catches everything from the library
+rustdl.ParseError             # the OWL file couldn't be parsed
+rustdl.UnsupportedAxiomError  # HasKey, role chains > length 2, etc.
+rustdl.UnknownClassError      # an IRI argument isn't a declared class
+```
+
+```python
+try:
+    result = rustdl.classify("ontology.ofn")
+except rustdl.ParseError as e:
+    print(f"bad input: {e}")
+except rustdl.RustdlError as e:
+    print(f"reasoning failed: {e}")
+```
+
+## Soundness & coverage
+
+`rustdl` is **sound**: every reported subsumption is a genuine entailment
+(FP=0 against Konclude on the validation corpus). Completeness is partial — the
+default classifier is empirically near-complete across the measured corpus but
+not provably complete on all of SROIQ. `saturation_only` and
+`per_pair_timeout_ms` are sound-but-incomplete by construction.
+
+Data-property and datatype axioms outside the recognized preprocessing patterns
+are silently dropped (a sound under-approximation). `HasKey` and role chains
+longer than length 2 raise `UnsupportedAxiomError`. SWRL rules are skipped.
+
+See the [project documentation](https://github.com/MaastrichtU-IDS/rustdl) for
+the full coverage matrix, soundness contract, and architecture notes.
+
+## License
+
+Apache-2.0 OR MIT.

{rustdl-0.2.0 → rustdl-0.2.2}/crates/owl-dl-py/src/errors.rs

@@ -35,15 +35,15 @@ create_exception!(
 /// Register all rustdl exception types on the module so Python
 /// callers can `except rustdl.RustdlError:` etc.
 pub(crate) fn register(m: &Bound<'_, PyModule>) -> PyResult<()> {
-    m.add("RustdlError", m.py().get_type_bound::<RustdlError>())?;
-    m.add("ParseError", m.py().get_type_bound::<ParseError>())?;
+    m.add("RustdlError", m.py().get_type::<RustdlError>())?;
+    m.add("ParseError", m.py().get_type::<ParseError>())?;
     m.add(
         "UnsupportedAxiomError",
-        m.py().get_type_bound::<UnsupportedAxiomError>(),
+        m.py().get_type::<UnsupportedAxiomError>(),
     )?;
     m.add(
         "UnknownClassError",
-        m.py().get_type_bound::<UnknownClassError>(),
+        m.py().get_type::<UnknownClassError>(),
     )?;
     Ok(())
 }

{rustdl-0.2.0 → rustdl-0.2.2}/crates/owl-dl-reasoner/src/abox_check.rs

@@ -34,7 +34,14 @@ pub(crate) enum AboxVerdict {
 /// The specific clash the check detected. Surfaced in `RUSTDL_TRACE`
 /// output and intended for a future `consistent --explain` extension
 /// (not part of this project's scope).
+///
+/// The per-variant fields are read only through the derived `Debug`
+/// impl (the `RUSTDL_TRACE=1` `abox_check: inconsistent — {reason:?}`
+/// line). Rust's dead-code analysis doesn't count `Debug`-only reads,
+/// so the fields would warn without this allow. They're load-bearing
+/// for the trace output and the planned `--explain` surface — keep them.
 #[derive(Debug, Clone)]
+#[allow(dead_code, reason = "fields read via Debug in RUSTDL_TRACE output + future --explain")]
 pub(crate) enum ClashReason {
     /// P1: `ClassAssertion(C, a)` with `Subsumers::is_unsatisfiable(C)`.
     AssertedBot { individual: IndividualId, class: ClassId },