pyintervals 1.2.2__tar.gz → 1.4.0__tar.gz

{pyintervals-1.2.2 → pyintervals-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pyintervals
-Version: 1.2.2
+Version: 1.4.0
 Summary: Efficient interval operations.
 License: MIT
 Keywords: interval,timespan

{pyintervals-1.2.2 → pyintervals-1.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pyintervals"
-version = "1.2.2"
+version = "1.4.0"
 description = "Efficient interval operations."
 authors = ["Serkan Kalay <serkanosmankalay@gmail.com>"]
 license = "MIT"
@@ -47,7 +47,7 @@ isort = "^5.7.0"
 tox = ">=3.26,<5.0"
 
 [tool.black]
-line-length = 79
+line-length = 120
 include = '\.pyi?$'
 exclude = '''
 /(
@@ -63,7 +63,7 @@ exclude = '''
 '''
 
 [tool.isort]
-line_length = 79
+line_length = 120
 profile = 'black'
 add_imports = ['from __future__ import annotations']
 

{pyintervals-1.2.2 → pyintervals-1.4.0}/src/pyintervals/interval.py

@@ -12,9 +12,7 @@ class Interval:
 
     def __post_init__(self) -> None:
         if self.start > self.end:
-            raise RuntimeError(
-                f"Invalid interval: {self.end=} is earlier than {self.start=}"
-            )
+            raise RuntimeError(f"Invalid interval: {self.end=} is earlier than {self.start=}")
 
     def is_degenerate(self) -> bool:
         return self.start == self.end
@@ -29,14 +27,8 @@ class Interval:
         return contains(self, other)
 
 
-def _get_ordered(
-    interval: Interval, other: Interval
-) -> tuple[Interval, Interval]:
-    return (
-        (interval, other)
-        if interval.start <= other.start
-        else (other, interval)
-    )
+def _get_ordered(interval: Interval, other: Interval) -> tuple[Interval, Interval]:
+    return (interval, other) if interval.start <= other.start else (other, interval)
 
 
 def contains_point(interval: Interval, point: datetime) -> bool:
@@ -75,9 +67,7 @@ def contains(interval: Interval, other: Interval) -> bool:
     return interval.start <= other.start and interval.end >= other.end
 
 
-def intersection(
-    interval: Interval, other_interval: Interval
-) -> Interval | None:
+def intersection(interval: Interval, other_interval: Interval) -> Interval | None:
     if overlaps(interval, other_interval):
         return Interval(
             max([interval.start, other_interval.start]),

pyintervals-1.4.0/src/pyintervals/interval_handler.py

@@ -0,0 +1,208 @@
+from __future__ import annotations
+
+import itertools
+import operator
+from collections.abc import Callable, Collection, Iterable
+from dataclasses import dataclass
+from datetime import datetime, timedelta, timezone
+from zoneinfo import ZoneInfo
+
+import more_itertools
+from sortedcontainers import SortedList
+
+from .constants import TIME_ZERO
+from .interval import Interval
+from .search import weak_predecessor
+from .time_value_node import TimeValueNode, _simplify
+
+
+def _to_new_node(
+    active_node: TimeValueNode | None,
+    time_point: datetime,
+) -> TimeValueNode | None:
+    if active_node is None:
+        return TimeValueNode(time_point)
+
+    return TimeValueNode.clone(active_node, time_point) if active_node.time_point < time_point else None
+
+
+def _active_node_at_time(nodes: SortedList[TimeValueNode], when: datetime) -> TimeValueNode:
+    if node := weak_predecessor(nodes, TimeValueNode(when)):
+        return node
+    else:
+        raise RuntimeError("Could not find active node at time.")
+
+
+def _make_range(nodes: SortedList[TimeValueNode], new_interval: Interval) -> None:
+    for t in {new_interval.start, new_interval.end}:
+        if new_node := _to_new_node(
+            active_node=_active_node_at_time(nodes, t),
+            time_point=t,
+        ):
+            nodes.add(new_node)
+
+
+def _operate(
+    a: IntervalHandler,
+    b: IntervalHandler,
+    operand: Callable[[float, float], float],
+) -> IntervalHandler:
+    """Only call this function through the methods bound to `IntervalHandler`."""
+    if not isinstance(b, IntervalHandler):
+        raise TypeError(f"unsupported operand type(s) for {operand.__name__}: " f"'{type(a)}' and '{type(b)}'")
+    change_times = set(n.time_point for n in itertools.chain(a.projection_graph, b.projection_graph))
+
+    return IntervalHandler(
+        intervals=[
+            Interval(
+                start=start,
+                end=end,
+                value=operand(a.value_at_time(start), b.value_at_time(start)),
+            )
+            for start, end in more_itertools.pairwise(sorted(change_times))
+        ],
+        tz=a._tz,
+    )
+
+
+def _relevant_nodes(
+    nodes: SortedList[TimeValueNode],
+    interval: Interval,
+) -> list[TimeValueNode]:
+    if interval.is_degenerate():
+        return [_active_node_at_time(nodes, interval.start)]
+    else:
+        return [
+            n
+            for n in nodes.islice(start=nodes.index(_active_node_at_time(nodes, interval.start)))
+            if n.time_point <= interval.end
+        ]
+
+
+def _area_during_interval(handler: IntervalHandler, during: Interval) -> timedelta:
+    first_node_in_interval = TimeValueNode.clone(handler.node_at_time(during.start), during.start)
+    last_node_in_interval = TimeValueNode.clone(handler.node_at_time(during.end), during.end)
+
+    relevant_nodes = itertools.chain(
+        [first_node_in_interval],
+        # ↓ Everything except the first node, since it's not ↓
+        # ↓ necessarily part of the interval ↓
+        _relevant_nodes(handler.projection_graph, during)[1:],
+        [last_node_in_interval],
+    )
+
+    return sum(
+        (
+            during.value * start.value * (end.time_point - start.time_point)
+            for start, end in more_itertools.pairwise(relevant_nodes)
+        ),
+        start=timedelta(0),
+    )
+
+
+@dataclass
+class IntervalHandler:
+    __intervals: list[Interval]
+    __projection_graph: SortedList[TimeValueNode]
+    _tz: ZoneInfo | timezone | None
+    __first_negative: TimeValueNode | None = None
+
+    def __init__(
+        self,
+        intervals: Iterable[Interval] = [],
+        tz: ZoneInfo | timezone | None = None,
+    ):
+        self._initialize(tz)
+        self.add(intervals)
+
+    def _initialize(self, tz: ZoneInfo | timezone | None) -> None:
+        self.__intervals = list()
+        self.__projection_graph = SortedList([TimeValueNode(time_point=TIME_ZERO.replace(tzinfo=tz))])
+        self._tz = tz
+
+    @property
+    def intervals(self) -> list[Interval]:
+        return list(self.__intervals)
+
+    def __add__(self, other: IntervalHandler) -> IntervalHandler:
+        return _operate(self, other, operand=operator.add)
+
+    def __iadd__(self, other: IntervalHandler) -> None:
+        simplified = _operate(self, other, operand=operator.add)
+        self._initialize(tz=self._tz)
+        self.add(intervals=simplified.intervals)
+        return None
+
+    def __sub__(self, other: IntervalHandler) -> IntervalHandler:
+        return _operate(self, other, operand=operator.sub)
+
+    def __isub__(self, other: IntervalHandler) -> None:
+        simplified = _operate(self, other, operand=operator.sub)
+        self._initialize(tz=self._tz)
+        self.add(intervals=simplified.intervals)
+        return None
+
+    def __mul__(self, other: IntervalHandler) -> IntervalHandler:
+        return _operate(self, other, operand=operator.mul)
+
+    def __imul__(self, other: IntervalHandler) -> None:
+        simplified = _operate(self, other, operand=operator.mul)
+        self._initialize(tz=self._tz)
+        self.add(intervals=simplified.intervals)
+        return None
+
+    def __truediv__(self, other: IntervalHandler) -> IntervalHandler:
+        return _operate(self, other, operand=operator.truediv)
+
+    def __itruediv__(self, other: IntervalHandler) -> None:
+        simplified = _operate(self, other, operand=operator.truediv)
+        self._initialize(tz=self._tz)
+        self.add(intervals=simplified.intervals)
+        return None
+
+    def add(self, intervals: Iterable[Interval]) -> None:
+        """Adds without simplifying the intervals."""
+        self.__intervals.extend(intervals)
+        for interval in intervals:
+            _make_range(self.__projection_graph, interval)
+            for node in _relevant_nodes(self.__projection_graph, interval):
+                node._add_interval(interval)
+                self._try_refresh_first_negative_point(node)
+
+    def remove(self, intervals: Collection[Interval]) -> None:
+        """Removes without simplifying the intervals."""
+        self.__intervals = [i for i in self.__intervals if i not in intervals]
+
+        for interval in intervals:
+            for node in _relevant_nodes(self.__projection_graph, interval):
+                node._remove_interval(interval)
+                self._try_refresh_first_negative_point(node)
+
+        self.__projection_graph = SortedList(_simplify(self.__projection_graph))
+        if self.__first_negative is None:
+            self.__first_negative = next((n for n in self.__projection_graph if n.value < 0), None)
+
+    def _try_refresh_first_negative_point(self, node: TimeValueNode) -> None:
+        if node.value < 0:
+            if self.__first_negative is None or node.time_point < self.__first_negative.time_point:
+                self.__first_negative = node
+
+        if self.__first_negative and self.__first_negative.value >= 0:
+            self.__first_negative = None
+
+    @property
+    def projection_graph(self) -> SortedList[TimeValueNode]:
+        return SortedList(self.__projection_graph)
+
+    def node_at_time(self, when: datetime) -> TimeValueNode:
+        return _active_node_at_time(self.__projection_graph, when)
+
+    def value_at_time(self, when: datetime) -> float:
+        return _active_node_at_time(self.__projection_graph, when).value
+
+    def get_area(self, during: Interval) -> timedelta:
+        return _area_during_interval(self, during)
+
+    @property
+    def first_negative_point(self) -> TimeValueNode | None:
+        return self.__first_negative

{pyintervals-1.2.2 → pyintervals-1.4.0}/src/pyintervals/search.py

@@ -1,23 +1,26 @@
 from __future__ import annotations
 
 from bisect import bisect_left
-from typing import Sequence, TypeVar, cast
+from typing import TYPE_CHECKING, Sequence, Union
 
-T = TypeVar("T")
+if TYPE_CHECKING:
+    from _typeshed import SupportsRichComparisonT
 
 
-def weak_predecessor(sorted_sequence: Sequence[T], point: T) -> T | None:
+def weak_predecessor(
+    sorted_sequence: Sequence[SupportsRichComparisonT], point: SupportsRichComparisonT
+) -> Union[SupportsRichComparisonT, None]:
     # If the passed sequence is empty, then no predecessor.
     if not sorted_sequence:
         return None
 
-    insertion_point = bisect_left(sorted_sequence, point)  # type: ignore
+    insertion_point = bisect_left(sorted_sequence, point)
     if insertion_point == len(sorted_sequence):
         # Then, we need to insert to the end of the collection.
         # Hence, the weak predecessor is the last element in the list.
-        return cast(T, sorted_sequence[insertion_point - 1])
+        return sorted_sequence[insertion_point - 1]
 
-    if (current := sorted_sequence[insertion_point]) and current > point:
+    if (current := sorted_sequence[insertion_point]) and current > point:  # type: ignore[operator]
         # Then, we found a point which is the successor of our reference.
         # Hence, return the predecessor.
 
@@ -25,7 +28,7 @@ def weak_predecessor(sorted_sequence: Sequence[T], point: T) -> T | None:
         if insertion_point == 0:
             return None
         else:
-            return cast(T, sorted_sequence[insertion_point - 1])
+            return sorted_sequence[insertion_point - 1]
 
     # Otherwise, we found the correct point
-    return cast(T, current)
+    return current

{pyintervals-1.2.2 → pyintervals-1.4.0}/src/pyintervals/time_value_node.py

@@ -16,12 +16,8 @@ from pyintervals.interval import contains_point
 class TimeValueNode:
     time_point: datetime
     __intervals: SortedList[Interval] = field(default_factory=SortedList)
-    __starting_intervals: SortedList[Interval] = field(
-        default_factory=SortedList
-    )
-    __ending_intervals: SortedList[Interval] = field(
-        default_factory=SortedList
-    )
+    __starting_intervals: SortedList[Interval] = field(default_factory=SortedList)
+    __ending_intervals: SortedList[Interval] = field(default_factory=SortedList)
 
     @property
     def intervals(self) -> list[Interval]:
@@ -40,19 +36,12 @@ class TimeValueNode:
         return sum(i.value for i in self.__intervals if not i.is_degenerate())
 
     def is_redundant(self) -> bool:
-        return (
-            self.time_point > TIME_ZERO
-            and not self.__starting_intervals
-            and not self.__ending_intervals
-        )
+        return self.time_point > TIME_ZERO and not self.__starting_intervals and not self.__ending_intervals
 
     def __eq__(self, other: object) -> bool:
         if not isinstance(other, TimeValueNode):
             raise NotImplementedError
-        return (
-            self.time_point == other.time_point
-            and self.__intervals == other.__intervals
-        )
+        return self.time_point == other.time_point and self.__intervals == other.__intervals
 
     def __ne__(self, other: object) -> bool:
         return not (self == other)
@@ -97,9 +86,7 @@ class TimeValueNode:
             self.__ending_intervals.remove(interval)
 
     @staticmethod
-    def clone(
-        given: TimeValueNode, to_time: datetime | None = None
-    ) -> TimeValueNode:
+    def clone(given: TimeValueNode, to_time: datetime | None = None) -> TimeValueNode:
         return (
             TimeValueNode(given.time_point, SortedList(given.__intervals))
             if not to_time

pyintervals-1.2.2/src/pyintervals/interval_handler.py

@@ -1,129 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from datetime import datetime, timedelta
-from typing import Collection, Iterable, Sequence
-from zoneinfo import ZoneInfo
-
-from sortedcontainers import SortedList
-
-from .constants import TIME_ZERO
-from .interval import Interval, intersection
-from .search import weak_predecessor
-from .time_value_node import TimeValueNode, _simplify
-
-
-def _to_new_node(
-    active_node: TimeValueNode | None,
-    time_point: datetime,
-) -> TimeValueNode | None:
-    if active_node is None:
-        return TimeValueNode(time_point)
-
-    return (
-        TimeValueNode.clone(active_node, time_point)
-        if active_node.time_point < time_point
-        else None
-    )
-
-
-def _active_node_at_time(
-    nodes: SortedList[TimeValueNode], when: datetime
-) -> TimeValueNode:
-    if node := weak_predecessor(nodes, TimeValueNode(when)):
-        return node
-    else:
-        raise RuntimeError("Could not find active node at time.")
-
-
-def _make_range(
-    nodes: SortedList[TimeValueNode], new_interval: Interval
-) -> None:
-    for t in {new_interval.start, new_interval.end}:
-        if new_node := _to_new_node(
-            active_node=_active_node_at_time(nodes, t),
-            time_point=t,
-        ):
-            nodes.add(new_node)
-
-
-def _relevant_nodes(
-    nodes: SortedList[TimeValueNode],
-    interval: Interval,
-) -> list[TimeValueNode]:
-    if interval.is_degenerate():
-        return [_active_node_at_time(nodes, interval.start)]
-    else:
-        return [
-            n
-            for n in nodes.islice(
-                start=nodes.index(_active_node_at_time(nodes, interval.start))
-            )
-            if n.time_point <= interval.end
-        ]
-
-
-def _area_during_interval(
-    handler: IntervalHandler,
-    during: Interval,
-) -> timedelta:
-    return sum(
-        (
-            interval.value * during.value * overlap.duration()
-            for interval in handler.intervals
-            if (overlap := intersection(during, interval))
-        ),
-        start=timedelta(0),
-    )
-
-
-@dataclass
-class IntervalHandler:
-    __intervals: list[Interval]
-    __projection_graph: SortedList[TimeValueNode]
-
-    def __init__(
-        self, intervals: Iterable[Interval] = [], tz: ZoneInfo | None = None
-    ):
-        self._initialize(tz)
-        self.add(intervals)
-
-    def _initialize(self, tz: ZoneInfo | None) -> None:
-        self.__intervals = list()
-        self.__projection_graph = SortedList(
-            [TimeValueNode(time_point=TIME_ZERO.replace(tzinfo=tz))]
-        )
-
-    @property
-    def intervals(self) -> list[Interval]:
-        return list(self.__intervals)
-
-    def add(self, intervals: Iterable[Interval]) -> None:
-        self.__intervals.extend(intervals)
-        for interval in intervals:
-            _make_range(self.__projection_graph, interval)
-            for node in _relevant_nodes(self.__projection_graph, interval):
-                node._add_interval(interval)
-
-    def remove(self, intervals: Collection[Interval]) -> None:
-        self.__intervals = [i for i in self.__intervals if i not in intervals]
-
-        for interval in intervals:
-            for node in _relevant_nodes(self.__projection_graph, interval):
-                node._remove_interval(interval)
-
-        self.__projection_graph = SortedList(
-            _simplify(self.__projection_graph)
-        )
-
-    def projection_graph(self) -> Sequence[TimeValueNode]:
-        return list(self.__projection_graph)
-
-    def node_at_time(self, when: datetime) -> TimeValueNode:
-        return _active_node_at_time(self.__projection_graph, when)
-
-    def value_at_time(self, when: datetime) -> float:
-        return _active_node_at_time(self.__projection_graph, when).value
-
-    def get_area(self, during: Interval) -> timedelta:
-        return _area_during_interval(self, during)