110 lines
4.0 KiB
Python
110 lines
4.0 KiB
Python
from datetime import datetime
|
|
import re
|
|
|
|
class Event_Counter:
|
|
"""A class to track and count events, storing the event timestamps and allowing queries
|
|
|
|
for the number of events in specific time windows (e.g., last 5 minutes, 10 minutes)."""
|
|
REGEX_PATTERN = r'(\d+)\s*(sec|second|seconds|s|min|minute|minutes|m|h|hour|hours|d|day|days)'
|
|
TIME_MULTIPLIERS = {
|
|
'sec': 1, 'second': 1, 'seconds': 1, 's': 1,
|
|
'min': 60, 'minute': 60, 'minutes': 60, 'm': 60,
|
|
'h': 3600, 'hour': 3600, 'hours': 3600,
|
|
'd': 86400, 'day': 86400, 'days': 86400
|
|
}
|
|
|
|
def __init__(self, retention_duration:int = 900) -> None:
|
|
"""
|
|
Initializes the Event_Counter object with a specified retention duration.
|
|
|
|
Args:
|
|
retention_duration (int, optional):
|
|
The time period (in seconds) for which event data should be retained. Defaults to 900 (15 minutes).
|
|
|
|
uwu
|
|
"""
|
|
self.__events:list[float] = []
|
|
self.__total_events = 0
|
|
self.__retention_duration = retention_duration
|
|
|
|
def cleanup(self):
|
|
"""Cleans up events that are older than the retention duration.
|
|
|
|
Removes all events that occurred outside the defined retention window."""
|
|
offset_time = datetime.now().timestamp() - self.__retention_duration
|
|
while len(self.__events) > 0:
|
|
event_time = self.__events[0]
|
|
if event_time < offset_time:
|
|
self.__events.pop(0)
|
|
else:
|
|
break
|
|
|
|
@classmethod
|
|
def duration_to_seconds(cls, duration_str:str) -> int:
|
|
"""Converts a human-readable duration string (e.g., '5min 2sec') into its equivalent in seconds.
|
|
|
|
Args:
|
|
duration_str (str): The string representing the duration (e.g., "5min 2sec").
|
|
|
|
Returns:
|
|
int: The total duration in seconds derived from the input string."""
|
|
matches = re.findall(cls.REGEX_PATTERN, duration_str, flags=re.IGNORECASE)
|
|
|
|
total_seconds = 0
|
|
for value, unit in matches:
|
|
unit = unit.lower()
|
|
total_seconds += int(value) * cls.TIME_MULTIPLIERS[unit]
|
|
|
|
return total_seconds
|
|
|
|
def increment(self, count:int = 1, skip_cleanup:bool = False):
|
|
"""Increments the event count by a specified number of events.
|
|
|
|
Args:
|
|
count (int, optional): The number of events to add. Defaults to 1.
|
|
skip_cleanup (bool, optional): If True, skips the cleanup process. Defaults to False."""
|
|
timestamp = datetime.now().timestamp()
|
|
self.__total_events += count
|
|
self.__events.extend([timestamp] * count)
|
|
|
|
if skip_cleanup:
|
|
return
|
|
self.cleanup()
|
|
|
|
def get_count(self, time_window:str = "5M") -> int:
|
|
"""Returns the number of events that occurred within a specified time window.
|
|
|
|
Args:
|
|
time_window (str, optional):
|
|
The time window to query, e.g., "5M" for 5 minutes. Defaults to "5M".
|
|
|
|
Returns:
|
|
int: The count of events that occurred within the specified time window."""
|
|
self.cleanup()
|
|
|
|
offset_time = datetime.now().timestamp() - self.duration_to_seconds(time_window)
|
|
counter = 0
|
|
for event_time in self.__events:
|
|
if event_time > offset_time:
|
|
counter += 1
|
|
else:
|
|
break
|
|
|
|
return counter
|
|
|
|
def get_total_events(self) -> int:
|
|
"""Returns the total number of events tracked by the Event_Counter.
|
|
|
|
Returns:
|
|
int: The total number of events that have been recorded."""
|
|
return self.__total_events
|
|
|
|
if __name__ == "__main__":
|
|
from time import sleep
|
|
counter = Event_Counter(1)
|
|
counter.increment()
|
|
sleep(1)
|
|
counter.increment()
|
|
print(counter.get_count("5sEc"))
|
|
sleep(0)
|
|
print(counter.get_count("5sEc")) |