rustdl 0.2.2__tar.gz → 0.3.0__tar.gz

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

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

{rustdl-0.2.2 → rustdl-0.3.0}/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.0"
 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.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" }
 
 horned-owl = { version = "1.4", default-features = false }
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rustdl
-Version: 0.2.2
+Version: 0.3.0
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: Apache Software License
@@ -67,15 +67,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 +89,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.0}/README.md

@@ -42,15 +42,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 +64,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.0/crates/owl-dl-py}/README.md

@@ -42,15 +42,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 +64,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.0}/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.0}/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.0/python/rustdl/__init__.py

@@ -0,0 +1,129 @@
+"""
+rustdl — sound, performant OWL 2 DL (SROIQ) reasoner.
+
+Python bindings for the rustdl Rust crate. Install via
+`pip install rustdl`; import as `import rustdl`. See
+https://github.com/MaastrichtU-IDS/rustdl for the full project.
+"""
+
+import warnings as _warnings
+
+# Native extension built by PyO3 + maturin
+from rustdl._native import (
+    __version__ as __version__,
+    Classification as Classification,
+    classify as _classify_native,
+    classify_bytes as _classify_bytes_native,
+    is_consistent as is_consistent,
+    is_class_satisfiable as is_class_satisfiable,
+    is_subclass_of as is_subclass_of,
+    is_instance_of as is_instance_of,
+    instances_of as instances_of,
+    realize as realize,
+    RustdlError as RustdlError,
+    ParseError as ParseError,
+    UnsupportedAxiomError as UnsupportedAxiomError,
+    UnknownClassError as UnknownClassError,
+    materialize_inferred_subclass_axioms as materialize_inferred_subclass_axioms,
+    materialize_inferred_class_assertions as materialize_inferred_class_assertions,
+)
+
+
+def _subclasses_of(self: "Classification", cls: str) -> list[str]:
+    """All classes D in the ontology with D ⊑ cls (reflexive + proper).
+
+    Pure-Python helper. O(N) over Classification.classes per call.
+    """
+    return [d for d in self.classes if self.is_subclass(d, cls)]
+
+
+def _superclasses_of(self: "Classification", cls: str) -> list[str]:
+    """All classes D in the ontology with cls ⊑ D (reflexive + proper).
+
+    Pure-Python helper. O(N) over Classification.classes per call.
+    """
+    return [d for d in self.classes if self.is_subclass(cls, d)]
+
+
+# Bind onto the PyO3 class so the API is symmetric:
+# `result.subclasses_of(...)` lives next to `result.is_subclass(...)`.
+Classification.subclasses_of = _subclasses_of  # type: ignore[attr-defined]
+Classification.superclasses_of = _superclasses_of  # type: ignore[attr-defined]
+
+
+class IncompleteClassificationWarning(UserWarning):
+    """Raised when classification hit the per-pair timeout, so the
+    returned hierarchy is a sound under-approximation (no false
+    subsumptions, but real ones may be missing). Silence with the
+    standard `warnings` module, or pass `per_pair_timeout_ms=0` to
+    classify for the complete (unbounded) result."""
+
+
+def _warn_if_incomplete(result: "Classification") -> "Classification":
+    n = result.timed_out_pairs
+    if n:
+        _warnings.warn(
+            f"{n} class pair(s) exceeded the per-pair timeout and were recorded as "
+            "'not subsumed' — this classification may be missing real subsumptions. "
+            "It is still sound (no false subsumptions). Pass per_pair_timeout_ms=0 "
+            "for the complete (unbounded) result, or check result.complete / "
+            "result.timed_out_pairs.",
+            IncompleteClassificationWarning,
+            stacklevel=3,
+        )
+    return result
+
+
+def classify(path, *, per_pair_timeout_ms=1000, saturation_only=False):
+    """Classify the ontology at `path` (format auto-detected from the
+    extension: .ofn / .owx / .owl / .rdf).
+
+    `per_pair_timeout_ms` bounds each subsumption test (default 1000;
+    `0` = unbounded/complete). Pairs that exceed the budget are recorded
+    as "not subsumed" — sound, but the result may be incomplete; an
+    `IncompleteClassificationWarning` is emitted when that happens, and
+    `result.complete` / `result.timed_out_pairs` report it.
+    `saturation_only=True` skips the tableau (EL-closure under-
+    approximation; fast)."""
+    return _warn_if_incomplete(
+        _classify_native(
+            path,
+            per_pair_timeout_ms=per_pair_timeout_ms,
+            saturation_only=saturation_only,
+        )
+    )
+
+
+def classify_bytes(data, *, format, per_pair_timeout_ms=1000, saturation_only=False):
+    """Like `classify`, but from in-memory `data` with an explicit
+    `format` ("ofn" | "owx" | "rdf-xml"). See `classify` for the
+    timeout/completeness semantics."""
+    return _warn_if_incomplete(
+        _classify_bytes_native(
+            data,
+            format=format,
+            per_pair_timeout_ms=per_pair_timeout_ms,
+            saturation_only=saturation_only,
+        )
+    )
+
+
+__all__ = [
+    "__version__",
+    "Classification",
+    "IncompleteClassificationWarning",
+    "classify",
+    "classify_bytes",
+    "is_consistent",
+    "is_class_satisfiable",
+    "is_subclass_of",
+    "is_instance_of",
+    "instances_of",
+    "realize",
+    "RustdlError",
+    "ParseError",
+    "UnsupportedAxiomError",
+    "UnknownClassError",
+    "materialize_inferred_subclass_axioms",
+    "materialize_inferred_class_assertions",
+]

