batutils 2.0.0__py3-none-any.whl

batutils/dtu/parsers/_timedelta.py

@@ -0,0 +1,161 @@
+__all__ = [
+    'str_to_delta',
+]
+from batutils.dtu.structs import *
+
+_PERIOD_PART = re.compile(r"([+-]?(?:\d+(?:\.(?:\d+)?)?|\.\d+))\s*([a-z]+)\s*", re.IGNORECASE)
+
+_KEYWORDS = {
+    'd': 'days',
+    'day': 'days',
+    'days': 'days',
+
+    'h': 'hours',
+    'hr': 'hours',
+    'hrs': 'hours',
+    'hour': 'hours',
+    'hours': 'hours',
+
+    'm': 'minutes',
+    'i': 'minutes',
+    'min': 'minutes',
+    'mins': 'minutes',
+    'minute': 'minutes',
+    'minutes': 'minutes',
+
+    's': 'seconds',
+    'sec': 'seconds',
+    'secs': 'seconds',
+    'second': 'seconds',
+    'seconds': 'seconds',
+
+    'w': 'weeks',
+    'wk': 'weeks',
+    'wks': 'weeks',
+    'week': 'weeks',
+    'weeks': 'weeks',
+}
+
+
+def _parse_split(string: str) -> Optional[List[Tuple[str, str]]]:
+    """Splits a string presumed to containing a written out time period into a
+    list of 2-tuples, each containing a numerical value first in string format
+    and then a unit keyword.
+
+    Strictly speaking this just searches for any number in a text (integer or
+    decimal, with an optional leading + or -) and the first word following that
+    number and pairs them up, but that basically does the job shockingly well.
+
+    Examples:
+        >>> _parse_split('2 days 7 hours 10 minutes')
+        [('2', 'days'), ('7', 'hours'), ('10', 'minutes')]
+
+        >>> _parse_split('2 days, 7.3 hours and 10 minutes')
+        [('2', 'days'), ('7.3', 'hours'), ('10', 'minutes')]
+
+        >>> _parse_split('2 days, 7.3 hrs and 10 mins')
+        [('2', 'days'), ('7.3', 'hrs'), ('10', 'mins')]
+
+        >>> _parse_split('2 days, -7.3 hrs and 10 floops')
+        [('2', 'days'), ('-7.3', 'hrs'), ('10', 'floops')]
+
+        >>> _parse_split('2d-7.3h10m')
+        [('2', 'd'), ('-7.3', 'h'), ('10', 'm')]
+
+        >>> _parse_split('1st of all, the 3 bears were really just 2 and-a-half bears')
+        [('1', 'st'), ('3', 'bears'), ('2', 'and')]
+    """
+    if string and isinstance(string, str):
+        buf = []
+        string = string.strip().lower()
+        for match in _PERIOD_PART.finditer(string):
+            buf.append(match.groups())
+        return buf or None
+    return None
+
+
+def _timedelta_keywords(list_of_lists: List[Tuple[str, str]]) -> Dict:
+    """Given a list of 2-tuples, containing the numerical value first in string
+    format and then a time unit keyword, parses the numerical value to a Python
+    float and changes any time unit format alias or shorthand into its
+    equivalent keyword that's a valid argument for initialising a timedelta,
+    and then pairs up each of those into a dict that can then be fed into
+    timedelta's __init__ as kwargs via the ** operator.
+
+    :raises KeyError: If a time unit keyword was not recognised
+    """
+    kw_map = {}
+    for num, kw in list_of_lists:
+        kw_map[_KEYWORDS[kw]] = float(num)
+    return kw_map
+
+
+def split_delta(delta, include_weeks=True, include_months=True, include_years=True):
+    """Splits a timedelta into the time periods it approximately
+    contains. Mean length of years and months are used and fractional
+    days/seconds might get shaved of but this is useful to evaluate individual
+    period lengths of displaying the maximum chunk of period a timedelta
+    contains.
+
+    This class includes an `is_past` property which is True if the timedelta
+    contained a negative value but all the values in the split are nevertheless
+    kept positive.
+
+    It also includes a few `largest` and `second_largest` properties that
+    contain the first and second period units that contain values greater than 0
+    in order of increasing accuracy (i.e. from year to second).
+
+    Example:
+
+        >>> total = datetime.timedelta(days=2002, seconds=20000)
+        >>> parts = split_delta(total)
+        >>> parts
+        {'seconds': 20, 'months': 5, 'days': 2, '2nd': 'months', 'hours': 5, '1st': 'years', 'is_past': False, 'weeks': 3, 'years': 5, 'minutes': 33}
+
+    :param delta: Time period to evaluate
+    :type delta: datetime.timedelta
+    :param include_weeks: Include weeks in the division (and reduce the days accordingly)?
+    :type include_weeks: bool
+    :rtype: dict
+    """
+    ds = DeltaSplit(time_delta=delta, include_weeks=include_weeks, include_months=include_months, include_years=include_years)
+    parts = ds.to_dict()
+    parts['1st'] = parts.pop('largest')
+    parts['2nd'] = parts.pop('second_largest')
+    return parts
+
+
+
+def str_to_delta(string: str, default: Any = 0) -> Union[TimeDelta, Any]:
+    """Converts a simple string with time duration keywords into a
+    `datetime.timedelta` object, akin to the keyword arguments in
+    `datetime.timedelta`.
+
+    Examples:
+    >>> str_to_delta('12days') == datetime.timedelta(days=12)
+    True
+    >>> str_to_delta('2h34m') == datetime.timedelta(hours=2, minutes=34)
+    True
+    >>> str_to_delta('-1.5 hours') == datetime.timedelta(hours=-1.5)
+    True
+
+    Valid keywords (and aliases):
+     - days (d, day)
+     - hours (h, hr, hrs, hour)
+     - minutes (m, i, min, mins, minute)
+     - seconds (s, sec, secs, second)
+     - weeks (w, wk, wks, week)
+
+    Numeric values can be integers or floats (with or without a plus or minus
+    sign) and all whitespaces are valid but ignored.
+    """
+    if default == 0:
+        default = TimeDelta(seconds=0)
+    res = _parse_split(string)
+    if res:
+        try:
+            return TimeDelta(**_timedelta_keywords(res))
+        except (ValueError, KeyError, IndexError):
+            return default
+    else:
+        return default

