boris-behav-obs 8.16.6__py3-none-any.whl → 9.7.1__py3-none-any.whl

boris/portion/interval.py

@@ -2,7 +2,7 @@ from collections import namedtuple
 from .const import Bound, inf
 
 
-Atomic = namedtuple('Atomic', ['left', 'lower', 'upper', 'right'])
+Atomic = namedtuple("Atomic", ["left", "lower", "upper", "right"])
 
 
 def mergeable(a, b):
@@ -96,7 +96,7 @@ class Interval:
     one of the helpers provided in this module (open, closed, openclosed, etc.)
     """
 
-    __slots__ = ('_intervals',)
+    __slots__ = ("_intervals",)
 
     def __init__(self, *intervals):
         """
@@ -111,7 +111,7 @@ class Interval:
                 if not interval.empty:
                     self._intervals.extend(interval._intervals)
             else:
-                raise TypeError('Parameters must be Interval instances')
+                raise TypeError("Parameters must be Interval instances")
 
         if len(self._intervals) == 0:
             # So we have at least one (empty) interval
@@ -181,10 +181,7 @@ class Interval:
         """
         True if interval is empty, False otherwise.
         """
-        return (
-            self.lower > self.upper or
-            (self.lower == self.upper and (self.left == Bound.OPEN or self.right == Bound.OPEN))
-        )
+        return self.lower > self.upper or (self.lower == self.upper and (self.left == Bound.OPEN or self.right == Bound.OPEN))
 
     @property
     def atomic(self):
@@ -307,7 +304,7 @@ class Interval:
             elif isinstance(value, tuple):
                 intervals.append(Interval.from_atomic(*value))
             else:
-                raise TypeError('Unsupported return type {} for {}'.format(type(value), value))
+                raise TypeError("Unsupported return type {} for {}".format(type(value), value))
 
         return Interval(*intervals)
 
@@ -350,7 +347,7 @@ class Interval:
                     return True
             return False
         else:
