Update reprs and add FieldSet repr

Multiline particle printing
Update function naming
FieldSet repr

Author: VeckoTheGecko

parcels/field.py

@@ -21,7 +21,7 @@
     assert_valid_gridindexingtype,
     assert_valid_interp_method,
 )
-from parcels.tools._helpers import deprecated_made_private, pretty_field
+from parcels.tools._helpers import deprecated_made_private, field_repr
 from parcels.tools.converters import (
     Geographic,
     GeographicPolar,
@@ -313,7 +313,7 @@ def __init__(
             raise SyntaxError(f'Field received an unexpected keyword argument "{list(kwargs.keys())[0]}"')
 
     def __repr__(self) -> str:
-        return pretty_field(self)
+        return field_repr(self)
 
     @property
     @deprecated_made_private  # TODO: Remove 6 months after v3.1.0

parcels/fieldset.py

@@ -14,7 +14,7 @@
 from parcels.grid import Grid
 from parcels.gridset import GridSet
 from parcels.particlefile import ParticleFile
-from parcels.tools._helpers import deprecated_made_private
+from parcels.tools._helpers import deprecated_made_private, fieldset_repr
 from parcels.tools.converters import TimeConverter, convert_xarray_time_units
 from parcels.tools.loggers import logger
 from parcels.tools.statuscodes import TimeExtrapolationError
@@ -56,6 +56,9 @@ def __init__(self, U: Field | NestedField | None, V: Field | NestedField | None,
         self.compute_on_defer = None
         self._add_UVfield()
 
+    def __repr__(self):
+        return fieldset_repr(self)
+
     @property
     def particlefile(self):
         return self._particlefile

parcels/particleset.py

@@ -27,7 +27,7 @@
 from parcels.particle import JITParticle, Variable
 from parcels.particledata import ParticleData, ParticleDataIterator
 from parcels.particlefile import ParticleFile
-from parcels.tools._helpers import deprecated, deprecated_made_private, pretty_particleset
+from parcels.tools._helpers import deprecated, deprecated_made_private, particleset_repr
 from parcels.tools.converters import _get_cftime_calendars, convert_to_flat_array
 from parcels.tools.global_statics import get_package_dir
 from parcels.tools.loggers import logger
@@ -386,7 +386,7 @@ def size(self):
         return len(self.particledata)
 
     def __repr__(self):
-        return pretty_particleset(self)
+        return particleset_repr(self)
 
     def __len__(self):
         return len(self.particledata)

parcels/tools/_helpers.py

@@ -3,13 +3,14 @@
 from __future__ import annotations
 
 import functools
+import textwrap
 import warnings
 from collections.abc import Callable
-from textwrap import dedent
 from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
-    from parcels import Field, ParticleSet
+    from parcels import Field, FieldSet, ParticleSet
+
 PACKAGE = "Parcels"
 
 
@@ -64,34 +65,70 @@ def patch_docstring(obj: Callable, extra: str) -> None:
     obj.__doc__ = f"{obj.__doc__ or ''}{extra}".strip()
 
 
-def pretty_field(field: Field) -> str:
+def field_repr(field: Field) -> str:
     """Return a pretty repr for Field"""
     out = f"""<{type(field).__name__}>
-    grid            : {field.grid!r                    }
+    grid            : {field.grid!r}
     extrapolate time: {field.allow_time_extrapolation!r}
-    time_periodic   : {field.time_periodic!r           }
-    gridindexingtype: {field.gridindexingtype!r        }
-    to_write        : {field.to_write!r                }
+    time_periodic   : {field.time_periodic!r}
+    gridindexingtype: {field.gridindexingtype!r}
+    to_write        : {field.to_write!r}
 """
-    return dedent(out).strip()
+    return textwrap.dedent(out).strip()
+
+
+def _format_list_items_multiline(items: list[str], level: int = 1) -> str:
+    """Given a list of strings, formats them across multiple lines.
+
+    Uses indentation levels of 4 spaces provided by ``level``.
+
+    Example
+    -------
+    >>> output = _format_list_items_multiline(["item1", "item2", "item3"], 4)
+    >>> f"my_items: {output}"
+    my_items: [
+        item1,
+        item2,
+        item3,
+    ]
+    """
+    if len(items) == 0:
+        return "[]"
 
+    assert level >= 1, "Indentation level >=1 supported"
+    indentation_str = level * 4 * " "
+    indentation_str_end = (level - 1) * 4 * " "
 
-def pretty_particleset(pset: ParticleSet) -> str:
+    items = ",\n".join([textwrap.indent(i, indentation_str) for i in items])
+    return f"[\n{items}\n{indentation_str_end}]"
+
+
+def particleset_repr(pset: ParticleSet) -> str:
     """Return a pretty repr for ParticleSet"""
     if len(pset) < 10:
-        particles = repr(list(pset))
+        particles = [repr(p for p in pset)]
     else:
-        lst = [repr(pset[i]) for i in range(7)] + ["..."]
-        particles = f"[{', '.join(lst)}]"
+        particles = [repr(pset[i]) for i in range(7)] + ["..."]
 
     out = f"""<{type(pset).__name__}>
     fieldset   : {pset.fieldset}
     pclass     : {pset.pclass}
     repeatdt   : {pset.repeatdt}
     # particles: {len(pset)}
-    particles  : {particles}
+    particles  : {_format_list_items_multiline(particles)}
+"""
+    return textwrap.dedent(out).strip()
+
+
+def fieldset_repr(fieldset: FieldSet) -> str:
+    """Return a pretty repr for FieldSet"""
+    fields_repr = "\n".join([repr(f) for f in fieldset.get_fields()])
+
+    out = f"""<{type(fieldset).__name__}>
+    fields:
+{textwrap.indent(fields_repr, 8 * " ")}
 """
-    return dedent(out).strip()
+    return textwrap.dedent(out).strip()
 
 
 def default_repr(obj: Any):

tests/test_reprs.py

@@ -9,7 +9,7 @@
 from tests.utils import create_fieldset_unit_mesh, create_simple_pset
 
 
-def validate_simple_repr(class_: type, kwargs: dict[str, Any]):
+def assert_simple_repr(class_: type, kwargs: dict[str, Any]):
     """Test that the repr of an object contains all the arguments. This only works for objects where the repr matches the calling signature."""
     obj = class_(**kwargs)
     obj_repr = repr(obj)
@@ -55,13 +55,13 @@ def test_grid_repr():
     kwargs = dict(
         lon=np.array([1, 2, 3]), lat=np.array([4, 5, 6]), time=None, time_origin=TimeConverter(), mesh="spherical"
     )
-    validate_simple_repr(Grid, kwargs)
+    assert_simple_repr(Grid, kwargs)
 
 
 def test_variable_repr():
     """Test arguments are in the repr of the Variable object."""
     kwargs = dict(name="test", dtype=np.float32, initial=0, to_write=False)
-    validate_simple_repr(Variable, kwargs)
+    assert_simple_repr(Variable, kwargs)
 
 
 def test_rectilineargrid_repr():
@@ -73,22 +73,27 @@ def test_rectilineargrid_repr():
     kwargs = dict(
         lon=np.array([1, 2, 3]), lat=np.array([4, 5, 6]), time=None, time_origin=TimeConverter(), mesh="spherical"
     )
-    validate_simple_repr(RectilinearGrid, kwargs)
+    assert_simple_repr(RectilinearGrid, kwargs)
 
 
 def test_particlefile_repr():
     pset = create_simple_pset()
     kwargs = dict(
         name="file.zarr", particleset=pset, outputdt=timedelta(hours=1), chunks=None, create_new_zarrfile=False
     )
-    validate_simple_repr(ParticleFile, kwargs)
+    assert_simple_repr(ParticleFile, kwargs)
 
 
 def test_field_repr():
     field = create_fieldset_unit_mesh().U
     assert valid_indentation(repr(field))
 
 
+def test_fieldset_repr():
+    fieldset = create_fieldset_unit_mesh()
+    assert valid_indentation(repr(fieldset))
+
+
 def test_particleset_repr():
     pset = create_simple_pset()
     valid_indentation(repr(pset))

tests/tools/test_helpers.py

@@ -1,8 +1,19 @@
 import pytest
 
+import parcels.tools._helpers as helpers
 from parcels.tools._helpers import deprecated, deprecated_made_private
 
 
+def test_format_list_items_multiline():
+    expected = """[
+    item1,
+    item2,
+    item3
+]"""
+    assert helpers._format_list_items_multiline(["item1", "item2", "item3"], 1) == expected
+    assert helpers._format_list_items_multiline([], 1) == "[]"
+
+
 def test_deprecated():
     class SomeClass:
         @deprecated()