rustdl 0.3.0__tar.gz → 0.3.2__tar.gz

{rustdl-0.3.0 → rustdl-0.3.2}/Cargo.lock

@@ -1037,7 +1037,7 @@ checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"
 
 [[package]]
 name = "owl-dl-bench"
-version = "0.3.0"
+version = "0.3.2"
 dependencies = [
  "anyhow",
  "clap",
@@ -1054,7 +1054,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-cli"
-version = "0.3.0"
+version = "0.3.2"
 dependencies = [
  "anyhow",
  "clap",
@@ -1066,7 +1066,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-core"
-version = "0.3.0"
+version = "0.3.2"
 dependencies = [
  "bitvec",
  "bumpalo",
@@ -1080,7 +1080,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-datatypes"
-version = "0.3.0"
+version = "0.3.2"
 dependencies = [
  "owl-dl-core",
  "proptest",
@@ -1090,7 +1090,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-py"
-version = "0.3.0"
+version = "0.3.2"
 dependencies = [
  "horned-owl",
  "owl-dl-core",
@@ -1101,7 +1101,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-reasoner"
-version = "0.3.0"
+version = "0.3.2"
 dependencies = [
  "dashmap",
  "horned-owl",
@@ -1117,7 +1117,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-saturation"
-version = "0.3.0"
+version = "0.3.2"
 dependencies = [
  "dashmap",
  "fixedbitset",
@@ -1133,7 +1133,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-tableau"
-version = "0.3.0"
+version = "0.3.2"
 dependencies = [
  "bitvec",
  "bumpalo",
@@ -2569,7 +2569,7 @@ dependencies = [
 
 [[package]]
 name = "xtask"
-version = "0.3.0"
+version = "0.3.2"
 dependencies = [
  "anyhow",
  "clap",

{rustdl-0.3.0 → rustdl-0.3.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.3.0"
+version = "0.3.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.3.0" }
-owl-dl-saturation = { path = "crates/owl-dl-saturation", version = "0.3.0" }
-owl-dl-tableau = { path = "crates/owl-dl-tableau", version = "0.3.0" }
-owl-dl-datatypes = { path = "crates/owl-dl-datatypes", version = "0.3.0" }
-owl-dl-reasoner = { path = "crates/owl-dl-reasoner", version = "0.3.0" }
+owl-dl-core = { path = "crates/owl-dl-core", version = "0.3.2" }
+owl-dl-saturation = { path = "crates/owl-dl-saturation", version = "0.3.2" }
+owl-dl-tableau = { path = "crates/owl-dl-tableau", version = "0.3.2" }
+owl-dl-datatypes = { path = "crates/owl-dl-datatypes", version = "0.3.2" }
+owl-dl-reasoner = { path = "crates/owl-dl-reasoner", version = "0.3.2" }
 
 horned-owl = { version = "1.4", default-features = false }
 
@@ -60,6 +60,12 @@ missing_errors_doc = "allow"
 missing_panics_doc = "allow"
 must_use_candidate = "allow"
 unnecessary_wraps = "allow"
+# Style-only pedantic lints allowed workspace-wide: refactoring long
+# functions / hoisting nested items / renaming similar bindings is churn
+# without correctness value (and risky on the larger engine functions).
+too_many_lines = "allow"
+items_after_statements = "allow"
+similar_names = "allow"
 unwrap_used = "warn"
 dbg_macro = "warn"
 print_stdout = "allow"

{rustdl-0.3.0 → rustdl-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rustdl
-Version: 0.3.0
+Version: 0.3.2
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: Apache Software License
@@ -48,18 +48,58 @@ Wheels are published for CPython 3.10+ on Linux (x86_64, aarch64), macOS
 ```python
 import rustdl
 
-# Classify an ontology. Format auto-detected from the extension:
+# A small OWL 2 DL ontology ships inside the wheel (gzip-compressed) — no
+# download needed. `examples.pizza()` returns its file path (decompressed
+# into a per-user cache dir on first use); `examples.PIZZA_NS` is its
+# namespace, so class IRIs are PIZZA_NS + local name (e.g. + "Pizza").
+from rustdl.examples import pizza, PIZZA_NS, SULO_NS
+
+# Classify. Format is auto-detected from the extension:
 # .ofn (OWL Functional), .owx (OWL/XML), .rdf / .owl (RDF/XML).
-result = rustdl.classify("pizza.ofn")
+result = rustdl.classify(pizza())
 
-print(f"{len(result.classes)} classes, {len(result.unsatisfiable)} unsatisfiable")
+print(f"{len(result.classes)} classes, {len(result.unsatisfiable)} unsatisfiable, "
+      f"complete={result.complete}")
+# -> 88 classes, 0 unsatisfiable, complete=True
 
 # 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)
+print(result.is_subclass(PIZZA_NS + "BoxedPizza", PIZZA_NS + "Pizza"))
+# -> True
+print(len(result.subclasses_of(PIZZA_NS + "FoodMaterial")))
+# -> 25
+
+# The pizza ontology is aligned to the SULO upper ontology, so reasoning
+# spans both — e.g. a pizza-making timestamp is inferred to be a SULO StartTime:
+print(result.is_subclass(PIZZA_NS + "BakingStartTime", SULO_NS + "StartTime"))
+# -> True
+
+# Other hierarchy queries (all take full class IRIs):
+result.superclasses_of(PIZZA_NS + "Cheese")        # -> list[str]
+result.equivalent_classes(PIZZA_NS + "Pizza")      # -> list[str]
+result.direct_subsumers(PIZZA_NS + "BoxedPizza")   # -> list[str] (Hasse-direct parents)
+```
+
+### Bundled examples
+
+Three real ontologies ship inside the wheel, gzip-compressed (~200 KB total).
+They classify with **no network access** — each `examples.X()` decompresses
+its ontology into a per-user cache dir (`$XDG_CACHE_HOME/rustdl/examples` or
+`~/.cache/rustdl/examples`) on first use, then reuses it. Each `examples.X_NS`
+is the namespace, so a class IRI is the namespace plus the local name.
+
+| helper | ontology | classes | notes |
+|---|---|---|---|
+| `pizza()` / `PIZZA_NS` | ontostart pizza | 88 | SULO-aligned pizza-making ontology; classifies instantly + complete |
+| `sulo()` / `SULO_NS` | SULO (Simple Upper-Level Ontology) | 17 | tiny; classifies in milliseconds |
+| `sio()` / `SIO_NS` | SIO (Semanticscience Integrated Ontology) | ~1600 | realistic larger workload; takes tens of seconds. Class IRIs are numeric codes, e.g. `SIO_NS + "SIO_000006"` ("process") |
+
+```python
+import rustdl
+from rustdl import examples
+
+r = rustdl.classify(examples.sulo())
+print(r.is_subclass(examples.SULO_NS + "StartTime", examples.SULO_NS + "Object"))
+# -> True
 ```
 
 ## API

{rustdl-0.3.0/crates/owl-dl-py → rustdl-0.3.2}/README.md

@@ -23,18 +23,58 @@ Wheels are published for CPython 3.10+ on Linux (x86_64, aarch64), macOS
 ```python
 import rustdl
 
-# Classify an ontology. Format auto-detected from the extension:
+# A small OWL 2 DL ontology ships inside the wheel (gzip-compressed) — no
+# download needed. `examples.pizza()` returns its file path (decompressed
+# into a per-user cache dir on first use); `examples.PIZZA_NS` is its
+# namespace, so class IRIs are PIZZA_NS + local name (e.g. + "Pizza").
+from rustdl.examples import pizza, PIZZA_NS, SULO_NS
+
+# Classify. Format is auto-detected from the extension:
 # .ofn (OWL Functional), .owx (OWL/XML), .rdf / .owl (RDF/XML).
-result = rustdl.classify("pizza.ofn")
+result = rustdl.classify(pizza())
 
-print(f"{len(result.classes)} classes, {len(result.unsatisfiable)} unsatisfiable")
+print(f"{len(result.classes)} classes, {len(result.unsatisfiable)} unsatisfiable, "
+      f"complete={result.complete}")
+# -> 88 classes, 0 unsatisfiable, complete=True
 
 # 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)
+print(result.is_subclass(PIZZA_NS + "BoxedPizza", PIZZA_NS + "Pizza"))
+# -> True
+print(len(result.subclasses_of(PIZZA_NS + "FoodMaterial")))
+# -> 25
+
+# The pizza ontology is aligned to the SULO upper ontology, so reasoning
+# spans both — e.g. a pizza-making timestamp is inferred to be a SULO StartTime:
+print(result.is_subclass(PIZZA_NS + "BakingStartTime", SULO_NS + "StartTime"))
+# -> True
+
+# Other hierarchy queries (all take full class IRIs):
+result.superclasses_of(PIZZA_NS + "Cheese")        # -> list[str]
+result.equivalent_classes(PIZZA_NS + "Pizza")      # -> list[str]
+result.direct_subsumers(PIZZA_NS + "BoxedPizza")   # -> list[str] (Hasse-direct parents)
+```
+
+### Bundled examples
+
+Three real ontologies ship inside the wheel, gzip-compressed (~200 KB total).
+They classify with **no network access** — each `examples.X()` decompresses
+its ontology into a per-user cache dir (`$XDG_CACHE_HOME/rustdl/examples` or
+`~/.cache/rustdl/examples`) on first use, then reuses it. Each `examples.X_NS`
+is the namespace, so a class IRI is the namespace plus the local name.
+
+| helper | ontology | classes | notes |
+|---|---|---|---|
+| `pizza()` / `PIZZA_NS` | ontostart pizza | 88 | SULO-aligned pizza-making ontology; classifies instantly + complete |
+| `sulo()` / `SULO_NS` | SULO (Simple Upper-Level Ontology) | 17 | tiny; classifies in milliseconds |
+| `sio()` / `SIO_NS` | SIO (Semanticscience Integrated Ontology) | ~1600 | realistic larger workload; takes tens of seconds. Class IRIs are numeric codes, e.g. `SIO_NS + "SIO_000006"` ("process") |
+
+```python
+import rustdl
+from rustdl import examples
+
+r = rustdl.classify(examples.sulo())
+print(r.is_subclass(examples.SULO_NS + "StartTime", examples.SULO_NS + "Object"))
+# -> True
 ```
 
 ## API

{rustdl-0.3.0 → rustdl-0.3.2}/crates/owl-dl-core/src/convert.rs

@@ -522,12 +522,9 @@ pub fn convert_ontology<A: ForIRI>(
     // out.axioms.extend (which doesn't need it but reads cleaner).
     let derived = {
         let concepts_cell = std::cell::RefCell::new(&mut out.concepts);
-        crate::data_axioms::derive_data_axioms(
-            src,
-            &out.vocabulary,
-            bot_id,
-            |cid| concepts_cell.borrow_mut().atomic(cid),
-        )
+        crate::data_axioms::derive_data_axioms(src, &out.vocabulary, bot_id, |cid| {
+            concepts_cell.borrow_mut().atomic(cid)
+        })
     };
     out.axioms.extend(derived);
     out.axioms.sort();
@@ -1069,7 +1066,7 @@ mod tests {
         );
     }
 
-    /// Phase D1: a SubClassOf where the SUP contains a data-range
+    /// Phase D1: a `SubClassOf` where the SUP contains a data-range
     /// constructor (e.g., `DataMaxCardinality`) is silently dropped —
     /// the `ce_or_skip!` macro maps `UnsupportedDataRange` to `Ok(None)`
     /// for the enclosing axiom. Sound under-approximation: we lose the

{rustdl-0.3.0 → rustdl-0.3.2}/crates/owl-dl-core/src/data_axioms.rs

@@ -91,7 +91,10 @@ pub fn derive_data_axioms<A: ForIRI>(
 /// (or its decomposition into mutual SubClassOf), if any atomic Mi
 /// has cardinality bounds on a data property dp, propagate those
 /// bounds to C. Iterates to fixpoint to handle transitive defs.
-#[allow(clippy::too_many_lines, reason = "single fixpoint with 4 facts to propagate; splitting hurts readability")]
+#[allow(
+    clippy::too_many_lines,
+    reason = "single fixpoint with 4 facts to propagate; splitting hurts readability"
+)]
 fn propagate_intersection_bounds<A: ForIRI>(src: &SetOntology<A>, facts: &mut Facts) {
     // Collect: class_iri → vec of atomic-member iris from Intersection
     // equivalences. Includes EquivalentClasses(C, Intersection(...)) and
@@ -110,8 +113,7 @@ fn propagate_intersection_bounds<A: ForIRI>(src: &SetOntology<A>, facts: &mut Fa
                     }
                 });
                 for parts in intersection_members {
-                    let part_iris: Vec<String> =
-                        parts.iter().filter_map(class_iri).collect();
+                    let part_iris: Vec<String> = parts.iter().filter_map(class_iri).collect();
                     for owner in &atomic_members {
                         for part in &part_iris {
                             if owner != part {
@@ -230,7 +232,10 @@ struct IntegerRange {
 
 impl IntegerRange {
     const fn unbounded() -> Self {
-        Self { min: None, max: None }
+        Self {
+            min: None,
+            max: None,
+        }
     }
     fn intersect(self, other: Self) -> Self {
         let min = match (self.min, other.min) {
@@ -334,11 +339,7 @@ fn scan_component<A: ForIRI>(c: &Component<A>, f: &mut Facts) {
             // purposes. Bound-collection: if a is atomic class C and b
             // is an ObjectIntersectionOf with data-cardinality conjuncts,
             // those conjuncts' bounds apply to C.
-            let atomic: Vec<String> = ax
-                .0
-                .iter()
-                .filter_map(class_iri)
-                .collect();
+            let atomic: Vec<String> = ax.0.iter().filter_map(class_iri).collect();
             for c in &atomic {
                 for other in &ax.0 {
                     scan_class_for_bounds(c, other, f);
@@ -405,11 +406,7 @@ fn scan_class_for_bounds<A: ForIRI>(class_iri: &str, ce: &ClassExpression<A>, f:
 /// `ObjectIntersectionOf`. Phase D5 (Tier C): also records integer
 /// ranges from `DataSomeValuesFrom(dp, DatatypeRestriction(xsd:integer, ...))`
 /// into `f.class_int_ranges`.
-fn scan_class_for_existentials<A: ForIRI>(
-    class_iri: &str,
-    ce: &ClassExpression<A>,
-    f: &mut Facts,
-) {
+fn scan_class_for_existentials<A: ForIRI>(class_iri: &str, ce: &ClassExpression<A>, f: &mut Facts) {
     match ce {
         ClassExpression::DataSomeValuesFrom { dp, dr } => {
             f.class_some.insert((class_iri.to_string(), dpe_iri(dp)));
@@ -467,14 +464,22 @@ fn parse_integer_facets<A: ForIRI>(facets: &[FacetRestriction<A>]) -> Option<Int
             Facet::MinExclusive => {
                 // xsd:integer-semantics: exclusive ≥ val + 1
                 let inclusive = val.checked_add(1)?;
-                range.min = Some(range.min.map_or(inclusive, |existing| existing.max(inclusive)));
+                range.min = Some(
+                    range
+                        .min
+                        .map_or(inclusive, |existing| existing.max(inclusive)),
+                );
             }
             Facet::MaxInclusive => {
                 range.max = Some(range.max.map_or(val, |existing| existing.min(val)));
             }
             Facet::MaxExclusive => {
                 let inclusive = val.checked_sub(1)?;
-                range.max = Some(range.max.map_or(inclusive, |existing| existing.min(inclusive)));
+                range.max = Some(
+                    range
+                        .max
+                        .map_or(inclusive, |existing| existing.min(inclusive)),
+                );
             }
             _ => return None,
         }
@@ -608,15 +613,18 @@ fn emit_subdataprop_transitivity(
     // C ⊑ DataSome(specific) + DataSome(general) ⊑ D ⇒ C ⊑ D.
     let closure = closure_sub_dp(&f.sub_data_property);
     for (class_iri, specific_dp) in &f.class_some {
-        let Some(supers) = closure.get(specific_dp) else { continue };
+        let Some(supers) = closure.get(specific_dp) else {
+            continue;
+        };
         for general_dp in supers {
-            let Some(super_classes) = f.some_super.get(general_dp) else { continue };
+            let Some(super_classes) = f.some_super.get(general_dp) else {
+                continue;
+            };
             for d_iri in super_classes {
                 if class_iri == d_iri {
                     continue;
                 }
-                if let (Some(c_id), Some(d_id)) =
-                    (vocab.class_id(class_iri), vocab.class_id(d_iri))
+                if let (Some(c_id), Some(d_id)) = (vocab.class_id(class_iri), vocab.class_id(d_iri))
                 {
                     out.push(Axiom::SubClassOf {
                         sub: atomic_id(c_id),
@@ -698,20 +706,22 @@ fn _unused_datarange<A: ForIRI>(_: &DataRange<A>) {}
 mod tests {
     use super::*;
     use crate::convert::convert_ontology;
-    use horned_owl::io::ofn::reader::read as read_ofn;
     use horned_owl::io::ParserConfiguration;
+    use horned_owl::io::ofn::reader::read as read_ofn;
     use horned_owl::model::RcStr;
     use horned_owl::ontology::set::SetOntology;
     use std::io::Cursor;
 
     fn parse_str(src: &str) -> SetOntology<RcStr> {
         let mut r = Cursor::new(src);
-        read_ofn(&mut r, ParserConfiguration::default()).unwrap().0
+        read_ofn(&mut r, ParserConfiguration::default())
+            .expect("test fixture parses")
+            .0
     }
 
     #[test]
     fn extracts_functional_dp_min_clash() {
-        let src = r#"Prefix(:=<http://t/>)
+        let src = r"Prefix(:=<http://t/>)
 Prefix(xsd:=<http://www.w3.org/2001/XMLSchema#>)
 Ontology(<http://t/x>
     Declaration(Class(:HasTwoAges))
@@ -719,19 +729,22 @@ Ontology(<http://t/x>
     FunctionalDataProperty(:age)
     SubClassOf(:HasTwoAges DataMinCardinality(2 :age))
 )
-"#;
+";
         let onto = parse_str(src);
         let facts = extract_facts(&onto);
         assert!(facts.functional_dps.contains("http://t/age"));
         assert_eq!(
-            facts.class_min.get(&("http://t/HasTwoAges".to_string(), "http://t/age".to_string())),
+            facts.class_min.get(&(
+                "http://t/HasTwoAges".to_string(),
+                "http://t/age".to_string()
+            )),
             Some(&2)
         );
     }
 
     #[test]
     fn derives_functional_dp_min_unsat_in_convert() {
-        let src = r#"Prefix(:=<http://t/>)
+        let src = r"Prefix(:=<http://t/>)
 Prefix(xsd:=<http://www.w3.org/2001/XMLSchema#>)
 Ontology(<http://t/x>
     Declaration(Class(:HasTwoAges))
@@ -739,15 +752,22 @@ Ontology(<http://t/x>
     FunctionalDataProperty(:age)
     SubClassOf(:HasTwoAges DataMinCardinality(2 :age))
 )
-"#;
+";
         let onto = parse_str(src);
-        let mut internal = convert_ontology(&onto).unwrap();
-        let has_two_ages = internal.vocabulary.class_id("http://t/HasTwoAges")
+        let mut internal = convert_ontology(&onto).expect("test ontology converts");
+        let has_two_ages = internal
+            .vocabulary
+            .class_id("http://t/HasTwoAges")
             .expect("HasTwoAges interned");
         let bot = internal.concepts.bot();
         let sub_concept = internal.concepts.atomic(has_two_ages);
-        let found_unsat = internal.axioms.iter().any(|ax| matches!(ax,
-            Axiom::SubClassOf { sub, sup } if *sub == sub_concept && *sup == bot));
-        assert!(found_unsat, "D4: HasTwoAges ⊑ Bot should be derived from Functional + DataMin");
+        let found_unsat = internal.axioms.iter().any(|ax| {
+            matches!(ax,
+            Axiom::SubClassOf { sub, sup } if *sub == sub_concept && *sup == bot)
+        });
+        assert!(
+            found_unsat,
+            "D4: HasTwoAges ⊑ Bot should be derived from Functional + DataMin"
+        );
     }
 }

{rustdl-0.3.0 → rustdl-0.3.2}/crates/owl-dl-core/src/ir.rs

@@ -599,7 +599,10 @@ mod tests {
             first, second,
             "bot_id() before Bot interning must be stable across pool growth"
         );
-        assert!(first.is_none(), "bot_id() returns None before Bot is interned");
+        assert!(
+            first.is_none(),
+            "bot_id() returns None before Bot is interned"
+        );
 
         // Intern Bot. Both subsequent calls must return the same Some(id).
         let _bot_id = pool.bot();

{rustdl-0.3.0 → rustdl-0.3.2/crates/owl-dl-py}/README.md

@@ -23,18 +23,58 @@ Wheels are published for CPython 3.10+ on Linux (x86_64, aarch64), macOS
 ```python
 import rustdl
 
-# Classify an ontology. Format auto-detected from the extension:
+# A small OWL 2 DL ontology ships inside the wheel (gzip-compressed) — no
+# download needed. `examples.pizza()` returns its file path (decompressed
+# into a per-user cache dir on first use); `examples.PIZZA_NS` is its
+# namespace, so class IRIs are PIZZA_NS + local name (e.g. + "Pizza").
+from rustdl.examples import pizza, PIZZA_NS, SULO_NS
+
+# Classify. Format is auto-detected from the extension:
 # .ofn (OWL Functional), .owx (OWL/XML), .rdf / .owl (RDF/XML).
-result = rustdl.classify("pizza.ofn")
+result = rustdl.classify(pizza())
 
-print(f"{len(result.classes)} classes, {len(result.unsatisfiable)} unsatisfiable")
+print(f"{len(result.classes)} classes, {len(result.unsatisfiable)} unsatisfiable, "
+      f"complete={result.complete}")
+# -> 88 classes, 0 unsatisfiable, complete=True
 
 # 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)
+print(result.is_subclass(PIZZA_NS + "BoxedPizza", PIZZA_NS + "Pizza"))
+# -> True
+print(len(result.subclasses_of(PIZZA_NS + "FoodMaterial")))
+# -> 25
+
+# The pizza ontology is aligned to the SULO upper ontology, so reasoning
+# spans both — e.g. a pizza-making timestamp is inferred to be a SULO StartTime:
+print(result.is_subclass(PIZZA_NS + "BakingStartTime", SULO_NS + "StartTime"))
+# -> True
+
+# Other hierarchy queries (all take full class IRIs):
+result.superclasses_of(PIZZA_NS + "Cheese")        # -> list[str]
+result.equivalent_classes(PIZZA_NS + "Pizza")      # -> list[str]
+result.direct_subsumers(PIZZA_NS + "BoxedPizza")   # -> list[str] (Hasse-direct parents)
+```
+
+### Bundled examples
+
+Three real ontologies ship inside the wheel, gzip-compressed (~200 KB total).
+They classify with **no network access** — each `examples.X()` decompresses
+its ontology into a per-user cache dir (`$XDG_CACHE_HOME/rustdl/examples` or
+`~/.cache/rustdl/examples`) on first use, then reuses it. Each `examples.X_NS`
+is the namespace, so a class IRI is the namespace plus the local name.
+
+| helper | ontology | classes | notes |
+|---|---|---|---|
+| `pizza()` / `PIZZA_NS` | ontostart pizza | 88 | SULO-aligned pizza-making ontology; classifies instantly + complete |
+| `sulo()` / `SULO_NS` | SULO (Simple Upper-Level Ontology) | 17 | tiny; classifies in milliseconds |
+| `sio()` / `SIO_NS` | SIO (Semanticscience Integrated Ontology) | ~1600 | realistic larger workload; takes tens of seconds. Class IRIs are numeric codes, e.g. `SIO_NS + "SIO_000006"` ("process") |
+
+```python
+import rustdl
+from rustdl import examples
+
+r = rustdl.classify(examples.sulo())
+print(r.is_subclass(examples.SULO_NS + "StartTime", examples.SULO_NS + "Object"))
+# -> True
 ```
 
 ## API

{rustdl-0.3.0 → rustdl-0.3.2}/crates/owl-dl-py/src/classify.rs

@@ -1,5 +1,5 @@
 //! `classify` / `classify_bytes` top-level functions + the
-//! `Classification` PyO3 class that wraps `owl_dl_reasoner::Classification`.
+//! `Classification` `PyO3` class that wraps `owl_dl_reasoner::Classification`.
 
 use owl_dl_reasoner::{Classification as RsClassification, classify as rs_classify};
 use pyo3::prelude::*;
@@ -32,7 +32,7 @@ impl PyClassification {
     }
 
     /// True iff the whole ontology was flagged inconsistent.
-    /// (Set by the Phase-A1 ABox consistency check.)
+    /// (Set by the Phase-A1 `ABox` consistency check.)
     #[getter]
     fn inconsistent(&self) -> bool {
         self.inner.stats().inconsistent

{rustdl-0.3.0 → rustdl-0.3.2}/crates/owl-dl-py/src/errors.rs

@@ -17,7 +17,12 @@ use pyo3::create_exception;
 use pyo3::exceptions::PyException;
 use pyo3::prelude::*;
 
-create_exception!(rustdl, RustdlError, PyException, "Base exception for all rustdl errors.");
+create_exception!(
+    rustdl,
+    RustdlError,
+    PyException,
+    "Base exception for all rustdl errors."
+);
 create_exception!(rustdl, ParseError, RustdlError, "OWL parser failure.");
 create_exception!(
     rustdl,
@@ -41,10 +46,7 @@ pub(crate) fn register(m: &Bound<'_, PyModule>) -> PyResult<()> {
         "UnsupportedAxiomError",
         m.py().get_type::<UnsupportedAxiomError>(),
     )?;
-    m.add(
-        "UnknownClassError",
-        m.py().get_type::<UnknownClassError>(),
-    )?;
+    m.add("UnknownClassError", m.py().get_type::<UnknownClassError>())?;
     Ok(())
 }
 

{rustdl-0.3.0 → rustdl-0.3.2}/crates/owl-dl-py/src/lib.rs

@@ -1,6 +1,6 @@
 //! Python bindings for the rustdl OWL DL reasoner.
 //!
-//! Built with PyO3 + maturin. Distributed on PyPI as `rustdl`;
+//! Built with `PyO3` + maturin. Distributed on `PyPI` as `rustdl`;
 //! imported in Python as `import rustdl`. See the spec at
 //! `docs/superpowers/specs/2026-06-04-python-bindings-design.md`.
 

{rustdl-0.3.0 → rustdl-0.3.2}/crates/owl-dl-py/src/materialize.rs

@@ -13,16 +13,12 @@ use crate::load;
 /// - Pairs involving `owl:Thing` or `owl:Nothing`
 /// - Pairs from unsatisfiable classes (which trivially subsume all)
 #[pyfunction]
-pub(crate) fn materialize_inferred_subclass_axioms(
-    path: &str,
-) -> PyResult<Vec<(String, String)>> {
+pub(crate) fn materialize_inferred_subclass_axioms(path: &str) -> PyResult<Vec<(String, String)>> {
     let ontology = load::load_path(path)?;
     let classification = owl_dl_reasoner::classify(&ontology).map_err(reason_error_to_py)?;
     let classes = classification.classes();
-    let unsat: std::collections::HashSet<&str> = classification
-        .unsatisfiable_classes()
-        .into_iter()
-        .collect();
+    let unsat: std::collections::HashSet<&str> =
+        classification.unsatisfiable_classes().into_iter().collect();
     let mut out = Vec::new();
     for sub in classes {
         if unsat.contains(sub.as_str()) {
@@ -53,15 +49,13 @@ pub(crate) fn materialize_inferred_subclass_axioms(
 /// Returns every (class IRI, individual IRI) pair `(c, i)` such that
 /// `ClassAssertion(c, i)` is entailed.
 #[pyfunction]
-pub(crate) fn materialize_inferred_class_assertions(
-    path: &str,
-) -> PyResult<Vec<(String, String)>> {
+pub(crate) fn materialize_inferred_class_assertions(path: &str) -> PyResult<Vec<(String, String)>> {
     let ontology = load::load_path(path)?;
     let realization = owl_dl_reasoner::realize(&ontology).map_err(reason_error_to_py)?;
     let mut out = Vec::new();
     for ind in realization.individuals() {
         for c in realization.most_specific_types(ind) {
-            out.push((c.to_string(), ind.to_string()));
+            out.push((c.clone(), ind.clone()));
         }
     }
     Ok(out)