python-dateutil 2.9.0__py2.py3-none-any.whl → 3.0.0__py2.py3-none-any.whl

dateutil/__init__.py

@@ -6,19 +6,21 @@ try:
 except ImportError:
     __version__ = 'unknown'
 
-__all__ = ['easter', 'parser', 'relativedelta', 'rrule', 'tz',
-           'utils', 'zoneinfo']
+__all__ = ["easter", "parser", "relativedelta", "rrule", "tz", "utils"]
+
 
 def __getattr__(name):
     import importlib
 
-    if name in __all__:
+    if name in __all__ or name == "zoneinfo":
         return importlib.import_module("." + name, __name__)
     raise AttributeError(
-        "module {!r} has not attribute {!r}".format(__name__, name)
+        "module {!r} has no attribute {!r}".format(__name__, name)
     )
 
 
 def __dir__():
     # __dir__ should include all the lazy-importable modules as well.
-    return [x for x in globals() if x not in sys.modules] + __all__
+    return (
+        [x for x in globals() if x not in sys.modules] + __all__ + ["zoneinfo"]
+    )

dateutil/_tzdata_impl.py

@@ -0,0 +1,147 @@
+"""This is an implementation of functions that interact with the tzdata module.
+
+It will only live as long as :mod:`dateutil.zoneinfo` lives; when the
+``dateutil.zoneinfo`` module is removed, this can all move under :mod:`tz`.
+"""
+
+import contextlib
+import importlib
+import io
+import os
+import pkgutil
+import sys
+
+import six
+
+if six.PY2:
+    _TZDATA_LOAD_EXCEPTIONS = (
+        ImportError,
+        IOError,
+        UnicodeEncodeError,
+        ValueError,
+    )
+else:
+    _TZDATA_LOAD_EXCEPTIONS = (
+        ImportError,
+        FileNotFoundError,
+        UnicodeEncodeError,
+        IsADirectoryError,
+        ValueError,
+    )
+
+if sys.version_info < (3, 8):
+    _nullcontext = getattr(contextlib, "nullcontext", None)
+    if _nullcontext is None:
+
+        @contextlib.contextmanager
+        def _nullcontext(v):
+            yield v
+
+    def _get_data(package, resource):
+        # pkgutil.get_data returns None rather than raising when the package
+        # cannot be found (and on Python 2 raises AttributeError if the
+        # package has been blocked by setting sys.modules[name] = None), so
+        # import the package first to get the ImportError the callers expect
+        # from the importlib.resources versions of these functions.
+        importlib.import_module(package)
+
+        pkg_data = pkgutil.get_data(package, resource)
+        if pkg_data is None:
+            raise ImportError("No package named %r" % package)
+
+        return pkg_data
+
+    def _open_text(package, resource):
+        str_package_data = _get_data(package, resource).decode("utf-8")
+
+        return _nullcontext(io.StringIO(str_package_data))
+
+    def _open_binary(package, resource):
+        return io.BytesIO(_get_data(package, resource))
+
+else:
+    import importlib.resources
+
+    if sys.version_info >= (3, 9):
+
+        def _open_text(package, resource):
+            return (
+                importlib.resources.files(package)
+                .joinpath(resource)
+                .open("r", encoding="utf-8")
+            )
+
+        def _open_binary(package, resource):
+            return (
+                importlib.resources.files(package).joinpath(resource).open("rb")
+            )
+
+    else:
+        _open_text = importlib.resources.open_text
+        _open_binary = importlib.resources.open_binary
+
+
+def _is_package_directory(package, resource):
+    """Whether ``resource`` names a directory inside ``package``.
+
+    Opening a directory raises IsADirectoryError on POSIX but PermissionError
+    on Windows, and on Python < 3.9 there is no portable way to ask the
+    resource API, so check the package's search path directly (the tzdata
+    package is a regular directory-backed package).
+    """
+    try:
+        pkg = importlib.import_module(package)
+    except ImportError:
+        return False
+
+    for base in getattr(pkg, "__path__", ()):
+        if os.path.isdir(os.path.join(base, resource)):
+            return True
+
+    return False
+
+
+def _load_tzdata(key):
+    components = key.split("/")
+    package_name = ".".join(["tzdata.zoneinfo"] + components[:-1])
+    resource_name = components[-1]
+
+    # Empty or relative path components cannot name a zone, and they produce
+    # module names that the import machinery handles inconsistently across
+    # versions, so treat them as not found up front. A key naming a directory
+    # (a subpackage) is not a zone either, and opening it raises a
+    # platform-dependent error, see CPython gh-85702.
+    if any(c in ("", ".", "..") for c in components) or _is_package_directory(
+        package_name, resource_name
+    ):
+        raise TZFileNotFound("Time zone not found: %s", zone_key=key)
+
+    try:
+        return _open_binary(package_name, resource_name)
+    except _TZDATA_LOAD_EXCEPTIONS:
+        # ImportError: package does not exist (or tzdata is not installed)
+        # FileNotFoundError: the key is not a file in the package
+        # UnicodeEncodeError: the key is not encodable as a filename
+        # IsADirectoryError: the key names a package rather than a resource
+        # ValueError: the key is not a valid path (e.g. contains a NUL byte)
+        six.raise_from(
+            TZFileNotFound("Time zone not found: %s", zone_key=key), None
+        )
+
+
+def _load_tzdata_keys():
+    with _open_text("tzdata", "zones") as f:
+        return list(filter(None, (l.strip() for l in f)))
+
+
+class TZFileNotFound(ValueError):
+    """Indicates that a time zone file isn't present in tzdata."""
+
+    def __init__(self, msg, *args, **kwargs):
+        # TODO: Use keyword-only argument when this is Python 3-only
+        zone_key = kwargs.pop("zone_key", None)
+        if zone_key is None:  # pragma: nocover
+            raise TypeError("Required keyword argument missing: zone_key")
+
+        super(TZFileNotFound, self).__init__(msg % zone_key, *args)
+        self.zone_key = zone_key