-            raise TypeError('Unsupported type {} for {}'.format(type(other), other))
+            raise TypeError("Unsupported type {} for {}".format(type(other), other))
 
     def intersection(self, other):
         """
@@ -468,14 +465,8 @@ class Interval:
             if item.empty:
                 return True
             elif self.atomic:
-                left = item.lower > self.lower or (
-                    item.lower == self.lower and
-                    (item.left == self.left or self.left == Bound.CLOSED)
-                )
-                right = item.upper < self.upper or (
-                    item.upper == self.upper and
-                    (item.right == self.right or self.right == Bound.CLOSED)
-                )
+                left = item.lower > self.lower or (item.lower == self.lower and (item.left == self.left or self.left == Bound.CLOSED))
+                right = item.upper < self.upper or (item.upper == self.upper and (item.right == self.right or self.right == Bound.CLOSED))
                 return left and right
             else:
                 selfiter = iter(self)
@@ -504,13 +495,11 @@ class Interval:
     def __invert__(self):
         complements = [
             Interval.from_atomic(Bound.OPEN, -inf, self.lower, ~self.left),
-            Interval.from_atomic(~self.right, self.upper, inf, Bound.OPEN)
+            Interval.from_atomic(~self.right, self.upper, inf, Bound.OPEN),
         ]
 
         for i, j in zip(self._intervals[:-1], self._intervals[1:]):
-            complements.append(
-                Interval.from_atomic(~i.right, i.upper, j.lower, ~j.left)
-            )
+            complements.append(Interval.from_atomic(~i.right, i.upper, j.lower, ~j.left))
 
         return Interval(*complements)
 
@@ -526,12 +515,7 @@ class Interval:
                 return False
 
             for a, b in zip(self._intervals, other._intervals):
-                eq = (
-                    a.left == b.left and
-                    a.lower == b.lower and
-                    a.upper == b.upper and
-                    a.right == b.right
-                )
+                eq = a.left == b.left and a.lower == b.lower and a.upper == b.upper and a.right == b.right
                 if not eq:
                     return False
             return True
@@ -543,8 +527,7 @@ class Interval:
             if self.right == Bound.OPEN:
                 return self.upper <= other.lower
             else:
-                return self.upper < other.lower or \
-                    (self.upper == other.lower and other.left == Bound.OPEN)
+                return self.upper < other.lower or (self.upper == other.lower and other.left == Bound.OPEN)
         else:
             return self.upper < other or (self.right == Bound.OPEN and self.upper == other)
 
@@ -553,8 +536,7 @@ class Interval:
             if self.left == Bound.OPEN:
                 return self.lower >= other.upper
             else:
-                return self.lower > other.upper or \
-                    (self.lower == other.upper and other.right == Bound.OPEN)
+                return self.lower > other.upper or (self.lower == other.upper and other.right == Bound.OPEN)
         else:
             return self.lower > other or (self.left == Bound.OPEN and self.lower == other)
 
@@ -563,8 +545,7 @@ class Interval:
             if self.right == Bound.OPEN:
                 return self.upper <= other.upper
             else:
-                return self.upper < other.upper or \
-                    (self.upper == other.upper and other.right == Bound.CLOSED)
+                return self.upper < other.upper or (self.upper == other.upper and other.right == Bound.CLOSED)
         else:
             return self.lower < other or (self.left == Bound.CLOSED and self.lower == other)
 
@@ -573,8 +554,7 @@ class Interval:
             if self.left == Bound.OPEN:
                 return self.lower >= other.lower
             else:
-                return self.lower > other.lower or \
-                    (self.lower == other.lower and other.left == Bound.CLOSED)
+                return self.lower > other.lower or (self.lower == other.lower and other.left == Bound.CLOSED)
         else:
             return self.upper > other or (self.right == Bound.CLOSED and self.upper == other)
 
@@ -586,16 +566,16 @@ class Interval:
 
         for interval in self:
             if interval.empty:
-                intervals.append('()')
+                intervals.append("()")
             elif interval.lower == interval.upper:
-                intervals.append('[{}]'.format(repr(interval.lower)))
+                intervals.append("[{}]".format(repr(interval.lower)))
             else:
                 intervals.append(
-                    '{}{},{}{}'.format(
-                        '[' if interval.left == Bound.CLOSED else '(',
+                    "{}{},{}{}".format(
+                        "[" if interval.left == Bound.CLOSED else "(",
                         repr(interval.lower),
                         repr(interval.upper),
-                        ']' if interval.right == Bound.CLOSED else ')',
+                        "]" if interval.right == Bound.CLOSED else ")",
                     )
                 )
-        return ' | '.join(intervals)
+        return " | ".join(intervals)

boris/portion/io.py

@@ -4,9 +4,20 @@ from .const import Bound, inf
 from .interval import Interval
 
 
-def from_string(string, conv, *, bound=r'.+?', disj=r' ?\| ?', sep=r', ?',
-                left_open=r'\(', left_closed=r'\[', right_open=r'\)', right_closed=r'\]',
-                pinf=r'\+inf', ninf=r'-inf'):
+def from_string(
+    string,
+    conv,
+    *,
+    bound=r".+?",
+    disj=r" ?\| ?",
+    sep=r", ?",
+    left_open=r"\(",
+    left_closed=r"\[",
+    right_open=r"\)",
+    right_closed=r"\]",
+    pinf=r"\+inf",
+    ninf=r"-inf",
+):
     """
     Parse given string and create an Interval instance.
     A converter function has to be provided to convert a bound (as string) to a value.
