Updated kodi settings on Lenovo

Kodi/Lenovo/addons/script.module.arrow/lib/arrow/__init__.py

@@ -0,0 +1,39 @@
+from ._version import __version__
+from .api import get, now, utcnow
+from .arrow import Arrow
+from .factory import ArrowFactory
+from .formatter import (
+    FORMAT_ATOM,
+    FORMAT_COOKIE,
+    FORMAT_RFC822,
+    FORMAT_RFC850,
+    FORMAT_RFC1036,
+    FORMAT_RFC1123,
+    FORMAT_RFC2822,
+    FORMAT_RFC3339,
+    FORMAT_RSS,
+    FORMAT_W3C,
+)
+from .parser import ParserError
+
+# https://mypy.readthedocs.io/en/stable/command_line.html#cmdoption-mypy-no-implicit-reexport
+# Mypy with --strict or --no-implicit-reexport requires an explicit reexport.
+__all__ = [
+    "__version__",
+    "get",
+    "now",
+    "utcnow",
+    "Arrow",
+    "ArrowFactory",
+    "FORMAT_ATOM",
+    "FORMAT_COOKIE",
+    "FORMAT_RFC822",
+    "FORMAT_RFC850",
+    "FORMAT_RFC1036",
+    "FORMAT_RFC1123",
+    "FORMAT_RFC2822",
+    "FORMAT_RFC3339",
+    "FORMAT_RSS",
+    "FORMAT_W3C",
+    "ParserError",
+]

Kodi/Lenovo/addons/script.module.arrow/lib/arrow/_version.py

@@ -0,0 +1 @@
+__version__ = "1.2.3"

Kodi/Lenovo/addons/script.module.arrow/lib/arrow/api.py

@@ -0,0 +1,126 @@
+"""
+Provides the default implementation of :class:`ArrowFactory <arrow.factory.ArrowFactory>`
+methods for use as a module API.
+
+"""
+
+from datetime import date, datetime
+from datetime import tzinfo as dt_tzinfo
+from time import struct_time
+from typing import Any, List, Optional, Tuple, Type, Union, overload
+
+from arrow.arrow import TZ_EXPR, Arrow
+from arrow.constants import DEFAULT_LOCALE
+from arrow.factory import ArrowFactory
+
+# internal default factory.
+_factory = ArrowFactory()
+
+# TODO: Use Positional Only Argument (https://www.python.org/dev/peps/pep-0570/)
+#  after Python 3.7 deprecation
+
+
+@overload
+def get(
+    *,
+    locale: str = DEFAULT_LOCALE,
+    tzinfo: Optional[TZ_EXPR] = None,
+    normalize_whitespace: bool = False,
+) -> Arrow:
+    ...  # pragma: no cover
+
+
+@overload
+def get(
+    *args: int,
+    locale: str = DEFAULT_LOCALE,
+    tzinfo: Optional[TZ_EXPR] = None,
+    normalize_whitespace: bool = False,
+) -> Arrow:
+    ...  # pragma: no cover
+
+
+@overload
+def get(
+    __obj: Union[
+        Arrow,
+        datetime,
+        date,
+        struct_time,
+        dt_tzinfo,
+        int,
+        float,
+        str,
+        Tuple[int, int, int],
+    ],
+    *,
+    locale: str = DEFAULT_LOCALE,
+    tzinfo: Optional[TZ_EXPR] = None,
+    normalize_whitespace: bool = False,
+) -> Arrow:
+    ...  # pragma: no cover
+
+
+@overload
+def get(
+    __arg1: Union[datetime, date],
+    __arg2: TZ_EXPR,
+    *,
+    locale: str = DEFAULT_LOCALE,
+    tzinfo: Optional[TZ_EXPR] = None,
+    normalize_whitespace: bool = False,
+) -> Arrow:
+    ...  # pragma: no cover
+
+
+@overload
+def get(
+    __arg1: str,
+    __arg2: Union[str, List[str]],
+    *,
+    locale: str = DEFAULT_LOCALE,
+    tzinfo: Optional[TZ_EXPR] = None,
+    normalize_whitespace: bool = False,
+) -> Arrow:
+    ...  # pragma: no cover
+
+
+def get(*args: Any, **kwargs: Any) -> Arrow:
+    """Calls the default :class:`ArrowFactory <arrow.factory.ArrowFactory>` ``get`` method."""
+
+    return _factory.get(*args, **kwargs)
+
+
+get.__doc__ = _factory.get.__doc__
+
+
+def utcnow() -> Arrow:
+    """Calls the default :class:`ArrowFactory <arrow.factory.ArrowFactory>` ``utcnow`` method."""
+
+    return _factory.utcnow()
+
+
+utcnow.__doc__ = _factory.utcnow.__doc__
+
+
+def now(tz: Optional[TZ_EXPR] = None) -> Arrow:
+    """Calls the default :class:`ArrowFactory <arrow.factory.ArrowFactory>` ``now`` method."""
+
+    return _factory.now(tz)
+
+
+now.__doc__ = _factory.now.__doc__
+
+
+def factory(type: Type[Arrow]) -> ArrowFactory:
+    """Returns an :class:`.ArrowFactory` for the specified :class:`Arrow <arrow.arrow.Arrow>`
+    or derived type.
+
+    :param type: the type, :class:`Arrow <arrow.arrow.Arrow>` or derived.
+
+    """
+
+    return ArrowFactory(type)
+
+
+__all__ = ["get", "utcnow", "now", "factory"]

Kodi/Lenovo/addons/script.module.arrow/lib/arrow/constants.py

