model2data 1.10.0__tar.gz → 1.10.1__tar.gz

{model2data-1.10.0/model2data.egg-info → model2data-1.10.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model2data
-Version: 1.10.0
+Version: 1.10.1
 Summary: Generate analytics-ready datasets from DBML models
 Author: JB Analytica
 License-Expression: MIT

{model2data-1.10.0 → model2data-1.10.1}/README.md

@@ -217,19 +217,19 @@ jobs:
   validate:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
       - uses: JB-Analytica/model2data@v1
 ```
 
 Inputs: `files` (glob, default `**/*.model2data.yml`), `version` (default: the release the tag
-points at, e.g. `1.10.0`; a specifier such as `>=1.10,<2` also works), `python-version` (3.12).
+points at, e.g. `1.10.1`; a specifier such as `>=1.10,<2` also works), `python-version` (3.12).
 
 **pre-commit**
 
 ```yaml
 repos:
   - repo: https://github.com/JB-Analytica/model2data
-    rev: v1.10.0
+    rev: v1.10.1
     hooks:
       - id: model2data-validate
 ```
@@ -243,7 +243,7 @@ model2data:
     - if: $CI_PIPELINE_SOURCE == "merge_request_event"
       changes: ["**/*.model2data.yml"]
   script:
-    - pip install model2data==1.10.0
+    - pip install model2data==1.10.1
     - model2data validate --glob "**/*.model2data.yml"
 ```
 

{model2data-1.10.0 → model2data-1.10.1}/model2data/cli.py

@@ -843,10 +843,13 @@ def validate_command(
                 f"✅ {file if len(targets) > 1 else file.name} conforms to spec {_spec_of(file)}."
             )
     if len(targets) > 1 or output_format == "github":
-        checked = f"{len(targets)} model file{'s' if len(targets) != 1 else ''}"
-        typer.echo(
-            f"❌ {failed} of {checked} do not conform." if failed else f"✅ {checked} conform."
-        )
+        count = len(targets)
+        checked = f"{count} model file{'s' if count != 1 else ''}"
+        if failed:
+            verb = "does" if failed == 1 else "do"
+            typer.echo(f"❌ {failed} of {checked} {verb} not conform.")
+        else:
+            typer.echo(f"✅ {checked} {'conforms' if count == 1 else 'conform'}.")
     if failed:
         raise typer.Exit(1)
 

{model2data-1.10.0 → model2data-1.10.1}/model2data/model/_yaml.py

@@ -23,6 +23,7 @@ from __future__ import annotations
 
 import math
 import re
+from dataclasses import replace
 from typing import Any
 
 import yaml
@@ -160,6 +161,71 @@ def _check_mappings(node: Node, path: list[PathPart], issues: list[Issue]) -> No
             _check_mappings(item, [*path, index], issues)
 
 
+def locate_issues(text: str, issues: list[Issue]) -> list[Issue]:
+    """`issues` with a `line` on each one that has none, from where its path sits in `text`.
+
+    `text` is a YAML (or JSON) document; it is composed once, with the profile's
+    own loader so the node tree is the one `parse_yaml` read, and each issue's
+    dotted path is walked down it. A path that stops resolving (a key that is
+    missing, say) takes the line of the deepest node that did. Text that does
+    not compose leaves the issues as they are.
+    """
+    if not any(issue.line is None and issue.path for issue in issues):
+        return issues
+    loader = _CoreLoader(text)
+    try:
+        root = loader.get_single_node()
+    except Exception:
+        return issues
+    finally:
+        loader.dispose()
+    if root is None:
+        return issues
+    located = []
+    for issue in issues:
+        if issue.line is None and issue.path:
+            line = _line_of_path(root, issue.path)
+            if line is not None:
+                issue = replace(issue, line=line)
+        located.append(issue)
+    return located
+
+
+def _line_of_path(root: Node, path: str) -> int | None:
+    """The line of the deepest node `path` reaches, or None if it reaches only the root."""
+    node = root
+    rest = path
+    line: int | None = None
+    while rest:
+        if isinstance(node, MappingNode):
+            best: tuple[Node, Node] | None = None
+            best_len = 0
+            for key_node, value_node in node.value:
+                key = _key_text(key_node)
+                if not isinstance(key, str) or not key or len(key) <= best_len:
+                    continue
+                if rest == key or rest.startswith(key + "."):
+                    best, best_len = (key_node, value_node), len(key)
+            if best is None:
+                break
+            line = best[0].start_mark.line + 1
+            node = best[1]
+            rest = rest[best_len + 1 :]
+        elif isinstance(node, SequenceNode):
+            match = re.match(r"^(?:\[(\d+)\]|(\d+))(?:\.|$)", rest)
+            if match is None:
+                break
+            index = int(match.group(1) or match.group(2))
+            if index >= len(node.value):
+                break
+            node = node.value[index]
+            line = node.start_mark.line + 1
+            rest = rest[match.end() :]
+        else:
+            break
+    return line
+
+
 def parse_yaml(text: str) -> Any:
     """Read one YAML document under the spec's profile, or raise `ModelError`."""
     loader = _CoreLoader(text)

{model2data-1.10.0 → model2data-1.10.1}/model2data/model/reader.py

@@ -7,7 +7,7 @@ import os
 from pathlib import Path
 from typing import Literal, Optional, Union
 
-from model2data.model._yaml import parse_yaml
+from model2data.model._yaml import locate_issues, parse_yaml
 from model2data.model.document import from_dict
 from model2data.model.errors import Issue, ModelError
 from model2data.model.types import Model
@@ -78,9 +78,16 @@ def load(source: Source, *, format: Optional[Format] = None) -> Model:
         from model2data.model.dbml import from_dbml
 
         return from_dbml(text)
-    if format == "json":
-        return from_dict(_parse_json(text))
-    return from_dict(parse_yaml(text))
+    document = _parse_json(text) if format == "json" else parse_yaml(text)
+    try:
+        model = from_dict(document)
+    except ModelError as error:
+        # One composition of the text, however many issues: each gets its line.
+        raise ModelError(
+            locate_issues(text, error.issues), locate_issues(text, error.warnings)
+        ) from None
+    model.warnings = locate_issues(text, model.warnings)
+    return model
 
 
 def _parse_json(text: str):

{model2data-1.10.0 → model2data-1.10.1/model2data.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model2data
-Version: 1.10.0
+Version: 1.10.1
 Summary: Generate analytics-ready datasets from DBML models
 Author: JB Analytica
 License-Expression: MIT

{model2data-1.10.0 → model2data-1.10.1}/model2data.egg-info/SOURCES.txt

@@ -140,6 +140,7 @@ tests/test_faker_name_inference.py
 tests/test_generation.py
 tests/test_hint_tests.py
 tests/test_history.py
+tests/test_issue_lines.py
 tests/test_lone_country.py
 tests/test_model.py
 tests/test_model_dbml.py

{model2data-1.10.0 → model2data-1.10.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "model2data"
-version = "1.10.0"
+version = "1.10.1"
 description = "Generate analytics-ready datasets from DBML models"
 readme = "README_PYPI.md"
 requires-python = ">=3.10"

{model2data-1.10.0 → model2data-1.10.1}/tests/test_cli_model.py

@@ -187,8 +187,8 @@ def test_validate_prints_every_issue_with_its_path_and_exits_1(tmp_path):
     result = runner.invoke(app, ["validate", str(model)])
     assert result.exit_code == 1
     assert "❌ m.model2data.yml: 2 errors" in result.output
-    assert "  - tables.orders.columns.customer_id.nul: unknown key" in result.output
-    assert "  - run.rows: must be 1 or more (got 0)" in result.output
+    assert "  - tables.orders.columns.customer_id.nul (line 16): unknown key" in result.output
+    assert "  - run.rows (line 21): must be 1 or more (got 0)" in result.output
 
 
 def test_validate_exits_0_on_warnings_alone(tmp_path):
@@ -270,8 +270,8 @@ def test_validate_several_files_one_invalid_exits_1_with_path_prefixed_issues(tm
     result = runner.invoke(app, ["validate", str(good), str(bad)])
     assert result.exit_code == 1
     assert f"❌ {bad}: 1 error" in result.output
-    assert "  - run.rows: must be 1 or more (got 0)" in result.output
-    assert "❌ 1 of 2 model files do not conform." in result.output
+    assert "  - run.rows (line 21): must be 1 or more (got 0)" in result.output
+    assert "❌ 1 of 2 model files does not conform." in result.output
 
 
 def test_validate_glob_matches_nested_files(tmp_path, monkeypatch):
@@ -304,7 +304,10 @@ def test_validate_format_github_prints_annotations(tmp_path, monkeypatch):
     monkeypatch.chdir(tmp_path)
     result = runner.invoke(app, ["validate", "bad.model2data.yml", "--format", "github"])
     assert result.exit_code == 1
-    assert "::error file=bad.model2data.yml::run.rows: must be 1 or more (got 0)" in result.output
+    assert (
+        "::error file=bad.model2data.yml,line=21::run.rows: must be 1 or more (got 0)"
+        in result.output
+    )
     yaml_error = _write(tmp_path, "dup.model2data.yml", MODEL + "name: again\n")
     result = runner.invoke(app, ["validate", yaml_error.name, "--format", "github"])
     assert "::error file=dup.model2data.yml,line=25::" in result.output
@@ -338,3 +341,40 @@ def test_ci_integration_files_run_the_validate_command():
     assert hooks[0]["entry"] == "model2data validate"
     assert hooks[0]["language"] == "python"
     assert hooks[0]["pass_filenames"] is True
+
+
+def test_validate_format_github_puts_the_line_on_a_value_issue(tmp_path, monkeypatch):
+    _write(
+        tmp_path,
+        "m.model2data.yml",
+        MODEL.replace("pk: true}\n      email", "pk: maybe}\n      email"),
+    )
+    monkeypatch.chdir(tmp_path)
+    result = runner.invoke(app, ["validate", "m.model2data.yml", "--format", "github"])
+    assert result.exit_code == 1
+    assert (
+        "::error file=m.model2data.yml,line=10::tables.customers.columns.id.pk: "
+        'must be true or false, not the string "maybe"'
+    ) in result.output
+
+
+def test_validate_summary_agrees_with_its_count(tmp_path):
+    good = _write(tmp_path, "good.model2data.yml", MODEL)
+    bad = _broken(tmp_path)
+    one_good = runner.invoke(app, ["validate", str(good), "--format", "github"])
+    assert "✅ 1 model file conforms." in one_good.output
+    one_bad = runner.invoke(app, ["validate", str(bad), "--format", "github"])
+    assert "❌ 1 of 1 model file does not conform." in one_bad.output
+    mixed = runner.invoke(app, ["validate", str(good), str(bad)])
+    assert "❌ 1 of 2 model files does not conform." in mixed.output
+    both = runner.invoke(app, ["validate", str(bad), str(_broken(tmp_path, "b2.model2data.yml"))])
+    assert "❌ 2 of 2 model files do not conform." in both.output
+
+
+def test_action_uses_setup_python_v6():
+    import yaml
+
+    root = Path(__file__).resolve().parent.parent
+    action = yaml.safe_load((root / "action.yml").read_text())
+    uses = [step.get("uses") for step in action["runs"]["steps"]]
+    assert "actions/setup-python@v6" in uses

model2data-1.10.1/tests/test_issue_lines.py

@@ -0,0 +1,87 @@
+"""Validation issues carry the line of the node their path points at."""
+
+from model2data.model import Issue, validate
+from model2data.model._yaml import _CoreLoader, _line_of_path, locate_issues
+
+DOC = """\
+model2data: 0.2.0
+name: shop
+tables:
+  raw.users:
+    columns:
+      id: {type: bigint, pk: true}
+      email: {type: email, bogus: 1}
+  orders:
+    columns:
+      id: {type: bigint, pk: maybe}
+    keys:
+      - unique: [id]
+      - unique: 5
+"""
+
+
+def _line(path, text=DOC):
+    loader = _CoreLoader(text)
+    try:
+        return _line_of_path(loader.get_single_node(), path)
+    finally:
+        loader.dispose()
+
+
+def test_a_simple_path_resolves_to_its_key_line():
+    assert _line("tables.orders.columns.id.pk") == 10
+    assert _line("name") == 2
+
+
+def test_a_table_name_with_a_dot_resolves_by_longest_key():
+    assert _line("tables.raw.users.columns.email") == 7
+
+
+def test_a_sequence_index_resolves_in_either_spelling():
+    assert _line("tables.orders.keys.1") == 13
+    assert _line("tables.orders.keys.[1]") == 13
+    assert _line("tables.orders.keys.1.unique") == 13
+
+
+def test_an_unresolvable_tail_falls_back_to_the_deepest_node():
+    assert _line("tables.orders.columns.nope.type") == 9
+    assert _line("tables.orders.keys.9") == 11
+    assert _line("nothing.at.all") is None
+    assert _line("") is None
+
+
+def test_validate_gives_issues_their_lines():
+    issues = validate(DOC)
+    by_path = {issue.path: issue for issue in issues}
+    assert by_path["tables.raw.users.columns.email.bogus"].line == 7
+    assert by_path["tables.orders.columns.id.pk"].line == 10
+    assert "(line 10)" in str(by_path["tables.orders.columns.id.pk"])
+
+
+def test_json_issues_get_lines_too():
+    text = '{\n  "model2data": "0.2.0",\n  "name": "m",\n  "tables": {\n    "t": {"columns": {"id": {"type": "bigint", "pk": "maybe"}}}\n  }\n}'
+    issues = validate(text)
+    assert [issue.line for issue in issues] == [5]
+
+
+def test_dbml_issues_keep_no_line():
+    assert all(issue.line is None for issue in validate("Table t { id int }\n", format="dbml"))
+
+
+def test_a_sequence_followed_by_a_name_stops_at_the_sequence():
+    # `keys` is a list: a path that names a key inside it cannot be followed.
+    assert _line("tables.orders.keys.unique") == 11
+
+
+def test_a_path_past_a_plain_value_stops_at_that_value():
+    assert _line("name.first") == 2
+
+
+def test_text_that_does_not_compose_leaves_the_issues_as_they_were():
+    issue = Issue("tables", "broken")
+    assert locate_issues("a: [unclosed", [issue]) == [issue]
+
+
+def test_an_empty_document_leaves_the_issues_as_they_were():
+    issue = Issue("tables", "missing")
+    assert locate_issues("", [issue]) == [issue]

{model2data-1.10.0 → model2data-1.10.1}/tests/test_model.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import copy
 import json
+from dataclasses import replace
 from pathlib import Path
 
 import pytest
@@ -350,7 +351,8 @@ def test_2_foreign_key_columns_pair_up():
         "are drawn from the ones it holds, but a parent of one row per value needs them to be "
         "its primary key, one of its keys, or a unique column",
     ]
-    assert [str(issue) for issue in validate(json.dumps(document))][1:] == [
+    # `validate` on text adds the line each issue sits on; `from_dict` has no text.
+    assert [str(replace(issue, line=None)) for issue in validate(json.dumps(document))][1:] == [
         str(issue) for issue in raised.value.warnings
     ]