Feat/inlined multivalued element identity

src/python/python/linkml_runtime_rust/_native.pyi

@@ -2789,7 +2789,12 @@ class LinkMLInstance:
     def __getitem__(self, key:typing.Any) -> LinkMLInstance: ...
     def navigate(self, path:typing.Any) -> typing.Optional[LinkMLInstance]:
         r"""
-        Navigate by a path of strings (map keys or list indices).
+        Navigate by a path of strings: slot names, mapping keys, and — for
+        lists — element identity labels (identifier/key or `unique_keys` value)
+        when the list carries unique labels, numeric indices otherwise. This is
+        the same addressing `diff` emits and `patch` applies, so delta paths are
+        navigable; a numeric segment aimed at a label-addressed list resolves to
+        nothing rather than to that position.
         Returns a new LinkMLInstance if found, otherwise None.
         """
     def keys(self) -> builtins.list[builtins.str]: ...
@@ -5478,6 +5483,43 @@ def import_turtle(reader:typing.Any, schema_view:SchemaView, root_classes:typing
     Import RDF/Turtle into a streaming iterator of LinkML instances.
     """
 
+def lint_element_identity(schema_view:SchemaView) -> builtins.list[ValidationResult]:
+    r"""
+    Schema-level lint: warn where a multivalued inlined slot's element identity
+    is absent, ambiguous, or cannot address the list.
+
+    Five rules: (1) no identity declared at all; (2) the declared identity is
+    the element class's type designator, whose value describes the class rather
+    than the element; (3) several ``unique_keys`` entries to choose from across
+    the range class and its descendants, of which only the name-sorted first is
+    load-bearing; (4) those classes labelled in different ways, so one list
+    carries two label spaces; (5) two classes of one ``is_a`` hierarchy
+    declaring the same ``class_uri`` while the hierarchy designates its type.
+
+    Warnings only — the schema stays usable. Results are deterministic: sorted
+    by subject, deduplicated across class URIs, and an inherited slot is
+    reported once, at the class that introduces the problem. Rules 1-4 are
+    per-slot and their ``subject`` is ``[class_name, slot_name]``; rule 5 is
+    class-level and its ``subject`` is ``"shared_class_uri"`` followed by the
+    classes sharing the URI — the marker distinguishes it from a per-slot
+    subject, which a rendering that joins the segments could not otherwise do.
+    """
+
+def lint_instance_identity(instance:LinkMLInstance) -> builtins.list[ValidationResult]:
+    r"""
+    Data-level lint: warn where loaded data defeats a declared element identity.
+
+    Two rules: a list whose elements repeat a declared identity — key/identifier
+    or ``unique_keys`` value — reported as ``duplicate_element_identity``; and a
+    list addressed positionally *despite* a declared identity, because some
+    element leaves the slot that identity names empty, reported as
+    ``ambiguous_element_identity``. Neither is visible in the schema: an
+    identity slot that is not ``required`` may be absent, and repeated or
+    missing values are alike valid data.
+
+    Warnings only. ``subject`` is the container's instance path.
+    """
+
 def load_json(source:typing.Any, sv:SchemaView, class_view:ClassView) -> tuple[typing.Optional[LinkMLInstance], builtins.list[ValidationResult]]: ...
 
 def load_yaml(source:typing.Any, sv:SchemaView, class_view:ClassView) -> tuple[typing.Optional[LinkMLInstance], builtins.list[ValidationResult]]: ...

src/python/src/lib.rs

@@ -4,8 +4,8 @@ use linkml_runtime::diff::{
 };
 use linkml_runtime::turtle::{turtle_to_string, TurtleOptions};
 use linkml_runtime::{
-    load_json_str, load_yaml_str, validate_issues, LinkMLInstance, LoadResult, NodeId,
-    ValidationProblemType, ValidationResult, ValidationSeverity, ValidationValue,
+    lint_element_identity, lint_instance_identity, load_json_str, load_yaml_str, validate_issues,
+    LinkMLInstance, LoadResult, NodeId, ValidationResult, ValidationSeverity, ValidationValue,
 };
 use linkml_schemaview::identifier::Identifier;
 use linkml_schemaview::io;
@@ -744,6 +744,8 @@ pub fn runtime_module(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(load_json, m)?)?;
     m.add_function(wrap_pyfunction!(py_diff, m)?)?;
     m.add_function(wrap_pyfunction!(py_patch, m)?)?;
+    m.add_function(wrap_pyfunction!(py_lint_element_identity, m)?)?;
+    m.add_function(wrap_pyfunction!(py_lint_instance_identity, m)?)?;
     m.add_function(wrap_pyfunction!(py_import_turtle, m)?)?;
     m.add_function(wrap_pyfunction!(py_import_ntriples, m)?)?;
     m.add_function(wrap_pyfunction!(py_export_turtle, m)?)?;
@@ -874,7 +876,7 @@ impl From<ValidationResult> for PyValidationResult {
 impl PyValidationResult {
     #[getter]
     fn r#type(&self) -> String {
-        validation_problem_type_label(&self.inner.problem_type).to_string()
+        self.inner.problem_type.label().to_string()
     }
 
     #[getter]
@@ -915,7 +917,7 @@ impl PyValidationResult {
     fn __repr__(&self) -> PyResult<String> {
         Ok(format!(
             "ValidationResult(type='{}', severity='{}', subject={:?}, detail={})",
-            validation_problem_type_label(&self.inner.problem_type),
+            self.inner.problem_type.label(),
             severity_label(&self.inner.severity),
             self.inner.subject,
             self.inner.detail
@@ -1045,17 +1047,6 @@ fn validation_value_to_py(py: Python<'_>, value: &ValidationValue) -> PyResult<P
     }
 }
 
-fn validation_problem_type_label(problem_type: &ValidationProblemType) -> &'static str {
-    match problem_type {
-        ValidationProblemType::UndeclaredSlot => "undeclared_slot",
-        ValidationProblemType::InapplicableSlot => "inapplicable_slot",
-        ValidationProblemType::MissingSlotValue => "missing_slot_value",
-        ValidationProblemType::SlotRangeViolation => "slot_range_violation",
-        ValidationProblemType::MaxCountViolation => "max_count_violation",
-        ValidationProblemType::ParsingError => "parsing_error",
-    }
-}
-
 fn severity_label(severity: &ValidationSeverity) -> &'static str {
     match severity {
         ValidationSeverity::Fatal => "fatal",
@@ -1223,7 +1214,12 @@ impl PyLinkMLInstance {
         }
     }
 
-    /// Navigate by a path of strings (map keys or list indices).
+    /// Navigate by a path of strings: slot names, mapping keys, and — for
+    /// lists — element identity labels (identifier/key or `unique_keys` value)
+    /// when the list carries unique labels, numeric indices otherwise. This is
+    /// the same addressing `diff` emits and `patch` applies, so delta paths are
+    /// navigable; a numeric segment aimed at a label-addressed list resolves to
+    /// nothing rather than to that position.
     /// Returns a new LinkMLInstance if found, otherwise None.
     #[pyo3(name = "navigate")]
     fn py_navigate<'py>(
@@ -1569,6 +1565,55 @@ fn py_patch(
     Py::new(py, result)
 }
 
+// ── Identity lints ──────────────────────────────────────────────────────────
+
+/// Schema-level lint: warn where a multivalued inlined slot's element identity
+/// is absent, ambiguous, or cannot address the list.
+///
+/// Five rules: (1) no identity declared at all; (2) the declared identity is
+/// the element class's type designator, whose value describes the class rather
+/// than the element; (3) several ``unique_keys`` entries to choose from across
+/// the range class and its descendants, of which only the name-sorted first is
+/// load-bearing; (4) those classes labelled in different ways, so one list
+/// carries two label spaces; (5) two classes of one ``is_a`` hierarchy
+/// declaring the same ``class_uri`` while the hierarchy designates its type.
+///
+/// Warnings only — the schema stays usable. Results are deterministic: sorted
+/// by subject, deduplicated across class URIs, and an inherited slot is
+/// reported once, at the class that introduces the problem. Rules 1-4 are
+/// per-slot and their ``subject`` is ``[class_name, slot_name]``; rule 5 is
+/// class-level and its ``subject`` is ``"shared_class_uri"`` followed by the
+/// classes sharing the URI — the marker distinguishes it from a per-slot
+/// subject, which a rendering that joins the segments could not otherwise do.
+#[cfg_attr(feature = "stubgen", gen_stub_pyfunction)]
+#[pyfunction(name = "lint_element_identity")]
+fn py_lint_element_identity(
+    py: Python<'_>,
+    schema_view: &PySchemaView,
+) -> PyResult<Vec<Py<PyValidationResult>>> {
+    validation_results_to_py(py, lint_element_identity(schema_view.as_rust()))
+}
+
+/// Data-level lint: warn where loaded data defeats a declared element identity.
+///
+/// Two rules: a list whose elements repeat a declared identity — key/identifier
+/// or ``unique_keys`` value — reported as ``duplicate_element_identity``; and a
+/// list addressed positionally *despite* a declared identity, because some
+/// element leaves the slot that identity names empty, reported as
+/// ``ambiguous_element_identity``. Neither is visible in the schema: an
+/// identity slot that is not ``required`` may be absent, and repeated or
+/// missing values are alike valid data.
+///
+/// Warnings only. ``subject`` is the container's instance path.
+#[cfg_attr(feature = "stubgen", gen_stub_pyfunction)]
+#[pyfunction(name = "lint_instance_identity")]
+fn py_lint_instance_identity(
+    py: Python<'_>,
+    instance: &PyLinkMLInstance,
+) -> PyResult<Vec<Py<PyValidationResult>>> {
+    validation_results_to_py(py, lint_instance_identity(&instance.value))
+}
+
 // ── RDF import/export ───────────────────────────────────────────────────────
 
 /// Streaming iterator over harvested LinkML instances.

src/python/tests/python_navigate.rs

@@ -62,13 +62,20 @@ value = load_no_errors(lr, lr.load_yaml, data_path, sv, cls)
 assert 'objects' in value.keys()
 assert value.navigate(['objects']) is not None
 
-# Navigate list index then nested keys to scalar
-name = value.navigate(['objects','2','has_medical_history','0','diagnosis','name'])
+# Navigate a list by element identity label, then nested keys to a scalar.
+# `objects` ranges on NamedThing, which declares an `id` identifier, so the
+# list is addressed by that label, never by position. `has_medical_history`
+# declares no identity and stays numeric.
+name = value.navigate(['objects','P:002','has_medical_history','0','diagnosis','name'])
 assert name is not None
 assert name.as_python() == 'headache'
 
 # Non-existent path -> None
-assert value.navigate(['objects','1000']) is None
+assert value.navigate(['objects','P:404']) is None
+
+# A numeric segment aimed at a label-addressed list resolves to nothing
+# rather than to that position: it never guesses an element.
+assert value.navigate(['objects','2']) is None
 "#
         );
     });

src/runtime/src/blame/mod.rs

@@ -22,6 +22,12 @@ use std::fmt;
 /// strategy: every node touched by the patch (added or updated according to the
 /// [`PatchTrace`]) will have the supplied metadata cloned into the provided
 /// `blame` map.
+///
+/// Deltas that did not apply are in [`PatchTrace::failed`] and touch nothing,
+/// so they leave no blame entry — and, since [`patch`] never hard-errors on
+/// one (spec addendum rule 4), an `Ok` here does not mean the whole batch
+/// landed. Callers that treat a patch as atomic must check `trace.failed`
+/// themselves; the blame map records what actually happened either way.
 pub fn patch_with_blame<M: Clone>(
     value: &LinkMLInstance,
     deltas: &[Delta],