Remove _step.EmptyStep logic

Non existing snapshots now raise InvalidSnapshotError akin to
InvalidTimestepError. This is less surprising than returning a
dummy object and allow for handling missing data using the error
handling tools of Python.

Author: amorison

stagpy/_step.py

@@ -444,25 +444,11 @@ def isnap(self):
             # memory for what it's worth if search algo is efficient)
             while (istep is None or istep < self.istep) and isnap < 99999:
                 isnap += 1
-                istep = self.sdat.snaps[isnap].istep
+                try:
+                    istep = self.sdat.snaps[isnap].istep
+                except KeyError:
+                    pass
                 # all intermediate istep could have their ._isnap to None
             if istep != self.istep:
                 self._isnap = None
         return self._isnap
-
-
-class EmptyStep(Step):
-    """Dummy step object for nonexistent snaps.
-
-    This class inherits from :class:`Step`, but its :meth:`__getattribute__`
-    method always return :obj:`None`. Its instances are falsy values.
-    """
-
-    def __init__(self):
-        super().__init__(None, None)
-
-    def __getattribute__(self, name):
-        return None
-
-    def __bool__(self):
-        return False

stagpy/error.py

@@ -95,6 +95,29 @@ def __init__(self, sdat, istep, msg):
         super().__init__(sdat, istep, msg)
 
 
+class InvalidSnapshotError(StagpyError, KeyError):
+    """Raised when invalid snapshot is requested.
+
+    Args:
+        sdat (:class:`~stagpy.stagyydata.StagyyData`): the StagyyData
+            instance for which the request was made.
+        isnap (int): the invalid snapshot index.
+        msg (str): the error message.
+
+    Attributes:
+        sdat (:class:`~stagpy.stagyydata.StagyyData`): the StagyyData
+            instance for which the request was made.
+        isnap (int): the invalid snapshot index.
+        msg (str): the error message.
+    """
+
+    def __init__(self, sdat, isnap, msg):
+        self.sdat = sdat
+        self.isnap = isnap
+        self.msg = msg
+        super().__init__(sdat, isnap, msg)
+
+
 class InvalidTimeFractionError(StagpyError):
     """Raised when invalid fraction of series is requested.
 

stagpy/stagyydata.py

@@ -192,14 +192,12 @@ class _Steps:
     def __init__(self, sdat):
         self.sdat = sdat
         self._len = UNDETERMINED
-        self._data = {None: _step.EmptyStep()}  # for non existent snaps
+        self._data = {}
 
     def __repr__(self):
         return '{}.steps'.format(repr(self.sdat))
 
     def __getitem__(self, istep):
-        if istep is None:
-            return self._data[None]
         keys = _as_view_item(istep)
         if keys is not None:
             return _StepsView(self, keys)
@@ -316,6 +314,9 @@ def __getitem__(self, isnap):
                 self._bind(isnap, istep)
             else:
                 self._isteps[isnap] = None
+        if istep is None:
+            raise error.InvalidSnapshotError(
+                self.sdat, isnap, 'Invalid snapshot index')
         return self.sdat.steps[istep]
 
     def __delitem__(self, isnap):
@@ -430,8 +431,12 @@ def __repr__(self):
             rep += '.filter({})'.format(', '.join(flts))
         return rep
 
-    def _pass(self, step):
-        """Check whether a :class:`~stagpy._step.Step` passes the filters."""
+    def _pass(self, item):
+        """Check whether an item passes the filters."""
+        try:
+            step = self._col[item]
+        except KeyError:
+            return False
         okf = True
         okf = okf and (not self._flt['snap'] or step.isnap is not None)
         okf = okf and (not self._flt['rprof'] or step.rprof is not None)
@@ -475,8 +480,8 @@ def __iter__(self):
             if isinstance(item, slice):
                 idx = item.indices(len(self._col))
                 yield from (self._col[i] for i in range(*idx)
-                            if self._pass(self._col[i]))
-            elif self._pass(self._col[item]):
+                            if self._pass(i))
+            elif self._pass(item):
                 yield self._col[item]
 
     def __eq__(self, other):

tests/test_stagyydata.py

@@ -72,8 +72,8 @@ def test_snaps_last(sdat):
 
 
 def test_snaps_empty(sdat):
-    empty = sdat.snaps[len(sdat.snaps)]
-    assert isinstance(empty, stagpy._step.EmptyStep)
+    with pytest.raises(stagpy.error.InvalidSnapshotError):
+        sdat.snaps[len(sdat.snaps)]
 
 
 def test_step_is_snap(sdat):