dateutilx 0.2.0__tar.gz → 0.4.0__tar.gz

{dateutilx-0.2.0 → dateutilx-0.4.0}/.gitignore

@@ -17,9 +17,6 @@ venv/
 .hypothesis/
 .coverage
 
-# Autogenerated version information
-src/dateutilx/_version.py
-
 # Sphinx documentation
 docs/_build/
 docs/docs_venv

{dateutilx-0.2.0 → dateutilx-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: dateutilx
-Version: 0.2.0
+Version: 0.4.0
 Summary: Modern extension to the standard Python datetime module
 Project-URL: Homepage, https://github.com/rsb-23/dateutilx
 Project-URL: Documentation, https://dateutilx.readthedocs.io/en/stable/

{dateutilx-0.2.0/src → dateutilx-0.4.0/dateutilx}/__init__.py

@@ -13,7 +13,7 @@ def __getattr__(name):
 
     if name in __all__:
         return importlib.import_module(f".{name}", __name__)
-    raise AttributeError(f"module {__name__!r} has not attribute {name!r}")
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
 
 
 def __dir__():

{dateutilx-0.2.0/src → dateutilx-0.4.0/dateutilx}/parser/_parser.py

@@ -39,8 +39,8 @@ from decimal import Decimal
 from io import StringIO
 from warnings import warn
 
-from src import relativedelta, tz
-from src.errors import ParserError, UnknownTimezoneWarning
+from dateutilx import relativedelta, tz
+from dateutilx.errors import ParserError, UnknownTimezoneWarning
 
 from .utils import standard_dt_parser
 
@@ -391,15 +391,16 @@ class _YMD(list):
         return 1 <= value <= monthrange(year, month)[1]
 
     def append(self, val, label=None):
+        _valid_labels = (None, "Y")
         if hasattr(val, "__len__"):
             if val.isdigit() and len(val) > 2:
                 self.century_specified = True
-                if label not in [None, "Y"]:  # pragma: no cover
+                if label not in _valid_labels:  # pragma: no cover
                     raise ValueError(label)
                 label = "Y"
         elif val > 100:
             self.century_specified = True
-            if label not in [None, "Y"]:  # pragma: no cover
+            if label not in _valid_labels:  # pragma: no cover
                 raise ValueError(label)
             label = "Y"
 
@@ -426,7 +427,7 @@ class _YMD(list):
         if len(self) == 3 and len(strids) == 2:
             # we can back out the remaining stridx value
             missing = [x for x in range(3) if x not in strids.values()]
-            key = [x for x in ["y", "m", "d"] if x not in strids]
+            key = [x for x in ("y", "m", "d") if x not in strids]
             assert len(missing) == len(key) == 1
             key = key[0]
             val = missing[0]
@@ -562,8 +563,8 @@ class Parser:
             .. doctest::
                :options: +NORMALIZE_WHITESPACE
 
-                >>> from src.parser import parse
-                >>> from src.tz import gettz
+                >>> from dateutilx.parser import parse
+                >>> from dateutilx.tz import gettz
                 >>> tzinfos = {"BRST": -7200, "CST": gettz("America/Chicago")}
                 >>> parse("2012-01-19 17:21:00 BRST", tzinfos=tzinfos)
                 datetime.datetime(2012, 1, 19, 17, 21, tzinfo=tzoffset(u'BRST', -7200))
@@ -667,7 +668,7 @@ class Parser:
 
             .. doctest::
 
-                >>> from src.parser import parse
+                >>> from dateutilx.parser import parse
                 >>> parse("Today is January 1, 2047 at 8:21:00AM", fuzzy_with_tokens=True)
                 (datetime.datetime(2047, 1, 1, 8, 21), (u'Today is ', u' ', u'at '))
 
@@ -1022,8 +1023,7 @@ class Parser:
     def _could_be_tzname(self, hour, tzname, tzoffset, token):
         return (
             hour is not None
-            and tzname is None
-            and tzoffset is None
+            and tzname is tzoffset is None
             and len(token) <= 5
             and (all(x in string.ascii_uppercase for x in token) or token in self.info.UTCZONE)
         )
@@ -1132,9 +1132,9 @@ class Parser:
         if isinstance(tzdata, datetime.tzinfo) or tzdata is None:
             tzinfo = tzdata
         elif isinstance(tzdata, str):
-            tzinfo = tz.tzstr(tzdata)
+            tzinfo = tz.TzStr(tzdata)
         elif isinstance(tzdata, int):
-            tzinfo = tz.tzoffset(tzname, tzdata)
+            tzinfo = tz.TzOffset(tzname, tzdata)
         else:
             raise TypeError("Offset must be tzinfo subclass, tz string, or int offset.")
         return tzinfo
@@ -1146,7 +1146,7 @@ class Parser:
             aware = self._assign_tzname(aware, res.tzname)
 
         elif res.tzname and res.tzname in time.tzname:
-            aware = naive.replace(tzinfo=tz.tzlocal())
+            aware = naive.replace(tzinfo=tz.TzLocal())
 
             # Handle ambiguous local datetime
             aware = self._assign_tzname(aware, res.tzname)
@@ -1159,7 +1159,7 @@ class Parser:
             aware = naive.replace(tzinfo=tz.UTC)
 
         elif res.tzoffset:
-            aware = naive.replace(tzinfo=tz.tzoffset(res.tzname, res.tzoffset))
+            aware = naive.replace(tzinfo=tz.TzOffset(res.tzname, res.tzoffset))
 
         elif not res.tzname:
             # i.e. no timezone information was found.
@@ -1268,8 +1268,8 @@ def parse(timestr, parser_info=None, **kwargs):
         .. doctest::
            :options: +NORMALIZE_WHITESPACE
 
-            >>> from src.parser import parse
-            >>> from src.tz import gettz
+            >>> from dateutilx.parser import parse
+            >>> from dateutilx.tz import gettz
             >>> tzinfos = {"BRST": -7200, "CST": gettz("America/Chicago")}
             >>> parse("2012-01-19 17:21:00 BRST", tzinfos=tzinfos)
             datetime.datetime(2012, 1, 19, 17, 21, tzinfo=tzoffset(u'BRST', -7200))
@@ -1305,7 +1305,7 @@ def parse(timestr, parser_info=None, **kwargs):
 
         .. doctest::
 
-            >>> from src.parser import parse
+            >>> from dateutilx.parser import parse
             >>> parse("Today is January 1, 2047 at 8:21:00AM", fuzzy_with_tokens=True)
             (datetime.datetime(2047, 1, 1, 8, 21), (u'Today is ', u' ', u'at '))
 
@@ -1370,7 +1370,7 @@ class _TzParser:
 
                 used_idxs.extend([*range(j)])
                 i = j
-                if i < len_l and (_tmp_list[i] in ("+", "-") or _tmp_list[i][0] in "0123456789"):
+                if i < len_l and (_tmp_list[i] in ("+", "-") or _tmp_list[i][0] in string.digits):
                     if _tmp_list[i] in ("+", "-"):
                         # Yes, that's right. See the TZ variable documentation.
                         signal = (1, -1)[_tmp_list[i] == "+"]
@@ -1462,7 +1462,7 @@ class _TzParser:
                     for x in _tmp_list[i:]
                     if x not in (",", "/", "J", "M", ".", "-", ":")
                     for y in x
-                    if y not in "0123456789"
+                    if y not in string.digits
                 ]
             ):
                 for x in (res.start, res.end):

