tablassert 7.4.12__tar.gz → 7.4.14__tar.gz

{tablassert-7.4.12 → tablassert-7.4.14}/AGENTS.md

@@ -6,7 +6,7 @@
 - Install with `uv sync`. QC is not available unless you install an extra: `uv sync --extra qc` or `uv sync --extra qc-cuda`.
 - CLI entrypoint is `tablassert.cli:APP`. Real user commands are:
   - `uv run tablassert build <graph.yaml>`
-  - `uv run tablassert validate <table.yaml> <datassert>`
+  - `uv run tablassert validate <table.yaml>`
 
 ## Verify Changes
 

{tablassert-7.4.12 → tablassert-7.4.14}/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 All notable changes to this project are documented in this file.
 
+## 7.4.14 - 2026-06-30
+
+### Changes
+- Extended `sig()` in `lib.py` to select a p-value column by fuzzy matching rather than requiring an exact `"p value"` name. All schema columns whose names contain the substring `"p value"` are now considered candidates; `fuzz.ratio` (rapidfuzz) scores each against the literal `"p value"` and the highest-scoring column is used to compute the `"significant"` output. An exact `"p value"` column scores 100 and is always preferred; columns like `"adjusted p value"` or `"log p value"` are used only when no exact match is present. If no column contains the substring the function continues to emit `"UNSURE"` for all rows.
+- Added five regression tests in `test_lib.py` covering: exact-match preference, non-exact fallback, closest-match selection among multiple non-exact candidates, no-p-value column (UNSURE), and null value handling.
+
+## 7.4.13 - 2026-06-30
+
+### Changes
+- Removed the datassert prevalidation failure for unresolved `statement.subject` / `statement.object` literal encodings under `method: value`. Graph builds no longer abort during `Tcode.model_validate(...)` for cases like `"Incertae Sedis XI"`; unresolved literal values are now allowed through config validation so downstream runtime handling can decide whether they map or get filtered.
+- Added a regression test at the `Tcode.model_validate(...)` layer covering an unresolved `method: value` subject encoding, matching the build-time validation path reported in the field.
+
 ## 7.4.12 - 2026-06-29
 
 ### Changes