dateutil/_version.py

@@ -1,16 +1,4 @@
 # file generated by setuptools_scm
 # don't change, don't track in version control
-TYPE_CHECKING = False
-if TYPE_CHECKING:
-    from typing import Tuple, Union
-    VERSION_TUPLE = Tuple[Union[int, str], ...]
-else:
-    VERSION_TUPLE = object
-
-version: str
-__version__: str
-__version_tuple__: VERSION_TUPLE
-version_tuple: VERSION_TUPLE
-
-__version__ = version = '2.9.0'
-__version_tuple__ = version_tuple = (2, 9, 0)
+__version__ = version = '3.0.0'
+__version_tuple__ = version_tuple = (3, 0, 0)

dateutil/relativedelta.py

@@ -564,9 +564,6 @@ class relativedelta(object):
             self.microsecond,
         ))
 
-    def __ne__(self, other):
-        return not self.__eq__(other)
-
     def __div__(self, other):
         try:
             reciprocal = 1 / float(other)

dateutil/rrule.py

@@ -102,6 +102,30 @@ class rrulebase(object):
             self._cache_complete = False
             self._len = None
 
+    def __reduce_ex__(self, protocol):
+        rv = super(rrulebase, self).__reduce_ex__(protocol)
+        state, slots = rv[2], None
+        if isinstance(state, tuple):
+            state, slots = state
+        if self._cache is not None:
+            state = dict(state)
+            state.pop("_cache_lock", None)
+            state.pop("_cache_gen", None)
+            state["_cache"] = []
+        if slots is not None:
+            state = (state, slots)
+        return rv[:2] + (state,) + rv[3:]
+
+    def __setstate__(self, state):
+        if isinstance(state, tuple):
+            state, slots = state
+            for name, value in slots.items():
+                setattr(self, name, value)
+        self.__dict__.update(state)
+        if self._cache is not None:
+            self._cache_lock = _thread.allocate_lock()
+            self._invalidate_cache()
+
     def __iter__(self):
         if self._cache_complete:
             return iter(self._cache)
@@ -1672,7 +1696,10 @@ class _rrulestr(object):
                 parms = parms[1:]
                 if name == "RRULE":
                     for parm in parms:
-                        raise ValueError("unsupported RRULE parm: "+parm)
+                        if parm.startswith("X-"):
+                            # Experimental random vendor features; safe to ignore
+                            continue
+                        raise ValueError("unsupported RRULE parm: " + parm)
                     rrulevals.append(value)
                 elif name == "RDATE":
                     for parm in parms:

dateutil/tz/__init__.py

@@ -1,11 +1,59 @@
 # -*- coding: utf-8 -*-
+import sys
+
+from . import _tzpath
+from ._tzpath import reset_tzpath
 from .tz import *
 from .tz import __doc__
 
-__all__ = ["tzutc", "tzoffset", "tzlocal", "tzfile", "tzrange",
-           "tzstr", "tzical", "tzwin", "tzwinlocal", "gettz",
-           "enfold", "datetime_ambiguous", "datetime_exists",
-           "resolve_imaginary", "UTC", "DeprecatedTzFormatWarning"]
+__all__ = [
+    "tzutc",
+    "tzoffset",
+    "tzlocal",
+    "tzfile",
+    "tzrange",
+    "tzstr",
+    "tzical",
+    "tzwin",
+    "tzwinlocal",
+    "gettz",
+    "enfold",
+    "datetime_ambiguous",
+    "datetime_exists",
+    "resolve_imaginary",
+    "available_iana_timezones",
+    "UTC",
+    "TZPATH",
+    "reset_tzpath",
+    "DeprecatedTzFormatWarning",
+    "DeprecatedTzKeyWarning",
+]
+
+if sys.version_info < (3, 7):
+    # Module-level __getattr__ was added in Python 3.7, so instead of lazily
+    # populating TZPATH on every access, we will register a callback with
+    # reset_tzpath to update the top-level tuple.
+    TZPATH = _tzpath.TZPATH
+
+    def _tzpath_callback(new_tzpath):
+        global TZPATH
+        TZPATH = new_tzpath
+
+    _tzpath.TZPATH_CALLBACKS.append(_tzpath_callback)
+
+else:
+
+    def __getattr__(name):
+        if name == "TZPATH":
+            return _tzpath.TZPATH
+        else:
+            raise AttributeError(
+                "Module %s has no attribute %s" % (repr(__name__), repr(name))
+            )
+
+
+def __dir__():
+    return sorted(list(globals()) + ["TZPATH"])
 
 
 class DeprecatedTzFormatWarning(Warning):