@@ -0,0 +1,177 @@
+"""Constants used internally in arrow."""
+
+import sys
+from datetime import datetime
+
+if sys.version_info < (3, 8):  # pragma: no cover
+    from typing_extensions import Final
+else:
+    from typing import Final  # pragma: no cover
+
+# datetime.max.timestamp() errors on Windows, so we must hardcode
+# the highest possible datetime value that can output a timestamp.
+# tl;dr platform-independent max timestamps are hard to form
+# See: https://stackoverflow.com/q/46133223
+try:
+    # Get max timestamp. Works on POSIX-based systems like Linux and macOS,
+    # but will trigger an OverflowError, ValueError, or OSError on Windows
+    _MAX_TIMESTAMP = datetime.max.timestamp()
+except (OverflowError, ValueError, OSError):  # pragma: no cover
+    # Fallback for Windows and 32-bit systems if initial max timestamp call fails
+    # Must get max value of ctime on Windows based on architecture (x32 vs x64)
+    # https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/ctime-ctime32-ctime64-wctime-wctime32-wctime64
+    # Note: this may occur on both 32-bit Linux systems (issue #930) along with Windows systems
+    is_64bits = sys.maxsize > 2**32
+    _MAX_TIMESTAMP = (
+        datetime(3000, 1, 1, 23, 59, 59, 999999).timestamp()
+        if is_64bits
+        else datetime(2038, 1, 1, 23, 59, 59, 999999).timestamp()
+    )
+
+MAX_TIMESTAMP: Final[float] = _MAX_TIMESTAMP
+MAX_TIMESTAMP_MS: Final[float] = MAX_TIMESTAMP * 1000
+MAX_TIMESTAMP_US: Final[float] = MAX_TIMESTAMP * 1_000_000
+
+MAX_ORDINAL: Final[int] = datetime.max.toordinal()
+MIN_ORDINAL: Final[int] = 1
+
+DEFAULT_LOCALE: Final[str] = "en-us"
+
+# Supported dehumanize locales
+DEHUMANIZE_LOCALES = {
+    "en",
+    "en-us",
+    "en-gb",
+    "en-au",
+    "en-be",
+    "en-jp",
+    "en-za",
+    "en-ca",
+    "en-ph",
+    "fr",
+    "fr-fr",
+    "fr-ca",
+    "it",
+    "it-it",
+    "es",
+    "es-es",
+    "el",
+    "el-gr",
+    "ja",
+    "ja-jp",
+    "se",
+    "se-fi",
+    "se-no",
+    "se-se",
+    "sv",
+    "sv-se",
+    "fi",
+    "fi-fi",
+    "zh",
+    "zh-cn",
+    "zh-tw",
+    "zh-hk",
+    "nl",
+    "nl-nl",
+    "be",
+    "be-by",
+    "pl",
+    "pl-pl",
+    "ru",
+    "ru-ru",
+    "af",
+    "bg",
+    "bg-bg",
+    "ua",
+    "uk",
+    "uk-ua",
+    "mk",
+    "mk-mk",
+    "de",
+    "de-de",
+    "de-ch",
+    "de-at",
+    "nb",
+    "nb-no",
+    "nn",
+    "nn-no",
+    "pt",
+    "pt-pt",
+    "pt-br",
+    "tl",
+    "tl-ph",
+    "vi",
+    "vi-vn",
+    "tr",
+    "tr-tr",
+    "az",
+    "az-az",
+    "da",
+    "da-dk",
+    "ml",
+    "hi",
+    "cs",
+    "cs-cz",
+    "sk",
+    "sk-sk",
+    "fa",
+    "fa-ir",
+    "mr",
+    "ca",
+    "ca-es",
+    "ca-ad",
+    "ca-fr",
+    "ca-it",
+    "eo",
+    "eo-xx",
+    "bn",
+    "bn-bd",
+    "bn-in",
+    "rm",
+    "rm-ch",
+    "ro",
+    "ro-ro",
+    "sl",
+    "sl-si",
+    "id",
+    "id-id",
+    "ne",
+    "ne-np",
+    "ee",
+    "et",
+    "sw",
+    "sw-ke",
+    "sw-tz",
+    "la",
+    "la-va",
+    "lt",
+    "lt-lt",
+    "ms",
+    "ms-my",
+    "ms-bn",
+    "or",
+    "or-in",
+    "lb",
+    "lb-lu",
+    "zu",
+    "zu-za",
+    "sq",
+    "sq-al",
+    "ta",
+    "ta-in",
+    "ta-lk",
+    "ur",
+    "ur-pk",
+    "ka",
+    "ka-ge",
+    "kk",
+    "kk-kz",
+    # "lo",
+    # "lo-la",
+    "am",
+    "am-et",
+    "hy-am",
+    "hy",
+    "uz",
+    "uz-uz",
+}

Kodi/Lenovo/addons/script.module.arrow/lib/arrow/factory.py