{tablassert-7.4.12 → tablassert-7.4.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tablassert
-Version: 7.4.12
+Version: 7.4.14
 Summary: Extract knowledge assertions from tabular data into NCATS Translator-compliant KGX NDJSON — declaratively, with entity resolution and quality control built in.
 Project-URL: Homepage, https://github.com/SkyeAv/Tablassert
 Project-URL: Source, https://github.com/SkyeAv/Tablassert

tablassert-7.4.14/docs/changelog.md

@@ -0,0 +1,25 @@
+# Changelog
+
+The canonical release history lives in the repository root at [`CHANGELOG.md`](https://github.com/SkyeAv/Tablassert/blob/main/CHANGELOG.md).
+
+## Current Release Notes
+
+## 7.4.14 - 2026-06-30
+
+### Changes
+
+- Extended `sig()` in `lib.py` to select a p-value column by fuzzy matching rather than requiring an exact `"p value"` name. All schema columns whose names contain the substring `"p value"` are now considered candidates; `fuzz.ratio` (rapidfuzz) scores each against the literal `"p value"` and the highest-scoring column is used to compute the `"significant"` output. An exact `"p value"` column scores 100 and is always preferred; columns like `"adjusted p value"` or `"log p value"` are used only when no exact match is present. If no column contains the substring the function continues to emit `"UNSURE"` for all rows.
+- Added five regression tests in `test_lib.py` covering: exact-match preference, non-exact fallback, closest-match selection among multiple non-exact candidates, no-p-value column (UNSURE), and null value handling.
+
+## 7.4.13 - 2026-06-30
+
+### Changes
+
+- Removed the datassert prevalidation failure for unresolved `statement.subject` / `statement.object` literal encodings under `method: value`. Graph builds no longer abort during `Tcode.model_validate(...)` for cases like `"Incertae Sedis XI"`; unresolved literal values are now allowed through config validation so downstream runtime handling can decide whether they map or get filtered.
+- Added a regression test at the `Tcode.model_validate(...)` layer covering an unresolved `method: value` subject encoding, matching the build-time validation path reported in the field.
+
+## 7.4.12 - 2026-06-29
+
+### Changes
+
+- Expanded the placeholder-term filter regex in `distinct()` (`fullmap.py`) to drop additional non-informative terms during entity resolution. The `bad` pattern now also excludes `not applicable`, `p value`, `variable`, `result`, `exposure`, `expression`, and `symbol` alongside the existing `none`, `nan`, `na`, `null`, and `unknown`, preventing these generic column-header-like values from being sent through resolution and producing spurious CURIE mappings.

{tablassert-7.4.12 → tablassert-7.4.14}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tablassert"
-version = "7.4.12"
+version = "7.4.14"
 description = "Extract knowledge assertions from tabular data into NCATS Translator-compliant KGX NDJSON — declaratively, with entity resolution and quality control built in."
 authors = [
     { name = "Skye Lane Goetz", email = "sgoetz@isbscience.org" }
@@ -90,17 +90,17 @@ qc-cuda = [
 
 [dependency-groups]
 dev = [
-    "grayskull>=3.1.0",
     "mkdocs>=1.6.1",
     "pre-commit>=4.5.1",
     "pyright>=1.1.408",
     "pytest>=9.0.2",
+    "pytest-cov>=7.1.0",
     "ruff>=0.15.6",
 ]
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]
-markers = ["network: requires internet", "gpu: requires CUDAExecutionProvider", "datassert: requires the datassert DuckDB shards"]
+markers = ["network: requires internet", "gpu: requires CUDAExecutionProvider"]
 
 [tool.ruff]
 line-length = 120

{tablassert-7.4.12 → tablassert-7.4.14}/src/tablassert/cli.py

@@ -57,30 +57,29 @@ def build_pipeline(graph_configuration_file: Path, progress: "PipelineProgress")
     sections: list[dict[str, Any]] = list(chain.from_iterable(temp))
     n: int = len(sections)
 
+    # * Build TCode (3/6)
+    progress.stage(f"Building TCode | Sections: {n}")
+    advance = progress.section_loop(n, "TCode")
+    tcode: list[Tcode] = []
+    for idx, s in enumerate(sections, start=1):
+        try:
+            tcode.append(
+                Tcode.model_validate(
+                    {**s, "number": idx, "store": (STORE / f"{mkhash(s)}.parquet"), "log": g.log, "qc": g.qc}
+                )
+            )
+        except pydantic.ValidationError as e:
+            raise RuntimeError(
+                f"02 | FAILED VALIDATION | CONFIG: {graph_configuration_file} | IDX: {idx} | HASH: {mkhash(s)} | PYDANTIC: {flatten_pydantic_error(e)}"
+            ) from e
+        advance(format_section_oneline(tcode[-1]))
+
     with ExitStack() as stack:
         conns: list[object] = [
             stack.enter_context(duckdb.connect(g.datassert / "data" / f"{x}.duckdb", read_only=True))
             for x in range(SHARDS)
         ]
 
-        # * Build TCode (3/6)
-        progress.stage(f"Building TCode | Sections: {n}")
-        advance = progress.section_loop(n, "TCode")
-        tcode: list[Tcode] = []
-        for idx, s in enumerate(sections, start=1):
-            try:
-                tcode.append(
-                    Tcode.model_validate(
-                        {**s, "number": idx, "store": (STORE / f"{mkhash(s)}.parquet"), "log": g.log, "qc": g.qc},
-                        context={"conns": conns},
-                    )
-                )
-            except pydantic.ValidationError as e:
-                raise RuntimeError(
-                    f"02 | FAILED VALIDATION | CONFIG: {graph_configuration_file} | IDX: {idx} | HASH: {mkhash(s)} | PYDANTIC: {flatten_pydantic_error(e)}"
-                ) from e
-            advance(format_section_oneline(tcode[-1]))
-
         # * Collect Instructions (4/6)
         progress.stage(f"Collecting Instructions | Sections: {n}")
         advance = progress.section_loop(n, "Collect")
@@ -106,9 +105,8 @@ def build_pipeline(graph_configuration_file: Path, progress: "PipelineProgress")
     logger.info(f"BUILD DONE | SECTIONS: {n} | NAME: {g.name} | VERSION: {g.version}")
 
 
-def validate_pipeline(table_configuration_file: Path, datassert: Path, progress: "PipelineProgress") -> None:
+def validate_pipeline(table_configuration_file: Path, progress: "PipelineProgress") -> None:
     # ? Validate Section Syntax From A Configuration File
-    from tablassert.fullmap import SHARDS
     from tablassert.ingests import from_yaml, to_sections
     from tablassert.lib import Tcode
     from tablassert.progress import flatten_pydantic_error
@@ -126,32 +124,27 @@ def validate_pipeline(table_configuration_file: Path, datassert: Path, progress:
     # * Validate Section Syntax (3/3)
     progress.stage(f"Validating Section Syntax | Sections: {n}")
     advance = progress.section_loop(n, "Validate")
-    with ExitStack() as stack:
-        conns: list[object] = [
-            stack.enter_context(duckdb.connect(datassert / "data" / f"{x}.duckdb", read_only=True))
-            for x in range(SHARDS)
-        ]
-        for idx, s in enumerate(sections, start=1):
-            h: str = mkhash(s)
-            try:
-                Tcode.model_validate({**s, "number": idx, "store": (STORE / f"{h}.parquet")}, context={"conns": conns})
-            except pydantic.ValidationError as e:
-                raise RuntimeError(
-                    f"02 | FAILED VALIDATION | CONFIG: {table_configuration_file} | IDX: {idx} | HASH: {h} | PYDANTIC: {flatten_pydantic_error(e)}"
-                ) from e
-            advance(f"#{idx} | HASH: {h}")
+    for idx, s in enumerate(sections, start=1):
+        h: str = mkhash(s)
+        try:
+            Tcode.model_validate({**s, "number": idx, "store": (STORE / f"{h}.parquet")})
+        except pydantic.ValidationError as e:
+            raise RuntimeError(
+                f"02 | FAILED VALIDATION | CONFIG: {table_configuration_file} | IDX: {idx} | HASH: {h} | PYDANTIC: {flatten_pydantic_error(e)}"
+            ) from e
+        advance(f"#{idx} | HASH: {h}")
 
     logger.info(f"VALIDATE DONE | SECTIONS: {n} | CONFIG: {table_configuration_file.name}")
 
 
-def run(stages: int, fn: Any, *args: Path) -> None:
+def run(stages: int, fn: Any, arg: Path) -> None:
     from tablassert.log import LOG_FORMAT, logger
     from tablassert.progress import PipelineProgress
 
     with PipelineProgress(total_stages=stages) as progress:
         sink_id: int = logger.add(progress.log_sink, level="INFO", format=LOG_FORMAT)
         try:
-            fn(*args, progress)
+            fn(arg, progress)
         finally:
             logger.remove(sink_id)
 
@@ -163,6 +156,6 @@ def build(graph_configuration_file: Path) -> None:
 
 
 @APP.command
-def validate(table_configuration_file: Path, datassert: Path) -> None:
-    """Validate section syntax from a YAML configuration file against a datassert directory."""
-    run(3, validate_pipeline, table_configuration_file, datassert)
+def validate(table_configuration_file: Path) -> None:
+    """Validate section syntax from a YAML configuration file."""
+    run(3, validate_pipeline, table_configuration_file)

{tablassert-7.4.12 → tablassert-7.4.14}/src/tablassert/lib.py

@@ -101,14 +101,18 @@ def sig(
     out: str = "significant",
 ) -> pl.LazyFrame:
     # ? Creates The "significant" Column
-    if col in lf.collect_schema().names():
-        expr: pl.Expr = pl.col(col).cast(pl.Float64, strict=False)
+    from rapidfuzz import fuzz
+
+    names: list[str] = lf.collect_schema().names()
+    candidates: list[str] = [c for c in names if col in c]
+    chosen: Optional[str] = max(candidates, key=lambda c: fuzz.ratio(c, col)) if candidates else None
+    if chosen is not None:
+        expr: pl.Expr = pl.col(chosen).cast(pl.Float64, strict=False)
         cond: pl.Expr = le(expr, cutoff)
         cutoff: pl.Expr = (
             pl.when(expr.is_null()).then(pl.lit("UNSURE")).when(cond).then(pl.lit("YES")).otherwise(pl.lit("NO"))
         )
         return lf.with_columns(cutoff.alias(out))
-
     else:
         return lf.with_columns(pl.lit("UNSURE").alias(out))
 

{tablassert-7.4.12 → tablassert-7.4.14}/src/tablassert/models.py

@@ -25,9 +25,6 @@ from tablassert.enums import (
     Tokens,
 )
 
-from tablassert.fullmap import resolve
-from tablassert.nlp import level_one, level_two
-
 if TYPE_CHECKING:
     import httpx
     import polars as pl
@@ -318,35 +315,6 @@ class Annotation(Encoding):
         return annotation.replace("_", " ").strip()
 
 
-def resolves_value_encodings(statement: Statement, conns: list[object]) -> None:
-    # ? Resolve Every Value-Method Literal Against The Shared Datassert Shards
-    nodes: list[tuple[str, NodeEncoding]] = [("subject", statement.subject), ("object", statement.object)]
-    if statement.qualifiers:
-        nodes += [(q.qualifier, q) for q in statement.qualifiers]
-
-    for label, node in nodes:
-        if not eq(node.method, EncodingMethods.VALUE):
-            continue
-
-        term: str = str(node.encoding)
-        lf: pl.LazyFrame = pl.DataFrame({"term": [term]}).lazy()
-        lf = level_one(lf, "term")
-        lf = level_two(lf, "term")
-        resolved: pl.DataFrame = resolve(
-            lf,
-            "term",
-            conns,
-            taxon=str(node.taxon) if node.taxon else None,
-            prioritize=node.prioritize,
-            avoid=node.avoid,
-            log=False,
-            column_context=False,
-        ).collect()
-        if resolved.height == 0:
-            msg: str = f"21 | value encoding {term!r} in {label!r} did not resolve against datassert"
-            raise ValueError(msg)
-
-
 class Section(TablaBase):
     # ? Pydantic "Section" Model And Coercion
     syntax: Syntaxes = Field(Syntaxes.TC3, description="Section configuration syntax version.")
@@ -358,16 +326,6 @@ class Section(TablaBase):
         None, description="Optional extra encoded columns added to each row."
     )
 
-    @field_validator("statement", mode="after")
-    @classmethod
-    def value_encodings_resolve(cls, statement: Statement, info: Any) -> Statement:
-        # ? Ensure Value-Method Encodings Resolve Against The Shared Datassert Shards
-        conns: Optional[list[object]] = info.context.get("conns") if info.context else None
-        if conns is None:
-            return statement  # * skip without shared connections (contextless path)
-        resolves_value_encodings(statement, conns)
-        return statement
-
 
 class Graph(TablaBase):
     # ? Pydantic "Graph" Configuration

{tablassert-7.4.12 → tablassert-7.4.14}/tests/conftest.py

@@ -1,8 +1,7 @@
 from __future__ import annotations
 
-import os
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any
 
 import httpx
 import pytest
@@ -27,15 +26,3 @@ def mockhttpxhead(monkeypatch: pytest.MonkeyPatch) -> None:
 @pytest.fixture
 def fixtures_path() -> Path:
     return Path(__file__).parent / "fixtures"
-
-
-@pytest.fixture
-def datassert_dir() -> Path:
-    # ? Shared Datassert Shard Directory (Skipped When Unavailable)
-    env: Optional[str] = os.environ.get("DATASSERT")
-    if not env:
-        pytest.skip("DATASSERT env var not set; skipping datassert-dependent test")
-    directory: Path = Path(env)
-    if not (directory / "data" / "0.duckdb").is_file():
-        pytest.skip(f"datassert shard data/0.duckdb not found under {directory}")
-    return directory

{tablassert-7.4.12 → tablassert-7.4.14}/tests/test_lib.py

@@ -138,6 +138,20 @@ def test_tcode_collect_threads_download_context(fixtures_path: Path) -> None:
     assert first_op[1] == ("https://example.com/test.tsv", Path("test.tsv"), "minimal_section.yaml", "sectionhash")
 
 
+# ? Tcode Allows Unresolved Value Encodings During Validation
+def test_tcode_model_allows_unresolved_value_encoding(fixtures_path: Path) -> None:
+    data: Any = from_yaml(fixtures_path / "minimal_section.yaml")
+    store: Path = Path("/tmp/sectionhash.parquet")
+    data["statement"]["subject"] = {"method": "value", "encoding": "Incertae Sedis XI"}
+
+    tcode_model: Tcode = Tcode.model_validate(  # pyright: ignore
+        {**data, "number": 55, "config": fixtures_path / "minimal_section.yaml", "store": store}
+    )
+
+    assert tcode_model.statement.subject.method == "value"
+    assert tcode_model.statement.subject.encoding == "Incertae Sedis XI"
+
+
 # ? Tcode collect Enables QC Logging By Default
 def test_tcode_collect_skips_qc_by_default(fixtures_path: Path) -> None:
     data: Any = from_yaml(fixtures_path / "minimal_section.yaml")
@@ -253,3 +267,39 @@ def test_resolve_many_runs_qc(monkeypatch: Any, tmp_path: Path) -> None:
 
     assert result == [{"subject": "brca1", "original subject": "BRCA1", "subject two": "brca1", "passed": "YES"}]
     assert ("qc", "subject", "", "", "passed", True, None) in calls
+
+
+# ? sig Uses Exact "p value" Column When Present Alongside Other P-Value Columns
+def test_sig_prefers_exact_p_value_column() -> None:
+    lf: pl.LazyFrame = pl.DataFrame({"p value": [0.01, 0.1], "adjusted p value": [0.5, 0.5]}).lazy()
+    result: pl.DataFrame = lib.sig(lf).collect()
+    assert list(result["significant"]) == ["YES", "NO"]
+
+
+# ? sig Falls Back To Non-Exact P-Value Column When No Exact Match
+def test_sig_uses_non_exact_p_value_column() -> None:
+    lf: pl.LazyFrame = pl.DataFrame({"adjusted p value": [0.01, 0.1]}).lazy()
+    result: pl.DataFrame = lib.sig(lf).collect()
+    assert list(result["significant"]) == ["YES", "NO"]
+
+
+# ? sig Picks Closest Match When Multiple Non-Exact Columns Present
+def test_sig_picks_closest_non_exact_match() -> None:
+    lf: pl.LazyFrame = pl.DataFrame({"log p value": [0.01], "adjusted p value corrected": [0.5]}).lazy()
+    result: pl.DataFrame = lib.sig(lf).collect()
+    # "log p value" has higher fuzz.ratio to "p value" than "adjusted p value corrected"
+    assert list(result["significant"]) == ["YES"]
+
+
+# ? sig Returns UNSURE When No P-Value Column Exists
+def test_sig_returns_unsure_with_no_p_value_column() -> None:
+    lf: pl.LazyFrame = pl.DataFrame({"gene": ["BRCA1"]}).lazy()
+    result: pl.DataFrame = lib.sig(lf).collect()
+    assert list(result["significant"]) == ["UNSURE"]
+
+
+# ? sig Marks Null P-Values As UNSURE
+def test_sig_marks_null_as_unsure() -> None:
+    lf: pl.LazyFrame = pl.DataFrame({"p value": [None, 0.01, 0.1]}).lazy()
+    result: pl.DataFrame = lib.sig(lf).collect()
+    assert list(result["significant"]) == ["UNSURE", "YES", "NO"]

{tablassert-7.4.12 → tablassert-7.4.14}/tests/test_models.py

@@ -3,11 +3,9 @@ from __future__ import annotations
 from pathlib import Path
 from typing import Any
 
-import polars as pl
 import pytest
 from pydantic import ValidationError
 
-import tablassert.models as models
 from tablassert.enums import Categories
 from tablassert.ingests import from_yaml
 from tablassert.models import (
@@ -282,193 +280,3 @@ def test_section_with_annotations() -> None:
         ],
     )
     assert len(section.annotations) == 2  # pyright: ignore
-
-
-# ? Value Encoding Resolves Against Datassert (Context-Aware Pass)
-def test_value_encoding_resolves_pass(monkeypatch: pytest.MonkeyPatch) -> None:
-    def fake_resolve(_lf: Any, _col: str, _conns: list[object], **_kwargs: Any) -> Any:
-        return pl.DataFrame({"resolved": ["YES"]}).lazy()
-
-    monkeypatch.setattr(models, "resolve", fake_resolve)
-    section: Section = Section.model_validate(
-        {
-            "source": {"local": "./t.tsv", "url": "https://example.com/t.tsv", "kind": "text"},
-            "statement": {
-                "subject": {"method": "value", "encoding": "BRCA1"},
-                "object": {"method": "value", "encoding": "TP53"},
-            },
-            "provenance": {
-                "repo": "PMC",
-                "publication": "PMC000",
-                "contributors": [{"kind": "curation", "name": "T", "date": "2025"}],
-            },
-        },
-        context={"conns": [object()]},
-    )
-    assert section.statement.subject.encoding == "BRCA1"
-
-
-# ? Value Encoding Fails To Resolve Raises Code 21
-def test_value_encoding_resolves_fail(monkeypatch: pytest.MonkeyPatch) -> None:
-    def fake_resolve_empty(_lf: Any, _col: str, _conns: list[object], **_kwargs: Any) -> Any:
-        return pl.DataFrame({"resolved": []}).lazy()
-
-    monkeypatch.setattr(models, "resolve", fake_resolve_empty)
-    with pytest.raises(ValidationError) as exc_info:
-        Section.model_validate(
-            {
-                "source": {"local": "./t.tsv", "url": "https://example.com/t.tsv", "kind": "text"},
-                "statement": {
-                    "subject": {"method": "value", "encoding": "BRCA1"},
-                    "object": {"method": "value", "encoding": "TP53"},
-                },
-                "provenance": {
-                    "repo": "PMC",
-                    "publication": "PMC000",
-                    "contributors": [{"kind": "curation", "name": "T", "date": "2025"}],
-                },
-            },
-            context={"conns": [object()]},
-        )
-    assert "21 |" in str(exc_info.value)
-
-
-# ? Value Encoding Validator Skips Without Context
-def test_value_encoding_skips_without_context(monkeypatch: pytest.MonkeyPatch) -> None:
-    def fake_resolve_empty(_lf: Any, _col: str, _conns: list[object], **_kwargs: Any) -> Any:
-        return pl.DataFrame({"resolved": []}).lazy()
-
-    monkeypatch.setattr(models, "resolve", fake_resolve_empty)
-    section: Section = Section(  # pyright: ignore
-        source={"local": "./t.tsv", "url": "https://example.com/t.tsv", "kind": "text"},
-        statement={
-            "subject": {"method": "value", "encoding": "BRCA1"},
-            "object": {"method": "value", "encoding": "TP53"},
-        },
-        provenance={
-            "repo": "PMC",
-            "publication": "PMC000",
-            "contributors": [{"kind": "curation", "name": "T", "date": "2025"}],
-        },
-    )
-    assert section.statement.subject.encoding == "BRCA1"
-
-
-# ? Column Method Encodings Are Not Checked
-def test_column_encoding_not_checked(monkeypatch: pytest.MonkeyPatch) -> None:
-    def boom_resolve(_lf: Any, _col: str, _conns: list[object], **_kwargs: Any) -> Any:
-        raise AssertionError("resolve must not be called for column-method encodings")
-
-    monkeypatch.setattr(models, "resolve", boom_resolve)
-    section: Section = Section.model_validate(
-        {
-            "source": {"local": "./t.tsv", "url": "https://example.com/t.tsv", "kind": "text"},
-            "statement": {
-                "subject": {"method": "column", "encoding": "A"},
-                "object": {"method": "column", "encoding": "B"},
-            },
-            "provenance": {
-                "repo": "PMC",
-                "publication": "PMC000",
-                "contributors": [{"kind": "curation", "name": "T", "date": "2025"}],
-            },
-        },
-        context={"conns": [object()]},
-    )
-    assert section.statement.subject.encoding == "A"
-
-
-# ? Qualifier Value Encoding Is Checked Against Datassert
-def test_qualifier_value_encoding_checked(monkeypatch: pytest.MonkeyPatch) -> None:
-    def fake_resolve(lf: Any, col: str, _conns: list[object], **_kwargs: Any) -> Any:
-        term: str = str(lf.collect().get_column(col).to_list()[0])
-        if term in ("brca1", "tp53"):
-            return pl.DataFrame({"resolved": ["YES"]}).lazy()
-        return pl.DataFrame({"resolved": []}).lazy()
-
-    monkeypatch.setattr(models, "resolve", fake_resolve)
-    with pytest.raises(ValidationError) as exc_info:
-        Section.model_validate(
-            {
-                "source": {"local": "./t.tsv", "url": "https://example.com/t.tsv", "kind": "text"},
-                "statement": {
-                    "subject": {"method": "value", "encoding": "BRCA1"},
-                    "object": {"method": "value", "encoding": "TP53"},
-                    "qualifiers": [
-                        {"qualifier": "disease_context_qualifier", "method": "value", "encoding": "ZZZNOTAREALGENE123"}
-                    ],
-                },
-                "provenance": {
-                    "repo": "PMC",
-                    "publication": "PMC000",
-                    "contributors": [{"kind": "curation", "name": "T", "date": "2025"}],
-                },
-            },
-            context={"conns": [object()]},
-        )
-    assert "21 |" in str(exc_info.value)
-
-
-# ? Real Value Encoding Resolves Against The Datassert Shards
-@pytest.mark.datassert
-def test_real_value_encoding_resolves(datassert_dir: Path) -> None:
-    from contextlib import ExitStack
-
-    import duckdb
-
-    from tablassert.fullmap import SHARDS
-
-    with ExitStack() as stack:
-        conns: list[object] = [
-            stack.enter_context(duckdb.connect(datassert_dir / "data" / f"{x}.duckdb", read_only=True))
-            for x in range(SHARDS)
-        ]
-        section: Section = Section.model_validate(
-            {
-                "source": {"local": "./t.tsv", "url": "https://example.com/t.tsv", "kind": "text"},
-                "statement": {
-                    "subject": {"method": "value", "encoding": "BRCA1"},
-                    "object": {"method": "value", "encoding": "TP53"},
-                },
-                "provenance": {
-                    "repo": "PMC",
-                    "publication": "PMC000",
-                    "contributors": [{"kind": "curation", "name": "T", "date": "2025"}],
-                },
-            },
-            context={"conns": conns},
-        )
-        assert section.statement.subject.encoding == "BRCA1"
-
-
-# ? Real Value Encoding Failure Raises Code 21
-@pytest.mark.datassert
-def test_real_value_encoding_fails(datassert_dir: Path) -> None:
-    from contextlib import ExitStack
-
-    import duckdb
-
-    from tablassert.fullmap import SHARDS
-
-    with ExitStack() as stack:
-        conns: list[object] = [
-            stack.enter_context(duckdb.connect(datassert_dir / "data" / f"{x}.duckdb", read_only=True))
-            for x in range(SHARDS)
-        ]
-        with pytest.raises(ValidationError) as exc_info:
-            Section.model_validate(
-                {
-                    "source": {"local": "./t.tsv", "url": "https://example.com/t.tsv", "kind": "text"},
-                    "statement": {
-                        "subject": {"method": "value", "encoding": "ZZZNOTAREALGENE123"},
-                        "object": {"method": "value", "encoding": "TP53"},
-                    },
-                    "provenance": {
-                        "repo": "PMC",
-                        "publication": "PMC000",
-                        "contributors": [{"kind": "curation", "name": "T", "date": "2025"}],
-                    },
-                },
-                context={"conns": conns},
-            )
-        assert "21 |" in str(exc_info.value)