Remove _Steps.last and _Snaps.last

They are relics from when _Steps and _Snaps were not implementing
the Mapping interface correctly.  The logic in the last property
are now in the __len__ special method.  Access to the last step
or snap should be done with the canonical [-1] syntax.

Author: amorison

docs/sources/cookbook/nura.rst

@@ -1,7 +1,7 @@
 Plotting a scalar diagnostic as function of control parameter
 =============================================================
 
-Stagpy is suitable for scripting using StagyyData. Suppose you have a group 
+StagPy is suitable for scripting using StagyyData. Suppose you have a group
 of directories, each for a given set of parameters,
 and you want to plot the results of all cases on the same figure, compute
 statistics etc. The :class:`~stagpy.stagyydata.StagyyData` class comes in handy
@@ -27,7 +27,7 @@ the script is executed::
       # get the value of the Rayleigh number
       ran.append(sdat.par['refstate']['ra0'])
       # get the last value of the Nusselt number
-      nun.append(sdat.steps.last.timeinfo['Nutop'])
+      nun.append(sdat.steps[-1].timeinfo['Nutop'])
 
   ran = np.array(ran)
   nun = np.array(nun)

docs/sources/stagyydata.rst

@@ -192,7 +192,7 @@ Tracer data (position, mass, composition...) are accessible through
 :attr:`_Step.tracers<stagpy.stagyydata._Step.tracers>` using the
 property name as key.  They are organized by block.  For example,
 the masses of tracers in the first block is obtained with
-``sdat.snaps.last.tracers['Mass'][0]``. This is a one dimensional
+``sdat.snaps[-1].tracers['Mass'][0]``. This is a one dimensional
 array containing the mass of each tracers. Their positions can be
 recovered through the ``'x'``, ``'y'`` and ``'z'`` items.
 

stagpy/_step.py

@@ -361,8 +361,8 @@ class Step:
         instances.
 
         >>> sdat = StagyyData('path/to/run')
-        >>> istep_last_snap = sdat.snaps.last.istep
-        >>> assert(sdat.steps[istep_last_snap] is sdat.snaps.last)
+        >>> istep_last_snap = sdat.snaps[-1].istep
+        >>> assert(sdat.steps[istep_last_snap] is sdat.snaps[-1])
         >>> n = 0  # or any valid time step / snapshot index
         >>> assert(sdat.steps[n].sdat is sdat)
         >>> assert(sdat.steps[n].istep == n)

stagpy/commands.py

@@ -22,8 +22,8 @@ def info_cmd():
     """
     varlist = [var for var in conf.info.output.replace(',', ' ').split()]
     sdat = stagyydata.StagyyData(conf.core.path)
-    lsnap = sdat.snaps.last
-    lstep = sdat.steps.last
+    lsnap = sdat.snaps[-1]
+    lstep = sdat.steps[-1]
     print('StagYY run in {}'.format(sdat.path))
     if lsnap.geom.threed:
         dimension = '{} x {} x {}'.format(lsnap.geom.nxtot,

stagpy/processing.py

@@ -72,7 +72,7 @@ def ebalance(sdat, tstart=None, tend=None):
         tuple of :class:`numpy.array`: energy balance and time arrays.
     """
     tseries = sdat.tseries_between(tstart, tend)
-    rbot, rtop = misc.get_rbounds(sdat.steps.last)
+    rbot, rtop = misc.get_rbounds(sdat.steps[-1])
     if rbot != 0:  # spherical
         coefsurf = (rtop / rbot)**2
         volume = rbot * ((rtop / rbot)**3 - 1) / 3

stagpy/stagyydata.py

