Remove the python-dateutil dependency

botocore/compat.py

@@ -28,7 +28,6 @@
 
 from botocore.vendored import six
 from botocore.exceptions import MD5UnavailableError
-from dateutil.tz import tzlocal
 from urllib3 import exceptions
 
 logger = logging.getLogger(__name__)
@@ -269,15 +268,53 @@ def _windows_shell_split(s):
 
 
 def get_tzinfo_options():
-    # Due to dateutil/dateutil#197, Windows may fail to parse times in the past
-    # with the system clock. We can alternatively fallback to tzwininfo when
-    # this happens, which will get time info from the Windows registry.
-    if sys.platform == 'win32':
-        from dateutil.tz import tzwinlocal
+    # Historical compatibility shim for tzinfo options.
+    # Previously had to use the third party `dateutil` library to get tzinfo objects,
+    # but now that botocore require Python 3.10+, use the built in tzinfo support.
+    # TODO: Remove this function and implement directly in the codebase,
+    # and simplify since there's now only a single option.
+    return (datetime.datetime.now().astimezone().tzinfo,)
 
-        return (tzlocal, tzwinlocal)
-    else:
-        return (tzlocal,)
+
+_ISO_ZONE_SUFFIX_RE = re.compile(r"\s*(Z|UTC|GMT)$", re.IGNORECASE)
+_ISO_COMPACT_RE = re.compile(
+    r"^(\d{4})(\d{2})(\d{2})T(\d{2})(\d{2})(\d{2}(?:\.\d+)?)?"
+)
+_ISO_SPACE_SEPARATOR_RE = re.compile(
+    r"^(\d{4}-\d{2}-\d{2}) (\d{2}:\d{2}:\d{2})"
+)
+_ISO_OFFSET_NO_COLON_RE = re.compile(r"\s*([+-])(\d{2})(\d{2})$")
+_ISO_FRACTIONAL_SECONDS_RE = re.compile(r"\.(\d+)")
+
+
+def _normalize_iso8601_for_python_310(value):
+    """Normalize an ISO 8601 string into a shape Python 3.10's strict
+    ``datetime.fromisoformat`` accepts. Python 3.11+ accepts these shapes
+    natively.
+
+    Handled: ``Z``/``UTC``/``GMT`` zone suffixes (any case, with optional
+    leading whitespace), compact basic form ``YYYYMMDDTHHMM[SS]``,
+    space-separated date and time, tz offsets without a colon
+    (``+HHMM``), and fractional seconds with anything other than 3 or 6
+    digits.
+
+    Drop this helper and its call sites when 3.10 support ends.
+    """
+    value = _ISO_ZONE_SUFFIX_RE.sub("+00:00", value)
+    compact = _ISO_COMPACT_RE.match(value)
+    if compact:
+        y, mo, d, h, mi, s = compact.groups()
+        value = (
+            f"{y}-{mo}-{d}T{h}:{mi}:{s or '00'}{value[compact.end():]}"
+        )
+    value = _ISO_SPACE_SEPARATOR_RE.sub(r"\1T\2", value)
+    value = _ISO_OFFSET_NO_COLON_RE.sub(r"\1\2:\3", value)
+    value = _ISO_FRACTIONAL_SECONDS_RE.sub(
+        lambda m: "." + m.group(1).ljust(6, "0")[:6],
+        value,
+        count=1,
+    )
+    return value
 
 
 # Detect if CRT is available for use

botocore/credentials.py

@@ -25,15 +25,12 @@
 from copy import deepcopy
 from hashlib import sha1, sha256
 
-import dateutil.parser
-from dateutil.parser import parse
-from dateutil.tz import tzlocal, tzutc
-
 import botocore.compat
 import botocore.configloader
 from botocore import UNSIGNED
 from botocore.compat import (
     EC,
+    _normalize_iso8601_for_python_310,
     compat_shell_split,
     total_seconds,
 )
