_get_cached_elements -> get_cached_elements

Author: davidhassell

cf/aggregate.py

@@ -4112,7 +4112,7 @@ def _get_hfl(
         # Record the bounds of the first and last (sorted) cells
         first, last = hfl_cache.flb.get(hash_value, (None, None))
         if first is None:
-            cached_elements = d._get_cached_elements()
+            cached_elements = d.get_cached_elements()
             x = []
             for i in (0, 1, -2, -1):
                 value = cached_elements.get(i)

cf/dimensioncoordinate.py

@@ -165,7 +165,7 @@ def _infer_direction(self):
         if data is not None:
             # Infer the direction from the data
             if data.size > 1:
-                c = data._get_cached_elements()
+                c = data.get_cached_elements()
                 if c:
                     try:
                         return bool(c.get(0) <= c.get(1))
@@ -179,7 +179,7 @@ def _infer_direction(self):
         data = self.get_bounds_data(None, _fill_value=False)
         if data is not None:
             # Infer the direction from the bounds
-            c = data._get_cached_elements()
+            c = data.get_cached_elements()
             if c:
                 try:
                     return bool(c.get(0) <= c.get(1))

cf/field.py

@@ -6994,7 +6994,7 @@ def collapse(
                 else:
                     b = dim.data
 
-                cached_elements = b._get_cached_elements()
+                cached_elements = b.get_cached_elements()
                 try:
                     # Try to set the new bounds from cached values
                     bounds_data = Data(

cf/test/test_Data.py

@@ -1165,7 +1165,7 @@ def test_Data_concatenate(self):
         str(d)
         str(e)
         f = cf.Data.concatenate([d, e], axis=1)
-        cached = f._get_cached_elements()
+        cached = f.get_cached_elements()
         self.assertEqual(cached[0], d.first_element())
         self.assertEqual(cached[-1], e.last_element())
 
@@ -1205,7 +1205,7 @@ def test_Data_concatenate(self):
         repr(e)
         f = cf.Data.concatenate([d, e], axis=0)
         self.assertEqual(
-            f._get_cached_elements(),
+            f.get_cached_elements(),
             {0: d.first_element(), -1: e.last_element()},
         )
 
@@ -4378,7 +4378,7 @@ def test_Data_Units(self):
         d = cf.Data([1000, 2000, 3000], "m")
         repr(d)
         d.Units = cf.Units("km")
-        self.assertEqual(d._get_cached_elements(), {0: 1.0, 1: 2.0, -1: 3.0})
+        self.assertEqual(d.get_cached_elements(), {0: 1.0, 1: 2.0, -1: 3.0})
 
     def test_Data_get_data(self):
         """Test the `get_data` Data method."""
@@ -4446,57 +4446,30 @@ def test_Data__init__datetime(self):
         self.assertTrue((q == d).array.all())
         self.assertTrue((d == q).array.all())
 
-    def test_Data__str__(self):
-        """Test `Data.__str__`"""
-        elements0 = (0, -1, 1)
-        for array in ([1], [1, 2], [1, 2, 3]):
-            elements = elements0[: len(array)]
-
-            d = cf.Data(array)
-            cache = d._get_cached_elements()
-            for element in elements:
-                self.assertNotIn(element, cache)
-
-            self.assertEqual(str(d), str(array))
-            cache = d._get_cached_elements()
-            for element in elements:
-                self.assertIn(element, cache)
-
-            d[0] = 1
-            cache = d._get_cached_elements()
-            for element in elements:
-                self.assertNotIn(element, cache)
-
-            self.assertEqual(str(d), str(array))
-            cache = d._get_cached_elements()
-            for element in elements:
-                self.assertIn(element, cache)
-
-            d += 0
-            cache = d._get_cached_elements()
-            for element in elements:
-                self.assertNotIn(element, cache)
-
-            self.assertEqual(str(d), str(array))
-            cache = d._get_cached_elements()
-            for element in elements:
-                self.assertIn(element, cache)
-
-        # Test when size > 3, i.e. second element is not there.
-        d = cf.Data([1, 2, 3, 4])
-        cache = d._get_cached_elements()
-        for element in elements0:
-            self.assertNotIn(element, cache)
-
-        self.assertEqual(str(d), "[1, ..., 4]")
-        cache = d._get_cached_elements()
-        self.assertNotIn(1, cache)
-        for element in elements0[:2]:
-            self.assertIn(element, cache)
-
-        d[0] = 1
-        for element in elements0:
-            self.assertNotIn(element, d._get_cached_elements())
+    def test_Data__repr__str(self):
+        """Test all means of Data inspection."""
+        for d in [
+            cf.Data(9, units="km"),
+            cf.Data([9], units="km"),
+            cf.Data([[9]], units="km"),
+            cf.Data([8, 9], units="km"),
+            cf.Data([[8, 9]], units="km"),
+            cf.Data([7, 8, 9], units="km"),
+            cf.Data([[7, 8, 9]], units="km"),
+            cf.Data([6, 7, 8, 9], units="km"),
+            cf.Data([[6, 7, 8, 9]], units="km"),
+            cf.Data([[6, 7], [8, 9]], units="km"),
+            cf.Data([[6, 7, 8, 9], [6, 7, 8, 9]], units="km"),
+        ]:
+            _ = repr(d)
+            _ = str(d)
+
+        # Test when the data contains date-times with the first
+        # element masked
+        dt = np.ma.array([10, 20], mask=[True, False])
+        d = cf.Data(dt, units="days since 2000-01-01")
+        self.assertTrue(str(d) == "[--, 2000-01-21 00:00:00]")
+        self.assertTrue(repr(d) == "<CF Data(2): [--, 2000-01-21 00:00:00]>")
 
     def test_Data_cull_graph(self):
         """Test Data.cull_graph."""