@@ -198,7 +198,7 @@ def __init__(self, sdat):
                 :class:`_Steps` instance.
         """
         self.sdat = sdat
-        self._last = UNDETERMINED
+        self._len = UNDETERMINED
         self._data = {None: _step.EmptyStep()}  # for non existent snaps
 
     def __repr__(self):
@@ -221,7 +221,7 @@ def __getitem__(self, istep):
                 istep -= len(self)
                 raise error.InvalidTimestepError(
                     self.sdat, istep,
-                    'Last istep is {}'.format(self.last.istep))
+                    'Last istep is {}'.format(len(self) - 1))
         if istep not in self._data:
             self._data[istep] = _step.Step(istep, self.sdat)
         return self._data[istep]
@@ -233,7 +233,10 @@ def __delitem__(self, istep):
             del self._data[istep]
 
     def __len__(self):
-        return self.last.istep + 1
+        if self._len is UNDETERMINED:
+            # not necessarily the last one...
+            self._len = self.sdat.tseries.index[-1] + 1
+        return self._len
 
     def __iter__(self):
         return iter(self[:])
@@ -270,19 +273,6 @@ def filter(self, **filters):
         """Build a _StepsView with requested filters."""
         return self[:].filter(**filters)
 
-    @property
-    def last(self):
-        """Last time step available.
-
-        Example:
-            >>> sdat = StagyyData('path/to/run')
-            >>> assert(sdat.steps.last is sdat.steps[-1])
-        """
-        if self._last is UNDETERMINED:
-            # not necessarily the last one...
-            self._last = self.sdat.tseries.index[-1]
-        return self[self._last]
-
 
 class _Snaps(_Steps):
 
@@ -343,15 +333,15 @@ def __delitem__(self, isnap):
         del self.sdat.steps[istep]
 
     def __len__(self):
-        if self._last is UNDETERMINED:
-            self._last = -1
+        if self._len is UNDETERMINED:
+            self._len = -1
             if self.sdat.hdf5:
                 isnap = -1
                 for isnap, istep in stagyyparsers.read_time_h5(self.sdat.hdf5):
                     self._bind(isnap, istep)
-                self._last = isnap
+                self._len = isnap
                 self._all_isteps_known = True
-            if self._last < 0:
+            if self._len < 0:
                 out_stem = re.escape(pathlib.Path(
                     self.sdat.par['ioin']['output_file_stem'] + '_').name[:-1])
                 rgx = re.compile(
@@ -360,10 +350,11 @@ def __len__(self):
                 for fname in self.sdat._files:
                     match = rgx.match(fname.name)
                     if match is not None and match.group(1) in fstems:
-                        self._last = max(int(match.group(2)), self._last)
-            if self._last < 0:
+                        self._len = max(int(match.group(2)), self._len)
+            if self._len < 0:
                 raise error.NoSnapshotError(self.sdat)
-        return self._last + 1
+            self._len += 1
+        return self._len
 
     def at_time(self, time, after=False):
         """Return snap corresponding to a given physical time.
@@ -405,16 +396,6 @@ def _bind(self, isnap, istep):
         self._isteps[isnap] = istep
         self.sdat.steps[istep]._isnap = isnap
 
-    @property
-    def last(self):
-        """Last snapshot available.
-
-        Example:
-            >>> sdat = StagyyData('path/to/run')
-            >>> assert(sdat.snaps.last is sdat.snaps[-1])
-        """
-        return self[len(self) - 1]
-
 
 class _StepsView:
 

tests/conftest.py

@@ -21,4 +21,4 @@ def sdat(example_dir):
 
 @pytest.fixture(scope='module')
 def step(sdat):
-    return sdat.snaps.last
+    return sdat.snaps[-1]

tests/test_parsers.py

@@ -25,22 +25,21 @@ def test_rprof_invalid_prs():
 
 
 def test_fields_prs(sdat):
-    hdr, flds = prs.fields(sdat.filename('t', sdat.snaps.last.isnap))
+    hdr, flds = prs.fields(sdat.filename('t', len(sdat.snaps) - 1))
     assert flds.shape[0] == 1
     assert flds.shape[4] == 1
     assert flds.shape[1:4] == tuple(hdr['nts'])
 
 
 def test_fields_header_only_prs(sdat):
-    hdr = prs.fields(sdat.filename('t', sdat.snaps.last.isnap),
-                     only_header=True)
+    hdr = prs.fields(sdat.filename('t', len(sdat.snaps) - 1), only_header=True)
     assert hdr['nts'].shape == (3,)
 
 
 def test_fields_istep_only_prs(sdat):
-    istep = prs.fields(sdat.filename('t', sdat.snaps.last.isnap),
+    istep = prs.fields(sdat.filename('t', len(sdat.snaps) - 1),
                        only_istep=True)
-    assert istep == sdat.snaps.last.istep
+    assert istep == sdat.snaps[-1].istep
 
 
 def test_fields_invalid_prs():

tests/test_stagyydata.py

@@ -68,7 +68,7 @@ def test_filter_even_steps(sdat):
 
 
 def test_snaps_last(sdat):
-    assert sdat.snaps.last is sdat.snaps[-1]
+    assert sdat.snaps[-1] is sdat.snaps[len(sdat.snaps) - 1]
 
 
 def test_snaps_empty(sdat):
@@ -77,8 +77,8 @@ def test_snaps_empty(sdat):
 
 
 def test_step_is_snap(sdat):
-    istep = sdat.snaps.last.istep
-    assert sdat.steps[istep] is sdat.snaps.last
+    istep = sdat.snaps[-1].istep
+    assert sdat.steps[istep] is sdat.snaps[-1]
 
 
 def test_step_sdat(sdat):