add proxy for the first part and try to develop the second part

2025-12-03 12:08:56 +00:00
parent 6c34d510e5
commit 460f18d85a
1095 changed files with 358799 additions and 5 deletions
@@ -0,0 +1,110 @@
+import heapq
+from typing import Iterator
+
+import arrow
+from arrow.arrow import Arrow
+
+from .event import Event
+
+
+class Timeline(object):
+    def __init__(self, calendar) -> None:
+        """Instanciates a new Timeline.
+        (You should not have to instanciate a new timeline by yourself)
+
+        Args:
+            calendar : :class:`ics.icalendar.Calendar`
+        """
+        self._calendar = calendar
+
+    def __iter__(self) -> Iterator[Event]:
+        """Iterates on every event from the :class:`ics.icalendar.Calendar` in chronological order
+
+        Note :
+            - chronological order is defined by the comparaison operators in :class:`ics.event.Event`
+            - Events with no `begin` will not appear here. (To list all events in a `Calendar` use `Calendar.events`)
+        """
+        # Using a heap is faster than sorting if the number of events (n) is
+        # much bigger than the number of events we extract from the iterator (k).
+        # Complexity: O(n + k log n).
+        heap = [x for x in self._calendar.events if x.begin is not None]
+        heapq.heapify(heap)
+        while heap:
+            yield heapq.heappop(heap)
+
+    def included(self, start: Arrow, stop: Arrow) -> Iterator[Event]:
+        """Iterates (in chronological order) over every event that is included
+        in the timespan between `start` and `stop`
+
+        Args:
+            start : (Arrow object)
+            stop : (Arrow object)
+        """
+        for event in self:
+            if (start <= event.begin <= stop # if start is between the bonds
+            and start <= event.end <= stop): # and stop is between the bonds
+                yield event
+
+    def overlapping(self, start: Arrow, stop: Arrow) -> Iterator[Event]:
+        """Iterates (in chronological order) over every event that has an intersection
+        with the timespan between `start` and `stop`
+
+        Args:
+            start : (Arrow object)
+            stop : (Arrow object)
+        """
+        for event in self:
+            if ((start <= event.begin <= stop # if start is between the bonds
+            or start <= event.end <= stop) # or stop is between the bonds
+            or event.begin <= start and event.end >= stop): # or event is a superset of [start,stop]
+                yield event
+
+    def start_after(self, instant: Arrow) -> Iterator[Event]:
+        """Iterates (in chronological order) on every event from the :class:`ics.icalendar.Calendar` in chronological order.
+        The first event of the iteration has a starting date greater (later) than `instant`
+
+        Args:
+            instant : (Arrow object) starting point of the iteration
+        """
+        for event in self:
+            if event.begin > instant:
+                yield event
+
+    def at(self, instant: Arrow) -> Iterator[Event]:
+        """Iterates (in chronological order) over all events that are occuring during `instant`.
+
+        Args:
+            instant (Arrow object)
+        """
+
+        for event in self:
+            if event.begin <= instant <= event.end:
+                yield event
+
+    def on(self, day: Arrow, strict: bool = False) -> Iterator[Event]:
+        """Iterates (in chronological order) over all events that occurs on `day`
+
+        Args:
+            day (Arrow object)
+            strict (bool): if True events will be returned only if they are\
+            strictly *included* in `day`.
+        """
+        day_start, day_stop = day.floor('day').span('day')
+        if strict:
+            return self.included(day_start, day_stop)
+        else:
+            return self.overlapping(day_start, day_stop)
+
+    def today(self, strict: bool = False) -> Iterator[Event]:
+        """Iterates (in chronological order) over all events that occurs today
+
+        Args:
+            strict (bool): if True events will be returned only if they are\
+            strictly *included* in `day`.
+        """
+        return self.on(arrow.now(), strict=strict)
+
+    def now(self) -> Iterator[Event]:
+        """Iterates (in chronological order) over all events that occurs now
+        """
+        return self.at(arrow.now())