batutils/dtu/shortcuts/__init__.py

@@ -0,0 +1,3 @@
+from ._aliases import *
+from ._checkers import *
+from ._finders import *

batutils/dtu/shortcuts/_aliases.py

@@ -0,0 +1,29 @@
+__all__ = [
+    'now',
+    'now_time',
+    'today',
+    'ticks',
+]
+
+from batutils.dtu.structs import *
+import time
+
+
+def now() -> Datetime:
+    """Shortcut alias to `datetime.datetime.now()`"""
+    return Datetime.now()
+
+
+def now_time() -> Time:
+    """Shortcut alias to `datetime.datetime.now().time()`"""
+    return Datetime.now().time()
+
+
+def today() -> Date:
+    """Shortcut alias to `datetime.date.today()`"""
+    return Date.today()
+
+
+def ticks() -> float:
+    """Shortcut alias to `time.time()`"""
+    return time.time()

batutils/dtu/shortcuts/_checkers.py

@@ -0,0 +1,21 @@
+__all__ = [
+    'is_past',
+    'is_future',
+]
+
+from batutils.dtu.structs import *
+from batutils.dtu.casting import *
+from ._aliases import *
+
+
+def is_past(temporal_object: T_TEMPORAL_VALUE) -> bool:
+    """Returns true if the given temporal value is in the past.
+    """
+    return any_to_datetime(temporal_object) < now()
+
+
+def is_future(temporal_object: T_TEMPORAL_VALUE) -> bool:
+    """Returns true if the given temporal value is in the future.
+    """
+    return any_to_datetime(temporal_object) > now()
+

batutils/dtu/shortcuts/_finders.py