@@ -275,13 +272,19 @@ def get_credentials(session):
 
 
 def _local_now():
-    return datetime.datetime.now(tzlocal())
+    return datetime.datetime.now().astimezone()
+
+
+def _parse_iso_utc(value):
+    return datetime.datetime.fromisoformat(
+        _normalize_iso8601_for_python_310(value)
+    )
 
 
 def _parse_if_needed(value):
     if isinstance(value, datetime.datetime):
         return value
-    return parse(value)
+    return _parse_iso_utc(value)
 
 
 def _serialize_if_needed(value, iso=False):
@@ -634,7 +637,7 @@ def _protected_refresh(self, is_mandatory):
 
     @staticmethod
     def _expiry_datetime(time_str):
-        return parse(time_str)
+        return _parse_iso_utc(time_str)
 
     def _set_from_data(self, data):
         expected_keys = ['access_key', 'secret_key', 'token', 'expiry_time']
@@ -653,7 +656,7 @@ def _set_from_data(self, data):
         self.access_key = data['access_key']
         self.secret_key = data['secret_key']
         self.token = data['token']
-        self._expiry_time = parse(data['expiry_time'])
+        self._expiry_time = _parse_iso_utc(data['expiry_time'])
         self.account_id = data.get('account_id')
         logger.debug(
             "Retrieved credentials will expire at: %s", self._expiry_time
@@ -1256,7 +1259,7 @@ def load(self):
 
             expiry_time = credentials['expiry_time']
             if expiry_time is not None:
-                expiry_time = parse(expiry_time)
+                expiry_time = _parse_iso_utc(expiry_time)
                 return RefreshableCredentials(
                     credentials['access_key'],
                     credentials['secret_key'],
@@ -2302,7 +2305,9 @@ def _create_cache_key(self):
     def _parse_timestamp(self, timestamp_ms):
         # fromtimestamp expects seconds so: milliseconds / 1000 = seconds
         timestamp_seconds = timestamp_ms / 1000.0
-        timestamp = datetime.datetime.fromtimestamp(timestamp_seconds, tzutc())
+        timestamp = datetime.datetime.fromtimestamp(
+            timestamp_seconds, datetime.timezone.utc
+        )
         return timestamp.strftime(self._UTC_DATE_FORMAT)
 
     def _get_credentials(self):
@@ -2322,7 +2327,7 @@ def _get_credentials(self):
             # raise an UnauthorizedSSOTokenError if the loaded legacy token
             # is expired to save a call to GetRoleCredentials with an
             # expired token.
-            expiration = dateutil.parser.parse(token_dict['expiresAt'])
+            expiration = _parse_iso_utc(token_dict['expiresAt'])
             remaining = total_seconds(expiration - self._time_fetcher())
             if remaining <= 0:
                 raise UnauthorizedSSOTokenError()
@@ -2657,7 +2662,7 @@ def refresh_credentials(self):
         output = response.get('tokenOutput')
 
         expires_timestamp = self._time_fetcher().astimezone(
-            tzutc()
+            datetime.timezone.utc
         ) + datetime.timedelta(seconds=output['expiresIn'])
 
         # Overwrite token with refreshed fields

botocore/tokens.py

@@ -14,14 +14,11 @@
 import logging
 import os
 import threading
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 from typing import NamedTuple
 
-import dateutil.parser
-from dateutil.tz import tzutc
-
 from botocore import UNSIGNED
-from botocore.compat import total_seconds
+from botocore.compat import _normalize_iso8601_for_python_310, total_seconds
 from botocore.config import Config
 from botocore.exceptions import (
     ClientError,
@@ -40,7 +37,11 @@
 
 
 def _utc_now():
-    return datetime.now(tzutc())
+    return datetime.now(timezone.utc)
+
+
+def _parse_iso_utc(value):
+    return datetime.fromisoformat(_normalize_iso8601_for_python_310(value))
 
 
 def create_token_resolver(session):
@@ -295,7 +296,7 @@ def _refresh_access_token(self, token):
             logger.info(msg)
             return None
 
-        expiry = dateutil.parser.parse(token["registrationExpiresAt"])
+        expiry = _parse_iso_utc(token["registrationExpiresAt"])
         if total_seconds(expiry - self._now()) <= 0:
             logger.info("SSO token registration expired at %s", expiry)
             return None
@@ -311,7 +312,7 @@ def _refresher(self):
         session_name = self._sso_config["session_name"]
         logger.info("Loading cached SSO token for %s", session_name)
         token_dict = self._token_loader(start_url, session_name=session_name)
-        expiration = dateutil.parser.parse(token_dict["expiresAt"])
+        expiration = _parse_iso_utc(token_dict["expiresAt"])
         logger.debug("Cached SSO token expires at %s", expiration)
 
         remaining = total_seconds(expiration - self._now())

botocore/utils.py

@@ -14,6 +14,7 @@
 import binascii
 import datetime
 import email.message
+import email.utils
 import functools
 import hashlib
 import io
@@ -31,8 +32,6 @@
 from pathlib import Path
 from urllib.request import getproxies, proxy_bypass
 
-import dateutil.parser
-from dateutil.tz import tzutc
 from urllib3.exceptions import LocationParseError
 
 import botocore
@@ -54,6 +53,7 @@
     UNSAFE_URL_CHARS,
     ZONE_ID_PAT,  # noqa: F401
     OrderedDict,
+    _normalize_iso8601_for_python_310,
     get_current_datetime,
     get_md5,
     get_tzinfo_options,
@@ -948,31 +948,55 @@ def _epoch_seconds_to_datetime(value, tzinfo):
     :type value: float or int
     :param value: The Unix timestamps as number.
 
-    :type tzinfo: callable
-    :param tzinfo: A ``datetime.tzinfo`` class or compatible callable.
+    :type tzinfo: datetime.tzinfo
+    :param tzinfo: A ``datetime.tzinfo`` instance.
     """
-    epoch_zero = datetime.datetime(1970, 1, 1, 0, 0, 0, tzinfo=tzutc())
-    epoch_zero_localized = epoch_zero.astimezone(tzinfo())
+    epoch_zero = datetime.datetime(
+        1970, 1, 1, 0, 0, 0, tzinfo=datetime.timezone.utc
+    )
+    epoch_zero_localized = epoch_zero.astimezone(tzinfo)
     return epoch_zero_localized + datetime.timedelta(seconds=value)
 
 
 def _parse_timestamp_with_tzinfo(value, tzinfo):
     """Parse timestamp with pluggable tzinfo options."""
     if isinstance(value, (int, float)):
         # Possibly an epoch time.
-        return datetime.datetime.fromtimestamp(value, tzinfo())
+        return datetime.datetime.fromtimestamp(value, tzinfo)
     else:
         try:
-            return datetime.datetime.fromtimestamp(float(value), tzinfo())
+            return datetime.datetime.fromtimestamp(float(value), tzinfo)
+        except (TypeError, ValueError):
+            pass
+    if not isinstance(value, str):
+        raise ValueError(f'Invalid timestamp "{value}"')
+    # Non-numeric string. Try ISO 8601 first (the common AWS shape), then
+    # RFC 2822 / HTTP-date / asctime via email.utils, then a couple of
+    # lenient strptime fallbacks for legacy HTTP Expires-header shapes
+    # seen in the wild.
+    iso_value = _normalize_iso8601_for_python_310(value)
+    try:
+        return datetime.datetime.fromisoformat(iso_value)
+    except (TypeError, ValueError):
+        pass
+    # A handful of AWS shared examples have a malformed ISO hour like
+    # "T016:15:21" — collapse the leading zero and retry.
+    fixed_iso = re.sub(r"T0(\d{2}):", r"T\1:", iso_value, count=1)
+    if fixed_iso != iso_value:
+        try:
+            return datetime.datetime.fromisoformat(fixed_iso)
         except (TypeError, ValueError):
             pass
     try:
-        # In certain cases, a timestamp marked with GMT can be parsed into a
-        # different time zone, so here we provide a context which will
-        # enforce that GMT == UTC.
-        return dateutil.parser.parse(value, tzinfos={'GMT': tzutc()})
-    except (TypeError, ValueError) as e:
-        raise ValueError(f'Invalid timestamp "{value}": {e}')
+        return email.utils.parsedate_to_datetime(value)
+    except (TypeError, ValueError):
+        pass
+    for fmt in ("%m/%d/%Y", "%d %b %Y"):
+        try:
+            return datetime.datetime.strptime(value.title(), fmt)
+        except ValueError:
+            continue
+    raise ValueError(f'Invalid timestamp "{value}"')
 
 
 def parse_timestamp(value):
@@ -994,7 +1018,7 @@ def parse_timestamp(value):
         except (OSError, OverflowError) as e:
             logger.debug(
                 'Unable to parse timestamp with "%s" timezone info.',
-                tzinfo.__name__,
+                tzinfo,
                 exc_info=e,
             )
     # For numeric values attempt fallback to using fromtimestamp-free method.
@@ -1015,7 +1039,7 @@ def parse_timestamp(value):
             logger.debug(
                 'Unable to parse timestamp using fallback method with "%s" '
                 'timezone info.',
-                tzinfo.__name__,
+                tzinfo,
                 exc_info=e,
             )
     raise RuntimeError(
@@ -1062,9 +1086,9 @@ def parse_to_aware_datetime(value):
         # we should use the local time.  However, to restore backwards
         # compat, the previous behavior was to assume UTC, which is
         # what we're going to do here.
-        datetime_obj = datetime_obj.replace(tzinfo=tzutc())
+        datetime_obj = datetime_obj.replace(tzinfo=datetime.timezone.utc)
     else:
-        datetime_obj = datetime_obj.astimezone(tzutc())
+        datetime_obj = datetime_obj.astimezone(datetime.timezone.utc)
     return datetime_obj
 
 
@@ -1074,14 +1098,14 @@ def datetime2timestamp(dt, default_timezone=None):
     :type dt: datetime
     :param dt: A datetime object to be converted into timestamp
     :type default_timezone: tzinfo
-    :param default_timezone: If it is provided as None, we treat it as tzutc().
+    :param default_timezone: If it is provided as None, we treat it as UTC.
                              But it is only used when dt is a naive datetime.
     :returns: The timestamp
     """
     epoch = datetime.datetime(1970, 1, 1)
     if dt.tzinfo is None:
         if default_timezone is None:
-            default_timezone = tzutc()
+            default_timezone = datetime.timezone.utc
         dt = dt.replace(tzinfo=default_timezone)
     d = dt.replace(tzinfo=None) - dt.utcoffset() - epoch
     return d.total_seconds()

botocore/validate.py

@@ -403,9 +403,7 @@ def _type_check_datetime(self, value):
         try:
             parse_to_aware_datetime(value)
             return True
-        except (TypeError, ValueError, AttributeError):
-            # Yes, dateutil can sometimes raise an AttributeError
-            # when parsing timestamps.
+        except (TypeError, ValueError):
             return False
 
 

setup.cfg

@@ -4,7 +4,6 @@ universal = 0
 [metadata]
 requires_dist =
     jmespath>=0.7.1,<2.0.0
-    python-dateutil>=2.1,<3.0.0
     urllib3>=1.25.4,!=2.2.0,<3
 
 [options.extras_require]

setup.py

@@ -24,7 +24,6 @@ def find_version(*file_paths):
 
 requires = [
     'jmespath>=0.7.1,<2.0.0',
-    'python-dateutil>=2.1,<3.0.0',
     'urllib3>=1.25.4,!=2.2.0,<3',
 ]