@@ -0,0 +1,348 @@
+"""
+Implements the :class:`ArrowFactory <arrow.factory.ArrowFactory>` class,
+providing factory methods for common :class:`Arrow <arrow.arrow.Arrow>`
+construction scenarios.
+
+"""
+
+
+import calendar
+from datetime import date, datetime
+from datetime import tzinfo as dt_tzinfo
+from decimal import Decimal
+from time import struct_time
+from typing import Any, List, Optional, Tuple, Type, Union, overload
+
+from dateutil import tz as dateutil_tz
+
+from arrow import parser
+from arrow.arrow import TZ_EXPR, Arrow
+from arrow.constants import DEFAULT_LOCALE
+from arrow.util import is_timestamp, iso_to_gregorian
+
+
+class ArrowFactory:
+    """A factory for generating :class:`Arrow <arrow.arrow.Arrow>` objects.
+
+    :param type: (optional) the :class:`Arrow <arrow.arrow.Arrow>`-based class to construct from.
+        Defaults to :class:`Arrow <arrow.arrow.Arrow>`.
+
+    """
+
+    type: Type[Arrow]
+
+    def __init__(self, type: Type[Arrow] = Arrow) -> None:
+        self.type = type
+
+    @overload
+    def get(
+        self,
+        *,
+        locale: str = DEFAULT_LOCALE,
+        tzinfo: Optional[TZ_EXPR] = None,
+        normalize_whitespace: bool = False,
+    ) -> Arrow:
+        ...  # pragma: no cover
+
+    @overload
+    def get(
+        self,
+        __obj: Union[
+            Arrow,
+            datetime,
+            date,
+            struct_time,
+            dt_tzinfo,
+            int,
+            float,
+            str,
+            Tuple[int, int, int],
+        ],
+        *,
+        locale: str = DEFAULT_LOCALE,
+        tzinfo: Optional[TZ_EXPR] = None,
+        normalize_whitespace: bool = False,
+    ) -> Arrow:
+        ...  # pragma: no cover
+
+    @overload
+    def get(
+        self,
+        __arg1: Union[datetime, date],
+        __arg2: TZ_EXPR,
+        *,
+        locale: str = DEFAULT_LOCALE,
+        tzinfo: Optional[TZ_EXPR] = None,
+        normalize_whitespace: bool = False,
+    ) -> Arrow:
+        ...  # pragma: no cover
+
+    @overload
+    def get(
+        self,
+        __arg1: str,
+        __arg2: Union[str, List[str]],
+        *,
+        locale: str = DEFAULT_LOCALE,
+        tzinfo: Optional[TZ_EXPR] = None,
+        normalize_whitespace: bool = False,
+    ) -> Arrow:
+        ...  # pragma: no cover
+
+    def get(self, *args: Any, **kwargs: Any) -> Arrow:
+        """Returns an :class:`Arrow <arrow.arrow.Arrow>` object based on flexible inputs.
+
+        :param locale: (optional) a ``str`` specifying a locale for the parser. Defaults to 'en-us'.
+        :param tzinfo: (optional) a :ref:`timezone expression <tz-expr>` or tzinfo object.
+            Replaces the timezone unless using an input form that is explicitly UTC or specifies
+            the timezone in a positional argument. Defaults to UTC.
+        :param normalize_whitespace: (optional) a ``bool`` specifying whether or not to normalize
+            redundant whitespace (spaces, tabs, and newlines) in a datetime string before parsing.
+            Defaults to false.
+
+        Usage::
+
+            >>> import arrow
+
+        **No inputs** to get current UTC time::
+
+            >>> arrow.get()
+            <Arrow [2013-05-08T05:51:43.316458+00:00]>
+
+        **One** :class:`Arrow <arrow.arrow.Arrow>` object, to get a copy.
+
+            >>> arw = arrow.utcnow()
+            >>> arrow.get(arw)
+            <Arrow [2013-10-23T15:21:54.354846+00:00]>
+
+        **One** ``float`` or ``int``, convertible to a floating-point timestamp, to get
+        that timestamp in UTC::
+
+            >>> arrow.get(1367992474.293378)
+            <Arrow [2013-05-08T05:54:34.293378+00:00]>
+
+            >>> arrow.get(1367992474)
+            <Arrow [2013-05-08T05:54:34+00:00]>
+
+        **One** ISO 8601-formatted ``str``, to parse it::
+
+            >>> arrow.get('2013-09-29T01:26:43.830580')
+            <Arrow [2013-09-29T01:26:43.830580+00:00]>
+
+        **One** ISO 8601-formatted ``str``, in basic format, to parse it::
+
+            >>> arrow.get('20160413T133656.456289')
+            <Arrow [2016-04-13T13:36:56.456289+00:00]>
+
+        **One** ``tzinfo``, to get the current time **converted** to that timezone::
+
+            >>> arrow.get(tz.tzlocal())
+            <Arrow [2013-05-07T22:57:28.484717-07:00]>
+
+        **One** naive ``datetime``, to get that datetime in UTC::
+
+            >>> arrow.get(datetime(2013, 5, 5))
+            <Arrow [2013-05-05T00:00:00+00:00]>
+
+        **One** aware ``datetime``, to get that datetime::
+
+            >>> arrow.get(datetime(2013, 5, 5, tzinfo=tz.tzlocal()))
+            <Arrow [2013-05-05T00:00:00-07:00]>
+
+        **One** naive ``date``, to get that date in UTC::
+
+            >>> arrow.get(date(2013, 5, 5))
+            <Arrow [2013-05-05T00:00:00+00:00]>
+
+        **One** time.struct time::
+
+            >>> arrow.get(gmtime(0))
+            <Arrow [1970-01-01T00:00:00+00:00]>
+
+        **One** iso calendar ``tuple``, to get that week date in UTC::
+
+            >>> arrow.get((2013, 18, 7))
+            <Arrow [2013-05-05T00:00:00+00:00]>
+
+        **Two** arguments, a naive or aware ``datetime``, and a replacement
+        :ref:`timezone expression <tz-expr>`::
+
+            >>> arrow.get(datetime(2013, 5, 5), 'US/Pacific')
+            <Arrow [2013-05-05T00:00:00-07:00]>
+
+        **Two** arguments, a naive ``date``, and a replacement
+        :ref:`timezone expression <tz-expr>`::
+
+            >>> arrow.get(date(2013, 5, 5), 'US/Pacific')
+            <Arrow [2013-05-05T00:00:00-07:00]>
+
+        **Two** arguments, both ``str``, to parse the first according to the format of the second::
+
+            >>> arrow.get('2013-05-05 12:30:45 America/Chicago', 'YYYY-MM-DD HH:mm:ss ZZZ')
+            <Arrow [2013-05-05T12:30:45-05:00]>
+
+        **Two** arguments, first a ``str`` to parse and second a ``list`` of formats to try::
+
+            >>> arrow.get('2013-05-05 12:30:45', ['MM/DD/YYYY', 'YYYY-MM-DD HH:mm:ss'])
+            <Arrow [2013-05-05T12:30:45+00:00]>
+
+        **Three or more** arguments, as for the direct constructor of an ``Arrow`` object::
+
+            >>> arrow.get(2013, 5, 5, 12, 30, 45)
+            <Arrow [2013-05-05T12:30:45+00:00]>
+
+        """
+
+        arg_count = len(args)
+        locale = kwargs.pop("locale", DEFAULT_LOCALE)
+        tz = kwargs.get("tzinfo", None)
+        normalize_whitespace = kwargs.pop("normalize_whitespace", False)
+
+        # if kwargs given, send to constructor unless only tzinfo provided
+        if len(kwargs) > 1:
+            arg_count = 3
+
+        # tzinfo kwarg is not provided
+        if len(kwargs) == 1 and tz is None:
+            arg_count = 3
+
+        # () -> now, @ tzinfo or utc
+        if arg_count == 0:
+            if isinstance(tz, str):
+                tz = parser.TzinfoParser.parse(tz)
+                return self.type.now(tzinfo=tz)
+
+            if isinstance(tz, dt_tzinfo):
+                return self.type.now(tzinfo=tz)
+
+            return self.type.utcnow()
+
+        if arg_count == 1:
+            arg = args[0]
+            if isinstance(arg, Decimal):
+                arg = float(arg)
+
+            # (None) -> raises an exception
+            if arg is None:
+                raise TypeError("Cannot parse argument of type None.")
+
+            # try (int, float) -> from timestamp @ tzinfo
+            elif not isinstance(arg, str) and is_timestamp(arg):
+                if tz is None:
+                    # set to UTC by default
+                    tz = dateutil_tz.tzutc()
+                return self.type.fromtimestamp(arg, tzinfo=tz)
+
+            # (Arrow) -> from the object's datetime @ tzinfo
+            elif isinstance(arg, Arrow):
+                return self.type.fromdatetime(arg.datetime, tzinfo=tz)
+
+            # (datetime) -> from datetime @ tzinfo
+            elif isinstance(arg, datetime):
+                return self.type.fromdatetime(arg, tzinfo=tz)
+
+            # (date) -> from date @ tzinfo
+            elif isinstance(arg, date):
+                return self.type.fromdate(arg, tzinfo=tz)
+
+            # (tzinfo) -> now @ tzinfo
+            elif isinstance(arg, dt_tzinfo):
+                return self.type.now(tzinfo=arg)
+
+            # (str) -> parse @ tzinfo
+            elif isinstance(arg, str):
+                dt = parser.DateTimeParser(locale).parse_iso(arg, normalize_whitespace)
+                return self.type.fromdatetime(dt, tzinfo=tz)
+
+            # (struct_time) -> from struct_time
+            elif isinstance(arg, struct_time):
+                return self.type.utcfromtimestamp(calendar.timegm(arg))
+
+            # (iso calendar) -> convert then from date @ tzinfo
+            elif isinstance(arg, tuple) and len(arg) == 3:
+                d = iso_to_gregorian(*arg)
+                return self.type.fromdate(d, tzinfo=tz)
+
+            else:
+                raise TypeError(f"Cannot parse single argument of type {type(arg)!r}.")
+
+        elif arg_count == 2:
+
+            arg_1, arg_2 = args[0], args[1]
+
+            if isinstance(arg_1, datetime):
+
+                # (datetime, tzinfo/str) -> fromdatetime @ tzinfo
+                if isinstance(arg_2, (dt_tzinfo, str)):
+                    return self.type.fromdatetime(arg_1, tzinfo=arg_2)
+                else:
+                    raise TypeError(
+                        f"Cannot parse two arguments of types 'datetime', {type(arg_2)!r}."
+                    )
+
+            elif isinstance(arg_1, date):
+
+                # (date, tzinfo/str) -> fromdate @ tzinfo
+                if isinstance(arg_2, (dt_tzinfo, str)):
+                    return self.type.fromdate(arg_1, tzinfo=arg_2)
+                else:
+                    raise TypeError(
+                        f"Cannot parse two arguments of types 'date', {type(arg_2)!r}."
+                    )
+
+            # (str, format) -> parse @ tzinfo
+            elif isinstance(arg_1, str) and isinstance(arg_2, (str, list)):
+                dt = parser.DateTimeParser(locale).parse(
+                    args[0], args[1], normalize_whitespace
+                )
+                return self.type.fromdatetime(dt, tzinfo=tz)
+
+            else:
+                raise TypeError(
+                    f"Cannot parse two arguments of types {type(arg_1)!r} and {type(arg_2)!r}."
+                )
+
+        # 3+ args -> datetime-like via constructor
+        else:
+            return self.type(*args, **kwargs)
+
+    def utcnow(self) -> Arrow:
+        """Returns an :class:`Arrow <arrow.arrow.Arrow>` object, representing "now" in UTC time.
+
+        Usage::
+
+            >>> import arrow
+            >>> arrow.utcnow()
+            <Arrow [2013-05-08T05:19:07.018993+00:00]>
+        """
+
+        return self.type.utcnow()
+
+    def now(self, tz: Optional[TZ_EXPR] = None) -> Arrow:
+        """Returns an :class:`Arrow <arrow.arrow.Arrow>` object, representing "now" in the given
+        timezone.
+
+        :param tz: (optional) A :ref:`timezone expression <tz-expr>`.  Defaults to local time.
+
+        Usage::
+
+            >>> import arrow
+            >>> arrow.now()
+            <Arrow [2013-05-07T22:19:11.363410-07:00]>
+
+            >>> arrow.now('US/Pacific')
+            <Arrow [2013-05-07T22:19:15.251821-07:00]>
+
+            >>> arrow.now('+02:00')
+            <Arrow [2013-05-08T07:19:25.618646+02:00]>
+
+            >>> arrow.now('local')
+            <Arrow [2013-05-07T22:19:39.130059-07:00]>
+        """
+
+        if tz is None:
+            tz = dateutil_tz.tzlocal()
+        elif not isinstance(tz, dt_tzinfo):
+            tz = parser.TzinfoParser.parse(tz)
+
+        return self.type.now(tz)

Kodi/Lenovo/addons/script.module.arrow/lib/arrow/formatter.py