{dateutilx-0.2.0/src → dateutilx-0.4.0/dateutilx}/parser/isoparser.py

@@ -10,9 +10,10 @@ ISO-8601 specification.
 import calendar
 import datetime as dt
 import re
+import string
 from functools import wraps
 
-from src.tz import UTC, TzOffset
+from dateutilx.tz import UTC, TzOffset
 
 __all__ = ["isoparse", "isoparser"]
 
@@ -49,7 +50,7 @@ class IsoParser:
             For strict ISO-8601 adherence, pass ``'T'``.
         """
         if sep is not None:
-            if len(sep) != 1 or ord(sep) >= 128 or sep in "0123456789":
+            if len(sep) != 1 or ord(sep) >= 128 or sep in string.digits:
                 raise ValueError("Separator must be a single, non-numeric " + "ASCII character")
 
             sep = sep.encode("ascii")
@@ -107,10 +108,10 @@ class IsoParser:
         - `±HHMM`
         - `±HH`
 
-        Offsets will be represented as :class:`dateutilx.tz.tzoffset` objects,
+        Offsets will be represented as :class:`dateutilx.tz.TzOffset` objects,
         with the exception of UTC, which will be represented as
-        :class:`dateutilx.tz.tzutc`. Time zone offsets equivalent to UTC (such
-        as `+00:00`) will also be represented as :class:`dateutilx.tz.tzutc`.
+        :class:`dateutilx.tz.TzUTC`. Time zone offsets equivalent to UTC (such
+        as `+00:00`) will also be represented as :class:`dateutilx.tz.TzUTC`.
 
         :param dt_str:
             A string or stream containing only an ISO-8601 datetime string
@@ -188,11 +189,11 @@ class IsoParser:
             A string representing an ISO time zone offset
 
         :param zero_as_utc:
-            Whether to return :class:`dateutilx.tz.tzutc` for zero-offset zones
+            Whether to return :class:`dateutilx.tz.TzUTC` for zero-offset zones
 
         :return:
-            Returns :class:`dateutilx.tz.tzoffset` for offsets and
-            :class:`dateutilx.tz.tzutc` for ``Z`` and (if ``zero_as_utc`` is
+            Returns :class:`dateutilx.tz.TzOffset` for offsets and
+            :class:`dateutilx.tz.TzUTC` for ``Z`` and (if ``zero_as_utc`` is
             specified) offsets equivalent to UTC.
         """
         return self._parse_tzstr(tzstr, zero_as_utc=zero_as_utc)
@@ -202,6 +203,13 @@ class IsoParser:
     _TIME_SEP = b":"
     _FRACTION_REGEX = re.compile(b"[.,]([0-9]+)")
 
+    def _parse_digits(self, s, pos, n):
+        """Parse exactly ``n`` ASCII digits starting at ``pos``."""
+        digits = s[pos : pos + n]
+        if len(digits) != n or not digits.isdigit():
+            raise ValueError("Expected {} digits, got {!r}".format(n, digits.decode("ascii")))
+        return int(digits)
+
     def _parse_isodate(self, dt_str: str) -> tuple:
         if len(dt_str) < 4:
             raise ValueError("ISO string too short")
@@ -216,7 +224,7 @@ class IsoParser:
         components = [1, 1, 1]
 
         # Year
-        components[0] = int(dt_str[:4])
+        components[0] = self._parse_digits(dt_str, 0, 4)
         pos = 4
         if pos >= len_str:
             return components, pos
@@ -229,7 +237,7 @@ class IsoParser:
         if len_str - pos < 2:
             raise ValueError("Invalid common month")
 
-        components[1] = int(dt_str[pos : pos + 2])
+        components[1] = self._parse_digits(dt_str, pos, 2)
         pos += 2
 
         if pos >= len_str:
@@ -245,12 +253,12 @@ class IsoParser:
         # Day
         if len_str - pos < 2:
             raise ValueError("Invalid common day")
-        components[2] = int(dt_str[pos : pos + 2])
+        components[2] = self._parse_digits(dt_str, pos, 2)
         return components, pos + 2
 
     def _parse_isodate_uncommon(self, dt_str: str) -> tuple:
         # All ISO formats start with the year
-        year = int(dt_str[:4])
+        year = self._parse_digits(dt_str, 0, 4)
 
         has_sep = dt_str[4:5] == self._DATE_SEP
 
@@ -258,7 +266,7 @@ class IsoParser:
         if dt_str[pos : pos + 1] == b"W":
             # YYYY-?Www-?D?
             pos += 1
-            weekno = int(dt_str[pos : pos + 2])
+            weekno = self._parse_digits(dt_str, pos, 2)
             pos += 2
 
             dayno = 1
@@ -268,7 +276,7 @@ class IsoParser:
 
                 pos += has_sep
 
-                dayno = int(dt_str[pos : pos + 1])
+                dayno = self._parse_digits(dt_str, pos, 1)
                 pos += 1
 
             base_date = self._calculate_weekdate(year, weekno, dayno)
