python-dateutil 4.0.0__py3-none-any.whl

dateutil/__init__.py

@@ -0,0 +1,25 @@
+import sys
+
+try:
+    from ._version import version as __version__
+except ImportError:
+    __version__ = 'unknown'
+
+__all__ = ["easter", "parser", "relativedelta", "rrule", "tz", "utils"]
+
+
+def __getattr__(name):
+    import importlib
+
+    if name in __all__ or name == "zoneinfo":
+        return importlib.import_module("." + name, __name__)
+    raise AttributeError(
+        "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__ + ["zoneinfo"]
+    )

dateutil/_common.py

@@ -0,0 +1,40 @@
+"""
+Common code used in multiple modules.
+"""
+
+
+class weekday:
+    __slots__ = ["weekday", "n"]
+
+    def __init__(self, weekday, n=None):
+        self.weekday = weekday
+        self.n = n
+
+    def __call__(self, n):
+        if n == self.n:
+            return self
+        else:
+            return self.__class__(self.weekday, n)
+
+    def __eq__(self, other):
+        try:
+            if self.weekday != other.weekday or self.n != other.n:
+                return False
+        except AttributeError:
+            return False
+        return True
+
+    def __hash__(self):
+        return hash((
+          self.weekday,
+          self.n,
+        ))
+
+    def __repr__(self):
+        s = ("MO", "TU", "WE", "TH", "FR", "SA", "SU")[self.weekday]
+        if not self.n:
+            return s
+        else:
+            return "%s(%+d)" % (s, self.n)
+
+# vim:ts=4:sw=4:et

dateutil/_tzdata_impl.py