@@ -0,0 +1,152 @@
+"""Provides the :class:`Arrow <arrow.formatter.DateTimeFormatter>` class, an improved formatter for datetimes."""
+
+import re
+import sys
+from datetime import datetime, timedelta
+from typing import Optional, Pattern, cast
+
+from dateutil import tz as dateutil_tz
+
+from arrow import locales
+from arrow.constants import DEFAULT_LOCALE
+
+if sys.version_info < (3, 8):  # pragma: no cover
+    from typing_extensions import Final
+else:
+    from typing import Final  # pragma: no cover
+
+
+FORMAT_ATOM: Final[str] = "YYYY-MM-DD HH:mm:ssZZ"
+FORMAT_COOKIE: Final[str] = "dddd, DD-MMM-YYYY HH:mm:ss ZZZ"
+FORMAT_RFC822: Final[str] = "ddd, DD MMM YY HH:mm:ss Z"
+FORMAT_RFC850: Final[str] = "dddd, DD-MMM-YY HH:mm:ss ZZZ"
+FORMAT_RFC1036: Final[str] = "ddd, DD MMM YY HH:mm:ss Z"
+FORMAT_RFC1123: Final[str] = "ddd, DD MMM YYYY HH:mm:ss Z"
+FORMAT_RFC2822: Final[str] = "ddd, DD MMM YYYY HH:mm:ss Z"
+FORMAT_RFC3339: Final[str] = "YYYY-MM-DD HH:mm:ssZZ"
+FORMAT_RSS: Final[str] = "ddd, DD MMM YYYY HH:mm:ss Z"
+FORMAT_W3C: Final[str] = "YYYY-MM-DD HH:mm:ssZZ"
+
+
+class DateTimeFormatter:
+
+    # This pattern matches characters enclosed in square brackets are matched as
+    # an atomic group. For more info on atomic groups and how to they are
+    # emulated in Python's re library, see https://stackoverflow.com/a/13577411/2701578
+
+    _FORMAT_RE: Final[Pattern[str]] = re.compile(
+        r"(\[(?:(?=(?P<literal>[^]]))(?P=literal))*\]|YYY?Y?|MM?M?M?|Do|DD?D?D?|d?dd?d?|HH?|hh?|mm?|ss?|SS?S?S?S?S?|ZZ?Z?|a|A|X|x|W)"
+    )
+
+    locale: locales.Locale
+
+    def __init__(self, locale: str = DEFAULT_LOCALE) -> None:
+
+        self.locale = locales.get_locale(locale)
+
+    def format(cls, dt: datetime, fmt: str) -> str:
+
+        # FIXME: _format_token() is nullable
+        return cls._FORMAT_RE.sub(
+            lambda m: cast(str, cls._format_token(dt, m.group(0))), fmt
+        )
+
+    def _format_token(self, dt: datetime, token: Optional[str]) -> Optional[str]:
+
+        if token and token.startswith("[") and token.endswith("]"):
+            return token[1:-1]
+
+        if token == "YYYY":
+            return self.locale.year_full(dt.year)
+        if token == "YY":
+            return self.locale.year_abbreviation(dt.year)
+
+        if token == "MMMM":
+            return self.locale.month_name(dt.month)
+        if token == "MMM":
+            return self.locale.month_abbreviation(dt.month)
+        if token == "MM":
+            return f"{dt.month:02d}"
+        if token == "M":
+            return f"{dt.month}"
+
+        if token == "DDDD":
+            return f"{dt.timetuple().tm_yday:03d}"
+        if token == "DDD":
+            return f"{dt.timetuple().tm_yday}"
+        if token == "DD":
+            return f"{dt.day:02d}"
+        if token == "D":
+            return f"{dt.day}"
+
+        if token == "Do":
+            return self.locale.ordinal_number(dt.day)
+
+        if token == "dddd":
+            return self.locale.day_name(dt.isoweekday())
+        if token == "ddd":
+            return self.locale.day_abbreviation(dt.isoweekday())
+        if token == "d":
+            return f"{dt.isoweekday()}"
+
+        if token == "HH":
+            return f"{dt.hour:02d}"
+        if token == "H":
+            return f"{dt.hour}"
+        if token == "hh":
+            return f"{dt.hour if 0 < dt.hour < 13 else abs(dt.hour - 12):02d}"
+        if token == "h":
+            return f"{dt.hour if 0 < dt.hour < 13 else abs(dt.hour - 12)}"
+
+        if token == "mm":
+            return f"{dt.minute:02d}"
+        if token == "m":
+            return f"{dt.minute}"
+
+        if token == "ss":
+            return f"{dt.second:02d}"
+        if token == "s":
+            return f"{dt.second}"
+
+        if token == "SSSSSS":
+            return f"{dt.microsecond:06d}"
+        if token == "SSSSS":
+            return f"{dt.microsecond // 10:05d}"
+        if token == "SSSS":
+            return f"{dt.microsecond // 100:04d}"
+        if token == "SSS":
+            return f"{dt.microsecond // 1000:03d}"
+        if token == "SS":
+            return f"{dt.microsecond // 10000:02d}"
+        if token == "S":
+            return f"{dt.microsecond // 100000}"
+
+        if token == "X":
+            return f"{dt.timestamp()}"
+
+        if token == "x":
+            return f"{dt.timestamp() * 1_000_000:.0f}"
+
+        if token == "ZZZ":
+            return dt.tzname()
+
+        if token in ["ZZ", "Z"]:
+            separator = ":" if token == "ZZ" else ""
+            tz = dateutil_tz.tzutc() if dt.tzinfo is None else dt.tzinfo
+            # `dt` must be aware object. Otherwise, this line will raise AttributeError
+            # https://github.com/arrow-py/arrow/pull/883#discussion_r529866834
+            # datetime awareness: https://docs.python.org/3/library/datetime.html#aware-and-naive-objects
+            total_minutes = int(cast(timedelta, tz.utcoffset(dt)).total_seconds() / 60)
+
+            sign = "+" if total_minutes >= 0 else "-"
+            total_minutes = abs(total_minutes)
+            hour, minute = divmod(total_minutes, 60)
+
+            return f"{sign}{hour:02d}{separator}{minute:02d}"
+
+        if token in ("a", "A"):
+            return self.locale.meridian(dt.hour, token)
+
+        if token == "W":
+            year, week, day = dt.isocalendar()
+            return f"{year}-W{week:02d}-{day}"

Kodi/Lenovo/addons/script.module.arrow/lib/arrow/parser.py