@@ -277,7 +285,7 @@ class IsoParser:
             if len(dt_str) - pos < 3:
                 raise ValueError("Invalid ordinal day")
 
-            ordinal_day = int(dt_str[pos : pos + 3])
+            ordinal_day = self._parse_digits(dt_str, pos, 3)
             pos += 3
 
             if ordinal_day < 1 or ordinal_day > (365 + calendar.isleap(year)):
@@ -347,7 +355,7 @@ class IsoParser:
 
             if comp < 3:
                 # Hour, minute, second
-                components[comp] = int(timestr[pos : pos + 2])
+                components[comp] = self._parse_digits(timestr, pos, 2)
                 pos += 2
 
             if comp == 3:
@@ -383,13 +391,16 @@ class IsoParser:
         else:
             raise ValueError("Time zone offset requires sign")
 
-        hours = int(tzstr[1:3])
+        hours = self._parse_digits(tzstr, 1, 2)
         if len(tzstr) == 3:
             minutes = 0
         else:
-            minutes = int(tzstr[(4 if tzstr[3:4] == self._TIME_SEP else 3) :])
+            pos = 4 if tzstr[3:4] == self._TIME_SEP else 3
+            if len(tzstr) != pos + 2:
+                raise ValueError("Invalid minutes in time zone offset")
+            minutes = self._parse_digits(tzstr, pos, 2)
 
-        if zero_as_utc and hours == 0 and minutes == 0:
+        if zero_as_utc and hours == minutes == 0:
             return UTC
 
         if minutes > 59:

{dateutilx-0.2.0/src → dateutilx-0.4.0/dateutilx}/relativedelta.py

@@ -3,18 +3,13 @@ import datetime as dt
 import operator
 from math import copysign
 from types import NotImplementedType
-from typing import Self, TypeAlias
+from typing import Self
 from warnings import warn
 
-from src.weekday import Weekday, weekdays
+from dateutilx.utils import Weekday, weekdays
 
-MO, TU, WE, TH, FR, SA, SU = weekdays
-
-__all__ = ["RelativeDelta", "MO", "TU", "WE", "TH", "FR", "SA", "SU"]
-Number: TypeAlias = float | int
-
-REL_FIELDS = "years", "months", "days", "hours", "minutes", "seconds", "microseconds"
-ABS_FIELDS = "year", "month", "day", "hour", "minute", "second", "microsecond"
+__all__ = ["RelativeDelta"]
+Number = float | int
 
 
 class RelativeDelta:
@@ -91,7 +86,7 @@ class RelativeDelta:
     For example
 
     >>> from datetime import datetime
-    >>> from src.relativedelta import RelativeDelta, MO
+    >>> from dateutilx.relativedelta import RelativeDelta, MO
     >>> dt_ = datetime(2018, 4, 9, 13, 37, 0)
     >>> delta = RelativeDelta(hours=25, day=1, weekday=MO(1))
     >>> dt_ + delta
@@ -217,25 +212,48 @@ class RelativeDelta:
 
         yday = nlyearday or yearday
 
-        if yearday and not nlyearday and yearday > 59:
+        if yearday and not nlyearday and (59 < yearday < 366):
+            # Shifting for leapday except Dec 32/31
             self.leapdays = -1
 
         if yday:
             if not 1 <= yday <= 366:
                 raise ValueError(f"invalid year day ({yday})")
 
-            resolved = dt.date(2001, 1, 1) + dt.timedelta(days=yday - 1)
+            resolved = dt.date(2001, 1, 1) + dt.timedelta(days=min(yday, 365) - 1)
             self.day, self.month = resolved.day, resolved.month
 
+    def _absolutes(self) -> dict[str, Number]:
+        return {
+            "year": self.year,
+            "month": self.month,
+            "day": self.day,
+            "hour": self.hour,
+            "minute": self.minute,
+            "second": self.second,
+            "microsecond": self.microsecond,
+        }
+
+    def _relatives(self) -> dict[str, Number]:
+        return {
+            "years": self.years,
+            "months": self.months,
+            "days": self.days,
+            "hours": self.hours,
+            "minutes": self.minutes,
+            "seconds": self.seconds,
+            "microseconds": self.microseconds,
+        }
+
     def _reset(self):
         self.leapdays = 0
         self.weekday = None
         self._has_time = 0
 
-        for attr in REL_FIELDS:
+        for attr in ("years", "months", "days", "hours", "minutes", "seconds", "microseconds"):
             setattr(self, attr, 0)
 
-        for attr in ABS_FIELDS:
+        for attr in ("year", "month", "day", "hour", "minute", "second", "microsecond"):
             setattr(self, attr, None)
 
     def _fix(self):
@@ -295,8 +313,8 @@ class RelativeDelta:
 
     def _make_relativedelta(self, **kwargs) -> Self:
         """Factory method to create a new RelativeDelta with given overrides."""