@@ -0,0 +1,75 @@
+"""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 importlib.resources
+from typing import BinaryIO, TextIO
+
+_TZDATA_LOAD_EXCEPTIONS = (
+    ImportError,
+    FileNotFoundError,
+    UnicodeEncodeError,
+    IsADirectoryError,
+    ValueError,
+)
+
+
+def _open_text(package: str, resource: str) -> TextIO:
+    return (
+        importlib.resources.files(package)
+        .joinpath(resource)
+        .open("r", encoding="utf-8")
+    )
+
+
+def _open_binary(package: str, resource: str) -> BinaryIO:
+    return importlib.resources.files(package).joinpath(resource).open("rb")
+
+
+def _is_package_directory(package: str, resource: str) -> bool:
+    """Checks for directories before opening resources on Windows."""
+    try:
+        return importlib.resources.files(package).joinpath(resource).is_dir()
+    except ImportError:
+        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)
+        raise TZFileNotFound("Time zone not found: %s", zone_key=key) from 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: str, *args: object, zone_key: str) -> None:
+        super().__init__(msg % zone_key, *args)
+        self.zone_key = zone_key

dateutil/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '4.0.0'
+__version_tuple__ = version_tuple = (4, 0, 0)
+
+__commit_id__ = commit_id = None

dateutil/easter.py

@@ -0,0 +1,88 @@
+"""
+This module offers a generic Easter computing method for any given year, using
+Western, Orthodox or Julian algorithms.
+"""
+
+import datetime
+
+__all__ = ["easter", "EASTER_JULIAN", "EASTER_ORTHODOX", "EASTER_WESTERN"]
+
+EASTER_JULIAN = 1
+EASTER_ORTHODOX = 2
+EASTER_WESTERN = 3
+
+
+def easter(year, method=EASTER_WESTERN):
+    """
+    This method was ported from the work done by GM Arts,
+    on top of the algorithm by Claus Tondering, which was
+    based in part on the algorithm of Ouding (1940), as
+    quoted in "Explanatory Supplement to the Astronomical
+    Almanac", P.  Kenneth Seidelmann, editor.
+
+    This algorithm implements three different Easter
+    calculation methods:
+
+    1. Original calculation in Julian calendar, valid in
+       dates after 326 AD
+    2. Original method, with date converted to Gregorian
+       calendar, valid in years 1583 to 4099
+    3. Revised method, in Gregorian calendar, valid in
+       years 1583 to 4099 as well
+
+    These methods are represented by the constants:
+
+    * ``EASTER_JULIAN   = 1``
+    * ``EASTER_ORTHODOX = 2``
+    * ``EASTER_WESTERN  = 3``
+
+    The default method is method 3.
+
+    More about the algorithm may be found at:
+
+    `GM Arts: Easter Algorithms <http://www.gmarts.org/index.php?go=415>`_
+
+    and
+
+    `The Calendar FAQ: Easter <https://www.tondering.dk/claus/cal/easter.php>`_
+
+    """
+
+    if not (1 <= method <= 3):
+        raise ValueError("invalid method")
+
+    # g - Golden year - 1
+    # c - Century
+    # h - (23 - Epact) mod 30
+    # i - Number of days from March 21 to Paschal Full Moon
+    # j - Weekday for PFM (0=Sunday, etc)
+    # p - Number of days from March 21 to Sunday on or before PFM
+    #     (-6 to 28 methods 1 & 3, to 56 for method 2)
+    # e - Extra days to add for method 2 (converting Julian
+    #     date to Gregorian date)
+
+    y = year
+    g = y % 19
+    e = 0
+    if method < 3:
+        # Old method
+        i = (19*g + 15) % 30
+        j = (y + y//4 + i) % 7
+        if method == 2:
+            # Extra dates to convert Julian to Gregorian date
+            e = 10
+            if y > 1600:
+                e = e + y//100 - 16 - (y//100 - 16)//4
+    else:
+        # New method
+        c = y//100
+        h = (c - c//4 - (8*c + 13)//25 + 19*g + 15) % 30
+        i = h - (h//28)*(1 - (h//28)*(29//(h + 1))*((21 - g)//11))
+        j = (y + y//4 + i + 2 - c + c//4) % 7
+
+    # p can be from -6 to 56 corresponding to dates 22 March to 23 May
+    # (later dates apply to method 2, although 23 May never actually occurs)
+    p = i - j + e
+    d = 1 + (p + 27 + (p + 6)//40) % 31
+    m = 3 + (p + 26)//30
+    return datetime.date(int(y), int(m), int(d))

dateutil/parser/__init__.py

@@ -0,0 +1,63 @@
+from ._parser import (
+    DEFAULTPARSER,
+    DEFAULTTZPARSER,
+    ParserError,
+    UnknownTimezoneWarning,
+    __doc__,
+    parse,
+    parser,
+    parserinfo,
+)
+from .isoparser import isoparse, isoparser
+
+__all__ = ['parse', 'parser', 'parserinfo',
+           'isoparse', 'isoparser',
+           'ParserError',
+           'UnknownTimezoneWarning']
+
+
+###
+# Deprecate portions of the private interface so that downstream code that
+# is improperly relying on it is given *some* notice.
+
+
+def __deprecated_private_func(f):
+    import warnings
+    from functools import wraps
+
+    msg = ('{name} is a private function and may break without warning, '
+           'it will be moved and or renamed in future versions.')
+    msg = msg.format(name=f.__name__)
+
+    @wraps(f)
+    def deprecated_func(*args, **kwargs):
+        warnings.warn(msg, DeprecationWarning)
+        return f(*args, **kwargs)
+
+    return deprecated_func
+
+def __deprecate_private_class(c):
+    import warnings
+
+    msg = ('{name} is a private class and may break without warning, '
+           'it will be moved and or renamed in future versions.')
+    msg = msg.format(name=c.__name__)
+
+    class private_class(c):
+        __doc__ = c.__doc__
+
+        def __init__(self, *args, **kwargs):
+            warnings.warn(msg, DeprecationWarning)
+            super().__init__(*args, **kwargs)
+
+    private_class.__name__ = c.__name__
+
+    return private_class
+
+
+from ._parser import _parsetz, _resultbase, _timelex, _tzparser
+
+_timelex = __deprecate_private_class(_timelex)
+_tzparser = __deprecate_private_class(_tzparser)
+_resultbase = __deprecate_private_class(_resultbase)
+_parsetz = __deprecated_private_func(_parsetz)