dateutilx 0.3.0__tar.gz → 0.4.0__tar.gz

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: dateutilx
-Version: 0.3.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.3.0 → dateutilx-0.4.0}/dateutilx/parser/_parser.py

@@ -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]
@@ -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)
         )
@@ -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.3.0 → dateutilx-0.4.0}/dateutilx/parser/isoparser.py

@@ -10,6 +10,7 @@ ISO-8601 specification.
 import calendar
 import datetime as dt
 import re
+import string
 from functools import wraps
 
 from dateutilx.tz import UTC, TzOffset
@@ -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")
@@ -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.3.0 → dateutilx-0.4.0}/dateutilx/relativedelta.py

@@ -172,7 +172,7 @@ class RelativeDelta:
 
         # Remove the year/month delta so the timedelta is just well-defined
         # time units (seconds, days and microseconds)
-        dtm = self.__radd__(dt2)
+        dtm = self + dt2
 
         # If we've overshot our target, make an adjustment
         if dt1 < dt2:
@@ -185,7 +185,7 @@ class RelativeDelta:
         while compare(dt1, dtm):
             months += increment
             self._set_months(months)
-            dtm = self.__radd__(dt2)
+            dtm = self + dt2
 
         # Get the timedelta between the "months-adjusted" date and dt1
         delta = dt1 - dtm
@@ -212,14 +212,15 @@ 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]:
@@ -393,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
@@ -512,11 +513,11 @@ class RelativeDelta:
 
     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.3.0 → dateutilx-0.4.0}/dateutilx/rrule.py

@@ -106,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:
@@ -459,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
@@ -660,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"),
@@ -671,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))))

{dateutilx-0.3.0 → dateutilx-0.4.0}/dateutilx/tz/tz.py

@@ -11,6 +11,7 @@ import bisect
 import contextlib
 import datetime
 import os
+import string
 import struct
 import threading
 import time
@@ -67,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
@@ -172,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):
@@ -191,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:
@@ -1231,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:
@@ -1537,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