@@ -0,0 +1,80 @@
+__all__ = [
+    'next_time',
+    'next_weekday',
+    'set_midnight',
+    'from_now',
+    'ago',
+]
+
+from batutils.dtu.structs import *
+
+
+def next_time(find_time: Time, start_dt: Optional[Datetime] = None) -> Datetime:
+    """Find the earlier datetime when the given `find_time` occurs, after an
+    optional given `start_dt`, which is the current datetime by default.
+
+    Useful if you need something like "When does the next happy hour start?" if
+    "Happy-Hour" starts at 17:00 every day.
+
+    So if it's 2023-09-02 and 13:23:57...
+    >>> next_time(Time(17, 0))
+    datetime.datetime(2023, 9, 2, 17, 0, 0, 0)
+
+    But if its past 17, or 2023-09-02 and 19:23:57, we get tomorrow...
+    >>> next_time(Time(17, 0))
+    datetime.datetime(2023, 9, 3, 17, 0, 0, 0)
+    """
+    start_dt = start_dt or Datetime.now()
+    dt_with_time_replaced = Datetime.combine(start_dt.date(), find_time)
+    if dt_with_time_replaced <= start_dt:
+        # New time is BEFORE the original time, so move it forward by one day
+        dt_with_time_replaced += TimeDelta(days=1)
+    return dt_with_time_replaced
+
+
+def next_weekday(day_of_week: Union[Weekday, int],
+                 find_time: Optional[Time] = None,
+                 start_dt: Optional[Datetime] = None) -> Datetime:
+    """Find the earlier datetime occurrence of the given `day_of_week`
+    (where 0 = Monday) after an optional given `start_dt`, which is the current
+    datetime by default and using the optional given `find_time`, which is
+    midnight by default.
+    """
+    start_dt = start_dt or Datetime.now()  # Today
+    find_time = find_time or Time()  # Midnight
+    dt_with_time_replaced = datetime.datetime.combine(start_dt.date(), find_time)
+    if dt_with_time_replaced <= start_dt:
+        # New time is BEFORE the original time, so move it forward by one day
+        dt_with_time_replaced += datetime.timedelta(days=1)
+
+    # Now we need to advance enough days to land on the correct week day
+    days_to_advance = (day_of_week - dt_with_time_replaced.weekday()) % 7
+    return dt_with_time_replaced + datetime.timedelta(days=days_to_advance)
+
+
+def set_midnight(dt: T_DATE_VALUE) -> Datetime:
+    """Rounds off any hours, minutes, seconds, etc. of a datetime object and
+    sets the time to midnight that day or combines a date object with a time
+    object set to midnight.
+    """
+    if isinstance(dt, Datetime):
+        dt = dt.date()
+    if isinstance(dt, Date):
+        return datetime.datetime.combine(dt, Time())
+    return dt
+
+
+def from_now(days: T_NUMBER = 0, hours: T_NUMBER = 0, minutes: T_NUMBER = 0,
+             seconds: T_NUMBER = 0, weeks: T_NUMBER = 0) -> Datetime:
+    """Adds the given number of weeks, days, hours, minutes and/or seconds
+    to the current datetime and returns it.
+    """
+    return Datetime.now() + TimeDelta(days=days, hours=hours, minutes=minutes, seconds=seconds, weeks=weeks)
+
+
+def ago(days: T_NUMBER = 0, hours: T_NUMBER = 0, minutes: T_NUMBER = 0,
+           seconds: T_NUMBER = 0, weeks: T_NUMBER = 0) -> Datetime:
+    """Subtracts the given number of weeks, days, hours, minutes and/or seconds
+    from the current datetime and returns it.
+    """
+    return Datetime.now() - TimeDelta(days=days, hours=hours, minutes=minutes, seconds=seconds, weeks=weeks)

batutils/dtu/structs/__init__.py

@@ -0,0 +1,5 @@
+from batutils.dtu.structs._base import *
+from batutils.dtu.structs._deltasplit import *
+from batutils.dtu.structs.aliases import *
+from batutils.dtu.structs.consts import *
+from batutils.dtu.structs._types import *

batutils/dtu/structs/_base.py

@@ -0,0 +1,5 @@
+import datetime
+
+from batutils.structs._base import *  # noqa
+
+

batutils/dtu/structs/_deltasplit.py

