rustdl 0.2.2__tar.gz → 0.3.1__tar.gz

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

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

{rustdl-0.2.2 → rustdl-0.3.1}/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.2"
+version = "0.3.1"
 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.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" }
+owl-dl-core = { path = "crates/owl-dl-core", version = "0.3.1" }
+owl-dl-saturation = { path = "crates/owl-dl-saturation", version = "0.3.1" }
+owl-dl-tableau = { path = "crates/owl-dl-tableau", version = "0.3.1" }
+owl-dl-datatypes = { path = "crates/owl-dl-datatypes", version = "0.3.1" }
+owl-dl-reasoner = { path = "crates/owl-dl-reasoner", version = "0.3.1" }
 
 horned-owl = { version = "1.4", default-features = false }
 

{rustdl-0.2.2 → rustdl-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rustdl
-Version: 0.2.2
+Version: 0.3.1
 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
@@ -67,15 +107,20 @@ result.direct_subsumers("http://ex.org/Margherita") # -> list[str] (Hasse-direct
 ### 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)
+result = rustdl.classify(path, *, per_pair_timeout_ms=1000, saturation_only=False)
+result = rustdl.classify_bytes(data, format="ofn", *, per_pair_timeout_ms=1000, 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).
+- `per_pair_timeout_ms` — bound each subsumption test (**default 1000**;
+  `0` = unbounded). A pair that exceeds the budget is recorded as "not
+  subsumed": **sound** (never a false subsumption) but the result may be
+  **incomplete**. When that happens, an `IncompleteClassificationWarning`
+  is emitted and `result.complete` is `False`. Pass `0` for the complete,
+  unbounded classification. The default bounds pathological SROIQ inputs
+  so classification can't hang silently.
 - `saturation_only` — skip the tableau entirely; EL-closure-only
-  under-approximation. Dramatically faster on mostly-EL ontologies.
+  under-approximation. Dramatically faster on mostly-EL ontologies, and
+  always `complete` (no tableau ⇒ no timeout).
 
 `classify` / `classify_bytes` return a `Classification`:
 
@@ -84,6 +129,8 @@ result = rustdl.classify_bytes(data, format="ofn", *, per_pair_timeout_ms=None,
 | `.classes` | `list[str]` | all declared class IRIs |
 | `.unsatisfiable` | `list[str]` | classes proved `⊑ ⊥` |
 | `.inconsistent` | `bool` | whole ontology unsatisfiable |
+| `.complete` | `bool` | `False` if any pair hit the timeout (result may miss edges) |
+| `.timed_out_pairs` | `int` | how many pairs hit the timeout |
 | `.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` |

{rustdl-0.2.2/crates/owl-dl-py → rustdl-0.3.1}/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
@@ -42,15 +82,20 @@ result.direct_subsumers("http://ex.org/Margherita") # -> list[str] (Hasse-direct
 ### 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)
+result = rustdl.classify(path, *, per_pair_timeout_ms=1000, saturation_only=False)
+result = rustdl.classify_bytes(data, format="ofn", *, per_pair_timeout_ms=1000, 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).
+- `per_pair_timeout_ms` — bound each subsumption test (**default 1000**;
+  `0` = unbounded). A pair that exceeds the budget is recorded as "not
+  subsumed": **sound** (never a false subsumption) but the result may be
+  **incomplete**. When that happens, an `IncompleteClassificationWarning`
+  is emitted and `result.complete` is `False`. Pass `0` for the complete,
+  unbounded classification. The default bounds pathological SROIQ inputs
+  so classification can't hang silently.
 - `saturation_only` — skip the tableau entirely; EL-closure-only
-  under-approximation. Dramatically faster on mostly-EL ontologies.
+  under-approximation. Dramatically faster on mostly-EL ontologies, and
+  always `complete` (no tableau ⇒ no timeout).
 
 `classify` / `classify_bytes` return a `Classification`:
 
@@ -59,6 +104,8 @@ result = rustdl.classify_bytes(data, format="ofn", *, per_pair_timeout_ms=None,
 | `.classes` | `list[str]` | all declared class IRIs |
 | `.unsatisfiable` | `list[str]` | classes proved `⊑ ⊥` |
 | `.inconsistent` | `bool` | whole ontology unsatisfiable |
+| `.complete` | `bool` | `False` if any pair hit the timeout (result may miss edges) |
+| `.timed_out_pairs` | `int` | how many pairs hit the timeout |
 | `.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` |

{rustdl-0.2.2 → rustdl-0.3.1/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
@@ -42,15 +82,20 @@ result.direct_subsumers("http://ex.org/Margherita") # -> list[str] (Hasse-direct
 ### 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)
+result = rustdl.classify(path, *, per_pair_timeout_ms=1000, saturation_only=False)
+result = rustdl.classify_bytes(data, format="ofn", *, per_pair_timeout_ms=1000, 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).
+- `per_pair_timeout_ms` — bound each subsumption test (**default 1000**;
+  `0` = unbounded). A pair that exceeds the budget is recorded as "not
+  subsumed": **sound** (never a false subsumption) but the result may be
+  **incomplete**. When that happens, an `IncompleteClassificationWarning`
+  is emitted and `result.complete` is `False`. Pass `0` for the complete,
+  unbounded classification. The default bounds pathological SROIQ inputs
+  so classification can't hang silently.
 - `saturation_only` — skip the tableau entirely; EL-closure-only
-  under-approximation. Dramatically faster on mostly-EL ontologies.
+  under-approximation. Dramatically faster on mostly-EL ontologies, and
+  always `complete` (no tableau ⇒ no timeout).
 
 `classify` / `classify_bytes` return a `Classification`:
 
@@ -59,6 +104,8 @@ result = rustdl.classify_bytes(data, format="ofn", *, per_pair_timeout_ms=None,
 | `.classes` | `list[str]` | all declared class IRIs |
 | `.unsatisfiable` | `list[str]` | classes proved `⊑ ⊥` |
 | `.inconsistent` | `bool` | whole ontology unsatisfiable |
+| `.complete` | `bool` | `False` if any pair hit the timeout (result may miss edges) |
+| `.timed_out_pairs` | `int` | how many pairs hit the timeout |
 | `.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` |

{rustdl-0.2.2 → rustdl-0.3.1}/crates/owl-dl-py/src/classify.rs

@@ -38,6 +38,25 @@ impl PyClassification {
         self.inner.stats().inconsistent
     }
 
+    /// Number of class pairs that exceeded the per-pair timeout and
+    /// were recorded as "not subsumed". `> 0` means the classification
+    /// is a sound under-approximation — no false subsumptions, but real
+    /// ones may be missing. `0` when classification ran to completion
+    /// (or no timeout was set).
+    #[getter]
+    fn timed_out_pairs(&self) -> usize {
+        self.inner.stats().timed_out_pairs
+    }
+
+    /// True iff classification ran to completion — no pair hit the
+    /// timeout. When `False`, the hierarchy may be missing real
+    /// subsumptions (see `timed_out_pairs`); re-classify with
+    /// `per_pair_timeout_ms=0` for the complete (unbounded) result.
+    #[getter]
+    fn complete(&self) -> bool {
+        self.inner.stats().timed_out_pairs == 0
+    }
+
     /// True iff `sub ⊑ sup` is entailed.
     fn is_subclass(&self, sub: &str, sup: &str) -> bool {
         self.inner.is_subclass(sub, sup)
@@ -74,7 +93,7 @@ impl PyClassification {
 /// `rustdl.classify(path)` — classify the ontology at `path`.
 /// Format auto-detected from the file extension.
 #[pyfunction]
-#[pyo3(signature = (path, *, per_pair_timeout_ms=None, saturation_only=false))]
+#[pyo3(signature = (path, *, per_pair_timeout_ms=1000, saturation_only=false))]
 pub(crate) fn classify(
     path: &str,
     per_pair_timeout_ms: Option<u64>,
@@ -86,7 +105,7 @@ pub(crate) fn classify(
 
 /// `rustdl.classify_bytes(data, format="ofn")` — same but from bytes.
 #[pyfunction]
-#[pyo3(signature = (data, *, format, per_pair_timeout_ms=None, saturation_only=false))]
+#[pyo3(signature = (data, *, format, per_pair_timeout_ms=1000, saturation_only=false))]
 pub(crate) fn classify_bytes(
     data: &[u8],
     format: &str,
@@ -103,9 +122,12 @@ fn do_classify(
     saturation_only: bool,
 ) -> PyResult<PyClassification> {
     use std::time::Duration;
+    // `None` or `0` → unbounded (complete); any positive value bounds
+    // each pair (sound under-approximation; check `.complete` after).
+    let bounded = per_pair_timeout_ms.filter(|&ms| ms > 0);
     let inner = if saturation_only {
         owl_dl_reasoner::classify_saturation_only(ontology).map_err(reason_error_to_py)?
-    } else if let Some(ms) = per_pair_timeout_ms {
+    } else if let Some(ms) = bounded {
         owl_dl_reasoner::classify_top_down_with_timeout(ontology, Duration::from_millis(ms))
             .map_err(reason_error_to_py)?
     } else {

{rustdl-0.2.2 → rustdl-0.3.1}/crates/owl-dl-py/tests/python/test_classify.py

@@ -46,3 +46,33 @@ def test_superclasses_of(fixtures_dir):
     result = rustdl.classify(str(fixture))
     sups = result.superclasses_of("http://t/Adult")
     assert "http://t/Person" in sups
+
+
+def test_completeness_signal_and_warning(fixtures_dir):
+    import warnings
+    fixture = fixtures_dir / "datatype" / "datatype_definition.ofn"
+
+    # Default budget on a tiny EL-ish ontology: completes, no warning.
+    with warnings.catch_warnings(record=True) as rec:
+        warnings.simplefilter("always")
+        r = rustdl.classify(str(fixture))
+    assert r.complete is True
+    assert r.timed_out_pairs == 0
+    assert not any(
+        issubclass(w.category, rustdl.IncompleteClassificationWarning) for w in rec
+    )
+
+
+def test_saturation_only_is_complete(fixtures_dir):
+    fixture = fixtures_dir / "datatype" / "datatype_definition.ofn"
+    r = rustdl.classify(str(fixture), saturation_only=True)
+    # saturation-only never invokes the tableau, so no pair can time out
+    assert r.complete is True
+    assert r.timed_out_pairs == 0
+
+
+def test_unbounded_timeout_accepted(fixtures_dir):
+    fixture = fixtures_dir / "datatype" / "datatype_definition.ofn"
+    # per_pair_timeout_ms=0 means unbounded — must classify, complete.
+    r = rustdl.classify(str(fixture), per_pair_timeout_ms=0)
+    assert r.complete is True

rustdl-0.3.1/crates/owl-dl-py/tests/python/test_examples.py

@@ -0,0 +1,34 @@
+"""Bundled example ontologies — must work fully offline (shipped in the wheel)."""
+import os
+import rustdl
+from rustdl import examples
+
+
+def test_all_three_examples_materialize():
+    for fn in (examples.pizza, examples.sulo, examples.sio):
+        path = fn()
+        assert os.path.exists(path)
+        assert os.path.getsize(path) > 0
+
+
+def test_pizza_classifies_complete():
+    # ontostart pizza: 88 classes, no unsat, classifies instantly + complete.
+    r = rustdl.classify(examples.pizza())
+    assert len(r.classes) == 88
+    assert len(r.unsatisfiable) == 0
+    assert r.complete is True
+    ns = examples.PIZZA_NS
+    assert r.is_subclass(ns + "BoxedPizza", ns + "Pizza")
+    # cross-ontology: aligned to SULO upper ontology
+    assert r.is_subclass(ns + "BakingStartTime", examples.SULO_NS + "StartTime")
+
+
+def test_sulo_classifies():
+    r = rustdl.classify(examples.sulo())
+    assert len(r.classes) == 17
+    assert r.complete is True
+
+
+def test_namespace_constants_are_strings():
+    for ns in (examples.PIZZA_NS, examples.SULO_NS, examples.SIO_NS):
+        assert isinstance(ns, str) and ns

{rustdl-0.2.2 → rustdl-0.3.1}/pyproject.toml

@@ -35,5 +35,6 @@ Changelog = "https://github.com/MaastrichtU-IDS/rustdl/blob/main/CHANGELOG.md"
 module-name = "rustdl._native"
 features = ["pyo3/extension-module"]
 strip = true
+include = ["python/rustdl/data/*.owl.gz"]
 manifest-path = "crates/owl-dl-py/Cargo.toml"
 python-source = "python"