feed dvc-render updates into API output

Author: mattseddon

dvc/render/__init__.py

@@ -3,6 +3,6 @@
 FILENAME_FIELD = "filename"
 FIELD_FIELD = "field"
 REVISIONS_KEY = "revisions"
-ANCHORS_Y_DEFN = "anchors_y_defn"
+ANCHOR_DEFINITIONS = "anchor_definitions"
 TYPE_KEY = "type"
 SRC_FIELD = "src"

dvc/render/convert.py

@@ -1,12 +1,6 @@
 from typing import Dict, List, Union
 
-from dvc.render import (
-    ANCHORS_Y_DEFN,
-    REVISION_FIELD,
-    REVISIONS_KEY,
-    SRC_FIELD,
-    TYPE_KEY,
-)
+from dvc.render import REVISION_FIELD, REVISIONS_KEY, SRC_FIELD, TYPE_KEY
 from dvc.render.converter.image import ImageConverter
 from dvc.render.converter.vega import VegaConverter
 
@@ -28,20 +22,19 @@ def to_json(renderer, split: bool = False) -> List[Dict]:
     if renderer.TYPE == "vega":
         if not renderer.datapoints:
             return []
+        revs = renderer.get_revs()
         if split:
-            content = renderer.get_filled_template(
-                skip_anchors=["data"], as_string=False
-            )
+            content, split_content = renderer.get_partial_filled_template()
         else:
             content = renderer.get_filled_template(as_string=False)
+            split_content = {}
 
         return [
             {
-                ANCHORS_Y_DEFN: renderer.properties.get("anchors_y_defn", {}),
                 TYPE_KEY: renderer.TYPE,
-                REVISIONS_KEY: renderer.properties.get("anchor_revs", []),
+                REVISIONS_KEY: revs,
                 "content": content,
-                "datapoints": renderer.datapoints,
+                **split_content,
             }
         ]
     if renderer.TYPE == "image":

pyproject.toml

@@ -29,14 +29,15 @@ classifiers = [
     "Programming Language :: Python :: 3.11",
 ]
 dynamic = ["version"]