@@ -0,0 +1,779 @@
+"""Provides the :class:`Arrow <arrow.parser.DateTimeParser>` class, a better way to parse datetime strings."""
+
+import re
+import sys
+from datetime import datetime, timedelta
+from datetime import tzinfo as dt_tzinfo
+from functools import lru_cache
+from typing import (
+    Any,
+    ClassVar,
+    Dict,
+    Iterable,
+    List,
+    Match,
+    Optional,
+    Pattern,
+    SupportsFloat,
+    SupportsInt,
+    Tuple,
+    Union,
+    cast,
+    overload,
+)
+
+from dateutil import tz
+
+from arrow import locales
+from arrow.constants import DEFAULT_LOCALE
+from arrow.util import next_weekday, normalize_timestamp
+
+if sys.version_info < (3, 8):  # pragma: no cover
+    from typing_extensions import Literal, TypedDict
+else:
+    from typing import Literal, TypedDict  # pragma: no cover
+
+
+class ParserError(ValueError):
+    pass
+
+
+# Allows for ParserErrors to be propagated from _build_datetime()
+# when day_of_year errors occur.
+# Before this, the ParserErrors were caught by the try/except in
+# _parse_multiformat() and the appropriate error message was not
+# transmitted to the user.
+class ParserMatchError(ParserError):
+    pass
+
+
+_WEEKDATE_ELEMENT = Union[str, bytes, SupportsInt, bytearray]
+
+_FORMAT_TYPE = Literal[
+    "YYYY",
+    "YY",
+    "MM",
+    "M",
+    "DDDD",
+    "DDD",
+    "DD",
+    "D",
+    "HH",
+    "H",
+    "hh",
+    "h",
+    "mm",
+    "m",
+    "ss",
+    "s",
+    "X",
+    "x",
+    "ZZZ",
+    "ZZ",
+    "Z",
+    "S",
+    "W",
+    "MMMM",
+    "MMM",
+    "Do",
+    "dddd",
+    "ddd",
+    "d",
+    "a",
+    "A",
+]
+
+
+class _Parts(TypedDict, total=False):
+    year: int
+    month: int
+    day_of_year: int
+    day: int
+    hour: int
+    minute: int
+    second: int
+    microsecond: int
+    timestamp: float
+    expanded_timestamp: int
+    tzinfo: dt_tzinfo
+    am_pm: Literal["am", "pm"]
+    day_of_week: int
+    weekdate: Tuple[_WEEKDATE_ELEMENT, _WEEKDATE_ELEMENT, Optional[_WEEKDATE_ELEMENT]]
+
+
+class DateTimeParser:
+    _FORMAT_RE: ClassVar[Pattern[str]] = re.compile(
+        r"(YYY?Y?|MM?M?M?|Do|DD?D?D?|d?d?d?d|HH?|hh?|mm?|ss?|S+|ZZ?Z?|a|A|x|X|W)"
+    )
+    _ESCAPE_RE: ClassVar[Pattern[str]] = re.compile(r"\[[^\[\]]*\]")
+
+    _ONE_OR_TWO_DIGIT_RE: ClassVar[Pattern[str]] = re.compile(r"\d{1,2}")
+    _ONE_OR_TWO_OR_THREE_DIGIT_RE: ClassVar[Pattern[str]] = re.compile(r"\d{1,3}")
+    _ONE_OR_MORE_DIGIT_RE: ClassVar[Pattern[str]] = re.compile(r"\d+")
+    _TWO_DIGIT_RE: ClassVar[Pattern[str]] = re.compile(r"\d{2}")
+    _THREE_DIGIT_RE: ClassVar[Pattern[str]] = re.compile(r"\d{3}")
+    _FOUR_DIGIT_RE: ClassVar[Pattern[str]] = re.compile(r"\d{4}")
+    _TZ_Z_RE: ClassVar[Pattern[str]] = re.compile(r"([\+\-])(\d{2})(?:(\d{2}))?|Z")
+    _TZ_ZZ_RE: ClassVar[Pattern[str]] = re.compile(r"([\+\-])(\d{2})(?:\:(\d{2}))?|Z")
+    _TZ_NAME_RE: ClassVar[Pattern[str]] = re.compile(r"\w[\w+\-/]+")
+    # NOTE: timestamps cannot be parsed from natural language strings (by removing the ^...$) because it will
+    # break cases like "15 Jul 2000" and a format list (see issue #447)
+    _TIMESTAMP_RE: ClassVar[Pattern[str]] = re.compile(r"^\-?\d+\.?\d+$")
+    _TIMESTAMP_EXPANDED_RE: ClassVar[Pattern[str]] = re.compile(r"^\-?\d+$")
+    _TIME_RE: ClassVar[Pattern[str]] = re.compile(
+        r"^(\d{2})(?:\:?(\d{2}))?(?:\:?(\d{2}))?(?:([\.\,])(\d+))?$"
+    )
+    _WEEK_DATE_RE: ClassVar[Pattern[str]] = re.compile(
+        r"(?P<year>\d{4})[\-]?W(?P<week>\d{2})[\-]?(?P<day>\d)?"
+    )
+
+    _BASE_INPUT_RE_MAP: ClassVar[Dict[_FORMAT_TYPE, Pattern[str]]] = {
+        "YYYY": _FOUR_DIGIT_RE,
+        "YY": _TWO_DIGIT_RE,
+        "MM": _TWO_DIGIT_RE,
+        "M": _ONE_OR_TWO_DIGIT_RE,
+        "DDDD": _THREE_DIGIT_RE,
+        "DDD": _ONE_OR_TWO_OR_THREE_DIGIT_RE,
+        "DD": _TWO_DIGIT_RE,
+        "D": _ONE_OR_TWO_DIGIT_RE,
+        "HH": _TWO_DIGIT_RE,
+        "H": _ONE_OR_TWO_DIGIT_RE,
+        "hh": _TWO_DIGIT_RE,
+        "h": _ONE_OR_TWO_DIGIT_RE,
+        "mm": _TWO_DIGIT_RE,
+        "m": _ONE_OR_TWO_DIGIT_RE,
+        "ss": _TWO_DIGIT_RE,
+        "s": _ONE_OR_TWO_DIGIT_RE,
+        "X": _TIMESTAMP_RE,
+        "x": _TIMESTAMP_EXPANDED_RE,
+        "ZZZ": _TZ_NAME_RE,
+        "ZZ": _TZ_ZZ_RE,
+        "Z": _TZ_Z_RE,
+        "S": _ONE_OR_MORE_DIGIT_RE,
+        "W": _WEEK_DATE_RE,
+    }
+
+    SEPARATORS: ClassVar[List[str]] = ["-", "/", "."]
+
+    locale: locales.Locale
+    _input_re_map: Dict[_FORMAT_TYPE, Pattern[str]]
+
+    def __init__(self, locale: str = DEFAULT_LOCALE, cache_size: int = 0) -> None:
+
+        self.locale = locales.get_locale(locale)
+        self._input_re_map = self._BASE_INPUT_RE_MAP.copy()
+        self._input_re_map.update(
+            {
+                "MMMM": self._generate_choice_re(
+                    self.locale.month_names[1:], re.IGNORECASE
+                ),
+                "MMM": self._generate_choice_re(
+                    self.locale.month_abbreviations[1:], re.IGNORECASE
+                ),
+                "Do": re.compile(self.locale.ordinal_day_re),
+                "dddd": self._generate_choice_re(
+                    self.locale.day_names[1:], re.IGNORECASE
+                ),
+                "ddd": self._generate_choice_re(
+                    self.locale.day_abbreviations[1:], re.IGNORECASE
+                ),
+                "d": re.compile(r"[1-7]"),
+                "a": self._generate_choice_re(
+                    (self.locale.meridians["am"], self.locale.meridians["pm"])
+                ),
+                # note: 'A' token accepts both 'am/pm' and 'AM/PM' formats to
+                # ensure backwards compatibility of this token
+                "A": self._generate_choice_re(self.locale.meridians.values()),
+            }
+        )
+        if cache_size > 0:
+            self._generate_pattern_re = lru_cache(maxsize=cache_size)(  # type: ignore
+                self._generate_pattern_re
+            )
+
+    # TODO: since we support more than ISO 8601, we should rename this function
+    # IDEA: break into multiple functions
+    def parse_iso(
+        self, datetime_string: str, normalize_whitespace: bool = False
+    ) -> datetime:
+
+        if normalize_whitespace:
+            datetime_string = re.sub(r"\s+", " ", datetime_string.strip())
+
+        has_space_divider = " " in datetime_string
+        has_t_divider = "T" in datetime_string
+
+        num_spaces = datetime_string.count(" ")
+        if has_space_divider and num_spaces != 1 or has_t_divider and num_spaces > 0:
+            raise ParserError(
+                f"Expected an ISO 8601-like string, but was given {datetime_string!r}. "
+                "Try passing in a format string to resolve this."
+            )
+
+        has_time = has_space_divider or has_t_divider
+        has_tz = False
+
+        # date formats (ISO 8601 and others) to test against
+        # NOTE: YYYYMM is omitted to avoid confusion with YYMMDD (no longer part of ISO 8601, but is still often used)
+        formats = [
+            "YYYY-MM-DD",
+            "YYYY-M-DD",
+            "YYYY-M-D",
+            "YYYY/MM/DD",
+            "YYYY/M/DD",
+            "YYYY/M/D",
+            "YYYY.MM.DD",
+            "YYYY.M.DD",
+            "YYYY.M.D",
+            "YYYYMMDD",
+            "YYYY-DDDD",
+            "YYYYDDDD",
+            "YYYY-MM",
+            "YYYY/MM",
+            "YYYY.MM",
+            "YYYY",
+            "W",
+        ]
+
+        if has_time:
+
+            if has_space_divider:
+                date_string, time_string = datetime_string.split(" ", 1)
+            else:
+                date_string, time_string = datetime_string.split("T", 1)
+
+            time_parts = re.split(r"[\+\-Z]", time_string, 1, re.IGNORECASE)
+
+            time_components: Optional[Match[str]] = self._TIME_RE.match(time_parts[0])
+
+            if time_components is None:
+                raise ParserError(
+                    "Invalid time component provided. "
+                    "Please specify a format or provide a valid time component in the basic or extended ISO 8601 time format."
+                )
+
+            (
+                hours,
+                minutes,
+                seconds,
+                subseconds_sep,
+                subseconds,
+            ) = time_components.groups()
+
+            has_tz = len(time_parts) == 2
+            has_minutes = minutes is not None
+            has_seconds = seconds is not None
+            has_subseconds = subseconds is not None
+
+            is_basic_time_format = ":" not in time_parts[0]
+            tz_format = "Z"
+
+            # use 'ZZ' token instead since tz offset is present in non-basic format
+            if has_tz and ":" in time_parts[1]:
+                tz_format = "ZZ"
+
+            time_sep = "" if is_basic_time_format else ":"
+
+            if has_subseconds:
+                time_string = "HH{time_sep}mm{time_sep}ss{subseconds_sep}S".format(
+                    time_sep=time_sep, subseconds_sep=subseconds_sep
+                )
+            elif has_seconds:
+                time_string = "HH{time_sep}mm{time_sep}ss".format(time_sep=time_sep)
+            elif has_minutes:
+                time_string = f"HH{time_sep}mm"
+            else:
+                time_string = "HH"
+
+            if has_space_divider:
+                formats = [f"{f} {time_string}" for f in formats]
+            else:
+                formats = [f"{f}T{time_string}" for f in formats]
+
+        if has_time and has_tz:
+            # Add "Z" or "ZZ" to the format strings to indicate to
+            # _parse_token() that a timezone needs to be parsed
+            formats = [f"{f}{tz_format}" for f in formats]
+
+        return self._parse_multiformat(datetime_string, formats)
+
+    def parse(
+        self,
+        datetime_string: str,
+        fmt: Union[List[str], str],
+        normalize_whitespace: bool = False,
+    ) -> datetime:
+
+        if normalize_whitespace:
+            datetime_string = re.sub(r"\s+", " ", datetime_string)
+
+        if isinstance(fmt, list):
+            return self._parse_multiformat(datetime_string, fmt)
+
+        try:
+            fmt_tokens: List[_FORMAT_TYPE]
+            fmt_pattern_re: Pattern[str]
+            fmt_tokens, fmt_pattern_re = self._generate_pattern_re(fmt)
+        except re.error as e:
+            raise ParserMatchError(
+                f"Failed to generate regular expression pattern: {e}."
+            )
+
+        match = fmt_pattern_re.search(datetime_string)
+
+        if match is None:
+            raise ParserMatchError(
+                f"Failed to match {fmt!r} when parsing {datetime_string!r}."
+            )
+
+        parts: _Parts = {}
+        for token in fmt_tokens:
+            value: Union[Tuple[str, str, str], str]
+            if token == "Do":
+                value = match.group("value")
+            elif token == "W":
+                value = (match.group("year"), match.group("week"), match.group("day"))
+            else:
+                value = match.group(token)
+
+            if value is None:
+                raise ParserMatchError(
+                    f"Unable to find a match group for the specified token {token!r}."
+                )
+
+            self._parse_token(token, value, parts)  # type: ignore
+
+        return self._build_datetime(parts)
+
+    def _generate_pattern_re(self, fmt: str) -> Tuple[List[_FORMAT_TYPE], Pattern[str]]:
+
+        # fmt is a string of tokens like 'YYYY-MM-DD'
+        # we construct a new string by replacing each
+        # token by its pattern:
+        # 'YYYY-MM-DD' -> '(?P<YYYY>\d{4})-(?P<MM>\d{2})-(?P<DD>\d{2})'
+        tokens: List[_FORMAT_TYPE] = []
+        offset = 0
+
+        # Escape all special RegEx chars
+        escaped_fmt = re.escape(fmt)
+
+        # Extract the bracketed expressions to be reinserted later.
+        escaped_fmt = re.sub(self._ESCAPE_RE, "#", escaped_fmt)
+
+        # Any number of S is the same as one.
+        # TODO: allow users to specify the number of digits to parse
+        escaped_fmt = re.sub(r"S+", "S", escaped_fmt)
+
+        escaped_data = re.findall(self._ESCAPE_RE, fmt)
+
+        fmt_pattern = escaped_fmt
+
+        for m in self._FORMAT_RE.finditer(escaped_fmt):
+            token: _FORMAT_TYPE = cast(_FORMAT_TYPE, m.group(0))
+            try:
+                input_re = self._input_re_map[token]
+            except KeyError:
+                raise ParserError(f"Unrecognized token {token!r}.")
+            input_pattern = f"(?P<{token}>{input_re.pattern})"
+            tokens.append(token)
+            # a pattern doesn't have the same length as the token
+            # it replaces! We keep the difference in the offset variable.
+            # This works because the string is scanned left-to-right and matches
+            # are returned in the order found by finditer.
+            fmt_pattern = (
+                fmt_pattern[: m.start() + offset]
+                + input_pattern
+                + fmt_pattern[m.end() + offset :]
+            )
+            offset += len(input_pattern) - (m.end() - m.start())
+
+        final_fmt_pattern = ""
+        split_fmt = fmt_pattern.split(r"\#")
+
+        # Due to the way Python splits, 'split_fmt' will always be longer
+        for i in range(len(split_fmt)):
+            final_fmt_pattern += split_fmt[i]
+            if i < len(escaped_data):
+                final_fmt_pattern += escaped_data[i][1:-1]
+
+        # Wrap final_fmt_pattern in a custom word boundary to strictly
+        # match the formatting pattern and filter out date and time formats
+        # that include junk such as: blah1998-09-12 blah, blah 1998-09-12blah,
+        # blah1998-09-12blah. The custom word boundary matches every character
+        # that is not a whitespace character to allow for searching for a date
+        # and time string in a natural language sentence. Therefore, searching
+        # for a string of the form YYYY-MM-DD in "blah 1998-09-12 blah" will
+        # work properly.
+        # Certain punctuation before or after the target pattern such as
+        # "1998-09-12," is permitted. For the full list of valid punctuation,
+        # see the documentation.
+
+        starting_word_boundary = (
+            r"(?<!\S\S)"  # Don't have two consecutive non-whitespace characters. This ensures that we allow cases
+            # like .11.25.2019 but not 1.11.25.2019 (for pattern MM.DD.YYYY)
+            r"(?<![^\,\.\;\:\?\!\"\'\`\[\]\{\}\(\)<>\s])"  # This is the list of punctuation that is ok before the
+            # pattern (i.e. "It can't not be these characters before the pattern")
+            r"(\b|^)"
+            # The \b is to block cases like 1201912 but allow 201912 for pattern YYYYMM. The ^ was necessary to allow a
+            # negative number through i.e. before epoch numbers
+        )
+        ending_word_boundary = (
+            r"(?=[\,\.\;\:\?\!\"\'\`\[\]\{\}\(\)\<\>]?"  # Positive lookahead stating that these punctuation marks
+            # can appear after the pattern at most 1 time
+            r"(?!\S))"  # Don't allow any non-whitespace character after the punctuation
+        )
+        bounded_fmt_pattern = r"{}{}{}".format(
+            starting_word_boundary, final_fmt_pattern, ending_word_boundary
+        )
+
+        return tokens, re.compile(bounded_fmt_pattern, flags=re.IGNORECASE)
+
+    @overload
+    def _parse_token(
+        self,
+        token: Literal[
+            "YYYY",
+            "YY",
+            "MM",
+            "M",
+            "DDDD",
+            "DDD",
+            "DD",
+            "D",
+            "Do",
+            "HH",
+            "hh",
+            "h",
+            "H",
+            "mm",
+            "m",
+            "ss",
+            "s",
+            "x",
+        ],
+        value: Union[str, bytes, SupportsInt, bytearray],
+        parts: _Parts,
+    ) -> None:
+        ...  # pragma: no cover
+
+    @overload
+    def _parse_token(
+        self,
+        token: Literal["X"],
+        value: Union[str, bytes, SupportsFloat, bytearray],
+        parts: _Parts,
+    ) -> None:
+        ...  # pragma: no cover
+
+    @overload
+    def _parse_token(
+        self,
+        token: Literal["MMMM", "MMM", "dddd", "ddd", "S"],
+        value: Union[str, bytes, bytearray],
+        parts: _Parts,
+    ) -> None:
+        ...  # pragma: no cover
+
+    @overload
+    def _parse_token(
+        self,
+        token: Literal["a", "A", "ZZZ", "ZZ", "Z"],
+        value: Union[str, bytes],
+        parts: _Parts,
+    ) -> None:
+        ...  # pragma: no cover
+
+    @overload
+    def _parse_token(
+        self,
+        token: Literal["W"],
+        value: Tuple[_WEEKDATE_ELEMENT, _WEEKDATE_ELEMENT, Optional[_WEEKDATE_ELEMENT]],
+        parts: _Parts,
+    ) -> None:
+        ...  # pragma: no cover
+
+    def _parse_token(
+        self,
+        token: Any,
+        value: Any,
+        parts: _Parts,
+    ) -> None:
+
+        if token == "YYYY":
+            parts["year"] = int(value)
+
+        elif token == "YY":
+            value = int(value)
+            parts["year"] = 1900 + value if value > 68 else 2000 + value
+
+        elif token in ["MMMM", "MMM"]:
+            # FIXME: month_number() is nullable
+            parts["month"] = self.locale.month_number(value.lower())  # type: ignore
+
+        elif token in ["MM", "M"]:
+            parts["month"] = int(value)
+
+        elif token in ["DDDD", "DDD"]:
+            parts["day_of_year"] = int(value)
+
+        elif token in ["DD", "D"]:
+            parts["day"] = int(value)
+
+        elif token == "Do":
+            parts["day"] = int(value)
+
+        elif token == "dddd":
+            # locale day names are 1-indexed
+            day_of_week = [x.lower() for x in self.locale.day_names].index(
+                value.lower()
+            )
+            parts["day_of_week"] = day_of_week - 1
+
+        elif token == "ddd":
+            # locale day abbreviations are 1-indexed
+            day_of_week = [x.lower() for x in self.locale.day_abbreviations].index(
+                value.lower()
+            )
+            parts["day_of_week"] = day_of_week - 1
+
+        elif token.upper() in ["HH", "H"]:
+            parts["hour"] = int(value)
+
+        elif token in ["mm", "m"]:
+            parts["minute"] = int(value)
+
+        elif token in ["ss", "s"]:
+            parts["second"] = int(value)
+
+        elif token == "S":
+            # We have the *most significant* digits of an arbitrary-precision integer.
+            # We want the six most significant digits as an integer, rounded.
+            # IDEA: add nanosecond support somehow? Need datetime support for it first.
+            value = value.ljust(7, "0")
+
+            # floating-point (IEEE-754) defaults to half-to-even rounding
+            seventh_digit = int(value[6])
+            if seventh_digit == 5:
+                rounding = int(value[5]) % 2
+            elif seventh_digit > 5:
+                rounding = 1
+            else:
+                rounding = 0
+
+            parts["microsecond"] = int(value[:6]) + rounding
+
+        elif token == "X":
+            parts["timestamp"] = float(value)
+
+        elif token == "x":
+            parts["expanded_timestamp"] = int(value)
+
+        elif token in ["ZZZ", "ZZ", "Z"]:
+            parts["tzinfo"] = TzinfoParser.parse(value)
+
+        elif token in ["a", "A"]:
+            if value in (self.locale.meridians["am"], self.locale.meridians["AM"]):
+                parts["am_pm"] = "am"
+                if "hour" in parts and not 0 <= parts["hour"] <= 12:
+                    raise ParserMatchError(
+                        f"Hour token value must be between 0 and 12 inclusive for token {token!r}."
+                    )
+            elif value in (self.locale.meridians["pm"], self.locale.meridians["PM"]):
+                parts["am_pm"] = "pm"
+        elif token == "W":
+            parts["weekdate"] = value
+
+    @staticmethod
+    def _build_datetime(parts: _Parts) -> datetime:
+        weekdate = parts.get("weekdate")
+
+        if weekdate is not None:
+
+            year, week = int(weekdate[0]), int(weekdate[1])
+
+            if weekdate[2] is not None:
+                _day = int(weekdate[2])
+            else:
+                # day not given, default to 1
+                _day = 1
+
+            date_string = f"{year}-{week}-{_day}"
+
+            #  tokens for ISO 8601 weekdates
+            dt = datetime.strptime(date_string, "%G-%V-%u")
+
+            parts["year"] = dt.year
+            parts["month"] = dt.month
+            parts["day"] = dt.day
+
+        timestamp = parts.get("timestamp")
+
+        if timestamp is not None:
+            return datetime.fromtimestamp(timestamp, tz=tz.tzutc())
+
+        expanded_timestamp = parts.get("expanded_timestamp")
+
+        if expanded_timestamp is not None:
+            return datetime.fromtimestamp(
+                normalize_timestamp(expanded_timestamp),
+                tz=tz.tzutc(),
+            )
+
+        day_of_year = parts.get("day_of_year")
+
+        if day_of_year is not None:
+            _year = parts.get("year")
+            month = parts.get("month")
+            if _year is None:
+                raise ParserError(
+                    "Year component is required with the DDD and DDDD tokens."
+                )
+
+            if month is not None:
+                raise ParserError(
+                    "Month component is not allowed with the DDD and DDDD tokens."
+                )
+
+            date_string = f"{_year}-{day_of_year}"
+            try:
+                dt = datetime.strptime(date_string, "%Y-%j")
+            except ValueError:
+                raise ParserError(
+                    f"The provided day of year {day_of_year!r} is invalid."
+                )
+
+            parts["year"] = dt.year
+            parts["month"] = dt.month
+            parts["day"] = dt.day
+
+        day_of_week: Optional[int] = parts.get("day_of_week")
+        day = parts.get("day")
+
+        # If day is passed, ignore day of week
+        if day_of_week is not None and day is None:
+            year = parts.get("year", 1970)
+            month = parts.get("month", 1)
+            day = 1
+
+            # dddd => first day of week after epoch
+            # dddd YYYY => first day of week in specified year
+            # dddd MM YYYY => first day of week in specified year and month
+            # dddd MM => first day after epoch in specified month
+            next_weekday_dt = next_weekday(datetime(year, month, day), day_of_week)
+            parts["year"] = next_weekday_dt.year
+            parts["month"] = next_weekday_dt.month
+            parts["day"] = next_weekday_dt.day
+
+        am_pm = parts.get("am_pm")
+        hour = parts.get("hour", 0)
+
+        if am_pm == "pm" and hour < 12:
+            hour += 12
+        elif am_pm == "am" and hour == 12:
+            hour = 0
+
+        # Support for midnight at the end of day
+        if hour == 24:
+            if parts.get("minute", 0) != 0:
+                raise ParserError("Midnight at the end of day must not contain minutes")
+            if parts.get("second", 0) != 0:
+                raise ParserError("Midnight at the end of day must not contain seconds")
+            if parts.get("microsecond", 0) != 0:
+                raise ParserError(
+                    "Midnight at the end of day must not contain microseconds"
+                )
+            hour = 0
+            day_increment = 1
+        else:
+            day_increment = 0
+
+        # account for rounding up to 1000000
+        microsecond = parts.get("microsecond", 0)
+        if microsecond == 1000000:
+            microsecond = 0
+            second_increment = 1
+        else:
+            second_increment = 0
+
+        increment = timedelta(days=day_increment, seconds=second_increment)
+
+        return (
+            datetime(
+                year=parts.get("year", 1),
+                month=parts.get("month", 1),
+                day=parts.get("day", 1),
+                hour=hour,
+                minute=parts.get("minute", 0),
+                second=parts.get("second", 0),
+                microsecond=microsecond,
+                tzinfo=parts.get("tzinfo"),
+            )
+            + increment
+        )
+
+    def _parse_multiformat(self, string: str, formats: Iterable[str]) -> datetime:
+
+        _datetime: Optional[datetime] = None
+
+        for fmt in formats:
+            try:
+                _datetime = self.parse(string, fmt)
+                break
+            except ParserMatchError:
+                pass
+
+        if _datetime is None:
+            supported_formats = ", ".join(formats)
+            raise ParserError(
+                f"Could not match input {string!r} to any of the following formats: {supported_formats}."
+            )
+
+        return _datetime
+
+    # generates a capture group of choices separated by an OR operator
+    @staticmethod
+    def _generate_choice_re(
+        choices: Iterable[str], flags: Union[int, re.RegexFlag] = 0
+    ) -> Pattern[str]:
+        return re.compile(r"({})".format("|".join(choices)), flags=flags)
+
+
+class TzinfoParser:
+    _TZINFO_RE: ClassVar[Pattern[str]] = re.compile(
+        r"^([\+\-])?(\d{2})(?:\:?(\d{2}))?$"
+    )
+
+    @classmethod
+    def parse(cls, tzinfo_string: str) -> dt_tzinfo:
+
+        tzinfo: Optional[dt_tzinfo] = None
+
+        if tzinfo_string == "local":
+            tzinfo = tz.tzlocal()
+
+        elif tzinfo_string in ["utc", "UTC", "Z"]:
+            tzinfo = tz.tzutc()
+
+        else:
+
+            iso_match = cls._TZINFO_RE.match(tzinfo_string)
+
+            if iso_match:
+                sign: Optional[str]
+                hours: str
+                minutes: Union[str, int, None]
+                sign, hours, minutes = iso_match.groups()
+                seconds = int(hours) * 3600 + int(minutes or 0) * 60
+
+                if sign == "-":
+                    seconds *= -1
+
+                tzinfo = tz.tzoffset(None, seconds)
+
+            else:
+                tzinfo = tz.gettz(tzinfo_string)
+
+        if tzinfo is None:
+            raise ParserError(f"Could not parse timezone expression {tzinfo_string!r}.")
+
+        return tzinfo