rustdl-0.2.2/python/rustdl/__init__.py

@@ -1,69 +0,0 @@
-"""
-rustdl — sound, performant OWL 2 DL (SROIQ) reasoner.
-
-Python bindings for the rustdl Rust crate. Install via
-`pip install rustdl`; import as `import rustdl`. See
-https://github.com/MaastrichtU-IDS/rustdl for the full project.
-"""
-
-# Native extension built by PyO3 + maturin
-from rustdl._native import (
-    __version__ as __version__,
-    Classification as Classification,
-    classify as classify,
-    classify_bytes as classify_bytes,
-    is_consistent as is_consistent,
-    is_class_satisfiable as is_class_satisfiable,
-    is_subclass_of as is_subclass_of,
-    is_instance_of as is_instance_of,
-    instances_of as instances_of,
-    realize as realize,
-    RustdlError as RustdlError,
-    ParseError as ParseError,
-    UnsupportedAxiomError as UnsupportedAxiomError,
-    UnknownClassError as UnknownClassError,
-    materialize_inferred_subclass_axioms as materialize_inferred_subclass_axioms,
-    materialize_inferred_class_assertions as materialize_inferred_class_assertions,
-)
-
-
-def _subclasses_of(self: "Classification", cls: str) -> list[str]:
-    """All classes D in the ontology with D ⊑ cls (reflexive + proper).
-
-    Pure-Python helper. O(N) over Classification.classes per call.
-    """
-    return [d for d in self.classes if self.is_subclass(d, cls)]
-
-
-def _superclasses_of(self: "Classification", cls: str) -> list[str]:
-    """All classes D in the ontology with cls ⊑ D (reflexive + proper).
-
-    Pure-Python helper. O(N) over Classification.classes per call.
-    """
-    return [d for d in self.classes if self.is_subclass(cls, d)]
-
-
-# Bind onto the PyO3 class so the API is symmetric:
-# `result.subclasses_of(...)` lives next to `result.is_subclass(...)`.
-Classification.subclasses_of = _subclasses_of  # type: ignore[attr-defined]
-Classification.superclasses_of = _superclasses_of  # type: ignore[attr-defined]
-
-
-__all__ = [
-    "__version__",
-    "Classification",
-    "classify",
-    "classify_bytes",
-    "is_consistent",
-    "is_class_satisfiable",
-    "is_subclass_of",
-    "is_instance_of",
-    "instances_of",
-    "realize",
-    "RustdlError",
-    "ParseError",
-    "UnsupportedAxiomError",
-    "UnknownClassError",
-    "materialize_inferred_subclass_axioms",
-    "materialize_inferred_class_assertions",
-]