+
 dependencies = [
     "colorama>=0.3.9",
     "configobj>=5.0.6",
     "distro>=1.3",
     "dpath<3,>=2.1.0",
     "dvc-data>=2.16.3,<2.17.0",
     "dvc-http>=2.29.0",
-    "dvc-render>=0.3.1,<1",
+    "dvc-render@git+https://github.com/iterative/dvc-render@refs/pull/142/head",
     "dvc-studio-client>=0.9.2,<1",
     "dvc-task>=0.3.0,<1",
     "flatten_dict<1,>=0.4.1",

tests/integration/plots/test_plots.py

@@ -111,22 +111,26 @@ def verify_vega(
         assert j[0]["type"] == "vega"
         assert set(j[0]["revisions"]) == set(versions)
 
-    assert json_result[0]["datapoints"] == split_json_result[0]["datapoints"]
+    assert (
+        json_result[0]["content"]["data"]["values"]
+        == split_json_result[0]["anchor_definitions"]["<DVC_METRIC_DATA>"]
+    )
     assert set(versions) == set(json_result[0]["revisions"])
 
     assert json_result[0]["content"]["data"]["values"]
     assert html_result["data"]["values"]
-    assert split_json_result[0]["content"]["data"]["values"] == "<DVC_METRIC_DATA>"
+    assert "<DVC_METRIC_DATA>" in split_json_result[0]["content"]
 
     def _assert_templates_equal(html_template, filled_template, split_template):
-        # besides data, json and split json should be equal
-        path = ["data", "values"]
+        # besides split anchors, json and split json should be equal
+        paths = [["data", "values"], ["encoding", "color"]]
         tmp1 = deepcopy(html_template)
         tmp2 = deepcopy(filled_template)
-        tmp3 = deepcopy(split_template)
-        dpath.set(tmp1, path, {})
-        dpath.set(tmp2, path, {})
-        dpath.set(tmp3, path, {})
+        tmp3 = deepcopy(json.loads(split_template))
+        for path in paths:
+            dpath.set(tmp1, path, {})
+            dpath.set(tmp2, path, {})
+            dpath.set(tmp3, path, {})
 
         assert tmp1 == tmp2 == tmp3
 
@@ -194,16 +198,12 @@ def test_repo_with_plots(tmp_dir, scm, dvc, capsys, run_copy_metrics, repo_with_
         linear_v1,
         {
             "rev": "workspace",
-            "filename": "linear.json",
-            "field": "y",
         },
     )
     assert html_result["linear.json"]["data"]["values"] == _update_datapoints(
         linear_v1,
         {
             REVISION_FIELD: "workspace",
-            "filename": "linear.json",
-            "field": "y",
         },
     )
     assert json_data["confusion.json"][0]["content"]["data"][
@@ -278,30 +278,22 @@ def test_repo_with_plots(tmp_dir, scm, dvc, capsys, run_copy_metrics, repo_with_
             linear_v2,
             {
                 "rev": "workspace",
-                "filename": "../linear.json",
-                "field": "y",
             },
         ) + _update_datapoints(
             linear_v1,
             {
                 "rev": "HEAD",
-                "filename": "../linear.json",
-                "field": "y",
             },
         )
         assert html_result["../linear.json"]["data"]["values"] == _update_datapoints(
             linear_v2,
             {
                 REVISION_FIELD: "workspace",
-                "filename": "../linear.json",
-                "field": "y",
             },
         ) + _update_datapoints(
             linear_v1,
             {
                 REVISION_FIELD: "HEAD",
-                "filename": "../linear.json",
-                "field": "y",
             },
         )
         assert json_data["../confusion.json"][0]["content"]["data"][
@@ -434,7 +426,7 @@ def test_repo_with_config_plots(tmp_dir, capsys, repo_with_config_plots):
     repo_state = repo_with_config_plots()
     plots = next(repo_state)
 
-    html_path, json_result, __ = call(capsys)
+    html_path, _, split_json_result = call(capsys)
 
     assert os.path.exists(html_path)
     html_result = extract_vega_specs(
@@ -450,19 +442,22 @@ def test_repo_with_config_plots(tmp_dir, capsys, repo_with_config_plots):
         {
             "rev": "workspace",
             "filename": "linear_train.json",
-            "field": "y",
         },
     ) + _update_datapoints(
         plots["data"]["linear_test.json"],
         {
             "rev": "workspace",
             "filename": "linear_test.json",
-            "field": "y",
         },
     )
 
     assert html_result["linear_train_vs_test"]["data"]["values"] == ble
-    # TODO check json results once vscode is able to handle flexible plots
+    assert (
+        split_json_result["data"]["linear_train_vs_test"][0]["anchor_definitions"][
+            "<DVC_METRIC_DATA>"
+        ]
+        == ble
+    )
 
 
 @pytest.mark.vscode

tests/unit/render/test_convert.py

@@ -1,5 +1,9 @@
+import json
+
+import pytest
+
 from dvc.render import (
-    ANCHORS_Y_DEFN,
+    ANCHOR_DEFINITIONS,
     REVISION_FIELD,
     REVISIONS_KEY,
     SRC_FIELD,
@@ -11,95 +15,67 @@
 def test_to_json_vega(mocker):
     vega_renderer = mocker.MagicMock()
     vega_renderer.TYPE = "vega"
-    vega_renderer.properties = {
-        ANCHORS_Y_DEFN: [{"filename": "foo.json", "field": "y"}],
-        "anchor_revs": ["bar", "foo"],
-    }
+    vega_renderer.get_revs.return_value = ["bar", "foo"]
     vega_renderer.get_filled_template.return_value = {"this": "is vega"}
-    vega_renderer.datapoints = [
-        {
-            "x": 1,
-            "y": 2,
-            "rev": "foo",
-            "filename": "foo.json",
-        },
-        {
-            "x": 2,
-            "y": 1,
-            "rev": "bar",
-            "filename": "foo.json",
-        },
-    ]
     result = to_json(vega_renderer)
     assert result[0] == {
-        ANCHORS_Y_DEFN: [{"filename": "foo.json", "field": "y"}],
         TYPE_KEY: vega_renderer.TYPE,
         REVISIONS_KEY: ["bar", "foo"],
         "content": {"this": "is vega"},
-        "datapoints": [
-            {
-                "x": 1,
-                "y": 2,
-                "filename": "foo.json",
-                "rev": "foo",
-            },
-            {
-                "x": 2,
-                "y": 1,
-                "filename": "foo.json",
-                "rev": "bar",
-            },
-        ],
     }
     vega_renderer.get_filled_template.assert_called()
 
 
+@pytest.mark.vscode
 def test_to_json_vega_split(mocker):
-    vega_renderer = mocker.MagicMock()
-    vega_renderer.TYPE = "vega"
-    vega_renderer.get_filled_template.return_value = {"this": "is split vega"}
-    vega_renderer.properties = {
-        ANCHORS_Y_DEFN: [{"filename": "foo.json", "field": "y"}],
-        "anchor_revs": ["bar", "foo"],
-    }
-    vega_renderer.datapoints = [
-        {
-            "x": 1,
-            "y": 2,
-            "rev": "foo",
-            "filename": "foo.json",
-        },
+    revs = ["bar", "foo"]
+    content = json.dumps(
         {
-            "x": 2,
-            "y": 1,
-            "rev": "bar",
-            "filename": "foo.json",
+            "this": "is split vega",
+            "encoding": {"color": "<DVC_METRIC_COLOR>"},
+            "data": {"values": "<DVC_METRIC_DATA>"},
+        }
+    )
+    anchor_definitions = {
+        "<DVC_METRIC_COLOR>": {
+            "field": "rev",
+            "scale": {
+                "domain": revs,
+                "range": ["#ff0000", "#00ff00"],
+            },
         },
-    ]
-    result = to_json(vega_renderer, split=True)
-    assert result[0] == {
-        ANCHORS_Y_DEFN: [{"filename": "foo.json", "field": "y"}],
-        TYPE_KEY: vega_renderer.TYPE,
-        REVISIONS_KEY: ["bar", "foo"],
-        "content": {"this": "is split vega"},
-        "datapoints": [
+        "<DVC_METRIC_DATA>": [
             {
                 "x": 1,
                 "y": 2,
-                "filename": "foo.json",
                 "rev": "foo",
+                "filename": "foo.json",
             },
             {
                 "x": 2,
                 "y": 1,
-                "filename": "foo.json",
                 "rev": "bar",
+                "filename": "foo.json",
             },
         ],
     }
-    vega_renderer.get_filled_template.assert_called_with(
-        as_string=False, skip_anchors=["data"]
+
+    vega_renderer = mocker.MagicMock()
+    vega_renderer.TYPE = "vega"
+    vega_renderer.get_partial_filled_template.return_value = (
+        content,
+        {ANCHOR_DEFINITIONS: anchor_definitions},
     )
+    vega_renderer.get_revs.return_value = ["bar", "foo"]
+
+    result = to_json(vega_renderer, split=True)
+    assert result[0] == {
+        ANCHOR_DEFINITIONS: anchor_definitions,
+        TYPE_KEY: vega_renderer.TYPE,
+        REVISIONS_KEY: revs,
+        "content": content,
+    }
+    vega_renderer.get_partial_filled_template.assert_called_once()
 
 
 def test_to_json_image(mocker):