Let from_break find and return proper gaps

strax/processing/general.py

@@ -51,18 +51,24 @@ def endtime(x):
 
 @export
 @numba.jit(nopython=True, nogil=True, cache=True)
-def from_break(x, safe_break=10000, left=True, tolerant=False):
+def from_break(x, safe_break, not_before=0, left=True, tolerant=False):
     """Return records on side of a break at least safe_break long
     If there is no such break, return the best break found.
     """
-    # TODO: This is extremely rough. Better to find proper gaps, and if we
-    # know the timing of the readers, consider breaks at end and start too.
-    break_i = find_break_i(x, safe_break=safe_break, tolerant=tolerant)
+    if tolerant:
+        raise NotImplementedError
+    if not len(x):
+        raise NotImplementedError("Cannot find breaks in empty data")
+    if len(x) == 1:
+        raise NoBreakFound()
+
+    break_i = _find_break_i(x, safe_break=safe_break, not_before=not_before)
+    break_time = x[break_i]['time']
 
     if left:
-        return x[:break_i]
+        return x[:break_i], break_time
     else:
-        return x[break_i:]
+        return x[break_i:], break_time
 
 
 @export
@@ -72,30 +78,25 @@ class NoBreakFound(Exception):
 
 @export
 @numba.jit(nopython=True, nogil=True, cache=True)
-def find_break_i(x, safe_break, tolerant=True):
-    """Returns LAST index of x whose time is more than safe_break away
-    from the x before
+def _find_break_i(data, safe_break, not_before):
+    """Return first index of element right of the first gap
+    larger than safe_break in data.
+
+    Assumes all x have the same length and are sorted!
+
     :param tolerant: if no break found, yield an as good as possible break
     anyway.
     """
-    max_gap = 0
-    max_gap_i = -1
-    for _i in range(len(x) - 1):
-        i = len(x) - 1 - _i
-        gap = x[i]['time'] - x[i - 1]['time']
-        if gap >= safe_break:
+    assert len(data) >= 2
+    latest_end_seen = max(not_before, strax.endtime(data[0]))
+    for i, d in enumerate(data):
+        if i == 0:
+            continue
+        if d['time'] >= latest_end_seen + safe_break:
             return i
-        if gap > max_gap:
-            max_gap_i = i
-            max_gap = gap
-
-    if not tolerant:
-        raise NoBreakFound
-
-    print("\t\tDid not find safe break, using largest available break: ",
-          max_gap,
-          " ns")
-    return max_gap_i
+        latest_end_seen = max(latest_end_seen,
+                              strax.endtime(d))
+    raise NoBreakFound
 
 
 @export

tests/test_general_processing.py

@@ -127,28 +127,41 @@ def test_split_array(data, t, allow_early_split):
 @hypothesis.settings(deadline=None)
 @hypothesis.given(strax.testutils.several_fake_records)
 def test_from_break(records):
+    if not len(records):
+        return
+
     window = 5
 
     def has_break(x):
         if len(x) < 2:
             return False
-        return np.diff(x['time']).max() > window
+        for i in range(1, len(x)):
+            if strax.endtime(x[:i]).max() + window <= x[i]['time']:
+                return True
+        return False
 
     try:
-        left = strax.from_break(records, safe_break=window,
-                                left=True, tolerant=False)
-        right = strax.from_break(records, safe_break=window,
-                                 left=False, tolerant=False)
+        left, t_break_l = strax.from_break(records, safe_break=window,
+                                           left=True, tolerant=False)
+        right, t_break_r = strax.from_break(records, safe_break=window,
+                                            left=False, tolerant=False)
     except strax.NoBreakFound:
         assert not has_break(records)
 
     else:
-        assert len(left) + len(right) == len(records)
+        assert t_break_l == t_break_r, "Inconsistent break time"
+        t_break = t_break_l
+
+        assert has_break(records), f"Found nonexistent break at {t_break}"
+
+        assert len(left) + len(right) == len(records), "Data loss"
+
         if len(records) > 0:
             np.testing.assert_equal(np.concatenate([left, right]),
                                     records)
-        if len(left) and len(right):
-            assert left[-1]['time'] <= right[0]['time'] - window
+        if len(right) and len(left):
+            assert t_break == right[0]['time']
+            assert strax.endtime(left).max() <= right[0]['time'] - window
         assert not has_break(right)