StagyyData.nfields_max is a property

This allows for a cleaner handling of spurious values.  Values
<6 are now forbidden.  Attempting to set nfields_max to a value
<6 raises an InvalidNfieldsError.  No limit is now achieved with
the None value.

Author: amorison

stagpy/_step.py

@@ -270,9 +270,10 @@ def _set(self, name, fld):
         sdat = self.step.sdat
         col_fld = sdat.collected_fields
         col_fld.append((self.step.istep, name))
-        while len(col_fld) > sdat.nfields_max > 5:
-            istep, fld_name = col_fld.pop(0)
-            del sdat.steps[istep].fields[fld_name]
+        if sdat.nfields_max is not None:
+            while len(col_fld) > sdat.nfields_max:
+                istep, fld_name = col_fld.pop(0)
+                del sdat.steps[istep].fields[fld_name]
         self._data[name] = fld
 
     def __delitem__(self, name):

stagpy/error.py

@@ -123,6 +123,24 @@ def __init__(self, fraction):
                          .format(fraction))
 
 
+class InvalidNfieldsError(StagpyError):
+
+    """Raised when invalid nfields_max is requested."""
+
+    def __init__(self, nfields):
+        """Initialization of instances:
+
+        Args:
+            nfields (int): the invalid number of fields.
+
+        Attributes:
+            nfields (int): the invalid number of field.
+        """
+        self.nfields = nfields
+        super().__init__('nfields_max should be >5 (received {})'
+                         .format(nfields))
+
+
 class InvalidZoomError(StagpyError):
 
     """Raised when invalid zoom is requested."""

stagpy/stagyydata.py

@@ -519,25 +519,19 @@ class StagyyData:
 
     """Generic lazy interface to StagYY output data."""
 
-    def __init__(self, path, nfields_max=50):
+    def __init__(self, path):
         """Initialization of instances:
 
         Args:
             path (pathlike): path of the StagYY run. It can either be the path
                 of the directory containing the par file, or the path of the
                 par file. If the path given is a directory, the path of the par
                 file is assumed to be path/par.
-            nfields_max (int): the maximum number of scalar fields that should
-                be kept in memory. Set to a value smaller than 6 if you want no
-                limit.
 
         Attributes:
             steps (:class:`_Steps`): collection of time steps.
             snaps (:class:`_Snaps`): collection of snapshots.
             scales (:class:`_Scales`): dimensionful scaling factors.
-            nfields_max (int): the maximum number of scalar fields that should
-                be kept in memory. Set to a value smaller than 6 if you want no
-                limit.
             collected_fields (list of (int, str)): list of fields currently in
                 memory, described by istep and field name.
         """
@@ -558,12 +552,11 @@ def __init__(self, path, nfields_max=50):
         self.refstate = _Refstate(self)
         self.steps = _Steps(self)
         self.snaps = _Snaps(self)
-        self.nfields_max = nfields_max
+        self._nfields_max = 50
         self.collected_fields = []
 
     def __repr__(self):
-        return 'StagyyData({}, nfields_max={})'.format(
-            repr(self.path), self.nfields_max)
+        return 'StagyyData({})'.format(repr(self.path))
 
     def __str__(self):
         return 'StagyyData in {}'.format(self.path)
@@ -684,6 +677,24 @@ def walk(self):
             return self.steps[conf.core.timesteps]
         return self.snaps[-1, ]
 
+    @property
+    def nfields_max(self):
+        """Maximum number of scalar fields kept in memory.
+
+        Setting this to a value lower or equal to 5 raises a
+        :class:`~stagpy.error.InvalidNfieldsError`.  Set this to ``None`` if
+        you do not want any limit on the number of scalar fields kept in
+        memory.  Defaults to 50.
+        """
+        return self._nfields_max
+
+    @nfields_max.setter
+    def nfields_max(self, nfields):
+        """Check nfields > 5 or None."""
+        if nfields is not None and nfields <= 5:
+            raise error.InvalidNfieldsError(nfields)
+        self._nfields_max = nfields
+
     def scale(self, data, unit):
         """Scales quantity to obtain dimensionful quantity.
 

tests/test_stagyydata.py

@@ -3,12 +3,33 @@
 import pandas
 import stagpy.stagyydata
 import stagpy._step
+import stagpy.error
 
 
 def test_sdat_path(example_dir, sdat):
     assert sdat.path == example_dir
 
 
+def test_sdat_deflt_nfields_max(sdat):
+    assert sdat.nfields_max == 50
+
+
+def test_sdat_set_nfields_max(sdat):
+    sdat.nfields_max = 6
+    assert sdat.nfields_max == 6
+
+
+def test_sdat_set_nfields_max_none(sdat):
+    sdat.nfields_max = None
+    assert sdat.nfields_max is None
+
+
+def test_sdat_set_nfields_max_invalid(sdat):
+    with pytest.raises(stagpy.error.InvalidNfieldsError) as err:
+        sdat.nfields_max = 5
+    assert err.value.nfields == 5
+
+
 def test_sdat_par(sdat):
     assert isinstance(sdat.par, f90nml.namelist.Namelist)