Kodi/Lenovo/addons/script.module.arrow/lib/arrow/util.py

@@ -0,0 +1,117 @@
+"""Helpful functions used internally within arrow."""
+
+import datetime
+from typing import Any, Optional, cast
+
+from dateutil.rrule import WEEKLY, rrule
+
+from arrow.constants import (
+    MAX_ORDINAL,
+    MAX_TIMESTAMP,
+    MAX_TIMESTAMP_MS,
+    MAX_TIMESTAMP_US,
+    MIN_ORDINAL,
+)
+
+
+def next_weekday(
+    start_date: Optional[datetime.date], weekday: int
+) -> datetime.datetime:
+    """Get next weekday from the specified start date.
+
+    :param start_date: Datetime object representing the start date.
+    :param weekday: Next weekday to obtain. Can be a value between 0 (Monday) and 6 (Sunday).
+    :return: Datetime object corresponding to the next weekday after start_date.
+
+    Usage::
+
+        # Get first Monday after epoch
+        >>> next_weekday(datetime(1970, 1, 1), 0)
+        1970-01-05 00:00:00
+
+        # Get first Thursday after epoch
+        >>> next_weekday(datetime(1970, 1, 1), 3)
+        1970-01-01 00:00:00
+
+        # Get first Sunday after epoch
+        >>> next_weekday(datetime(1970, 1, 1), 6)
+        1970-01-04 00:00:00
+    """
+    if weekday < 0 or weekday > 6:
+        raise ValueError("Weekday must be between 0 (Monday) and 6 (Sunday).")
+    return cast(
+        datetime.datetime,
+        rrule(freq=WEEKLY, dtstart=start_date, byweekday=weekday, count=1)[0],
+    )
+
+
+def is_timestamp(value: Any) -> bool:
+    """Check if value is a valid timestamp."""
+    if isinstance(value, bool):
+        return False
+    if not isinstance(value, (int, float, str)):
+        return False
+    try:
+        float(value)
+        return True
+    except ValueError:
+        return False
+
+
+def validate_ordinal(value: Any) -> None:
+    """Raise an exception if value is an invalid Gregorian ordinal.
+
+    :param value: the input to be checked
+
+    """
+    if isinstance(value, bool) or not isinstance(value, int):
+        raise TypeError(f"Ordinal must be an integer (got type {type(value)}).")
+    if not (MIN_ORDINAL <= value <= MAX_ORDINAL):
+        raise ValueError(f"Ordinal {value} is out of range.")
+
+
+def normalize_timestamp(timestamp: float) -> float:
+    """Normalize millisecond and microsecond timestamps into normal timestamps."""
+    if timestamp > MAX_TIMESTAMP:
+        if timestamp < MAX_TIMESTAMP_MS:
+            timestamp /= 1000
+        elif timestamp < MAX_TIMESTAMP_US:
+            timestamp /= 1_000_000
+        else:
+            raise ValueError(f"The specified timestamp {timestamp!r} is too large.")
+    return timestamp
+
+
+# Credit to https://stackoverflow.com/a/1700069
+def iso_to_gregorian(iso_year: int, iso_week: int, iso_day: int) -> datetime.date:
+    """Converts an ISO week date into a datetime object.
+
+    :param iso_year: the year
+    :param iso_week: the week number, each year has either 52 or 53 weeks
+    :param iso_day: the day numbered 1 through 7, beginning with Monday
+
+    """
+
+    if not 1 <= iso_week <= 53:
+        raise ValueError("ISO Calendar week value must be between 1-53.")
+
+    if not 1 <= iso_day <= 7:
+        raise ValueError("ISO Calendar day value must be between 1-7")
+
+    # The first week of the year always contains 4 Jan.
+    fourth_jan = datetime.date(iso_year, 1, 4)
+    delta = datetime.timedelta(fourth_jan.isoweekday() - 1)
+    year_start = fourth_jan - delta
+    gregorian = year_start + datetime.timedelta(days=iso_day - 1, weeks=iso_week - 1)
+
+    return gregorian
+
+
+def validate_bounds(bounds: str) -> None:
+    if bounds != "()" and bounds != "(]" and bounds != "[)" and bounds != "[]":
+        raise ValueError(
+            "Invalid bounds. Please select between '()', '(]', '[)', or '[]'."
+        )
+
+
+__all__ = ["next_weekday", "is_timestamp", "validate_ordinal", "iso_to_gregorian"]