tablassert 7.4.12__tar.gz → 7.4.13__tar.gz

{tablassert-7.4.12 → tablassert-7.4.13}/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.13}/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 All notable changes to this project are documented in this file.
 
+## 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.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tablassert
-Version: 7.4.12
+Version: 7.4.13
 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.12 → tablassert-7.4.13}/docs/changelog.md

@@ -4,6 +4,13 @@ The canonical release history lives in the repository root at [`CHANGELOG.md`](h
 
 ## Current Release Notes
 
+## 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.13}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tablassert"
-version = "7.4.12"
+version = "7.4.13"
 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" }
@@ -100,7 +100,7 @@ dev = [
 
 [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.13}/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.13}/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.13}/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.13}/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")

{tablassert-7.4.12 → tablassert-7.4.13}/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)

{tablassert-7.4.12 → tablassert-7.4.13}/uv.lock

@@ -2360,7 +2360,7 @@ wheels = [
 
 [[package]]
 name = "tablassert"
-version = "7.4.11"
+version = "7.4.13"
 source = { editable = "." }
 dependencies = [
     { name = "cyclopts" },

tablassert-7.4.12/.github/workflows/autotag.yml

@@ -1,26 +0,0 @@
-name: Auto Tag Versions
-on:
-  workflow_dispatch:
-  workflow_run:
-    workflows:
-      - "Deploy to PyPI"
-    types:
-      - completed
-    branches:
-      - main
-permissions:
-  contents: write
-jobs:
-  autotag:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-      - name: Autotag using pyproject.toml
-        uses: anothrNick/github-tag-action@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          INITIAL_VERSION: 7.1.0
-          TAG_PREFIX: v
-          DEFAULT_BUMP: minor