@@ -25,11 +36,11 @@ def from_string(string, conv, *, bound=r'.+?', disj=r' ?\| ?', sep=r', ?',
     :return: an Interval instance.
     """
 
-    re_left_boundary = r'(?P<left>{}|{})'.format(left_open, left_closed)
-    re_right_boundary = r'(?P<right>{}|{})'.format(right_open, right_closed)
-    re_bounds = r'(?P<lower>{bound})({sep}(?P<upper>{bound}))?'.format(bound=bound, sep=sep)
-    re_interval = r'{}(|{}){}'.format(re_left_boundary, re_bounds, re_right_boundary)
-    re_intervals = r'{}(?P<disj>{})?'.format(re_interval, disj)
+    re_left_boundary = r"(?P<left>{}|{})".format(left_open, left_closed)
+    re_right_boundary = r"(?P<right>{}|{})".format(right_open, right_closed)
+    re_bounds = r"(?P<lower>{bound})({sep}(?P<upper>{bound}))?".format(bound=bound, sep=sep)
+    re_interval = r"{}(|{}){}".format(re_left_boundary, re_bounds, re_right_boundary)
+    re_intervals = r"{}(?P<disj>{})?".format(re_interval, disj)
 
     intervals = []
     has_more = True
@@ -49,22 +60,23 @@ def from_string(string, conv, *, bound=r'.+?', disj=r' ?\| ?', sep=r', ?',
         else:
             group = match.groupdict()
 
-            left = Bound.CLOSED if re.match(left_closed + '$', group['left']) else Bound.OPEN
-            right = Bound.CLOSED if re.match(right_closed + '$', group['right']) else Bound.OPEN
+            left = Bound.CLOSED if re.match(left_closed + "$", group["left"]) else Bound.OPEN
+            right = Bound.CLOSED if re.match(right_closed + "$", group["right"]) else Bound.OPEN
 
-            lower = group.get('lower', None)
-            upper = group.get('upper', None)
+            lower = group.get("lower", None)
+            upper = group.get("upper", None)
             lower = _convert(lower) if lower is not None else inf
             upper = _convert(upper) if upper is not None else lower
 
             intervals.append(Interval.from_atomic(left, lower, upper, right))
-            string = string[match.end():]
+            string = string[match.end() :]
 
     return Interval(*intervals)
 
 
-def to_string(interval, conv=repr, *, disj=' | ', sep=',', left_open='(',
-              left_closed='[', right_open=')', right_closed=']', pinf='+inf', ninf='-inf'):
+def to_string(
+    interval, conv=repr, *, disj=" | ", sep=",", left_open="(", left_closed="[", right_open=")", right_closed="]", pinf="+inf", ninf="-inf"
+):
     """
     Export given interval to string.
 
@@ -81,7 +93,7 @@ def to_string(interval, conv=repr, *, disj=' | ', sep=',', left_open='(',
     :return: a string representation for given interval.
     """
     if interval.empty:
-        return '{}{}'.format(left_open, right_open)
+        return "{}{}".format(left_open, right_open)
 
     def _convert(bound):
         if bound == inf:
@@ -100,14 +112,14 @@ def to_string(interval, conv=repr, *, disj=' | ', sep=',', left_open='(',
         upper = _convert(item.upper)
 
         if item.lower == item.upper:
-            exported_intervals.append('{}{}{}'.format(left, lower, right))
+            exported_intervals.append("{}{}{}".format(left, lower, right))
         else:
-            exported_intervals.append('{}{}{}{}{}'.format(left, lower, sep, upper, right))
+            exported_intervals.append("{}{}{}{}{}".format(left, lower, sep, upper, right))
 
     return disj.join(exported_intervals)
 
 
-def from_data(data, conv=None, *, pinf=float('inf'), ninf=float('-inf')):
+def from_data(data, conv=None, *, pinf=float("inf"), ninf=float("-inf")):
     """
     Import an interval from a piece of data.
 
@@ -130,16 +142,18 @@ def from_data(data, conv=None, *, pinf=float('inf'), ninf=float('-inf')):
 
     for item in data:
         left, lower, upper, right = item
-        intervals.append(Interval.from_atomic(
-            Bound(left),
-            _convert(lower),
-            _convert(upper),
-            Bound(right),
-        ))
+        intervals.append(
+            Interval.from_atomic(
+                Bound(left),
+                _convert(lower),
+                _convert(upper),
+                Bound(right),
+            )
+        )
     return Interval(*intervals)
 
 
-def to_data(interval, conv=None, *, pinf=float('inf'), ninf=float('-inf')):
+def to_data(interval, conv=None, *, pinf=float("inf"), ninf=float("-inf")):
     """
     Export given interval to a list of 4-uples (left, lower,
     upper, right).
@@ -163,10 +177,5 @@ def to_data(interval, conv=None, *, pinf=float('inf'), ninf=float('-inf')):
             return conv(bound)
 
     for item in interval:
-        data.append((
-            item.left.value,
-            _convert(item.lower),
-            _convert(item.upper),
-            item.right.value
-        ))
+        data.append((item.left.value, _convert(item.lower), _convert(item.upper), item.right.value))
     return data