Trial combination of bouwe array-equal-fix and non-lazy-benchmarks

benchmarks/benchmarks/generate_data/__init__.py

@@ -106,11 +106,14 @@ def load_realised():
     file loading, but some benchmarks are only meaningful if starting with real
     arrays.
     """
+    from iris.fileformats._nc_load_rules import helpers
     from iris.fileformats.netcdf.loader import _get_cf_var_data as pre_patched
 
     def patched(cf_var, filename):
         return as_concrete_data(pre_patched(cf_var, filename))
 
-    netcdf._get_cf_var_data = patched
-    yield netcdf
-    netcdf._get_cf_var_data = pre_patched
+    netcdf.loader._get_cf_var_data = patched
+    helpers._get_cf_var_data = patched
+    yield
+    netcdf.loader._get_cf_var_data = pre_patched
+    helpers._get_cf_var_data = pre_patched

benchmarks/benchmarks/generate_data/stock.py

@@ -162,7 +162,8 @@ def realistic_4d_w_everything(w_mesh=False, lazy=False) -> iris.cube.Cube:
     lazy : bool
         If True, the Cube will be returned with all arrays as they would
         normally be loaded from file (i.e. most will still be lazy Dask
-        arrays). If False, all arrays will be realised NumPy arrays.
+        arrays). If False, all arrays (except derived coordinates) will be
+        realised NumPy arrays.
 
     """
 

docs/src/whatsnew/latest.rst

@@ -48,11 +48,11 @@ This document explains the changes made to Iris for this release
    However, :meth:`~iris.cube.Cube.transpose` will work, as will
    :meth:`~iris.cube.Cube.copy`. Note that, ``cube.copy(data=iris.DATALESS)``
    will provide a dataless copy of a cube. (:issue:`4447`, :pull:`6253`)
-   
+
 #. `@ESadek-MO`_ added the :mod:`iris.quickplot` ``footer`` kwarg to
    render text in the bottom right of the plot figure.
    (:issue:`6247`, :pull:`6332`)
-   
+
 
 🐛 Bugs Fixed
 =============
@@ -65,6 +65,9 @@ This document explains the changes made to Iris for this release
    older NetCDF formats e.g. ``NETCDF4_CLASSIC`` support a maximum precision of
    32-bit. (:issue:`6178`, :pull:`6343`)
 
+#. `@bouweandela`_ fixed handling of masked Dask arrays in
+    :func:`~iris.util.array_equal`.
+
 
 💣 Incompatible Changes
 =======================
@@ -145,6 +148,8 @@ This document explains the changes made to Iris for this release
 #. `@trexfeathers`_ temporarily pinned Sphinx to `<8.2`.
    (:pull:`6344`, :issue:`6345`)
 
+#. `@bouweandela`_ fixed a bug in the benchmarking code that caused all benchmarks
+    to be run with lazy data. (:pull:`6339`)
 
 .. comment
     Whatsnew author names (@github name) in alphabetical order. Note that,

lib/iris/coords.py

@@ -589,21 +589,22 @@ def __eq__(self, other):
         if hasattr(other, "metadata"):
             # metadata comparison
             eq = self.metadata == other.metadata
+
+            # Also consider bounds, if we have them.
+            # (N.B. though only Coords can ever actually *have* bounds).
+            if eq and eq is not NotImplemented:
+                eq = self.has_bounds() is other.has_bounds()
+
             # data values comparison
             if eq and eq is not NotImplemented:
                 eq = iris.util.array_equal(
                     self._core_values(), other._core_values(), withnans=True
                 )
-
-            # Also consider bounds, if we have them.
-            # (N.B. though only Coords can ever actually *have* bounds).
             if eq and eq is not NotImplemented:
                 if self.has_bounds() and other.has_bounds():
                     eq = iris.util.array_equal(
                         self.core_bounds(), other.core_bounds(), withnans=True
                     )
-                else:
-                    eq = not self.has_bounds() and not other.has_bounds()
 
         return eq
 

lib/iris/tests/unit/concatenate/test_hashing.py

@@ -9,6 +9,8 @@
 import pytest
 
 from iris import _concatenate
+from iris.tests.unit.util.test_array_equal import TEST_CASES
+from iris.util import array_equal
 
 
 @pytest.mark.parametrize(
@@ -75,6 +77,20 @@ def test_compute_hashes(a, b, eq):
     assert eq == (hashes["a"] == hashes["b"])
 
 
+@pytest.mark.parametrize(
+    "a,b",
+    [
+        (a, b)
+        for (a, b, withnans, eq) in TEST_CASES
+        if isinstance(a, np.ndarray | da.Array) and isinstance(b, np.ndarray | da.Array)
+    ],
+)
+def test_compute_hashes_vs_array_equal(a, b):
+    """Test that hashing give the same answer as `array_equal(withnans=True)`."""
+    hashes = _concatenate._compute_hashes({"a": a, "b": b})
+    assert array_equal(a, b, withnans=True) == (hashes["a"] == hashes["b"])
+
+
 def test_arrayhash_equal_incompatible_chunks_raises():
     hash1 = _concatenate._ArrayHash(1, chunks=((1, 1),))
     hash2 = _concatenate._ArrayHash(1, chunks=((2,),))