Make FieldSet.parse_wildcards() private

Author: VeckoTheGecko

parcels/fieldset.py

@@ -343,7 +343,12 @@ def check_velocityfields(U, V, W):
         self._completed = True
 
     @classmethod
-    def parse_wildcards(cls, paths, filenames, var):
+    @deprecated_made_private  # TODO: Remove 6 months after v3.1.0
+    def parse_wildcards(self, *args, **kwargs):
+        return self._parse_wildcards(*args, **kwargs)
+
+    @classmethod
+    def _parse_wildcards(cls, paths, filenames, var):
         if not isinstance(paths, list):
             paths = sorted(glob(str(paths)))
         if len(paths) == 0:
@@ -469,10 +474,10 @@ def from_netcdf(
             # Resolve all matching paths for the current variable
             paths = filenames[var] if type(filenames) is dict and var in filenames else filenames
             if type(paths) is not dict:
-                paths = cls.parse_wildcards(paths, filenames, var)
+                paths = cls._parse_wildcards(paths, filenames, var)
             else:
                 for dim, p in paths.items():
-                    paths[dim] = cls.parse_wildcards(p, filenames, var)
+                    paths[dim] = cls._parse_wildcards(p, filenames, var)
 
             # Use dimensions[var] and indices[var] if either of them is a dict of dicts
             dims = dimensions[var] if var in dimensions else dimensions

tests/test_deprecations.py

@@ -1,5 +1,8 @@
+import inspect
+
 import pytest
 
+from parcels import Field, FieldSet
 from tests.utils import create_fieldset_unit_mesh
 
 fieldset = create_fieldset_unit_mesh()
@@ -14,28 +17,96 @@
     "_chunk_set",
 ]
 
-private_fieldset_attrs = [
-    "_completed",
-]
 
+class FieldPrivate:
+    attributes = [
+        "_dataFiles",
+        "_loaded_time_indices",
+        "_creation_log",
+        "_data_chunks",
+        "_c_data_chunks",
+        "_chunk_set",
+    ]
+    methods = [
+        "_get_dim_filenames",
+        "_collect_timeslices",
+        "_reshape",
+        "_calc_cell_edge_sizes",
+        "_search_indices_vertical_z",
+        "_search_indices_vertical_s",
+        "_reconnect_bnd_indices",
+        "_search_indices_rectilinear",
+        "_search_indices_curvilinear",
+        "_search_indices",
+        "_interpolator2D",
+        "_interpolator3D",
+        "_ccode_eval",
+        "_ccode_convert",
+        "_get_block_id",
+        "_get_block",
+        "_chunk_setup",
+        "_chunk_data",
+        "_rescale_and_set_minmax",
+        "_data_concatenate",
+        "_spatial_interpolation",
+        "_time_index",
+    ]
 
-@pytest.mark.parametrize("private_attribute", private_field_attrs)
-def test_private_attribute_field(private_attribute):
+
+class FieldSetPrivate:
+    attributes = [
+        "_completed",
+    ]
+    methods = [
+        "_add_UVfield",
+        "_parse_wildcards",
+        "_check_complete",
+    ]
+
+
+def assert_private_public_attribute_equiv(obj, private_attribute: str):
     assert private_attribute.startswith("_")
     attribute = private_attribute.lstrip("_")
 
     with pytest.raises(DeprecationWarning):
-        assert hasattr(field, attribute)
-        assert hasattr(field, private_attribute)
-        assert getattr(field, attribute) is getattr(field, private_attribute)
+        assert hasattr(obj, attribute)
+        assert hasattr(obj, private_attribute)
+        assert getattr(obj, attribute) is getattr(obj, private_attribute)
+
+
+def assert_public_method_calls_private(type_, private_method):
+    """Looks at the source code to ensure that `public_method` calls `private_method`.
+
+    Looks for the string `.{method_name}(` in the source code of `public_method`.
+    """
+    assert private_method.startswith("_")
+    public_method_str = private_method.lstrip("_")
+    private_method_str = private_method
+
+    public_method = getattr(type_, public_method_str)
+    private_method = getattr(type_, private_method_str)
+
+    assert callable(public_method)
+    assert callable(private_method)
 
+    assert f".{private_method_str}(" in inspect.getsource(public_method)
 
-@pytest.mark.parametrize("private_attribute", private_fieldset_attrs)
+
+@pytest.mark.parametrize("private_attribute", FieldPrivate.attributes)
+def test_private_attribute_field(private_attribute):
+    assert_private_public_attribute_equiv(field, private_attribute)
+
+
+@pytest.mark.parametrize("private_attribute", FieldSetPrivate.attributes)
 def test_private_attribute_fieldset(private_attribute):
-    assert private_attribute.startswith("_")
-    attribute = private_attribute.lstrip("_")
+    assert_private_public_attribute_equiv(fieldset, private_attribute)
 
-    with pytest.raises(DeprecationWarning):
-        assert hasattr(fieldset, attribute)
-        assert hasattr(fieldset, private_attribute)
-        assert getattr(fieldset, attribute) is getattr(fieldset, private_attribute)
+
+@pytest.mark.parametrize("private_method", FieldPrivate.methods)
+def test_private_method_field(private_method):
+    assert_public_method_calls_private(Field, private_method)
+
+
+@pytest.mark.parametrize("private_method", FieldSetPrivate.methods)
+def test_private_method_fieldset(private_method):
+    assert_public_method_calls_private(FieldSet, private_method)