@@ -0,0 +1,278 @@
+__all__ = [
+    'DeltaSplit',
+]
+
+from ._base import *
+from .aliases import *
+from .consts import *
+from ._types import *
+
+
+_field_size_map: Dict[str, T_NUMBER] = {
+    'years': DAYS_IN_MEAN_YEAR,  # Days
+    'months': DAYS_IN_MEAN_MONTH,  # Days
+    'weeks': 7,  # Days
+
+    'hours': SECONDS_IN_ONE_HOUR,
+    'minutes': SECONDS_IN_ONE_MINUTE,
+}
+
+_DEFAULT_DIRECTIONALS = ('in {}', '{} ago')
+
+
+@dataclasses.dataclass(frozen=True)
+class DeltaSplit:
+    """Splits a timedelta into the time periods it approximately
+    contains. Mean length of years and months are used and fractional
+    days/seconds might get shaved of but this is useful to evaluate individual
+    period lengths of displaying the maximum chunk of period a timedelta
+    contains.
+
+    This class includes an `is_past` property which is True if the timedelta
+    contained a negative value but all the values in the split are nevertheless
+    kept positive.
+
+    It also includes a few `largest` and `second_largest` properties that
+    contain the first and second period units that contain values greater than 0
+    in order of increasing accuracy (i.e. from year to second).
+    """
+
+    # Names of unit fields with non-zero values in order of unit size
+    field_order: Tuple[str] = dataclasses.field(default_factory=tuple, init=False)
+
+    is_past: bool = dataclasses.field(default=False, init=False)  # Is this counting backwards in time?
+
+    years: Optional[int] = dataclasses.field(default=None, init=False)  # Optional
+    months: Optional[int] = dataclasses.field(default=None, init=False)  # Optional
+    weeks: Optional[int] = dataclasses.field(default=None, init=False)  # Optional
+    days: int = dataclasses.field(default=0, init=False)
+    hours: int = dataclasses.field(default=0, init=False)
+    minutes: int = dataclasses.field(default=0, init=False)
+    seconds: int = dataclasses.field(default=0, init=False)
+
+    time_delta: dataclasses.InitVar[TimeDelta]
+    include_weeks: dataclasses.InitVar[bool] = True
+    include_months: dataclasses.InitVar[bool] = True
+    include_years: dataclasses.InitVar[bool] = True
+
+    def get(self, field_name: str) -> str:
+        return f'{self.get_value(field_name)} {self._render_field_name(field_name)}'
+
+    def get_value(self, field_name: str) -> int:
+        return getattr(self, field_name, 0) or 0
+
+    def _render_field_name(self, field_name: str) -> str:
+        if self.get_value(field_name) == 1:
+            return field_name[:-1]  # Cut off the trailing 's'
+        return field_name
+
+    def _be_greedy(self, field_name: str, total: T_NUMBER) -> T_NUMBER:
+        object.__setattr__(self, field_name, (int(total // _field_size_map[field_name])))
+        return total % _field_size_map[field_name]
+
+    def __post_init__(self, time_delta: TimeDelta, include_weeks: bool = True,
+                      include_months: bool = True, include_years: bool = True):
+        field_order = []
+        if time_delta.total_seconds() < 0:
+            object.__setattr__(self, 'is_past', True)
+            # Invert deltas in the past because they track negative days but positive seconds, which gets confusing
+            time_delta = datetime.timedelta(seconds=-time_delta.total_seconds())
+
+        days = abs(time_delta.days)
+        if include_years:
+            days = self._be_greedy('years', days)
+            if self.years:
+                field_order.append('years')
+
+        if include_months:
+            days = self._be_greedy('months', days)
+            if self.months:
+                field_order.append('months')
+
+        if include_weeks:
+            days = self._be_greedy('weeks', days)
+            if self.weeks:
+                field_order.append('weeks')
+
+        object.__setattr__(self, 'days', int(days))
+        if self.days:
+            field_order.append('days')
+
+        seconds = self._be_greedy('hours', abs(time_delta.seconds))
+        if self.hours:
+            field_order.append('hours')
+
+        seconds = self._be_greedy('minutes', seconds)
+        if self.minutes:
+            field_order.append('minutes')
+
+        object.__setattr__(self, 'seconds', int(seconds))
+        if self.seconds:
+            field_order.append('seconds')
+
+        object.__setattr__(self, 'field_order', tuple(field_order))
+
+    @property
+    def largest(self) -> str:
+        """
+        :return: The largest
+        """
+        if self.field_order:
+            return f'{self.largest_value} {self._render_field_name(self.largest_field_name)}'
+        return ''
+
+    @property
+    def largest_field_name(self) -> Optional[str]:
+        """
+        :return: The name of the largest unit field with a non-zero value or None if there is none.
+        """
+        if self.field_order:
+            return self.field_order[0]
+        else:
+            return None
+
+    @property
+    def largest_value(self) -> int:
+        """
+        :return: The value of the largest unit field with a non-zero value or 0.
+        """
+        return self.get_value(self.largest_field_name) if self.largest_field_name else 0
+
+    @property
+    def second_largest(self) -> str:
+        """
+        :return: The largest
+        """
+        if len(self.field_order) > 1:
+            return f'{self.second_largest_value} {self._render_field_name(self.second_largest_field_name)}'
+        return ''
+
+    @property
+    def second_largest_field_name(self) -> Optional[str]:
+        """
+        :return: The name of the second-largest unit field with a non-zero value or None if there is none.
+        """
+        if len(self.field_order) > 1:
+            return self.field_order[1]
+        else:
+            return None
+
+    @property
+    def second_largest_value(self) -> int:
+        """
+        :return: The value of the second-largest unit field with a non-zero value or 0.
+        """
+        return self.get_value(self.second_largest_field_name) if self.second_largest_field_name else 0
+
+    def to_str(self, max_number_of_fields: int = 2, include_seconds: bool = False,
+               directionals: Optional[Tuple[str, str]] = _DEFAULT_DIRECTIONALS,
+               no_time_str: str = 'no time at all',
+               only_sec_str: str = 'a few seconds',
+               granularity_halting_threshold: Optional[int] = 1) -> str:
+        """Returns a "human-readable" textual representation of this DeltaSplit, e.g.
+        - "3 weeks"
+        - "a few seconds"
+        - "1 year and 7 months"
+        - "7 years, 3 months, 1 week, 6 days, 34 minutes and 7 seconds"
+        - "no time at all"
+
+        :param max_number_of_fields: Maximum number of fields to include in the
+                                     output. There can at most be 7 fields with
+                                     values so any number than 6 will include
+                                     all possible fields. The default is 2.
+        :param include_seconds: By default, the seconds field is allways omitted
+                                if there are any other larger unit fields with
+                                non-zero values (even if `max_number_of_fields`
+                                says it should be included) and if the only
+                                non-zero value field is seconds, then the text
+                                "a few seconds" is returned. If
+                                `include seconds` is True, then the seconds
+                                field is treated as all other fields and
+                                returned if `max_number_of_fields` allows and
+                                the exact number of seconds are always used.
+        :param directionals: A two-tuple of strings to use as final formatters
+                             (using `{}` as placeholder for the actual string)
+                             for future and past values respectively. By
+                             default, this is `('in {}', '{} ago')` so future
+                             values format like "in 3 weeks" and past like "7
+                             days and 3 hours ago". This can be fully excluded
+                             by setting the `directionals` to None.
+        :param no_time_str: The string to return if this DeltaSplit contains no
+                            time (or less than a whole second).
+        :param only_sec_str: The string to return if `include_seconds` is False
+                             and the DeltaSplit only contains seconds. Default
+                             is `a few seconds`.
+        :param granularity_halting_threshold: An optional threshold value that,
+                                              if a field value exceeds, causes
+                                              the rendering to halt its granular
+                                              descent. E.g. if `granularity_halting_threshold=1`
+                                              and `max_number_of_fields=2` and
+                                              we have the fields `days=1,
+                                              hours=2, minutes=3` we'll get "1
+                                              day and 2 hours" while if `days=2,
+                                              hours=2, minutes=3` we'll just get
+                                              "2 days" because `days` exceeds
+                                              the threshold of 1 and thus halts
+                                              diving into more granular fields.
+                                              The default is `1` but setting
+                                              this to `None` will just turn this
+                                              check off entirely.
+        """
+        if not self.field_order:
+            return no_time_str
+
+        def _internal() -> str:
+            # First of all, let's take care of this case where we only have seconds!
+            if self.largest_field_name == 'seconds':
+                if include_seconds:
+                    return self.largest  # Include them
+                else:
+                    return only_sec_str  # Skip them
+
+            # Now for a more "generic" approach
+            fields = list(self.field_order[0:max_number_of_fields])
+            if not include_seconds and fields[-1] == 'seconds':  # We have, but don't want seconds!
+                fields = fields[0:-1]  # Remove Seconds
+
+            as_strings = []
+            for f in fields:
+                as_strings.append(self.get(f))
+                if granularity_halting_threshold and self.get_value(f) > granularity_halting_threshold:
+                    break
+
+            if len(as_strings) == 1:
+                return as_strings[0]
+
+            elif len(as_strings) == 2:
+                return f'{as_strings[0]} and {as_strings[1]}'
+
+            else:
+                return f'{", ".join(as_strings[0:-1])} and {as_strings[-1]}'
+
+        if directionals:
+            if self.is_past:
+                return directionals[1].format(_internal())
+            return directionals[0].format(_internal())
+        return _internal()
+
+    def __str__(self) -> str:
+        return self.to_str()
+
+    def __repr__(self) -> str:
+        return f'<DeltaSplit {self.to_str(max_number_of_fields=7, directionals=("{}", "{}, is_past=True"), no_time_str="0", include_seconds=True,  granularity_halting_threshold=None)}>'
+
+    def to_dict(self) -> Dict:
+        parts = {'largest': self.largest_field_name,
+                 'second_largest': self.second_largest_field_name,
+                 'is_past': self.is_past,
+                 'days': self.days,
+                 'hours': self.hours,
+                 'minutes': self.minutes,
+                 'seconds': self.seconds}
+        if self.years:
+            parts['years'] = self.years
+        if self.months:
+            parts['months'] = self.months
+        if self.weeks:
+            parts['weeks'] = self.weeks
+        return parts

batutils/dtu/structs/_types.py

@@ -0,0 +1,24 @@
+__all__ = [
+    'T_DATETIME_VALUE',
+    'T_DATE_VALUE',
+    'T_TIME_VALUE',
+    'T_TEMPORAL_VALUE',
+    'T_NUMBER',
+]
+
+from batutils.dtu.structs._base import *
+
+# Any datetime value
+T_DATETIME_VALUE = Union[datetime.datetime, datetime.date, datetime.time]
+
+# Containing a date
+T_DATE_VALUE = Union[datetime.datetime, datetime.date]
+
+# Containing time
+T_TIME_VALUE = Union[datetime.datetime, datetime.time]
+
+# Any type that can possibly contain a date and/or time value
+T_TEMPORAL_VALUE = Union[T_DATETIME_VALUE, float, int, str, bytes]
+
+# Number
+T_NUMBER = Union[int, float]

batutils/dtu/structs/aliases.py

@@ -0,0 +1,21 @@
+__all__ = [
+    'Date',
+    'Time',
+    'Datetime',
+    'TimeDelta',
+    'TzInfo',
+    'TimeZone',
+]
+from batutils.dtu.structs._base import *
+
+# Aliases to "standard" PEP 8 class names. This is to increase readability and
+# reduce confusion related to the fact that the most commonly used class/object
+# shared the name of its own module (i.e. `datetime.datetime`)
+Date = datetime.date
+Time = datetime.time
+Datetime = datetime.datetime
+TimeDelta = datetime.timedelta
+TzInfo = datetime.tzinfo
+TimeZone = datetime.timezone
+
+

batutils/dtu/structs/consts.py

@@ -0,0 +1,35 @@
+__all__ = [
+    'DAYS_IN_MEAN_YEAR',
+    'DAYS_IN_MEAN_MONTH',
+    'DAYS_IN_MEDIAN_YEAR',
+    'DAYS_IN_MEDIAN_MONTH',
+    'WHOLE_DAYS_IN_MEAN_YEAR',
+    'WHOLE_DAYS_IN_MEAN_MONTH',
+    'SECONDS_IN_ONE_MINUTE',
+    'SECONDS_IN_ONE_HOUR',
+    'SECONDS_IN_ONE_DAY',
+    'Weekday',
+]
+
+import enum
+
+DAYS_IN_MEAN_YEAR = 365.2425  # Every 400 years we get 97 leap years (303*365 + 97*366)/400
+DAYS_IN_MEAN_MONTH = 30.436875  # Mean Year / 12
+DAYS_IN_MEDIAN_YEAR = 365  # Most common value (303 vs. 97 per 400 year cycle)
+DAYS_IN_MEDIAN_MONTH = 31  # Most common value (7 out of 12)
+WHOLE_DAYS_IN_MEAN_YEAR = 365
+WHOLE_DAYS_IN_MEAN_MONTH = 30
+
+SECONDS_IN_ONE_MINUTE = 60
+SECONDS_IN_ONE_HOUR = 3600  # 60 * 60
+SECONDS_IN_ONE_DAY = 86400  # 60 * 60 * 24
+
+
+class Weekday(enum.IntEnum):
+    MONDAY = 0
+    TUESDAY = 1
+    WEDNESDAY = 2
+    THURSDAY = 3
+    FRIDAY = 4
+    SATURDAY = 5
+    SUNDAY = 6

batutils/structs/__init__.py

@@ -0,0 +1,7 @@
+from batutils.structs._base import *
+
+from batutils.tpu.structs.empty import *
+from batutils.tpu.structs.singleton import *
+from batutils.tpu.structs.enumex import *
+
+from batutils.dtu.structs.aliases import *