-        rel_fields = {field: kwargs.get(field, getattr(self, field)) for field in REL_FIELDS}
-        abs_fields = {field: kwargs.get(field, getattr(self, field)) for field in ABS_FIELDS}
+        rel_fields = {field: kwargs.get(field, val) for field, val in self._relatives().items()}
+        abs_fields = {field: kwargs.get(field, val) for field, val in self._absolutes().items()}
         return self.__class__(
             **rel_fields,
             **abs_fields,
@@ -337,8 +355,8 @@ class RelativeDelta:
     def __add__(self, other):
         if isinstance(other, RelativeDelta):
             kwargs = {
-                field: getattr(self, field) if getattr(other, field) is None else getattr(other, field)
-                for field in ABS_FIELDS
+                field: val if getattr(other, field) is None else getattr(other, field)
+                for field, val in self._absolutes().items()
             }
             return self._make_relativedelta(
                 years=other.years + self.years,
@@ -376,7 +394,7 @@ class RelativeDelta:
                 month += 12
         day = min(calendar.monthrange(year, month)[1], self.day or other.day)
         repl = {"year": year, "month": month, "day": day}
-        for attr in ["hour", "minute", "second", "microsecond"]:
+        for attr in ("hour", "minute", "second", "microsecond"):
             value = getattr(self, attr)
             if value is not None:
                 repl[attr] = value
@@ -407,10 +425,7 @@ class RelativeDelta:
         if not isinstance(other, RelativeDelta):
             return NotImplemented  # In case the other object defines __rsub__
 
-        kwargs = {
-            field: getattr(other, field) if getattr(self, field) is None else getattr(self, field)
-            for field in ABS_FIELDS
-        }
+        kwargs = {field: getattr(other, field) if val is None else val for field, val in self._absolutes().items()}
         return self._make_relativedelta(
             years=self.years - other.years,
             months=self.months - other.months,
@@ -424,25 +439,28 @@ class RelativeDelta:
         )
 
     def __abs__(self):
-        fields = {field: abs(getattr(self, field)) for field in REL_FIELDS}
+        fields = {field: abs(val) for field, val in self._relatives().items()}
         return self._make_relativedelta(**fields)
 
     def __neg__(self):
-        fields = {field: -getattr(self, field) for field in REL_FIELDS}
+        fields = {field: -val for field, val in self._relatives().items()}
         return self._make_relativedelta(**fields)
 
-    def __bool__(self):
-        s_fields = (getattr(self, field) for field in REL_FIELDS)
-        attribs = (getattr(self, field) for field in ABS_FIELDS)
-        return any((*s_fields, self.leapdays, self.weekday, *(x is not None for x in attribs)))
+    def __bool__(self) -> bool:
+        return (
+            any(value for value in self._relatives().values())
+            or bool(self.leapdays)
+            or bool(self.weekday)
+            or any(value is not None for value in self._absolutes().values())
+        )
 
-    def __mul__(self, other) -> NotImplementedType | Self:
+    def __mul__(self, other) -> Self | NotImplementedType:
         try:
             f = float(other)
         except TypeError:
             return NotImplemented
 
-        fields = {field: int(getattr(self, field) * f) for field in REL_FIELDS}
+        fields = {field: int(val * f) for field, val in self._relatives().items()}
         return self._make_relativedelta(**fields)
 
     __rmul__ = __mul__
@@ -463,8 +481,10 @@ class RelativeDelta:
                 return False
 
         return (
-            all((getattr(self, field) == getattr(other, field) for field in REL_FIELDS + ABS_FIELDS))
+            all((a == b for a, b in zip(self._relatives().values(), other._relatives().values())))
+            and all((a == b for a, b in zip(self._absolutes().values(), other._absolutes().values())))
             and self.leapdays == other.leapdays
+            and self.weekday == other.weekday
         )
 
     def __hash__(self):
@@ -483,7 +503,7 @@ class RelativeDelta:
             return NotImplemented
         return not self.__eq__(other)
 
-    def __div__(self, other) -> NotImplementedType | Self:
+    def __truediv__(self, other) -> NotImplementedType | Self:
         try:
             reciprocal = 1 / float(other)
         except TypeError:
@@ -491,15 +511,13 @@ class RelativeDelta:
 
         return self.__mul__(reciprocal)
 
-    __truediv__ = __div__
-
     def __repr__(self):
         _tmp_list = []
-        for attr in ["years", "months", "days", "leapdays", "hours", "minutes", "seconds", "microseconds"]:
+        for attr in ("years", "months", "days", "leapdays", "hours", "minutes", "seconds", "microseconds"):
             value = getattr(self, attr)
             if value:
                 _tmp_list.append(f"{attr}={value:+g}")
-        for attr in ["year", "month", "day", "weekday", "hour", "minute", "second", "microsecond"]:
+        for attr in ("year", "month", "day", "weekday", "hour", "minute", "second", "microsecond"):
             value = getattr(self, attr)
             if value is not None:
                 _tmp_list.append(f"{attr}={value!r}")

{dateutilx-0.2.0/src → dateutilx-0.4.0/dateutilx}/rrule.py

@@ -6,7 +6,6 @@ the recurrence rules documented in the
 including support for caching of results.
 """
 
-import _thread
 import calendar
 import contextlib
 import datetime as dt
@@ -15,14 +14,14 @@ import itertools
 import operator
 import re
 import sys
+import threading
 from functools import wraps
 from itertools import product
 from math import gcd
 from typing import Any
 from warnings import warn
 
-from .helper import Day, Frequency
-from .weekday import Weekday, weekdays
+from dateutilx.utils import Day, Frequency, Weekday, weekdays
 
 # fmt: off
 __all__ = [
@@ -79,7 +78,7 @@ class RruleBase:
     def __init__(self, cache=False):
         if cache:
             self._cache = []
-            self._cache_lock = _thread.allocate_lock()
+            self._cache_lock = threading.Lock()
             self._invalidate_cache()
         else:
             self._cache = None
@@ -107,21 +106,20 @@ class RruleBase:
         i = 0
         gen = self._cache_gen
         cache = self._cache
-        acquire = self._cache_lock.acquire
-        release = self._cache_lock.release
+
         while gen:
             if i == len(cache):
-                acquire()
-                if self._cache_complete:
-                    break
-                try:
-                    for _ in range(10):
-                        cache.append(next(gen))
-                except StopIteration:
-                    self._cache_gen = gen = None
-                    self._cache_complete = True
-                    break
-                release()
+                with self._cache_lock:
+                    if self._cache_complete:
+                        break
+                    try:
+                        for _ in range(10):
+                            cache.append(next(gen))
+                    except StopIteration:
+                        self._cache_gen = gen = None
+                        self._cache_complete = True
+                        break
+
             yield cache[i]
             i += 1
         while i < self._len:
@@ -270,7 +268,7 @@ class Rrule(RruleBase):
         This can lead to possibly surprising behavior when, for example, the
         start date occurs at the end of the month:
 
-        >>> from src.rrule import rrule, MONTHLY
+        >>> from dateutilx.rrule import rrule, MONTHLY
         >>> from datetime import datetime
         >>> start_date = datetime(2014, 12, 31)
         >>> list(rrule(freq=MONTHLY, count=4, dtstart=start_date))
@@ -460,7 +458,7 @@ class Rrule(RruleBase):
         if self._bysetpos:
             self._original_rule["bysetpos"] = self._bysetpos
 
-        if byweekno is None and byyearday is None and bymonthday is None and byweekday is None and byeaster is None:
+        if all(x is None for x in (byweekno, byyearday, bymonthday, byweekday, byeaster)):
             if freq == YEARLY:
                 if bymonth is None:
                     bymonth = dtstart.month
@@ -498,7 +496,7 @@ class Rrule(RruleBase):
         self._byeaster = None
         if byeaster is not None:
             if not easter:
-                from src import easter
+                from dateutilx import easter
             if isinstance(byeaster, int):
                 self._byeaster = (byeaster,)
             else:
@@ -661,7 +659,7 @@ class Rrule(RruleBase):
             original_rule = self._original_rule
 
         partfmt = "{name}={vals}"
-        for name, key in [
+        for name, key in (
             ("BYSETPOS", "bysetpos"),
             ("BYMONTH", "bymonth"),
             ("BYMONTHDAY", "bymonthday"),
@@ -672,7 +670,7 @@ class Rrule(RruleBase):
             ("BYMINUTE", "byminute"),
             ("BYSECOND", "bysecond"),
             ("BYEASTER", "byeaster"),
-        ]:
+        ):
             value = original_rule.get(key)
             if value:
                 parts.append(partfmt.format(name=name, vals=(",".join(str(v) for v in value))))
@@ -1001,7 +999,7 @@ class Rrule(RruleBase):
 
         return cset
 
-    def __mod_distance(self, value, byxxx, base):
+    def __mod_distance(self, value, byxxx, base) -> tuple[int, int]:
         """
         Calculates the next value in a sequence where the `FREQ` parameter is
         specified along with a `BYXXX` parameter at the same "level"
@@ -1032,7 +1030,7 @@ class Rrule(RruleBase):
             accumulator += div
             if value in byxxx:
                 return accumulator, value
-        return None
+        raise ValueError("No valid values found")
 
 
 # pylint: disable=E0203
@@ -1403,7 +1401,7 @@ class _RRuleStr:
     def _handle_until(rrkwargs, name, value, **kwargs):
         global parser
         if not parser:
-            from src import parser
+            from dateutilx import parser
         try:
             rrkwargs["until"] = parser.parse(value, ignoretz=kwargs.get("ignoretz"), tzinfos=kwargs.get("tzinfos"))
         except ValueError as e:
@@ -1465,7 +1463,7 @@ class _RRuleStr:
     def _parse_date_value(self, date_value, parms, rule_tzids, *, ignoretz, tzids, tzinfos):
         global parser
         if not parser:
-            from src import parser
+            from dateutilx import parser
 
         datevals = []
         value_found = False
@@ -1597,7 +1595,7 @@ class _RRuleStr:
 
         if forceset or len(rrulevals) > 1 or rdatevals or exrulevals or exdatevals:
             if not parser and (rdatevals or exdatevals):
-                from src import parser
+                from dateutilx import parser
             rset = RruleSet(cache=cache)
             for value in rrulevals:
                 rset.rrule(self._parse_rfc_rrule(value, dtstart=dtstart, ignoretz=ignoretz, tzinfos=tzinfos))

{dateutilx-0.2.0/src → dateutilx-0.4.0/dateutilx}/tz/__init__.py

@@ -1,5 +1,4 @@
 from .tz import (
-    UTC,
     TzFile,
     TzIcal,
     TzLocal,
@@ -12,25 +11,17 @@ from .tz import (
     gettz,
     resolve_imaginary,
 )
-from .win import TzWin, TzWinLocal, tzwin, tzwinlocal
 
 # fmt: off
 __all__ = ["TzFile", "TzIcal", "TzLocal", "TzOffset", "TzRange", "TzStr", "TzUTC",
-           "tzutc", "gettz", "datetime_ambiguous", "datetime_exists",
+           "gettz", "datetime_ambiguous", "datetime_exists",
            "resolve_imaginary", "UTC", "DeprecatedTzFormatWarning",
-           "TzWin", "TzWinLocal"]
+          ]
 # fmt: on
 
 
-class DeprecatedTzFormatWarning(Warning):
-    """Warning raised when time zones are parsed from deprecated formats."""
+UTC = TzUTC()
 
 
-# Alias
-tzstr = TzStr
-tzfile = TzFile
-tzical = TzIcal
-tzlocal = TzLocal
-tzoffset = TzOffset
-tzrange = TzRange
-tzutc = TzUTC
+class DeprecatedTzFormatWarning(Warning):
+    """Warning raised when time zones are parsed from deprecated formats."""

dateutilx-0.4.0/dateutilx/tz/_factories.py

@@ -0,0 +1,61 @@
+import weakref
+from collections import OrderedDict
+from datetime import timedelta
+
+
+class _TzSingleton(type):
+    def __init__(cls, *args, **kwargs):
+        cls.__instance = None
+        super().__init__(*args, **kwargs)
+
+    def __call__(cls):
+        if cls.__instance is None:
+            cls.__instance = super().__call__()
+        return cls.__instance
+
+
+class _TzFactory(type):
+    def instance(cls, *args, **kwargs):
+        """Alternate constructor that returns a fresh instance"""
+        return type.__call__(cls, *args, **kwargs)
+
+
+class _TzCachedFactory(_TzFactory):
+    """Factory with a weak identity cache plus a small strong LRU cache
+    to keep the most recently used instances alive."""
+
+    _strong_cache_size = 8
+
+    def __init__(cls, *args, **kwargs):
+        cls._instances = weakref.WeakValueDictionary()
+        cls._strong_cache = OrderedDict()
+        super().__init__(*args, **kwargs)
+
+    def _cache_key(cls, *args, **kwargs):
+        """Subclasses define how constructor args map to a cache key."""
+        raise NotImplementedError
+
+    def __call__(cls, *args, **kwargs):
+        key = cls._cache_key(*args, **kwargs)
+
+        instance = cls._instances.get(key)
+        if instance is None:
+            instance = cls._instances.setdefault(key, cls.instance(*args, **kwargs))
+
+        cls._strong_cache[key] = cls._strong_cache.pop(key, instance)
+        if len(cls._strong_cache) > cls._strong_cache_size:
+            cls._strong_cache.popitem(last=False)
+
+        return instance
+
+
+class _TzOffsetFactory(_TzCachedFactory):
+    def _cache_key(cls, name, offset):
+        if isinstance(offset, timedelta):
+            offset = offset.total_seconds()
+        return name, offset
+
+
+class _TzStrFactory(_TzCachedFactory):
+    def _cache_key(cls, s, posix_offset=False):
+        return s, posix_offset

{dateutilx-0.2.0/src → dateutilx-0.4.0/dateutilx}/tz/_win.py

@@ -69,7 +69,7 @@ class TzRes:
         """
         Load a timezone name from a DLL offset (integer).
 
-        >>> from src.tzwin import TzRes
+        >>> from dateutilx.tzwin import TzRes
         >>> tzr = TzRes()
         >>> print(tzr.load_name(112))
         'Eastern Standard Time'
@@ -93,7 +93,7 @@ class TzRes:
         Parse strings as returned from the Windows registry into the time zone
         name as defined in the registry.
 
-        >>> from src.tzwin import TzRes
+        >>> from dateutilx.tzwin import TzRes
         >>> tzr = TzRes()
         >>> print(tzr.name_from_string('@tzres.dll,-251'))
         'Dateline Daylight Time'
@@ -255,16 +255,16 @@ class TzWinLocal(TzWinBase):
     """
     Class representing the local time zone information in the Windows registry
 
-    While :class:`dateutilx.tz.tzlocal` makes system calls (via the :mod:`time`
+    While :class:`dateutilx.tz.TzLocal` makes system calls (via the :mod:`time`
     module) to retrieve time zone information, ``tzwinlocal`` retrieves the
     rules directly from the Windows registry and creates an object like
     :class:`dateutilx.tz.tzwin`.
 
     Because Windows does not have an equivalent of :func:`time.tzset`, on
-    Windows, :class:`dateutilx.tz.tzlocal` instances will always reflect the
+    Windows, :class:`dateutilx.tz.TzLocal` instances will always reflect the
     time zone settings *at the time that the process was started*, meaning
     changes to the machine's time zone settings during the run of a program
-    on Windows will **not** be reflected by :class:`dateutilx.tz.tzlocal`.
+    on Windows will **not** be reflected by :class:`dateutilx.tz.TzLocal`.
     Because ``tzwinlocal`` reads the registry directly, it is unaffected by
     this issue.
     """

{dateutilx-0.2.0/src → dateutilx-0.4.0/dateutilx}/tz/tz.py

@@ -7,19 +7,20 @@ from relative deltas), local machine timezone, fixed offset timezone, and UTC
 timezone.
 """
 
-import _thread
 import bisect
 import contextlib
 import datetime
 import os
+import string
 import struct
+import threading
 import time
 import weakref
 from collections import OrderedDict
 from dataclasses import dataclass
 from typing import Any
 
-from src.helper import is_windows_os
+from dateutilx.utils import Day, is_windows_os, weekdays
 
 from ._common import TzRangeBase, _TzInfo, _validate_fromutc_inputs
 from ._factories import _TzOffsetFactory, _TzSingleton, _TzStrFactory
@@ -29,6 +30,7 @@ rrule = None  # pylint: disable=c0103
 ZERO = datetime.timedelta(0)
 EPOCH = datetime.datetime(1970, 1, 1, 0, 0)
 EPOCHORDINAL = EPOCH.toordinal()
+SU = weekdays[Day.SU]
 
 
 class TzUTC(datetime.tzinfo, metaclass=_TzSingleton):
@@ -40,7 +42,7 @@ class TzUTC(datetime.tzinfo, metaclass=_TzSingleton):
     .. doctest::
 
         >>> import datetime as dt
-        >>> from src.tz import *
+        >>> from dateutilx.tz import *
 
         >>> dt.datetime.now()
         datetime.datetime(2003, 9, 27, 9, 40, 1, 521290)
@@ -57,7 +59,7 @@ class TzUTC(datetime.tzinfo, metaclass=_TzSingleton):
 
         .. doctest::
 
-            >>> from src.tz import tzutc, UTC
+            >>> from dateutilx.tz import tzutc, UTC
             >>> tzutc() is tzutc()
             True
             >>> tzutc() is UTC
@@ -66,7 +68,9 @@ class TzUTC(datetime.tzinfo, metaclass=_TzSingleton):
 
     __name__ = "tzutc"
     __hash__ = None
-    __reduce__ = object.__reduce__
+
+    def __reduce__(self):
+        return self.__class__, tuple()
 
     def utcoffset(self, dt):
         return ZERO
@@ -111,9 +115,6 @@ class TzUTC(datetime.tzinfo, metaclass=_TzSingleton):
         return f"{self.__name__}()"
 
 
-#: Convenience constant providing a :class:`tzutc()` instance
-#:
-#: .. versionadded:: 2.7.0
 UTC = TzUTC()
 
 
@@ -174,7 +175,8 @@ class TzOffset(datetime.tzinfo, metaclass=_TzOffsetFactory):
     def __repr__(self):
         return f"{self.__class__.__name__}({self._name!r}, {int(self._offset.total_seconds())})"
 
-    __reduce__ = object.__reduce__
+    def __reduce__(self):
+        return self.__class__, (self._name, self._offset)
 
 
 class TzLocal(_TzInfo):
@@ -193,7 +195,7 @@ class TzLocal(_TzInfo):
 
         self._dst_saved = self._dst_offset - self._std_offset
         self._hasdst = bool(self._dst_saved)
-        self._tznames = tuple(time.tzname)
+        self._tznames = time.tzname
 
     def utcoffset(self, dt):
         if dt is None and self._hasdst:
@@ -242,7 +244,7 @@ class TzLocal(_TzInfo):
         # The code above yields the following result:
         #
         # >>> import tz, datetime
-        # >>> t = tz.tzlocal()
+        # >>> t = tz.TzLocal()
         # >>> datetime.datetime(2003,2,15,23,tzinfo=t).tzname()
         # 'BRDT'
         # >>> datetime.datetime(2003,2,16,0,tzinfo=t).tzname()
@@ -344,9 +346,6 @@ class _TzFile:
     ttinfo_first: Any | None = None
 
 
-_tzfile = _TzFile
-
-
 class TzFile(_TzInfo):
     """
     This is a ``tzinfo`` subclass that allows one to use the ``tzfile(5)``
@@ -384,7 +383,7 @@ class TzFile(_TzInfo):
 
     .. testsetup:: tzfile
 
-        from src.tz import gettz
+        from dateutilx.tz import gettz
         from datetime import datetime
 
     .. doctest:: tzfile
@@ -446,7 +445,7 @@ class TzFile(_TzInfo):
     def _set_tzdata(self, tzobj):
         """Set the time zone data of this object from a _tzfile object"""
         # Copy the relevant attributes over as private attributes
-        for attr in _tzfile.__slots__:
+        for attr in _TzFile.__slots__:
             setattr(self, f"_{attr}", getattr(tzobj, attr))
 
     def _read_tzfile(self, fileobj):
@@ -867,14 +866,14 @@ class TzRange(TzRangeBase):
 
     .. testsetup:: tzrange
 
-        >>> from src.tz import tzrange, tzstr
+        >>> from dateutilx.tz import tzrange, tzstr
 
     .. doctest:: tzrange
 
         >>> tzstr('EST5EDT') == tzrange("EST", -18000, "EDT")
         True
 
-        >>> from src.relativedelta import *
+        >>> from dateutilx.relativedelta import *
         >>> range1 = tzrange("EST", -18000, "EDT")
         >>> range2 = tzrange("EST", -18000, "EDT", -14400,
         ...                  RelativeDelta(hours=+2, month=4, day=1,
@@ -888,7 +887,8 @@ class TzRange(TzRangeBase):
 
     def __init__(self, stdabbr, stdoffset=None, dstabbr=None, dstoffset=None, *, start=None, end=None):
         # global relativedelta
-        from src.relativedelta import SU, RelativeDelta
+        from dateutilx.relativedelta import RelativeDelta
+        from dateutilx.utils.weekday import SU
 
         self._std_abbr = stdabbr
         self._dst_abbr = dstabbr
@@ -1009,7 +1009,7 @@ class TzStr(TzRange, metaclass=_TzStrFactory):
 
     def __init__(self, s, posix_offset=False):
         global parser
-        from src.parser import _parser as parser
+        from dateutilx.parser import _parser as parser
 
         self._s = s
 
@@ -1038,7 +1038,7 @@ class TzStr(TzRange, metaclass=_TzStrFactory):
         self.hasdst = bool(self._start_delta)
 
     def _delta(self, x, isend=0):
-        from src import relativedelta
+        from dateutilx import relativedelta
 
         kwargs = {}
         if x.month is not None:
@@ -1058,11 +1058,11 @@ class TzStr(TzRange, metaclass=_TzStrFactory):
             if not isend:
                 kwargs["month"] = 4
                 kwargs["day"] = 1
-                kwargs["weekday"] = relativedelta.SU(+1)
+                kwargs["weekday"] = SU(+1)
             else:
                 kwargs["month"] = 10
                 kwargs["day"] = 31
-                kwargs["weekday"] = relativedelta.SU(-1)
+                kwargs["weekday"] = SU(-1)
 
         kwargs["seconds"] = x.time if x.time is not None else 7200  # Default is 2AM.
 
@@ -1094,7 +1094,7 @@ class _TzIcalVtz(_TzInfo):
         self._tzid = tzid
         self._comps = comps or []
         self._cache = OrderedDict()
-        self._cache_lock = _thread.allocate_lock()
+        self._cache_lock = threading.Lock()
 
     def _find_comp(self, dt):
         if len(self._comps) == 1:
@@ -1176,7 +1176,7 @@ class TzIcal:
     def __init__(self, fileobj):
         global rrule
         if not rrule:
-            from src import rrule
+            from dateutilx import rrule
 
         if isinstance(fileobj, str):
             self._s = fileobj
@@ -1235,6 +1235,9 @@ class TzIcal:
         else:
             signal = +1
 
+        if not (s.isascii() and s.isdigit()):
+            raise ValueError("invalid offset: " + s)
+
         if len(s) == 4:
             return (int(s[:2]) * 3600 + int(s[2:]) * 60) * signal
         if len(s) == 6:
@@ -1436,7 +1439,7 @@ def __get_gettz():
             self.__instances = weakref.WeakValueDictionary()
             self.__strong_cache_size = 8
             self.__strong_cache = OrderedDict()
-            self._cache_lock = _thread.allocate_lock()
+            self._cache_lock = threading.Lock()
 
         def __call__(self, name=None):
             with self._cache_lock:
@@ -1541,7 +1544,7 @@ def __get_gettz():
                                 # one offset. For short values of "name", an
                                 # explicit for loop seems to be the fastest way
                                 # To determine if a string contains a digit
-                                if c in "0123456789":
+                                if c in string.digits:
                                     with contextlib.suppress(ValueError):
                                         tz = TzStr(name)
                                     break
@@ -1651,7 +1654,7 @@ def resolve_imaginary(dt):
 
     .. doctest::
 
-        >>> from src import tz
+        >>> from dateutilx import tz
         >>> from datetime import datetime
         >>> NYC = tz.gettz('America/New_York')
         >>> print(tz.resolve_imaginary(datetime(2017, 3, 12, 2, 30, tzinfo=NYC)))

{dateutilx-0.2.0/src → dateutilx-0.4.0/dateutilx}/tz/win.py

@@ -2,14 +2,11 @@
 Wrapper for _win.py to handle platform dependent import
 """
 
-from src.helper import is_windows_os
+from dateutilx.utils import is_windows_os
 
 if is_windows_os():
     from ._win import TzRes, TzWin, TzWinLocal
 else:
     TzRes = TzWin = TzWinLocal = None
 
-# Alias
-tzres = TzRes
-tzwin = TzWin
-tzwinlocal = TzWinLocal
+__all__ = ["TzRes", "TzWin", "TzWinLocal"]

dateutilx-0.4.0/dateutilx/utils/__init__.py

@@ -0,0 +1,10 @@
+from .constants import Day, Frequency, Month
+from .funcs import default_tzinfo, is_windows_os, today, within_delta
+from .weekday import Weekday, weekdays
+
+# fmt: off
+__all__ = ["Day", "Frequency", "Month",
+           "default_tzinfo", "is_windows_os", "today", "within_delta",
+           "Weekday", "weekdays"
+           ]
+# fmt: on

dateutilx-0.2.0/src/utils.py → dateutilx-0.4.0/dateutilx/utils/funcs.py

@@ -1,11 +1,9 @@
-"""
-This module offers general convenience and utility functions for dealing with
-datetimes.
+import datetime as dt
+import sys
 
-.. versionadded:: 2.7.0
-"""
 
-import datetime as dt
+def is_windows_os() -> bool:
+    return sys.platform.startswith("win")
 
 
 def today(tzinfo=None):
@@ -33,9 +31,9 @@ def default_tzinfo(dt, tzinfo):
 
     .. doctest::
 
-        >>> from src.tz import tzoffset
-        >>> from src.parser import parse
-        >>> from src.utils import default_tzinfo
+        >>> from dateutilx.tz import tzoffset
+        >>> from dateutilx.parser import parse
+        >>> from dateutilx.utils import default_tzinfo
         >>> dflt_tz = tzoffset("EST", -18000)
         >>> print(default_tzinfo(parse('2014-01-01 12:30 UTC'), dflt_tz))
         2014-01-01 12:30:00+00:00

{dateutilx-0.2.0/src → dateutilx-0.4.0/dateutilx/utils}/weekday.py

@@ -1,6 +1,6 @@
 from typing import Any
 
-from src.helper import Day
+from .constants import Day
 
 
 class NthWeekday:
@@ -22,6 +22,9 @@ class NthWeekday:
         except AttributeError:
             return False
 
+    def __hash__(self):
+        return hash((self.weekday, self.n))
+
     def __repr__(self) -> str:
         name = self.weekday.name
         return f"{name}({self.n:+d})" if self.n else name
@@ -30,13 +33,9 @@ class NthWeekday:
 # pylint: disable=r0903
 class Weekday(NthWeekday):
     def __init__(self, wkday: int, n: int | None = None):
+        if not 0 <= wkday <= 6:
+            raise ValueError(f"Weekday must be between 0 and 6, got {wkday}")
         super().__init__(wkday=Day(wkday), n=n)
 
-    def __hash__(self):
-        return hash((self.weekday, self.n))
-
 
 MO, TU, WE, TH, FR, SA, SU = weekdays = tuple(Weekday(x) for x in range(7))
-
-# Alias
-weekday = Weekday

{dateutilx-0.2.0 → dateutilx-0.4.0}/pyproject.toml

@@ -43,12 +43,12 @@ Source = "https://github.com/rsb-23/dateutilx"
 [tool.hatch.version]
 source = "vcs"
 [tool.hatch.build.targets.sdist]
-include = ["src", "LICENSE", "README.md", "pyproject.toml"]
+include = ["dateutilx", "LICENSE", "README.md", "pyproject.toml"]
 [tool.hatch.build.targets.wheel]
-packages = ["src"]
+packages = ["dateutilx"]
 
 [tool.coverage.run]
-source = ["src"]
+source = ["dateutilx"]
 [tool.coverage.report]
 fail_under = 85.0
 skip_covered = true

dateutilx-0.2.0/src/helper/__init__.py

@@ -1,4 +0,0 @@
-from .constants import Day, Frequency, Month
-from .funcs import is_windows_os
-
-__all__ = ["Day", "Frequency", "Month", "is_windows_os"]

dateutilx-0.2.0/src/helper/funcs.py

@@ -1,5 +0,0 @@
-import sys
-
-
-def is_windows_os() -> bool:
-    return sys.platform.startswith("win")

dateutilx-0.2.0/src/tz/_factories.py

@@ -1,67 +0,0 @@
-import weakref
-from collections import OrderedDict
-from datetime import timedelta
-
-
-class _TzSingleton(type):
-    def __init__(cls, *args, **kwargs):
-        cls.__instance = None
-        super().__init__(*args, **kwargs)
-
-    def __call__(cls):
-        if cls.__instance is None:
-            cls.__instance = super().__call__()
-        return cls.__instance
-
-
-class _TzFactory(type):
-    def instance(cls, *args, **kwargs):
-        """Alternate constructor that returns a fresh instance"""
-        return type.__call__(cls, *args, **kwargs)
-
-
-class _TzOffsetFactory(_TzFactory):
-    def __init__(cls, *args, **kwargs):
-        cls.__instances = weakref.WeakValueDictionary()
-        cls.__strong_cache = OrderedDict()
-        cls.__strong_cache_size = 8
-
-    def __call__(cls, name, offset):
-        if isinstance(offset, timedelta):
-            key = (name, offset.total_seconds())
-        else:
-            key = (name, offset)
-
-        instance = cls.__instances.get(key, None)
-        if instance is None:
-            instance = cls.__instances.setdefault(key, cls.instance(name, offset))
-
-        cls.__strong_cache[key] = cls.__strong_cache.pop(key, instance)
-
-        # Remove an item if the strong cache is overpopulated
-        if len(cls.__strong_cache) > cls.__strong_cache_size:
-            cls.__strong_cache.popitem(last=False)
-
-        return instance
-
-
-class _TzStrFactory(_TzFactory):
-    def __init__(cls, *args, **kwargs):
-        cls.__instances = weakref.WeakValueDictionary()
-        cls.__strong_cache = OrderedDict()
-        cls.__strong_cache_size = 8
-
-    def __call__(cls, s, posix_offset=False):
-        key = (s, posix_offset)
-        instance = cls.__instances.get(key, None)
-
-        if instance is None:
-            instance = cls.__instances.setdefault(key, cls.instance(s, posix_offset))
-
-        cls.__strong_cache[key] = cls.__strong_cache.pop(key, instance)
-
-        # Remove an item if the strong cache is overpopulated
-        if len(cls.__strong_cache) > cls.__strong_cache_size:
-            cls.__strong_cache.popitem(last=False)
-
-        return instance

dateutilx-0.2.0/src/tzwin.py

@@ -1,4 +0,0 @@
-# tzwin has moved to dateutilx.tz.win
-from .tz.win import TzRes, TzWin, TzWinLocal, tzres, tzwin, tzwinlocal  # noqa
-
-__all__ = ["TzRes", "TzWin", "TzWinLocal", "tzres", "tzwin", "tzwinlocal"]