Phase 1: settings validators + deep ring axis validation + persist axis defaults (#1280)

* phase1: validators, deep ring axis checks, and persist axis defaults

* fix: satisfy mypy for dataset_id URL refresh helper

* fix: make validate_settings typing compatible with python 3.8

* refactor: centralize axis field constants and typed dict contracts

* docs(changelog): record settings/axis validation + persist defaults work

* refactor(validate): centralize ring axis payload validators

* types(validate): add named url params/react settings aliases

* types(url_params): propagate named URLParamsDict across APIs

* feat(cypher): admit simple free-form intermediate MATCH (#1263) (#1279)

* feat(cypher/ir): add ReentryPlan.free_form marker for intermediate MATCH (#1263)

Adds a `free_form: bool = False` field to `ReentryPlan` so the runtime can
distinguish the LDBC SNB IC3 free-form intermediate MATCH shape from the
existing whole-row and scalar-only prefix shapes.

When the trailing MATCH after a prefix `WITH` introduces aliases none of
which is in the carried set, no carried alias anchors the seed pattern.
The runtime needs to broadcast carried columns onto the base node table
(single-prefix-row) or fall back to per-row union (multi-prefix-row) so
the trailing MATCH cross-joins implicitly via the row pipeline.

Default value preserves existing whole-row and scalar-only behavior.
Compile + runtime branches that consume this marker land in subsequent
commits.

Refs #1263 #999 #989

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* feat(cypher): admit free-form intermediate MATCH at compile (#1263)

Lifts the failfast at the trailing-MATCH-first-alias check in
``_compile_bounded_reentry_query`` for the free-form case (LDBC SNB IC3
endpoint): when the trailing MATCH binds aliases none of which is in the
prefix WITH's carried whole-row set, treat every carried alias as
non-source and use the trailing MATCH's first alias as the carrier label
for downstream rewrites.

The existing ``_collect_non_source_alias_property_refs`` /
``_rewrite_reentry_expr_to_hidden_properties`` machinery (slice 4.3a/b
from #1248) materializes carried-alias property references as hidden
columns; with this change the same machinery covers free-form cases by
passing all whole-row aliases as ``non_source_alias_names``.

The ``ReentryPlan`` constructed for free-form sets
``free_form=True`` (no ``CarriedAlias`` entry has
``is_reentry_alias=True``) so the runtime can branch into a broadcast
path. The runtime change lands in a follow-up commit; until then,
free-form queries compile but return wrong rows because the existing
``_compiled_query_reentry_state`` still seeds from the wrong alias's
node ids — the regression is gated by the failfast tests (which fail
intentionally at this commit and are retargeted alongside the runtime
commit).

Also tightens the surviving guard from ``first_alias is None or
first_alias != reentry_alias`` to ``first_alias is None`` since the
admit branch now sets ``reentry_alias = first_alias`` for the
previously-rejected case.

Refs #1263 #999 #989

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* feat(cypher): runtime broadcast for simple free-form + scoped failfast (#1263)

Lands the runtime half of the #1263 conservative admit:

* New ``_compiled_query_freeform_reentry_state`` in ``gfql_unified.py``
  branches on ``ReentryPlan.free_form``. For a single-row prefix WITH
  it broadcasts every ``__cypher_reentry_*`` hidden column from the
  prefix row onto every base node and returns ``start_nodes=None``, so
  the trailing MATCH runs as a regular MATCH and inherits the carried
  values via the row pipeline. Multi-row prefix raises a clear
  failfast pointing at the multi-row free-form follow-up slice.

* Compile gate added in ``_compile_bounded_reentry_query``: when
  ``free_form`` is True AND the trailing scope references any carried
  alias property (e.g. ``WHERE country.id IN [x.id, y.id]`` in literal
  IC3), raise a scoped ``#1263`` failfast pointing at the rewrite-order
  refactor follow-up. The double-rewrite that emerges from composing
  ``_demote_secondary_whole_row_aliases`` (#1071) with
  ``_rewrite_reentry_expr_to_hidden_properties`` (#1248) under
  free-form is deferred to its own focused slice.

End-to-end:
* Simple free-form (``MATCH (a) WITH a MATCH (c)-[:T]->(d) RETURN ...``)
  compiles + executes vectorized on pandas.
* IC3-shape with carried-property WHERE rejects with a scoped #1263
  failfast (clear error pointing at the follow-up).

Refs #1263 #999 #989

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* test(cypher): retarget free-form failfast tests for #1263 conservative admit

Two #1263 regression-locks added in #1270 expected the carried-alias gate to
fire for free-form intermediate MATCH. The conservative admit landed in the
preceding commits flips the simple shape from rejection to positive
execution and tightens the rejection scope to the carried-property variant:

* ``test_string_cypher_failfast_rejects_intermediate_reentry_match_with_no_carried_source``
  → renamed to ``..._with_carried_property_in_trailing_where`` and pinned to
  the new scoped #1263 failfast (carried-alias property in trailing scope).
* ``test_string_cypher_failfast_rejects_simple_freeform_intermediate_reentry_match``
  → renamed to ``test_string_cypher_executes_simple_freeform_intermediate_reentry_match``
  and converted to positive: asserts the trailing MATCH binds correctly
  against the broadcast carried row table.
* New ``..._on_cudf_when_available`` mirror with ``pytest.importorskip("cudf")``
  for engine parity per coordinator def-of-done.

Refs #1263 #999 #989

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* test(cypher): add multi-prefix-row free-form failfast regression (#1263)

Wave 1 review (single CONFIRMED IMPORTANT): the runtime failfast at
gfql_unified.py for multi-prefix-row free-form admit was untested. Adds a
positive regression-lock that builds a 2-row prefix and asserts the scoped
``single-row prefix WITH only`` failfast wording.

Refs #1263

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* docs(changelog): #1263 simple free-form intermediate MATCH admit

Records the conservative #1263 close: simple free-form admit + scoped
failfast for the carried-property-in-trailing-WHERE variant + runtime
broadcast helper + retargeted regression tests + three TCK admits.

Refs #1263 #999 #989

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* test(cypher): Wave 2 amplification — multi-carried + empty prefix free-form (#1263)

Wave 2 review per agents/skills/review/SKILL.md confirmed convergence
(two consecutive non-significant-advance waves) and surfaced two
amplification SUGGESTIONs that the reviewers verified produce correct
behavior. Locking the contract:

* test_string_cypher_executes_freeform_intermediate_reentry_match_with_multi_carried_aliases
  — covers `WITH a, b MATCH (c)-[:T]->(d)` shape (multi-carried-aliases admit).
* test_string_cypher_executes_freeform_intermediate_reentry_match_with_empty_prefix
  — covers `_compiled_query_freeform_reentry_state`'s empty-prefix
  early-return path.

Refs #1263

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: lmeyerov

CHANGELOG.md

@@ -28,6 +28,7 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 ### Added
 - **CI / Polars**: Added `test-polars` CI job (Python 3.9–3.14) with a dedicated `test-polars` lockfile profile; `polars` is now a named `setup.py` extra so the test matrix installs and exercises `test_polars.py` on every PR (#1133).
 - **Polars support**: `polars.DataFrame` and `polars.LazyFrame` now work in `plot()`, `materialize_nodes()`, `get_degrees()`, `get_indegrees()`, `get_outdegrees()`, and `hypergraph()`. Polars is an optional dependency — no behavior change when not installed. Upload path uses efficient Arrow conversion (`to_arrow()` with schema-metadata stripping and memoization); compute/hypergraph paths coerce to pandas at entry. `LazyFrame` is materialized via `.collect()` at each boundary. Adds `test_polars.py` with 17 tests; skips gracefully when polars is absent (#1133).
+- **Validation / settings + axis contracts (#1240, #1239, #1251)**: Added reusable public validation/settings contracts under `graphistry.validate` including `URL_PARAM_NAMES`/`REACT_SETTING_NAMES` (and set forms), `normalize_url_params()` / `normalize_react_settings()`, axis URL default contracts (`RADIAL_AXIS_URL_DEFAULTS`, `LINEAR_AXIS_URL_DEFAULTS`, `axis_url_defaults()`), and typed axis payload contracts (`AxisRow`, `AxisBounds`, `RingContinuousAxis`, `RingCategoricalAxis`, plus centralized allowed-field constants). GFQL call validation now deep-validates `ring_continuous_layout.axis` and `ring_categorical_layout.axis` against these contracts, and `gfql_remote(persist=True)` metadata hydration now round-trips and reapplies URL params/defaults correctly after server persistence.
 
 ### Internal
 - **GFQL / Cypher lowering — #1273 acceptance slice admits scalar multi-alias WITH shape A**: First-stage bounded reentry now admits `MATCH ... WITH a.id AS a_id, b.id AS b_id ... MATCH ...` multi-alias scalar/property projections (shape A) while keeping whole-row multi-alias carries (for example `WITH a, b`) outside the admitted lane. The admission gate is explicitly narrowed to scalar/property projections only, so known TCK xfail contract shape `WITH n, x` (`with-where3-3`) remains fail-fast and unchanged pending broader #1273 closure. Tests were converted to positive execution assertions for the admitted shape, and remaining rejected shapes continue to point explicitly to #1273.

graphistry/Plottable.py

@@ -19,6 +19,7 @@
 from graphistry.client_session import ClientSession, AuthManagerProtocol
 from graphistry.models.collections import CollectionsInput
 from graphistry.models.types import ValidationParam
+from graphistry.validate import URLParamsDict
 
 if TYPE_CHECKING:
     try:
@@ -83,7 +84,7 @@ class Plottable(Protocol):
     _point_latitude : Optional[str]
     _height : int
     _render : RenderModesConcrete
-    _url_params : dict
+    _url_params : URLParamsDict
     _privacy : Optional[Privacy]
     _name : Optional[str]
     _description : Optional[str]
@@ -780,8 +781,10 @@ def encode_axis(self, rows: List[Dict] = []) -> 'Plottable':
 
     def settings(self,
         height: Optional[int] = None,
-        url_params: Dict[str, Any] = {},
-        render: Optional[Union[bool, RenderModes]] = None
+        url_params: Optional[URLParamsDict] = None,
+        render: Optional[Union[bool, RenderModes]] = None,
+        validate: ValidationParam = 'autofix',
+        warn: bool = True
     ) -> 'Plottable':
         ...
 

graphistry/PlotterBase.py

@@ -4,6 +4,7 @@
 from graphistry.io.types import ComplexEncodingsDict
 from graphistry.models.collections import CollectionsInput
 from graphistry.models.types import ValidationMode, ValidationParam
+from graphistry.validate import URLParamsDict
 from graphistry.plugins_types.hypergraph import HypergraphResult
 from graphistry.render.resolve_render_mode import resolve_render_mode
 from graphistry.Engine import EngineAbstractType
@@ -227,7 +228,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
         # Settings
         self._height : int = 500
         self._render : RenderModesConcrete = resolve_render_mode(self, True)
-        self._url_params : dict = {'info': 'true'}
+        self._url_params : URLParamsDict = {'info': 'true'}
         self._privacy : Optional[Privacy] = None
         # Metadata
         self._name : Optional[str] = None
@@ -1883,7 +1884,14 @@ def graph(self, ig: Any) -> Plottable:
         return res
 
 
-    def settings(self, height=None, url_params={}, render=None):
+    def settings(
+        self,
+        height=None,
+        url_params: Optional[URLParamsDict] = None,
+        render=None,
+        validate: ValidationParam = 'autofix',
+        warn: bool = True
+    ):
         """Specify iframe height and add URL parameter dictionary.
 
         Collections URL params are normalized and URL-encoded at plot time; other
@@ -1898,11 +1906,19 @@ def settings(self, height=None, url_params={}, render=None):
         :param render: Whether to render the visualization using the native notebook environment (default True), or return the visualization URL
         :type render: bool
 
+        :param validate: Validation mode for url_params. 'autofix' (default) drops invalid keys/types with warnings; 'strict' raises.
+        :type validate: ValidationParam
+
+        :param warn: Whether to emit warnings in autofix mode.
+        :type warn: bool
+
         """
+        from graphistry.validate import normalize_url_params
 
         res = copy.copy(self)
         res._height = height or self._height
-        res._url_params = dict(self._url_params, **url_params)
+        normalized = normalize_url_params(url_params, validate=validate, warn=warn)
+        res._url_params = dict(self._url_params, **normalized)
         res._render = self._render if render is None else resolve_render_mode(self, render)
         return res
 

graphistry/client_session.py

@@ -6,6 +6,7 @@
 import warnings
 
 from graphistry.privacy import Privacy
+from graphistry.validate.validate_settings import URLParamsDict
 from . import util
 from .plugins_types.spanner_types import SpannerConfig
 from .plugins_types.kusto_types import KustoConfig
@@ -135,7 +136,7 @@ class AuthManagerProtocol(Protocol):
     def refresh(self, token: Optional[str] = None, fail_silent: bool = False) -> Optional[str]:
         ...
 
-    def _viz_url(self, info: DatasetInfo, url_params: Dict[str, Any]) -> str:
+    def _viz_url(self, info: DatasetInfo, url_params: URLParamsDict) -> str:
         ...
 
     def certificate_validation(self, value: Optional[bool] = None) -> bool:

graphistry/compute/chain_remote.py

@@ -92,6 +92,29 @@ def _compiled_to_let_json(compiled: CompiledQueryLike) -> Dict[str, Any]:
     return {"type": "Let", "bindings": bindings}
 
 
+def _refresh_url_from_dataset_id(g: Plottable) -> None:
+    dataset_id = getattr(g, "_dataset_id", None)
+    if not isinstance(dataset_id, str) or dataset_id == "":
+        return
+    info: DatasetInfo = {
+        "name": dataset_id,
+        "type": "arrow",
+        "viztoken": str(uuid.uuid4()),
+    }
+    g._url = g._pygraphistry._viz_url(info, g._url_params)
+
+
+def _apply_persist_axis_defaults(g: Plottable) -> None:
+    from graphistry.validate import apply_axis_url_defaults
+
+    merged = apply_axis_url_defaults(
+        getattr(g, "_url_params", None),
+        getattr(g, "_complex_encodings", None),
+    )
+    if isinstance(merged, dict):
+        g._url_params = merged
+
+
 def chain_remote_generic(
     self: Plottable,
     chain: Union[Chain, Dict[str, JSONVal], List[Any], 'ASTLet', str],
@@ -311,20 +334,17 @@ def chain_remote_generic(
 
                                 # Generate URL using existing infrastructure
                                 if result._dataset_id:  # Type guard
-                                    info: DatasetInfo = {
-                                        'name': result._dataset_id,
-                                        'type': 'arrow',
-                                        'viztoken': str(uuid.uuid4())
-                                    }
-
-                                    result._url = result._pygraphistry._viz_url(info, result._url_params)
+                                    _refresh_url_from_dataset_id(result)
 
                             # Optionally restore privacy settings
                             if 'privacy' in metadata:
                                 result._privacy = metadata['privacy']
 
                         if 'gfql_metadata' in metadata:
                             result = deserialize_plottable_metadata(metadata['gfql_metadata'], result)
+                            _apply_persist_axis_defaults(result)
+                            if persist:
+                                _refresh_url_from_dataset_id(result)
 
                     except Exception as e:
                         if persist:
@@ -390,20 +410,17 @@ def chain_remote_generic(
 
                 # Generate URL using existing infrastructure
                 if result._dataset_id:  # Type guard
-                    dataset_info: DatasetInfo = {
-                        'name': result._dataset_id,
-                        'type': 'arrow',
-                        'viztoken': str(uuid.uuid4())
-                    }
-
-                    result._url = result._pygraphistry._viz_url(dataset_info, result._url_params)
+                    _refresh_url_from_dataset_id(result)
             else:
                 warnings.warn("persist=True requested but server did not return dataset_id in JSON response. "
                             "URL generation will not be available. This indicates an older server version that doesn't support persistence.",
                             UserWarning, stacklevel=2)
 
         if 'metadata' in o:
             result = deserialize_plottable_metadata(o['metadata'], result)
+            _apply_persist_axis_defaults(result)
+            if persist:
+                _refresh_url_from_dataset_id(result)
 
         return result
     else:

graphistry/compute/gfql/call/validation.py

@@ -44,6 +44,10 @@
     is_unwind_expr,
     validate_hypergraph_opts,
 )
+from graphistry.validate import (
+    is_ring_categorical_axis_payload,
+    is_ring_continuous_axis_payload,
+)
 from graphistry.compute.gfql.row.order_expr import (
     is_order_aggregate_alias_ast,
     order_expr_ast_static_supported,
@@ -608,7 +612,7 @@ def _semi_apply_mark_added_node_cols(params: Dict[str, object]) -> Set[str]:
             'v_start': lambda v: v is None or is_int_or_float(v),
             'v_end': lambda v: v is None or is_int_or_float(v),
             'v_step': lambda v: v is None or is_int_or_float(v),
-            'axis': lambda v: v is None or is_list_or_dict(v),
+            'axis': lambda v: v is None or is_ring_continuous_axis_payload(v),
             'normalize_ring_col': is_bool,
             'reverse': is_bool,
             'play_ms': lambda v: v is None or is_int(v),
@@ -633,7 +637,7 @@ def _semi_apply_mark_added_node_cols(params: Dict[str, object]) -> Set[str]:
             'append_unhandled': is_bool,
             'min_r': lambda v: v is None or is_int_or_float(v),
             'max_r': lambda v: v is None or is_int_or_float(v),
-            'axis': lambda v: v is None or is_list_or_dict(v),
+            'axis': lambda v: v is None or is_ring_categorical_axis_payload(v),
             'reverse': is_bool,
             'play_ms': lambda v: v is None or is_int(v),
             'engine': lambda v: v is None or v in ('auto', 'pandas', 'cudf', 'dask', 'dask_cudf')

graphistry/io/metadata.py

@@ -9,6 +9,7 @@
 - encodings: simple (point_color, etc.) and complex encodings
 - metadata: name, description
 - style: visualization styles
+- url_params: viewer URL parameter defaults
 """
 from typing import Any, Dict, List, TYPE_CHECKING
 import copy
@@ -21,6 +22,7 @@
     NodeEdgeEncodingsDict,
     PlottableMetadata,
 )
+from graphistry.validate import URLParamsDict, normalize_url_params
 
 if TYPE_CHECKING:
     from graphistry.Plottable import Plottable
@@ -241,6 +243,10 @@ def serialize_plottable_metadata(g: 'Plottable') -> PlottableMetadata:
     style: Dict[str, Any] = {}
     if hasattr(g, '_style') and g._style:
         style = g._style
+    url_params: URLParamsDict = {}
+    if hasattr(g, "_url_params") and isinstance(g._url_params, dict):
+        # Keep serializer permissive and never raise from metadata export path.
+        url_params = normalize_url_params(g._url_params, validate="autofix", warn=False)
 
     result: PlottableMetadata = {}
     if bindings:
@@ -251,6 +257,8 @@ def serialize_plottable_metadata(g: 'Plottable') -> PlottableMetadata:
         result['metadata'] = metadata_obj
     if style:
         result['style'] = style
+    if url_params:
+        result['url_params'] = url_params
 
     return result
 
@@ -350,4 +358,13 @@ def deserialize_plottable_metadata(metadata: PlottableMetadata, g: 'Plottable')
         except Exception as e:
             warnings.warn(f"Failed to hydrate style from metadata: {e}", UserWarning, stacklevel=2)
 
+    if 'url_params' in metadata:
+        try:
+            url_params = metadata['url_params']
+            if isinstance(url_params, dict):
+                res = copy.copy(res)
+                res._url_params = normalize_url_params(url_params, validate="autofix", warn=False)
+        except Exception as e:
+            warnings.warn(f"Failed to hydrate url_params from metadata: {e}", UserWarning, stacklevel=2)
+
     return res

graphistry/io/types.py

@@ -6,6 +6,8 @@
 """
 from typing import Any, Dict, TypedDict
 
+from graphistry.validate import URLParamsDict
+
 
 # Complex Encodings Structure
 class ComplexEncodingModes(TypedDict):
@@ -116,6 +118,7 @@ class PlottableMetadata(TypedDict, total=False):
     :field encodings: Visual encoding mappings (colors, sizes, labels, complex)
     :field metadata: Graph metadata (name, description)
     :field style: Visualization styles (background, layout, etc.)
+    :field url_params: Visualization URL parameter defaults
 
     **Example**
 
@@ -144,3 +147,4 @@ class PlottableMetadata(TypedDict, total=False):
     encodings: EncodingsDict
     metadata: MetadataDict
     style: Dict[str, Any]
+    url_params: URLParamsDict

graphistry/pygraphistry.py

@@ -8,6 +8,7 @@
 from graphistry.Engine import EngineAbstractType
 from graphistry.models.collections import CollectionsInput
 from graphistry.models.types import ValidationParam
+from graphistry.validate import URLParamsDict
 from graphistry.otel import inject_trace_headers, otel as otel_config
 
 """Top-level import of class PyGraphistry as "Graphistry". Used to connect to the Graphistry server and then create a base plotter."""
@@ -2374,9 +2375,16 @@ def from_cugraph(self,
     ):
         return self._plotter().from_cugraph(G, node_attributes, edge_attributes, load_nodes, load_edges, merge_if_existing)
 
-    def settings(self, height=None, url_params={}, render=None):
+    def settings(
+        self,
+        height=None,
+        url_params: Optional[URLParamsDict] = None,
+        render=None,
+        validate: ValidationParam = 'autofix',
+        warn: bool = True,
+    ):
 
-        return self._plotter().settings(height, url_params, render)
+        return self._plotter().settings(height, url_params, render, validate=validate, warn=warn)
 
     def collections(
         self,
@@ -2396,7 +2404,7 @@ def collections(
             warn=warn
         )
 
-    def _viz_url(self, info: DatasetInfo, url_params: Dict[str, Any]) -> str:
+    def _viz_url(self, info: DatasetInfo, url_params: URLParamsDict) -> str:
         splash_time = int(calendar.timegm(time.gmtime())) + 15
         extra = "&".join([k + "=" + str(v) for k, v in list(url_params.items())])
         cph = self.client_protocol_hostname()

graphistry/tests/compute/test_gfql_call_validation.py

@@ -386,5 +386,53 @@ def test_call_helper_validates_params(self):
             call_obj.validate()
 
 
+class TestRingAxisValidation:
+    """Deep axis payload validation for ring layout calls."""
+
+    def test_ring_categorical_axis_label_map_valid(self):
+        params = validate_call_params('ring_categorical_layout', {
+            'ring_col': 'segment',
+            'axis': {'a': 'A', 'b': 'B'},
+        })
+        assert params['axis'] == {'a': 'A', 'b': 'B'}
+
+    def test_ring_categorical_axis_rows_valid(self):
+        params = validate_call_params('ring_categorical_layout', {
+            'ring_col': 'segment',
+            'axis': [{'r': 200, 'label': 'outer', 'external': True}],
+        })
+        assert isinstance(params['axis'], list)
+
+    def test_ring_categorical_axis_rejects_invalid_rows(self):
+        with pytest.raises(GFQLTypeError) as exc_info:
+            validate_call_params('ring_categorical_layout', {
+                'ring_col': 'segment',
+                'axis': [{'label': 'missing_pos'}],
+            })
+        assert 'axis' in exc_info.value.message
+
+    def test_ring_continuous_axis_accepts_string_labels(self):
+        params = validate_call_params('ring_continuous_layout', {
+            'ring_col': 'score',
+            'axis': ['low', 'mid', 'high'],
+        })
+        assert params['axis'] == ['low', 'mid', 'high']
+
+    def test_ring_continuous_axis_accepts_numeric_map(self):
+        params = validate_call_params('ring_continuous_layout', {
+            'ring_col': 'score',
+            'axis': {100.0: 'inner', 200.0: 'outer'},
+        })
+        assert isinstance(params['axis'], dict)
+
+    def test_ring_continuous_axis_rejects_bad_bounds(self):
+        with pytest.raises(GFQLTypeError) as exc_info:
+            validate_call_params('ring_continuous_layout', {
+                'ring_col': 'score',
+                'axis': [{'y': 40, 'bounds': {'min': '40', 'max': 100}}],
+            })
+        assert 'axis' in exc_info.value.message
+
+
 if __name__ == '__main__':
     pytest.main([__file__, '-v', '--tb=short'])