# SPDX-License-Identifier: BSD-3-Clause
+import pytest
+
def test_module_import():
import easydiffraction.crystallography.crystallography as MUT
@@ -23,3 +25,61 @@ def test_symmetry_operators_falls_back_to_identity_for_unlisted_group():
rotation, translation = ops[0]
assert np.array_equal(rotation, np.eye(3, dtype=int))
assert np.array_equal(translation, np.zeros(3))
+
+
+def test_reciprocal_cell_lengths_orthorhombic():
+ from easydiffraction.crystallography.crystallography import reciprocal_cell_lengths
+
+ # For 90-degree angles the reciprocal edges are simply 1/a, 1/b, 1/c.
+ a_star, b_star, c_star = reciprocal_cell_lengths(5.0, 6.0, 8.0, 90.0, 90.0, 90.0)
+
+ assert a_star == pytest.approx(1.0 / 5.0)
+ assert b_star == pytest.approx(1.0 / 6.0)
+ assert c_star == pytest.approx(1.0 / 8.0)
+
+
+def test_reciprocal_cell_lengths_cubic_isotropic():
+ from easydiffraction.crystallography.crystallography import reciprocal_cell_lengths
+
+ a_star, b_star, c_star = reciprocal_cell_lengths(10.13, 10.13, 10.13, 90.0, 90.0, 90.0)
+
+ assert a_star == pytest.approx(1.0 / 10.13)
+ assert a_star == pytest.approx(b_star)
+ assert b_star == pytest.approx(c_star)
+
+
+def test_reciprocal_cell_lengths_monoclinic_matches_volume_formula():
+ import numpy as np
+
+ from easydiffraction.crystallography.crystallography import reciprocal_cell_lengths
+
+ a, b, c, alpha, beta, gamma = 5.0, 6.0, 7.0, 90.0, 100.0, 90.0
+ a_star, b_star, c_star = reciprocal_cell_lengths(a, b, c, alpha, beta, gamma)
+
+ # a* = b*c*sin(alpha) / V, with V the direct-cell volume.
+ al, be, ga = np.radians([alpha, beta, gamma])
+ omega = np.sqrt(
+ 1.0
+ - np.cos(al) ** 2
+ - np.cos(be) ** 2
+ - np.cos(ga) ** 2
+ + 2.0 * np.cos(al) * np.cos(be) * np.cos(ga)
+ )
+ volume = a * b * c * omega
+ assert a_star == pytest.approx(b * c * np.sin(al) / volume)
+ assert b_star == pytest.approx(a * c * np.sin(be) / volume)
+ assert c_star == pytest.approx(a * b * np.sin(ga) / volume)
+
+
+def test_reciprocal_cell_lengths_rejects_non_positive_edge():
+ from easydiffraction.crystallography.crystallography import reciprocal_cell_lengths
+
+ with pytest.raises(ValueError, match='Non-positive cell edge'):
+ reciprocal_cell_lengths(0.0, 6.0, 8.0, 90.0, 90.0, 90.0)
+
+
+def test_reciprocal_cell_lengths_rejects_degenerate_angles():
+ from easydiffraction.crystallography.crystallography import reciprocal_cell_lengths
+
+ with pytest.raises(ValueError, match='Degenerate cell angles'):
+ reciprocal_cell_lengths(5.0, 6.0, 8.0, 150.0, 150.0, 150.0)
diff --git a/tests/unit/easydiffraction/datablocks/structure/categories/test_atom_site_aniso.py b/tests/unit/easydiffraction/datablocks/structure/categories/test_atom_site_aniso.py
index 383c6e429..8e30cd548 100644
--- a/tests/unit/easydiffraction/datablocks/structure/categories/test_atom_site_aniso.py
+++ b/tests/unit/easydiffraction/datablocks/structure/categories/test_atom_site_aniso.py
@@ -4,6 +4,8 @@
import math
+import pytest
+
# ------------------------------------------------------------------
# Module import
# ------------------------------------------------------------------
@@ -495,3 +497,65 @@ def test_adp_iso_not_free_when_aniso(self):
structure.atom_sites['Si'].adp_type = 'Bani'
structure.atom_sites._update()
assert structure.atom_sites['Si'].adp_iso.free is False
+
+
+class TestBetaDisplayAndTags:
+ def _make_beta_structure(self):
+ from easydiffraction.datablocks.structure.item.base import Structure
+
+ structure = Structure(name='test')
+ structure.space_group.name_h_m = 'P 1'
+ structure.cell.length_a = 5.0
+ structure.cell.length_b = 6.0
+ structure.cell.length_c = 8.0
+ structure.atom_sites.create(label='Fe', type_symbol='Fe', adp_iso=0.0)
+ structure.atom_sites['Fe'].adp_type = 'beta'
+ structure._sync_atom_site_aniso()
+ return structure
+
+ def test_beta_suppresses_display_units(self):
+ structure = self._make_beta_structure()
+ aniso = structure.atom_site_aniso['Fe']
+ assert aniso.adp_11.resolve_display_units('gui') == ''
+ assert aniso.adp_12.resolve_display_units('latex') == ''
+
+ def test_uani_keeps_angstrom_squared_units(self):
+ structure = self._make_beta_structure()
+ structure.atom_sites['Fe'].adp_type = 'Uani'
+ aniso = structure.atom_site_aniso['Fe']
+ assert aniso.adp_11.resolve_display_units('gui') == 'Ų'
+
+ def test_beta_cif_names_registered_on_aniso_components(self):
+ from easydiffraction.datablocks.structure.categories.atom_site_aniso.default import (
+ AtomSiteAniso,
+ )
+
+ entry = AtomSiteAniso()
+ assert '_atom_site_aniso.beta_11' in entry.adp_11._cif_handler.names
+ assert '_atom_site_aniso.beta_23' in entry.adp_23._cif_handler.names
+
+ def test_off_diagonal_accepts_negative_value(self):
+ from easydiffraction.datablocks.structure.categories.atom_site_aniso.default import (
+ AtomSiteAniso,
+ )
+
+ # Off-diagonal components (any convention, beta included) may be
+ # negative; the validator is unrestricted.
+ entry = AtomSiteAniso()
+ entry.adp_12 = -0.0005
+ entry.adp_13 = -0.00047650724
+ assert entry.adp_12.value == -0.0005
+ assert entry.adp_13.value == pytest.approx(-0.00047650724)
+
+ def test_diagonal_rejects_negative_value_in_raise_mode(self, monkeypatch):
+ from easydiffraction.datablocks.structure.categories.atom_site_aniso.default import (
+ AtomSiteAniso,
+ )
+ from easydiffraction.utils.logging import Logger
+
+ # Diagonal components keep the non-negative range guard
+ # (RangeValidator(ge=0.0, le=10.0)); a negative value is rejected.
+ monkeypatch.setattr(Logger, '_reaction', Logger.Reaction.RAISE, raising=True)
+ entry = AtomSiteAniso()
+ with pytest.raises(TypeError, match='outside'):
+ entry.adp_11 = -0.1
diff --git a/tests/unit/easydiffraction/datablocks/structure/categories/test_atom_sites.py b/tests/unit/easydiffraction/datablocks/structure/categories/test_atom_sites.py
index 2958fa494..baf4374e4 100644
--- a/tests/unit/easydiffraction/datablocks/structure/categories/test_atom_sites.py
+++ b/tests/unit/easydiffraction/datablocks/structure/categories/test_atom_sites.py
@@ -417,3 +417,246 @@ def test_cif_round_trip_redrives_letter(self):
reloaded._update_categories()
assert reloaded.atom_sites['A'].wyckoff_letter.value == 'a'
assert reloaded.atom_sites['A'].multiplicity.value == 1
+
+
+# ------------------------------------------------------------------
+# Beta-tensor conversion (cell-dependent)
+# ------------------------------------------------------------------
+
+
+class TestBetaConversion:
+ def _make_structure(self):
+ from easydiffraction.datablocks.structure.item.base import Structure
+
+ structure = Structure(name='test')
+ structure.space_group.name_h_m = 'P 1'
+ structure.cell.length_a = 5.0
+ structure.cell.length_b = 6.0
+ structure.cell.length_c = 8.0
+ structure.atom_sites.create(label='Fe', type_symbol='Fe', adp_iso=0.0)
+ structure.atom_sites['Fe'].adp_type = 'Uani'
+ structure._sync_atom_site_aniso()
+ return structure
+
+ def _set_aniso(self, structure, vals):
+ aniso = structure.atom_site_aniso['Fe']
+ aniso.adp_11, aniso.adp_22, aniso.adp_33 = vals[0], vals[1], vals[2]
+ aniso.adp_12, aniso.adp_13, aniso.adp_23 = vals[3], vals[4], vals[5]
+ return aniso
+
+ def _read_aniso(self, structure):
+ aniso = structure.atom_site_aniso['Fe']
+ return (
+ aniso.adp_11.value,
+ aniso.adp_22.value,
+ aniso.adp_33.value,
+ aniso.adp_12.value,
+ aniso.adp_13.value,
+ aniso.adp_23.value,
+ )
+
+ def test_uani_to_beta_round_trip(self):
+ import math
+
+ structure = self._make_structure()
+ u_vals = (0.012, 0.008, 0.015, -0.002, 0.001, -0.003)
+ self._set_aniso(structure, u_vals)
+ structure.atom_sites['Fe'].adp_type = 'beta'
+ structure.atom_sites['Fe'].adp_type = 'Uani'
+ for got, expected in zip(self._read_aniso(structure), u_vals, strict=True):
+ assert math.isclose(got, expected, rel_tol=1e-9, abs_tol=1e-12)
+
+ def test_uani_to_beta_uses_reciprocal_formula(self):
+ import math
+
+ structure = self._make_structure()
+ self._set_aniso(structure, (0.012, 0.0, 0.0, 0.0, 0.0, 0.0))
+ structure.atom_sites['Fe'].adp_type = 'beta'
+ # beta_11 = 2*pi**2 * U_11 * a*^2, with a* = 1/5 for this cell.
+ expected = 2.0 * math.pi**2 * 0.012 * (1.0 / 5.0) ** 2
+ assert math.isclose(structure.atom_site_aniso['Fe'].adp_11.value, expected, rel_tol=1e-9)
+
+ def test_bani_to_beta_round_trip(self):
+ import math
+
+ structure = self._make_structure()
+ structure.atom_sites['Fe'].adp_type = 'Bani'
+ b_vals = (0.9, 0.6, 1.2, -0.1, 0.05, -0.15)
+ self._set_aniso(structure, b_vals)
+ structure.atom_sites['Fe'].adp_type = 'beta'
+ structure.atom_sites['Fe'].adp_type = 'Bani'
+ for got, expected in zip(self._read_aniso(structure), b_vals, strict=True):
+ assert math.isclose(got, expected, rel_tol=1e-9, abs_tol=1e-12)
+
+ def test_param_identity_preserved_uani_to_beta(self):
+ structure = self._make_structure()
+ self._set_aniso(structure, (0.01, 0.01, 0.01, 0.0, 0.0, 0.0))
+ before = structure.atom_site_aniso['Fe'].adp_11
+ structure.atom_sites['Fe'].adp_type = 'beta'
+ after = structure.atom_site_aniso['Fe'].adp_11
+ assert before is after
+
+ def test_beta_to_biso_collapses_to_b_equivalent(self):
+ import math
+
+ structure = self._make_structure()
+ self._set_aniso(structure, (0.012, 0.008, 0.015, 0.0, 0.0, 0.0))
+ structure.atom_sites['Fe'].adp_type = 'beta'
+ structure.atom_sites['Fe'].adp_type = 'Biso'
+ u_eq = (0.012 + 0.008 + 0.015) / 3.0
+ expected = 8.0 * math.pi**2 * u_eq
+ assert math.isclose(structure.atom_sites['Fe'].adp_iso.value, expected, rel_tol=1e-6)
+
+ def test_switch_to_beta_on_unattached_atom_defers(self):
+ from easydiffraction.datablocks.structure.categories.atom_sites.default import AtomSite
+
+ # Inside create() the atom has no parent yet, so the beta switch
+ # defers the cell-dependent conversion (the structure's aniso sync
+ # completes it on add) rather than raising.
+ site = AtomSite()
+ site.adp_type = 'beta'
+ assert site.adp_type.value == 'beta'
+
+ def test_create_with_inline_beta_adp_type(self):
+ from easydiffraction.datablocks.structure.item.base import Structure
+
+ structure = Structure(name='test')
+ structure.space_group.name_h_m = 'P 1'
+ structure.cell.length_a = 5.0
+ structure.cell.length_b = 6.0
+ structure.cell.length_c = 8.0
+ # adp_type='beta' passed inline to create(): the atom is created
+ # with a zero-filled aniso row, ready for direct assignment.
+ structure.atom_sites.create(
+ label='Fe',
+ type_symbol='Fe',
+ fract_x=0.1,
+ fract_y=0.2,
+ fract_z=0.3,
+ adp_type='beta',
+ )
+ assert structure.atom_sites['Fe'].adp_type.value == 'beta'
+ aniso = structure.atom_site_aniso['Fe']
+ assert aniso.adp_11.value == 0.0
+ aniso.adp_11 = 0.0071
+ assert aniso.adp_11.value == 0.0071
+
+ def test_adp_iso_as_b_for_beta_atom_matches_b_equivalent(self):
+ import math
+
+ structure = self._make_structure()
+ u_vals = (0.012, 0.008, 0.015, 0.0, 0.0, 0.0)
+ self._set_aniso(structure, u_vals)
+ structure.atom_sites['Fe'].adp_type = 'beta'
+ # F1 regression: equivalent B computed straight from the beta
+ # tensor, independent of the stored adp_iso.
+ u_eq = (0.012 + 0.008 + 0.015) / 3.0
+ expected = 8.0 * math.pi**2 * u_eq
+ assert math.isclose(structure.atom_sites['Fe'].adp_iso_as_b, expected, rel_tol=1e-6)
+
+ def test_adp_iso_as_b_for_beta_from_bani(self):
+ import math
+
+ # F1 completeness: the equivalent B is correct for a beta atom
+ # reached from Bani too (B_eq = mean of the B diagonal).
+ structure = self._make_structure()
+ structure.atom_sites['Fe'].adp_type = 'Bani'
+ self._set_aniso(structure, (0.9, 0.6, 1.2, 0.0, 0.0, 0.0))
+ structure.atom_sites['Fe'].adp_type = 'beta'
+ expected = (0.9 + 0.6 + 1.2) / 3.0
+ assert math.isclose(structure.atom_sites['Fe'].adp_iso_as_b, expected, rel_tol=1e-6)
+
+ def test_uiso_to_beta_seeds_and_converts_diagonal(self):
+ import math
+
+ from easydiffraction.datablocks.structure.item.base import Structure
+
+ # iso → anisotropic-beta seeding: the diagonal is seeded from the
+ # isotropic U then mapped to beta (off-diagonals stay zero).
+ structure = Structure(name='test')
+ structure.space_group.name_h_m = 'P 1'
+ structure.cell.length_a = 5.0
+ structure.cell.length_b = 6.0
+ structure.cell.length_c = 8.0
+ structure.atom_sites.create(label='Fe', type_symbol='Fe', adp_type='Uiso', adp_iso=0.01)
+ structure.atom_sites['Fe'].adp_type = 'beta'
+ aniso = structure.atom_site_aniso['Fe']
+ assert math.isclose(aniso.adp_11.value, 2.0 * math.pi**2 * 0.01 * (1.0 / 5.0) ** 2)
+ assert math.isclose(aniso.adp_22.value, 2.0 * math.pi**2 * 0.01 * (1.0 / 6.0) ** 2)
+ assert aniso.adp_12.value == 0.0
+
+
+# ------------------------------------------------------------------
+# ADP symmetry constraints during minimization
+# ------------------------------------------------------------------
+
+
+class TestAdpSymmetryConstraintMinimizerBypass:
+ """Cover the ``called_by_minimizer`` ADP-constraint write path.
+
+ When the minimizer drives anisotropic tensor components, symmetry
+ averaging on a special position can write back a value that is
+ transiently outside the diagonal ``RangeValidator(ge=0, le=10)``.
+ The minimizer path must apply it raw (``_set_value_from_minimizer``)
+ so the fit is not aborted, while the interactive path keeps the
+ validating setter.
+ """
+
+ def _make_cubic_bani(self):
+ from easydiffraction.datablocks.structure.item.base import Structure
+
+ structure = Structure(name='test')
+ # P m -3 m Wyckoff a forces β11=β22=β33 and zero off-diagonals.
+ structure.space_group.name_h_m = 'P m -3 m'
+ structure.atom_sites.create(
+ label='Si',
+ type_symbol='Si',
+ adp_type='Bani',
+ adp_iso=0.3,
+ )
+ structure._sync_atom_site_aniso()
+ aniso = structure.atom_site_aniso['Si']
+ aniso.adp_11 = 0.3
+ aniso.adp_22 = 0.3
+ aniso.adp_33 = 0.3
+ # Populate the Wyckoff letter so the ADP constraint pass engages.
+ structure.atom_sites._update()
+ return structure
+
+ @staticmethod
+ def _drive_out_of_range(aniso):
+ # Distinct sub-zero diagonals (raw minimizer writes); the cubic
+ # constraint equalises them to an out-of-range value that differs
+ # from each current component, so the validating setter would fire.
+ aniso.adp_11._set_value_from_minimizer(-0.3)
+ aniso.adp_22._set_value_from_minimizer(-0.2)
+ aniso.adp_33._set_value_from_minimizer(-0.1)
+
+ def test_minimizer_path_applies_out_of_range_tensor_without_raising(self, monkeypatch):
+ from easydiffraction.utils.logging import Logger
+
+ structure = self._make_cubic_bani()
+ aniso = structure.atom_site_aniso['Si']
+ self._drive_out_of_range(aniso)
+
+ # RAISE mode makes the validating setter abort on a range breach.
+ monkeypatch.setattr(Logger, '_reaction', Logger.Reaction.RAISE, raising=True)
+ structure.atom_sites._apply_adp_symmetry_constraints(called_by_minimizer=True)
+
+ # The constrained diagonals are equalised and applied raw, even
+ # though the value is below the validator's lower bound.
+ assert aniso.adp_11.value == aniso.adp_22.value == aniso.adp_33.value
+ assert aniso.adp_11.value < 0.0
+
+ def test_interactive_path_still_validates(self, monkeypatch):
+ import pytest
+
+ from easydiffraction.utils.logging import Logger
+
+ structure = self._make_cubic_bani()
+ aniso = structure.atom_site_aniso['Si']
+ self._drive_out_of_range(aniso)
+
+ monkeypatch.setattr(Logger, '_reaction', Logger.Reaction.RAISE, raising=True)
+ with pytest.raises(TypeError, match='outside'):
+ structure.atom_sites._apply_adp_symmetry_constraints(called_by_minimizer=False)
diff --git a/tests/unit/easydiffraction/display/plotters/test_plotly.py b/tests/unit/easydiffraction/display/plotters/test_plotly.py
index 5a69f5670..932e87f99 100644
--- a/tests/unit/easydiffraction/display/plotters/test_plotly.py
+++ b/tests/unit/easydiffraction/display/plotters/test_plotly.py
@@ -215,84 +215,126 @@ def test_composite_x_range_is_tight():
assert pp.PlotlyPlotter._composite_x_range(np.array([])) == (None, None)
-def test_html_post_script_carries_theme_resize_and_legend_toggle():
+def test_html_post_script_delegates_to_shared_loader():
import plotly.graph_objects as go
import easydiffraction.display.plotters.plotly as pp
# A named trace gives the figure a visible legend, so the legend
- # toggle is included. This post-script is embedded by the report
- # (STANDALONE) serializer; the live loader provides the same
- # behaviour via ed-figures.js instead.
+ # toggle is requested. The STANDALONE (report) serializer no longer
+ # inlines theme/resize/legend logic; it delegates to the shared
+ # ed-figures.js loader through ``window.edFigures``, which stays the
+ # single source of that behaviour.
fig = go.Figure()
fig.add_trace(go.Scatter(x=[0, 1, 2], y=[1, 2, 3], name='calc'))
post_script = pp.PlotlyPlotter._html_post_script(fig)
- assert 'data-jp-theme-light' in post_script
- assert 'data-md-color-scheme' in post_script
- assert 'graphDiv.dataset.edPlotlyTheme' in post_script
- assert f"background: '{pp.DARK_BACKGROUND_COLOR}'" in post_script
- assert f"background: '{pp.LIGHT_BACKGROUND_COLOR}'" in post_script
- assert f"axisFrame: '{pp.DARK_AXIS_FRAME_COLOR}'" in post_script
- assert f"axisFrame: '{pp.LIGHT_AXIS_FRAME_COLOR}'" in post_script
- assert f"innerTickGrid: '{pp.DARK_INNER_TICK_GRID_COLOR}'" in post_script
- assert f"innerTickGrid: '{pp.LIGHT_INNER_TICK_GRID_COLOR}'" in post_script
- assert f"hoverBackground: '{pp.DARK_HOVER_BACKGROUND_COLOR}'" in post_script
- assert f"legend: '{pp.DARK_LEGEND_BACKGROUND_COLOR}'" in post_script
- assert "'modebar.color'" in post_script
- assert "'modebar.activecolor'" in post_script
- assert 'rgbaFromColor' in post_script
- # Modebar icons are also themed via a class-based !important rule so
- # they stay visible regardless of Plotly's inline fills.
- assert 'ed-plotly-themed-modebar' in post_script
- assert 'const correlationColorscale = function (colors) {' in post_script
- assert 'const themeSync = meta.ed_plotly_theme_sync;' in post_script
- assert 'const applyAnnotationTheme = function (update, colors) {' in post_script
- # The top-left metrics box must re-theme its background and border on a
- # theme switch, not just its font colour (its baked light bgcolor would
- # otherwise survive the dark switch).
- assert "annotation.name === 'ed-metrics-box'" in post_script
- assert "].bgcolor'] = colors.legend;" in post_script
- assert "].bordercolor'] = colors.axisFrame;" in post_script
- assert 'const shapeIndexes = themeSync.axis_frame_shape_indexes;' in post_script
- assert 'if (themeSync.correlation_heatmap !== true) {' in post_script
- assert 'window.Plotly.restyle(' in post_script
- assert 'window.Plotly.relayout(graphDiv, update)' in post_script
- assert 'Promise.all(pending).then(function () {' in post_script
- assert 'window.Plotly.Plots.resize(graphDiv)' in post_script
- assert "document.addEventListener('visibilitychange'" in post_script
- assert "window.addEventListener('focus', scheduleResize);" in post_script
- assert 'new ResizeObserver(scheduleResize)' in post_script
- assert 'data-legend-toggle="true"' in post_script
- assert 'Toggle legend' in post_script
- assert 'graphDiv.dataset.legendVisible' in post_script
- assert 'const applyLegendVisibility = function (legendVisible) {' in post_script
- assert "legend.style.display = legendVisible ? 'inline' : 'none';" in post_script
- assert 'const readLegendVisibility = function () {' in post_script
- assert "if (graphDiv.layout && typeof graphDiv.layout.showlegend === 'boolean')" in post_script
- assert "legendButton.classList.toggle('active', legendVisible);" in post_script
- assert "graphDiv.on('plotly_relayout', function (eventData) {" in post_script
- assert 'legendButton.onclick = toggleLegend;' in post_script
- assert 'resolveLegendButtonFill(legendVisible ? 0.7 : 0.3)' in post_script
- assert "legendButtonGroup.className = 'modebar-group';" in post_script
- assert 'modebar.appendChild(legendButtonGroup);' in post_script
- assert 'legendButton.innerHTML' in post_script
- assert 'height="1em" width="1em"' in post_script
-
-
-def test_html_post_script_skips_legend_toggle_without_legend():
+ # Plotly's to_html substitutes the plot id token at render time.
+ assert "document.getElementById('{plot_id}')" in post_script
+ assert 'window.edFigures.watchTheme(graphDiv,' in post_script
+ assert 'window.edFigures.watchResize(graphDiv)' in post_script
+ assert 'window.edFigures.installLegendToggle(graphDiv)' in post_script
+ # The baked theme payload carries both the light and dark colours
+ # the loader picks between.
+ assert f'"background": "{pp.LIGHT_BACKGROUND_COLOR}"' in post_script
+ assert f'"background": "{pp.DARK_BACKGROUND_COLOR}"' in post_script
+ assert f'"legend": "{pp.DARK_LEGEND_BACKGROUND_COLOR}"' in post_script
+ assert f'"axisFrame": "{pp.LIGHT_AXIS_FRAME_COLOR}"' in post_script
+ # The legend trace makes the toggle active rather than gated off.
+ assert 'if (true) {' in post_script
+
+
+def test_html_post_script_gates_legend_toggle_without_legend():
import plotly.graph_objects as go
import easydiffraction.display.plotters.plotly as pp
- # No visible legend (unnamed, non-legend trace) → no legend toggle,
- # but the theme-sync block is always present.
+ # No visible legend (unnamed, non-legend trace) → the legend toggle
+ # is gated off, but theme sync and resize delegation are always
+ # present.
fig = go.Figure()
fig.add_trace(go.Scatter(x=[0, 1], y=[1, 2], showlegend=False))
post_script = pp.PlotlyPlotter._html_post_script(fig)
- assert 'data-jp-theme-light' in post_script
- assert 'data-legend-toggle="true"' not in post_script
+ assert 'window.edFigures.watchTheme(graphDiv,' in post_script
+ assert 'window.edFigures.watchResize(graphDiv)' in post_script
+ assert 'if (false) {' in post_script
+
+
+def test_shared_loader_owns_theme_resize_and_legend_behaviour():
+ import easydiffraction.display.plotters.plotly as pp
+
+ # ed-figures.js is the single source for theme sync, resize, and the
+ # legend toggle. It must detect both mkdocs Material and JupyterLab
+ # host themes, re-theme the metrics box background/border (not just
+ # its font), and expose the entry points the standalone path calls.
+ loader = pp._packaged_asset(pp._FIGURE_LOADER_ASSET)
+
+ assert 'data-md-color-scheme' in loader
+ assert 'data-jp-theme-light' in loader
+ assert "var METRICS_ANNOTATION_NAME = 'ed-metrics-box';" in loader
+ assert 'annotation.name === METRICS_ANNOTATION_NAME' in loader
+ assert "].bgcolor'] = colors.legend;" in loader
+ assert "].bordercolor'] = colors.axisFrame;" in loader
+ assert 'window.edFigures.watchTheme = watchTheme;' in loader
+ assert 'window.edFigures.watchResize = watchResize;' in loader
+ assert 'window.edFigures.installLegendToggle = installLegendToggle;' in loader
+
+
+def test_serialize_html_standalone_embeds_loader_once():
+ import plotly.graph_objects as go
+
+ import easydiffraction.display.plotters.plotly as pp
+ from easydiffraction.utils.environment import FigureEmbedMode
+
+ fig = go.Figure()
+ fig.add_trace(go.Scatter(x=[0, 1, 2], y=[1, 2, 3], name='calc'))
+
+ marker = 'window.edFigures.watchTheme = watchTheme;'
+
+ # A self-contained figure embeds the loader by default.
+ embedded = pp.PlotlyPlotter.serialize_html(
+ fig,
+ include_plotlyjs=True,
+ mode=FigureEmbedMode.STANDALONE,
+ )
+ assert marker in embedded
+ assert 'window.edFigures.watchTheme(graphDiv,' in embedded
+
+ # A later figure on the same page opts out, reusing the
+ # already-defined window.edFigures.
+ reused = pp.PlotlyPlotter.serialize_html(
+ fig,
+ include_plotlyjs=False,
+ include_helper_loader=False,
+ mode=FigureEmbedMode.STANDALONE,
+ )
+ assert marker not in reused
+ assert 'window.edFigures.watchTheme(graphDiv,' in reused
+
+
+def test_serialize_html_standalone_loader_decoupled_from_plotlyjs():
+ import plotly.graph_objects as go
+
+ import easydiffraction.display.plotters.plotly as pp
+ from easydiffraction.utils.environment import FigureEmbedMode
+
+ fig = go.Figure()
+ fig.add_trace(go.Scatter(x=[0, 1, 2], y=[1, 2, 3], name='calc'))
+
+ marker = 'window.edFigures.watchTheme = watchTheme;'
+
+ # External-Plotly standalone snippet: Plotly is supplied elsewhere
+ # (include_plotlyjs=False), but the helper loader must still be
+ # embedded by default so theme sync, resize, and the legend toggle
+ # are not silently lost.
+ html = pp.PlotlyPlotter.serialize_html(
+ fig,
+ include_plotlyjs=False,
+ mode=FigureEmbedMode.STANDALONE,
+ )
+ assert marker in html
+ assert 'window.edFigures.watchTheme(graphDiv,' in html
def test_wrap_html_figure_wraps_fixed_aspect():
@@ -1174,7 +1216,10 @@ def test_serialize_html_inline_is_eager_self_contained():
mode=FigureEmbedMode.INLINE,
)
- assert 'data-ed-figure' not in html
+ # Eager INLINE output is not the lazy SHARED placeholder. (The
+ # embedded loader mentions the placeholder selector in a string, so
+ # match the actual placeholder div, not the bare attribute.)
+ assert '