Add files using upload-large-folder tool

lib/python3.10/site-packages/babel/__init__.py

@@ -0,0 +1,38 @@
+"""
+    babel
+    ~~~~~
+
+    Integrated collection of utilities that assist in internationalizing and
+    localizing applications.
+
+    This package is basically composed of two major parts:
+
+     * tools to build and work with ``gettext`` message catalogs
+     * a Python interface to the CLDR (Common Locale Data Repository), providing
+       access to various locale display names, localized number and date
+       formatting, etc.
+
+    :copyright: (c) 2013-2025 by the Babel Team.
+    :license: BSD, see LICENSE for more details.
+"""
+
+from babel.core import (
+    Locale,
+    UnknownLocaleError,
+    default_locale,
+    get_locale_identifier,
+    negotiate_locale,
+    parse_locale,
+)
+
+__version__ = '2.17.0'
+
+__all__ = [
+    'Locale',
+    'UnknownLocaleError',
+    '__version__',
+    'default_locale',
+    'get_locale_identifier',
+    'negotiate_locale',
+    'parse_locale',
+]

lib/python3.10/site-packages/babel/core.py

@@ -0,0 +1,1337 @@
+"""
+    babel.core
+    ~~~~~~~~~~
+
+    Core locale representation and locale data access.
+
+    :copyright: (c) 2013-2025 by the Babel Team.
+    :license: BSD, see LICENSE for more details.
+"""
+
+from __future__ import annotations
+
+import os
+import pickle
+from collections.abc import Iterable, Mapping
+from typing import TYPE_CHECKING, Any, Literal
+
+from babel import localedata
+from babel.plural import PluralRule
+
+__all__ = [
+    'Locale',
+    'UnknownLocaleError',
+    'default_locale',
+    'get_global',
+    'get_locale_identifier',
+    'negotiate_locale',
+    'parse_locale',
+]
+
+if TYPE_CHECKING:
+    from typing_extensions import TypeAlias
+
+    _GLOBAL_KEY: TypeAlias = Literal[
+        "all_currencies",
+        "currency_fractions",
+        "language_aliases",
+        "likely_subtags",
+        "meta_zones",
+        "parent_exceptions",
+        "script_aliases",
+        "territory_aliases",
+        "territory_currencies",
+        "territory_languages",
+        "territory_zones",
+        "variant_aliases",
+        "windows_zone_mapping",
+        "zone_aliases",
+        "zone_territories",
+    ]
+
+    _global_data: Mapping[_GLOBAL_KEY, Mapping[str, Any]] | None
+
+_global_data = None
+_default_plural_rule = PluralRule({})
+
+
+def _raise_no_data_error():
+    raise RuntimeError('The babel data files are not available. '
+                       'This usually happens because you are using '
+                       'a source checkout from Babel and you did '
+                       'not build the data files.  Just make sure '
+                       'to run "python setup.py import_cldr" before '
+                       'installing the library.')
+
+
+def get_global(key: _GLOBAL_KEY) -> Mapping[str, Any]:
+    """Return the dictionary for the given key in the global data.
+
+    The global data is stored in the ``babel/global.dat`` file and contains
+    information independent of individual locales.
+
+    >>> get_global('zone_aliases')['UTC']
+    u'Etc/UTC'
+    >>> get_global('zone_territories')['Europe/Berlin']
+    u'DE'
+
+    The keys available are:
+
+    - ``all_currencies``
+    - ``currency_fractions``
+    - ``language_aliases``
+    - ``likely_subtags``
+    - ``parent_exceptions``
+    - ``script_aliases``
+    - ``territory_aliases``
+    - ``territory_currencies``
+    - ``territory_languages``
+    - ``territory_zones``
+    - ``variant_aliases``
+    - ``windows_zone_mapping``
+    - ``zone_aliases``
+    - ``zone_territories``
+
+    .. note:: The internal structure of the data may change between versions.
+
+    .. versionadded:: 0.9
+
+    :param key: the data key
+    """
+    global _global_data
+    if _global_data is None:
+        dirname = os.path.join(os.path.dirname(__file__))
+        filename = os.path.join(dirname, 'global.dat')
+        if not os.path.isfile(filename):
+            _raise_no_data_error()
+        with open(filename, 'rb') as fileobj:
+            _global_data = pickle.load(fileobj)
+            assert _global_data is not None
+    return _global_data.get(key, {})
+
+
+LOCALE_ALIASES = {
+    'ar': 'ar_SY', 'bg': 'bg_BG', 'bs': 'bs_BA', 'ca': 'ca_ES', 'cs': 'cs_CZ',
+    'da': 'da_DK', 'de': 'de_DE', 'el': 'el_GR', 'en': 'en_US', 'es': 'es_ES',
+    'et': 'et_EE', 'fa': 'fa_IR', 'fi': 'fi_FI', 'fr': 'fr_FR', 'gl': 'gl_ES',
+    'he': 'he_IL', 'hu': 'hu_HU', 'id': 'id_ID', 'is': 'is_IS', 'it': 'it_IT',
+    'ja': 'ja_JP', 'km': 'km_KH', 'ko': 'ko_KR', 'lt': 'lt_LT', 'lv': 'lv_LV',
+    'mk': 'mk_MK', 'nl': 'nl_NL', 'nn': 'nn_NO', 'no': 'nb_NO', 'pl': 'pl_PL',
+    'pt': 'pt_PT', 'ro': 'ro_RO', 'ru': 'ru_RU', 'sk': 'sk_SK', 'sl': 'sl_SI',
+    'sv': 'sv_SE', 'th': 'th_TH', 'tr': 'tr_TR', 'uk': 'uk_UA',
+}
+
+
+class UnknownLocaleError(Exception):
+    """Exception thrown when a locale is requested for which no locale data
+    is available.
+    """
+
+    def __init__(self, identifier: str) -> None:
+        """Create the exception.
+
+        :param identifier: the identifier string of the unsupported locale
+        """
+        Exception.__init__(self, f"unknown locale {identifier!r}")
+
+        #: The identifier of the locale that could not be found.
+        self.identifier = identifier
+
+
+class Locale:
+    """Representation of a specific locale.
+
+    >>> locale = Locale('en', 'US')
+    >>> repr(locale)
+    "Locale('en', territory='US')"
+    >>> locale.display_name
+    u'English (United States)'
+
+    A `Locale` object can also be instantiated from a raw locale string:
+
+    >>> locale = Locale.parse('en-US', sep='-')
+    >>> repr(locale)
+    "Locale('en', territory='US')"
+
+    `Locale` objects provide access to a collection of locale data, such as
+    territory and language names, number and date format patterns, and more:
+
+    >>> locale.number_symbols['latn']['decimal']
+    u'.'
+
+    If a locale is requested for which no locale data is available, an
+    `UnknownLocaleError` is raised:
+
+    >>> Locale.parse('en_XX')
+    Traceback (most recent call last):
+        ...
+    UnknownLocaleError: unknown locale 'en_XX'
+
+    For more information see :rfc:`3066`.
+    """
+
+    def __init__(
+        self,
+        language: str,
+        territory: str | None = None,
+        script: str | None = None,
+        variant: str | None = None,
+        modifier: str | None = None,
+    ) -> None:
+        """Initialize the locale object from the given identifier components.
+
+        >>> locale = Locale('en', 'US')
+        >>> locale.language
+        'en'
+        >>> locale.territory
+        'US'
+
+        :param language: the language code
+        :param territory: the territory (country or region) code
+        :param script: the script code
+        :param variant: the variant code
+        :param modifier: a modifier (following the '@' symbol, sometimes called '@variant')
+        :raise `UnknownLocaleError`: if no locale data is available for the
+                                     requested locale
+        """
+        #: the language code
+        self.language = language
+        #: the territory (country or region) code
+        self.territory = territory
+        #: the script code
+        self.script = script
+        #: the variant code
+        self.variant = variant
+        #: the modifier
+        self.modifier = modifier
+        self.__data: localedata.LocaleDataDict | None = None
+
+        identifier = str(self)
+        identifier_without_modifier = identifier.partition('@')[0]
+        if localedata.exists(identifier):
+            self.__data_identifier = identifier
+        elif localedata.exists(identifier_without_modifier):
+            self.__data_identifier = identifier_without_modifier
+        else:
+            raise UnknownLocaleError(identifier)
+
+    @classmethod
+    def default(cls, category: str | None = None, aliases: Mapping[str, str] = LOCALE_ALIASES) -> Locale:
+        """Return the system default locale for the specified category.
+
+        >>> for name in ['LANGUAGE', 'LC_ALL', 'LC_CTYPE', 'LC_MESSAGES']:
+        ...     os.environ[name] = ''
+        >>> os.environ['LANG'] = 'fr_FR.UTF-8'
+        >>> Locale.default('LC_MESSAGES')
+        Locale('fr', territory='FR')
+
+        The following fallbacks to the variable are always considered:
+
+        - ``LANGUAGE``
+        - ``LC_ALL``
+        - ``LC_CTYPE``
+        - ``LANG``
+
+        :param category: one of the ``LC_XXX`` environment variable names
+        :param aliases: a dictionary of aliases for locale identifiers
+        """
+        # XXX: use likely subtag expansion here instead of the
+        # aliases dictionary.
+        locale_string = default_locale(category, aliases=aliases)
+        return cls.parse(locale_string)
+
+    @classmethod
+    def negotiate(
+        cls,
+        preferred: Iterable[str],
+        available: Iterable[str],
+        sep: str = '_',
+        aliases: Mapping[str, str] = LOCALE_ALIASES,
+    ) -> Locale | None:
+        """Find the best match between available and requested locale strings.
+
+        >>> Locale.negotiate(['de_DE', 'en_US'], ['de_DE', 'de_AT'])
+        Locale('de', territory='DE')
+        >>> Locale.negotiate(['de_DE', 'en_US'], ['en', 'de'])
+        Locale('de')
+        >>> Locale.negotiate(['de_DE', 'de'], ['en_US'])
+
+        You can specify the character used in the locale identifiers to separate
+        the different components. This separator is applied to both lists. Also,
+        case is ignored in the comparison:
+
+        >>> Locale.negotiate(['de-DE', 'de'], ['en-us', 'de-de'], sep='-')
+        Locale('de', territory='DE')
+
+        :param preferred: the list of locale identifiers preferred by the user
+        :param available: the list of locale identifiers available
+        :param aliases: a dictionary of aliases for locale identifiers
+        :param sep: separator for parsing; e.g. Windows tends to use '-' instead of '_'.
+        """
+        identifier = negotiate_locale(preferred, available, sep=sep,
+                                      aliases=aliases)
+        if identifier:
+            return Locale.parse(identifier, sep=sep)
+        return None
+
+    @classmethod
+    def parse(
+        cls,
+        identifier: Locale | str | None,
+        sep: str = '_',
+        resolve_likely_subtags: bool = True,
+    ) -> Locale:
+        """Create a `Locale` instance for the given locale identifier.
+
+        >>> l = Locale.parse('de-DE', sep='-')
+        >>> l.display_name
+        u'Deutsch (Deutschland)'
+
+        If the `identifier` parameter is not a string, but actually a `Locale`
+        object, that object is returned:
+
+        >>> Locale.parse(l)
+        Locale('de', territory='DE')
+
+        If the `identifier` parameter is neither of these, such as `None`
+        or an empty string, e.g. because a default locale identifier
+        could not be determined, a `TypeError` is raised:
+
+        >>> Locale.parse(None)
+        Traceback (most recent call last):
+            ...
+        TypeError: ...
+
+        This also can perform resolving of likely subtags which it does
+        by default.  This is for instance useful to figure out the most
+        likely locale for a territory you can use ``'und'`` as the
+        language tag:
+
+        >>> Locale.parse('und_AT')
+        Locale('de', territory='AT')
+
+        Modifiers are optional, and always at the end, separated by "@":
+
+        >>> Locale.parse('de_AT@euro')
+        Locale('de', territory='AT', modifier='euro')
+
+        :param identifier: the locale identifier string
+        :param sep: optional component separator
+        :param resolve_likely_subtags: if this is specified then a locale will
+                                       have its likely subtag resolved if the
+                                       locale otherwise does not exist.  For
+                                       instance ``zh_TW`` by itself is not a
+                                       locale that exists but Babel can
+                                       automatically expand it to the full
+                                       form of ``zh_hant_TW``.  Note that this
+                                       expansion is only taking place if no
+                                       locale exists otherwise.  For instance
+                                       there is a locale ``en`` that can exist
+                                       by itself.
+        :raise `ValueError`: if the string does not appear to be a valid locale
+                             identifier
+        :raise `UnknownLocaleError`: if no locale data is available for the
+                                     requested locale
+        :raise `TypeError`: if the identifier is not a string or a `Locale`
+        :raise `ValueError`: if the identifier is not a valid string
+        """
+        if isinstance(identifier, Locale):
+            return identifier
+
+        if not identifier:
+            msg = (
+                f"Empty locale identifier value: {identifier!r}\n\n"
+                f"If you didn't explicitly pass an empty value to a Babel function, "
+                f"this could be caused by there being no suitable locale environment "
+                f"variables for the API you tried to use.",
+            )
+            if isinstance(identifier, str):
+                raise ValueError(msg)  # `parse_locale` would raise a ValueError, so let's do that here
+            raise TypeError(msg)
+
+        if not isinstance(identifier, str):
+            raise TypeError(f"Unexpected value for identifier: {identifier!r}")
+
+        parts = parse_locale(identifier, sep=sep)
+        input_id = get_locale_identifier(parts)
+
+        def _try_load(parts):
+            try:
+                return cls(*parts)
+            except UnknownLocaleError:
+                return None
+
+        def _try_load_reducing(parts):
+            # Success on first hit, return it.
+            locale = _try_load(parts)
+            if locale is not None:
+                return locale
+
+            # Now try without script and variant
+            locale = _try_load(parts[:2])
+            if locale is not None:
+                return locale
+
+        locale = _try_load(parts)
+        if locale is not None:
+            return locale
+        if not resolve_likely_subtags:
+            raise UnknownLocaleError(input_id)
+
+        # From here onwards is some very bad likely subtag resolving.  This
+        # whole logic is not entirely correct but good enough (tm) for the
+        # time being.  This has been added so that zh_TW does not cause
+        # errors for people when they upgrade.  Later we should properly
+        # implement ICU like fuzzy locale objects and provide a way to
+        # maximize and minimize locale tags.
+
+        if len(parts) == 5:
+            language, territory, script, variant, modifier = parts
+        else:
+            language, territory, script, variant = parts
+            modifier = None
+        language = get_global('language_aliases').get(language, language)
+        territory = get_global('territory_aliases').get(territory or '', (territory,))[0]
+        script = get_global('script_aliases').get(script or '', script)
+        variant = get_global('variant_aliases').get(variant or '', variant)
+
+        if territory == 'ZZ':
+            territory = None
+        if script == 'Zzzz':
+            script = None
+
+        parts = language, territory, script, variant, modifier
+
+        # First match: try the whole identifier
+        new_id = get_locale_identifier(parts)
+        likely_subtag = get_global('likely_subtags').get(new_id)
+        if likely_subtag is not None:
+            locale = _try_load_reducing(parse_locale(likely_subtag))
+            if locale is not None:
+                return locale
+
+        # If we did not find anything so far, try again with a
+        # simplified identifier that is just the language
+        likely_subtag = get_global('likely_subtags').get(language)
+        if likely_subtag is not None:
+            parts2 = parse_locale(likely_subtag)
+            if len(parts2) == 5:
+                language2, _, script2, variant2, modifier2 = parts2
+            else:
+                language2, _, script2, variant2 = parts2
+                modifier2 = None
+            locale = _try_load_reducing((language2, territory, script2, variant2, modifier2))
+            if locale is not None:
+                return locale
+
+        raise UnknownLocaleError(input_id)
+
+    def __eq__(self, other: object) -> bool:
+        for key in ('language', 'territory', 'script', 'variant', 'modifier'):
+            if not hasattr(other, key):
+                return False
+        return (
+            self.language == getattr(other, 'language') and  # noqa: B009
+            self.territory == getattr(other, 'territory') and  # noqa: B009
+            self.script == getattr(other, 'script') and  # noqa: B009
+            self.variant == getattr(other, 'variant') and  # noqa: B009
+            self.modifier == getattr(other, 'modifier')  # noqa: B009
+        )
+
+    def __ne__(self, other: object) -> bool:
+        return not self.__eq__(other)
+
+    def __hash__(self) -> int:
+        return hash((self.language, self.territory, self.script,
+                     self.variant, self.modifier))
+
+    def __repr__(self) -> str:
+        parameters = ['']
+        for key in ('territory', 'script', 'variant', 'modifier'):
+            value = getattr(self, key)
+            if value is not None:
+                parameters.append(f"{key}={value!r}")
+        return f"Locale({self.language!r}{', '.join(parameters)})"
+
+    def __str__(self) -> str:
+        return get_locale_identifier((self.language, self.territory,
+                                      self.script, self.variant,
+                                      self.modifier))
+
+    @property
+    def _data(self) -> localedata.LocaleDataDict:
+        if self.__data is None:
+            self.__data = localedata.LocaleDataDict(localedata.load(self.__data_identifier))
+        return self.__data
+
+    def get_display_name(self, locale: Locale | str | None = None) -> str | None:
+        """Return the display name of the locale using the given locale.
+
+        The display name will include the language, territory, script, and
+        variant, if those are specified.
+
+        >>> Locale('zh', 'CN', script='Hans').get_display_name('en')
+        u'Chinese (Simplified, China)'
+
+        Modifiers are currently passed through verbatim:
+
+        >>> Locale('it', 'IT', modifier='euro').get_display_name('en')
+        u'Italian (Italy, euro)'
+
+        :param locale: the locale to use
+        """
+        if locale is None:
+            locale = self
+        locale = Locale.parse(locale)
+        retval = locale.languages.get(self.language)
+        if retval and (self.territory or self.script or self.variant):
+            details = []
+            if self.script:
+                details.append(locale.scripts.get(self.script))
+            if self.territory:
+                details.append(locale.territories.get(self.territory))
+            if self.variant:
+                details.append(locale.variants.get(self.variant))
+            if self.modifier:
+                details.append(self.modifier)
+            detail_string = ', '.join(atom for atom in details if atom)
+            if detail_string:
+                retval += f" ({detail_string})"
+        return retval
+
+    display_name = property(get_display_name, doc="""\
+        The localized display name of the locale.
+
+        >>> Locale('en').display_name
+        u'English'
+        >>> Locale('en', 'US').display_name
+        u'English (United States)'
+        >>> Locale('sv').display_name
+        u'svenska'
+
+        :type: `unicode`
+        """)
+
+    def get_language_name(self, locale: Locale | str | None = None) -> str | None:
+        """Return the language of this locale in the given locale.
+
+        >>> Locale('zh', 'CN', script='Hans').get_language_name('de')
+        u'Chinesisch'
+
+        .. versionadded:: 1.0
+
+        :param locale: the locale to use
+        """
+        if locale is None:
+            locale = self
+        locale = Locale.parse(locale)
+        return locale.languages.get(self.language)
+
+    language_name = property(get_language_name, doc="""\
+        The localized language name of the locale.
+
+        >>> Locale('en', 'US').language_name
+        u'English'
+    """)
+
+    def get_territory_name(self, locale: Locale | str | None = None) -> str | None:
+        """Return the territory name in the given locale."""
+        if locale is None:
+            locale = self
+        locale = Locale.parse(locale)
+        return locale.territories.get(self.territory or '')
+
+    territory_name = property(get_territory_name, doc="""\
+        The localized territory name of the locale if available.
+
+        >>> Locale('de', 'DE').territory_name
+        u'Deutschland'
+    """)
+
+    def get_script_name(self, locale: Locale | str | None = None) -> str | None:
+        """Return the script name in the given locale."""
+        if locale is None:
+            locale = self
+        locale = Locale.parse(locale)
+        return locale.scripts.get(self.script or '')
+
+    script_name = property(get_script_name, doc="""\
+        The localized script name of the locale if available.
+
+        >>> Locale('sr', 'ME', script='Latn').script_name
+        u'latinica'
+    """)
+
+    @property
+    def english_name(self) -> str | None:
+        """The english display name of the locale.
+
+        >>> Locale('de').english_name
+        u'German'
+        >>> Locale('de', 'DE').english_name
+        u'German (Germany)'
+
+        :type: `unicode`"""
+        return self.get_display_name(Locale('en'))
+
+    # { General Locale Display Names
+
+    @property
+    def languages(self) -> localedata.LocaleDataDict:
+        """Mapping of language codes to translated language names.
+
+        >>> Locale('de', 'DE').languages['ja']
+        u'Japanisch'
+
+        See `ISO 639 <https://www.loc.gov/standards/iso639-2/>`_ for
+        more information.
+        """
+        return self._data['languages']
+
+    @property
+    def scripts(self) -> localedata.LocaleDataDict:
+        """Mapping of script codes to translated script names.
+
+        >>> Locale('en', 'US').scripts['Hira']
+        u'Hiragana'
+
+        See `ISO 15924 <https://www.unicode.org/iso15924/>`_
+        for more information.
+        """
+        return self._data['scripts']
+
+    @property
+    def territories(self) -> localedata.LocaleDataDict:
+        """Mapping of script codes to translated script names.
+
+        >>> Locale('es', 'CO').territories['DE']
+        u'Alemania'
+
+        See `ISO 3166 <https://en.wikipedia.org/wiki/ISO_3166>`_
+        for more information.
+        """
+        return self._data['territories']
+
+    @property
+    def variants(self) -> localedata.LocaleDataDict:
+        """Mapping of script codes to translated script names.
+
+        >>> Locale('de', 'DE').variants['1901']
+        u'Alte deutsche Rechtschreibung'
+        """
+        return self._data['variants']
+
+    # { Number Formatting
+
+    @property
+    def currencies(self) -> localedata.LocaleDataDict:
+        """Mapping of currency codes to translated currency names.  This
+        only returns the generic form of the currency name, not the count
+        specific one.  If an actual number is requested use the
+        :func:`babel.numbers.get_currency_name` function.
+
+        >>> Locale('en').currencies['COP']
+        u'Colombian Peso'
+        >>> Locale('de', 'DE').currencies['COP']
+        u'Kolumbianischer Peso'
+        """
+        return self._data['currency_names']
+
+    @property
+    def currency_symbols(self) -> localedata.LocaleDataDict:
+        """Mapping of currency codes to symbols.
+
+        >>> Locale('en', 'US').currency_symbols['USD']
+        u'$'
+        >>> Locale('es', 'CO').currency_symbols['USD']
+        u'US$'
+        """
+        return self._data['currency_symbols']
+
+    @property
+    def number_symbols(self) -> localedata.LocaleDataDict:
+        """Symbols used in number formatting by number system.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('fr', 'FR').number_symbols["latn"]['decimal']
+        u','
+        >>> Locale('fa', 'IR').number_symbols["arabext"]['decimal']
+        u'٫'
+        >>> Locale('fa', 'IR').number_symbols["latn"]['decimal']
+        u'.'
+        """
+        return self._data['number_symbols']
+
+    @property
+    def other_numbering_systems(self) -> localedata.LocaleDataDict:
+        """
+        Mapping of other numbering systems available for the locale.
+        See: https://www.unicode.org/reports/tr35/tr35-numbers.html#otherNumberingSystems
+
+        >>> Locale('el', 'GR').other_numbering_systems['traditional']
+        u'grek'
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+        """
+        return self._data['numbering_systems']
+
+    @property
+    def default_numbering_system(self) -> str:
+        """The default numbering system used by the locale.
+        >>> Locale('el', 'GR').default_numbering_system
+        u'latn'
+        """
+        return self._data['default_numbering_system']
+
+    @property
+    def decimal_formats(self) -> localedata.LocaleDataDict:
+        """Locale patterns for decimal number formatting.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en', 'US').decimal_formats[None]
+        <NumberPattern u'#,##0.###'>
+        """
+        return self._data['decimal_formats']
+
+    @property
+    def compact_decimal_formats(self) -> localedata.LocaleDataDict:
+        """Locale patterns for compact decimal number formatting.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en', 'US').compact_decimal_formats["short"]["one"]["1000"]
+        <NumberPattern u'0K'>
+        """
+        return self._data['compact_decimal_formats']
+
+    @property
+    def currency_formats(self) -> localedata.LocaleDataDict:
+        """Locale patterns for currency number formatting.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en', 'US').currency_formats['standard']
+        <NumberPattern u'\\xa4#,##0.00'>
+        >>> Locale('en', 'US').currency_formats['accounting']
+        <NumberPattern u'\\xa4#,##0.00;(\\xa4#,##0.00)'>
+        """
+        return self._data['currency_formats']
+
+    @property
+    def compact_currency_formats(self) -> localedata.LocaleDataDict:
+        """Locale patterns for compact currency number formatting.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en', 'US').compact_currency_formats["short"]["one"]["1000"]
+        <NumberPattern u'¤0K'>
+        """
+        return self._data['compact_currency_formats']
+
+    @property
+    def percent_formats(self) -> localedata.LocaleDataDict:
+        """Locale patterns for percent number formatting.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en', 'US').percent_formats[None]
+        <NumberPattern u'#,##0%'>
+        """
+        return self._data['percent_formats']
+
+    @property
+    def scientific_formats(self) -> localedata.LocaleDataDict:
+        """Locale patterns for scientific number formatting.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en', 'US').scientific_formats[None]
+        <NumberPattern u'#E0'>
+        """
+        return self._data['scientific_formats']
+
+    # { Calendar Information and Date Formatting
+
+    @property
+    def periods(self) -> localedata.LocaleDataDict:
+        """Locale display names for day periods (AM/PM).
+
+        >>> Locale('en', 'US').periods['am']
+        u'AM'
+        """
+        try:
+            return self._data['day_periods']['stand-alone']['wide']
+        except KeyError:
+            return localedata.LocaleDataDict({})  # pragma: no cover
+
+    @property
+    def day_periods(self) -> localedata.LocaleDataDict:
+        """Locale display names for various day periods (not necessarily only AM/PM).
+
+        These are not meant to be used without the relevant `day_period_rules`.
+        """
+        return self._data['day_periods']
+
+    @property
+    def day_period_rules(self) -> localedata.LocaleDataDict:
+        """Day period rules for the locale.  Used by `get_period_id`.
+        """
+        return self._data.get('day_period_rules', localedata.LocaleDataDict({}))
+
+    @property
+    def days(self) -> localedata.LocaleDataDict:
+        """Locale display names for weekdays.
+
+        >>> Locale('de', 'DE').days['format']['wide'][3]
+        u'Donnerstag'
+        """
+        return self._data['days']
+
+    @property
+    def months(self) -> localedata.LocaleDataDict:
+        """Locale display names for months.
+
+        >>> Locale('de', 'DE').months['format']['wide'][10]
+        u'Oktober'
+        """
+        return self._data['months']
+
+    @property
+    def quarters(self) -> localedata.LocaleDataDict:
+        """Locale display names for quarters.
+
+        >>> Locale('de', 'DE').quarters['format']['wide'][1]
+        u'1. Quartal'
+        """
+        return self._data['quarters']
+
+    @property
+    def eras(self) -> localedata.LocaleDataDict:
+        """Locale display names for eras.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en', 'US').eras['wide'][1]
+        u'Anno Domini'
+        >>> Locale('en', 'US').eras['abbreviated'][0]
+        u'BC'
+        """
+        return self._data['eras']
+
+    @property
+    def time_zones(self) -> localedata.LocaleDataDict:
+        """Locale display names for time zones.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en', 'US').time_zones['Europe/London']['long']['daylight']
+        u'British Summer Time'
+        >>> Locale('en', 'US').time_zones['America/St_Johns']['city']
+        u'St. John\u2019s'
+        """
+        return self._data['time_zones']
+
+    @property
+    def meta_zones(self) -> localedata.LocaleDataDict:
+        """Locale display names for meta time zones.
+
+        Meta time zones are basically groups of different Olson time zones that
+        have the same GMT offset and daylight savings time.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en', 'US').meta_zones['Europe_Central']['long']['daylight']
+        u'Central European Summer Time'
+
+        .. versionadded:: 0.9
+        """
+        return self._data['meta_zones']
+
+    @property
+    def zone_formats(self) -> localedata.LocaleDataDict:
+        """Patterns related to the formatting of time zones.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en', 'US').zone_formats['fallback']
+        u'%(1)s (%(0)s)'
+        >>> Locale('pt', 'BR').zone_formats['region']
+        u'Hor\\xe1rio %s'
+
+        .. versionadded:: 0.9
+        """
+        return self._data['zone_formats']
+
+    @property
+    def first_week_day(self) -> int:
+        """The first day of a week, with 0 being Monday.
+
+        >>> Locale('de', 'DE').first_week_day
+        0
+        >>> Locale('en', 'US').first_week_day
+        6
+        """
+        return self._data['week_data']['first_day']
+
+    @property
+    def weekend_start(self) -> int:
+        """The day the weekend starts, with 0 being Monday.
+
+        >>> Locale('de', 'DE').weekend_start
+        5
+        """
+        return self._data['week_data']['weekend_start']
+
+    @property
+    def weekend_end(self) -> int:
+        """The day the weekend ends, with 0 being Monday.
+
+        >>> Locale('de', 'DE').weekend_end
+        6
+        """
+        return self._data['week_data']['weekend_end']
+
+    @property
+    def min_week_days(self) -> int:
+        """The minimum number of days in a week so that the week is counted as
+        the first week of a year or month.
+
+        >>> Locale('de', 'DE').min_week_days
+        4
+        """
+        return self._data['week_data']['min_days']
+
+    @property
+    def date_formats(self) -> localedata.LocaleDataDict:
+        """Locale patterns for date formatting.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en', 'US').date_formats['short']
+        <DateTimePattern u'M/d/yy'>
+        >>> Locale('fr', 'FR').date_formats['long']
+        <DateTimePattern u'd MMMM y'>
+        """
+        return self._data['date_formats']
+
+    @property
+    def time_formats(self) -> localedata.LocaleDataDict:
+        """Locale patterns for time formatting.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en', 'US').time_formats['short']
+        <DateTimePattern u'h:mm\u202fa'>
+        >>> Locale('fr', 'FR').time_formats['long']
+        <DateTimePattern u'HH:mm:ss z'>
+        """
+        return self._data['time_formats']
+
+    @property
+    def datetime_formats(self) -> localedata.LocaleDataDict:
+        """Locale patterns for datetime formatting.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en').datetime_formats['full']
+        u'{1}, {0}'
+        >>> Locale('th').datetime_formats['medium']
+        u'{1} {0}'
+        """
+        return self._data['datetime_formats']
+
+    @property
+    def datetime_skeletons(self) -> localedata.LocaleDataDict:
+        """Locale patterns for formatting parts of a datetime.
+
+        >>> Locale('en').datetime_skeletons['MEd']
+        <DateTimePattern u'E, M/d'>
+        >>> Locale('fr').datetime_skeletons['MEd']
+        <DateTimePattern u'E dd/MM'>
+        >>> Locale('fr').datetime_skeletons['H']
+        <DateTimePattern u"HH 'h'">
+        """
+        return self._data['datetime_skeletons']
+
+    @property
+    def interval_formats(self) -> localedata.LocaleDataDict:
+        """Locale patterns for interval formatting.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        How to format date intervals in Finnish when the day is the
+        smallest changing component:
+
+        >>> Locale('fi_FI').interval_formats['MEd']['d']
+        [u'E d.\u2009\u2013\u2009', u'E d.M.']
+
+        .. seealso::
+
+           The primary API to use this data is :py:func:`babel.dates.format_interval`.
+
+
+        :rtype: dict[str, dict[str, list[str]]]
+        """
+        return self._data['interval_formats']
+
+    @property
+    def plural_form(self) -> PluralRule:
+        """Plural rules for the locale.
+
+        >>> Locale('en').plural_form(1)
+        'one'
+        >>> Locale('en').plural_form(0)
+        'other'
+        >>> Locale('fr').plural_form(0)
+        'one'
+        >>> Locale('ru').plural_form(100)
+        'many'
+        """
+        return self._data.get('plural_form', _default_plural_rule)
+
+    @property
+    def list_patterns(self) -> localedata.LocaleDataDict:
+        """Patterns for generating lists
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en').list_patterns['standard']['start']
+        u'{0}, {1}'
+        >>> Locale('en').list_patterns['standard']['end']
+        u'{0}, and {1}'
+        >>> Locale('en_GB').list_patterns['standard']['end']
+        u'{0} and {1}'
+        """
+        return self._data['list_patterns']
+
+    @property
+    def ordinal_form(self) -> PluralRule:
+        """Plural rules for the locale.
+
+        >>> Locale('en').ordinal_form(1)
+        'one'
+        >>> Locale('en').ordinal_form(2)
+        'two'
+        >>> Locale('en').ordinal_form(3)
+        'few'
+        >>> Locale('fr').ordinal_form(2)
+        'other'
+        >>> Locale('ru').ordinal_form(100)
+        'other'
+        """
+        return self._data.get('ordinal_form', _default_plural_rule)
+
+    @property
+    def measurement_systems(self) -> localedata.LocaleDataDict:
+        """Localized names for various measurement systems.
+
+        >>> Locale('fr', 'FR').measurement_systems['US']
+        u'am\\xe9ricain'
+        >>> Locale('en', 'US').measurement_systems['US']
+        u'US'
+
+        """
+        return self._data['measurement_systems']
+
+    @property
+    def character_order(self) -> str:
+        """The text direction for the language.
+
+        >>> Locale('de', 'DE').character_order
+        'left-to-right'
+        >>> Locale('ar', 'SA').character_order
+        'right-to-left'
+        """
+        return self._data['character_order']
+
+    @property
+    def text_direction(self) -> str:
+        """The text direction for the language in CSS short-hand form.
+
+        >>> Locale('de', 'DE').text_direction
+        'ltr'
+        >>> Locale('ar', 'SA').text_direction
+        'rtl'
+        """
+        return ''.join(word[0] for word in self.character_order.split('-'))
+
+    @property
+    def unit_display_names(self) -> localedata.LocaleDataDict:
+        """Display names for units of measurement.
+
+        .. seealso::
+
+           You may want to use :py:func:`babel.units.get_unit_name` instead.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        """
+        return self._data['unit_display_names']
+
+
+def default_locale(
+    category: str | tuple[str, ...] | list[str] | None = None,
+    aliases: Mapping[str, str] = LOCALE_ALIASES,
+) -> str | None:
+    """Returns the system default locale for a given category, based on
+    environment variables.
+
+    >>> for name in ['LANGUAGE', 'LC_ALL', 'LC_CTYPE']:
+    ...     os.environ[name] = ''
+    >>> os.environ['LANG'] = 'fr_FR.UTF-8'
+    >>> default_locale('LC_MESSAGES')
+    'fr_FR'
+
+    The "C" or "POSIX" pseudo-locales are treated as aliases for the
+    "en_US_POSIX" locale:
+
+    >>> os.environ['LC_MESSAGES'] = 'POSIX'
+    >>> default_locale('LC_MESSAGES')
+    'en_US_POSIX'
+
+    The following fallbacks to the variable are always considered:
+
+    - ``LANGUAGE``
+    - ``LC_ALL``
+    - ``LC_CTYPE``
+    - ``LANG``
+
+    :param category: one or more of the ``LC_XXX`` environment variable names
+    :param aliases: a dictionary of aliases for locale identifiers
+    """
+
+    varnames = ('LANGUAGE', 'LC_ALL', 'LC_CTYPE', 'LANG')
+    if category:
+        if isinstance(category, str):
+            varnames = (category, *varnames)
+        elif isinstance(category, (list, tuple)):
+            varnames = (*category, *varnames)
+        else:
+            raise TypeError(f"Invalid type for category: {category!r}")
+
+    for name in varnames:
+        if not name:
+            continue
+        locale = os.getenv(name)
+        if locale:
+            if name == 'LANGUAGE' and ':' in locale:
+                # the LANGUAGE variable may contain a colon-separated list of
+                # language codes; we just pick the language on the list
+                locale = locale.split(':')[0]
+            if locale.split('.')[0] in ('C', 'POSIX'):
+                locale = 'en_US_POSIX'
+            elif aliases and locale in aliases:
+                locale = aliases[locale]
+            try:
+                return get_locale_identifier(parse_locale(locale))
+            except ValueError:
+                pass
+    return None
+
+
+def negotiate_locale(preferred: Iterable[str], available: Iterable[str], sep: str = '_', aliases: Mapping[str, str] = LOCALE_ALIASES) -> str | None:
+    """Find the best match between available and requested locale strings.
+
+    >>> negotiate_locale(['de_DE', 'en_US'], ['de_DE', 'de_AT'])
+    'de_DE'
+    >>> negotiate_locale(['de_DE', 'en_US'], ['en', 'de'])
+    'de'
+
+    Case is ignored by the algorithm, the result uses the case of the preferred
+    locale identifier:
+
+    >>> negotiate_locale(['de_DE', 'en_US'], ['de_de', 'de_at'])
+    'de_DE'
+
+    >>> negotiate_locale(['de_DE', 'en_US'], ['de_de', 'de_at'])
+    'de_DE'
+
+    By default, some web browsers unfortunately do not include the territory
+    in the locale identifier for many locales, and some don't even allow the
+    user to easily add the territory. So while you may prefer using qualified
+    locale identifiers in your web-application, they would not normally match
+    the language-only locale sent by such browsers. To workaround that, this
+    function uses a default mapping of commonly used language-only locale
+    identifiers to identifiers including the territory:
+
+    >>> negotiate_locale(['ja', 'en_US'], ['ja_JP', 'en_US'])
+    'ja_JP'
+
+    Some browsers even use an incorrect or outdated language code, such as "no"
+    for Norwegian, where the correct locale identifier would actually be "nb_NO"
+    (Bokmål) or "nn_NO" (Nynorsk). The aliases are intended to take care of
+    such cases, too:
+
+    >>> negotiate_locale(['no', 'sv'], ['nb_NO', 'sv_SE'])
+    'nb_NO'
+
+    You can override this default mapping by passing a different `aliases`
+    dictionary to this function, or you can bypass the behavior althogher by
+    setting the `aliases` parameter to `None`.
+
+    :param preferred: the list of locale strings preferred by the user
+    :param available: the list of locale strings available
+    :param sep: character that separates the different parts of the locale
+                strings
+    :param aliases: a dictionary of aliases for locale identifiers
+    """
+    available = [a.lower() for a in available if a]
+    for locale in preferred:
+        ll = locale.lower()
+        if ll in available:
+            return locale
+        if aliases:
+            alias = aliases.get(ll)
+            if alias:
+                alias = alias.replace('_', sep)
+                if alias.lower() in available:
+                    return alias
+        parts = locale.split(sep)
+        if len(parts) > 1 and parts[0].lower() in available:
+            return parts[0]
+    return None
+
+
+def parse_locale(
+    identifier: str,
+    sep: str = '_',
+) -> tuple[str, str | None, str | None, str | None] | tuple[str, str | None, str | None, str | None, str | None]:
+    """Parse a locale identifier into a tuple of the form ``(language,
+    territory, script, variant, modifier)``.
+
+    >>> parse_locale('zh_CN')
+    ('zh', 'CN', None, None)
+    >>> parse_locale('zh_Hans_CN')
+    ('zh', 'CN', 'Hans', None)
+    >>> parse_locale('ca_es_valencia')
+    ('ca', 'ES', None, 'VALENCIA')
+    >>> parse_locale('en_150')
+    ('en', '150', None, None)
+    >>> parse_locale('en_us_posix')
+    ('en', 'US', None, 'POSIX')
+    >>> parse_locale('it_IT@euro')
+    ('it', 'IT', None, None, 'euro')
+    >>> parse_locale('it_IT@custom')
+    ('it', 'IT', None, None, 'custom')
+    >>> parse_locale('it_IT@')
+    ('it', 'IT', None, None)
+
+    The default component separator is "_", but a different separator can be
+    specified using the `sep` parameter.
+
+    The optional modifier is always separated with "@" and at the end:
+
+    >>> parse_locale('zh-CN', sep='-')
+    ('zh', 'CN', None, None)
+    >>> parse_locale('zh-CN@custom', sep='-')
+    ('zh', 'CN', None, None, 'custom')
+
+    If the identifier cannot be parsed into a locale, a `ValueError` exception
+    is raised:
+
+    >>> parse_locale('not_a_LOCALE_String')
+    Traceback (most recent call last):
+      ...
+    ValueError: 'not_a_LOCALE_String' is not a valid locale identifier
+
+    Encoding information is removed from the identifier, while modifiers are
+    kept:
+
+    >>> parse_locale('en_US.UTF-8')
+    ('en', 'US', None, None)
+    >>> parse_locale('de_DE.iso885915@euro')
+    ('de', 'DE', None, None, 'euro')
+
+    See :rfc:`4646` for more information.
+
+    :param identifier: the locale identifier string
+    :param sep: character that separates the different components of the locale
+                identifier
+    :raise `ValueError`: if the string does not appear to be a valid locale
+                         identifier
+    """
+    if not identifier:
+        raise ValueError("empty locale identifier")
+    identifier, _, modifier = identifier.partition('@')
+    if '.' in identifier:
+        # this is probably the charset/encoding, which we don't care about
+        identifier = identifier.split('.', 1)[0]
+
+    parts = identifier.split(sep)
+    lang = parts.pop(0).lower()
+    if not lang.isalpha():
+        raise ValueError(f"expected only letters, got {lang!r}")
+
+    script = territory = variant = None
+    if parts and len(parts[0]) == 4 and parts[0].isalpha():
+        script = parts.pop(0).title()
+
+    if parts:
+        if len(parts[0]) == 2 and parts[0].isalpha():
+            territory = parts.pop(0).upper()
+        elif len(parts[0]) == 3 and parts[0].isdigit():
+            territory = parts.pop(0)
+
+    if parts and (
+        len(parts[0]) == 4 and parts[0][0].isdigit() or
+        len(parts[0]) >= 5 and parts[0][0].isalpha()
+    ):
+        variant = parts.pop().upper()
+
+    if parts:
+        raise ValueError(f"{identifier!r} is not a valid locale identifier")
+
+    # TODO(3.0): always return a 5-tuple
+    if modifier:
+        return lang, territory, script, variant, modifier
+    else:
+        return lang, territory, script, variant
+
+
+def get_locale_identifier(
+    tup: tuple[str]
+    | tuple[str, str | None]
+    | tuple[str, str | None, str | None]
+    | tuple[str, str | None, str | None, str | None]
+    | tuple[str, str | None, str | None, str | None, str | None],
+    sep: str = "_",
+) -> str:
+    """The reverse of :func:`parse_locale`.  It creates a locale identifier out
+    of a ``(language, territory, script, variant, modifier)`` tuple.  Items can be set to
+    ``None`` and trailing ``None``\\s can also be left out of the tuple.
+
+    >>> get_locale_identifier(('de', 'DE', None, '1999', 'custom'))
+    'de_DE_1999@custom'
+    >>> get_locale_identifier(('fi', None, None, None, 'custom'))
+    'fi@custom'
+
+
+    .. versionadded:: 1.0
+
+    :param tup: the tuple as returned by :func:`parse_locale`.
+    :param sep: the separator for the identifier.
+    """
+    tup = tuple(tup[:5])  # type: ignore  # length should be no more than 5
+    lang, territory, script, variant, modifier = tup + (None,) * (5 - len(tup))
+    ret = sep.join(filter(None, (lang, script, territory, variant)))
+    return f'{ret}@{modifier}' if modifier else ret

lib/python3.10/site-packages/babel/dates.py

@@ -0,0 +1,1999 @@
+"""
+    babel.dates
+    ~~~~~~~~~~~
+
+    Locale dependent formatting and parsing of dates and times.
+
+    The default locale for the functions in this module is determined by the
+    following environment variables, in that order:
+
+     * ``LC_TIME``,
+     * ``LC_ALL``, and
+     * ``LANG``
+
+    :copyright: (c) 2013-2025 by the Babel Team.
+    :license: BSD, see LICENSE for more details.
+"""
+
+from __future__ import annotations
+
+import math
+import re
+import warnings
+from functools import lru_cache
+from typing import TYPE_CHECKING, Literal, SupportsInt
+
+try:
+    import pytz
+except ModuleNotFoundError:
+    pytz = None
+    import zoneinfo
+
+import datetime
+from collections.abc import Iterable
+
+from babel import localtime
+from babel.core import Locale, default_locale, get_global
+from babel.localedata import LocaleDataDict
+
+if TYPE_CHECKING:
+    from typing_extensions import TypeAlias
+    _Instant: TypeAlias = datetime.date | datetime.time | float | None
+    _PredefinedTimeFormat: TypeAlias = Literal['full', 'long', 'medium', 'short']
+    _Context: TypeAlias = Literal['format', 'stand-alone']
+    _DtOrTzinfo: TypeAlias = datetime.datetime | datetime.tzinfo | str | int | datetime.time | None
+
+# "If a given short metazone form is known NOT to be understood in a given
+#  locale and the parent locale has this value such that it would normally
+#  be inherited, the inheritance of this value can be explicitly disabled by
+#  use of the 'no inheritance marker' as the value, which is 3 simultaneous [sic]
+#  empty set characters ( U+2205 )."
+#  - https://www.unicode.org/reports/tr35/tr35-dates.html#Metazone_Names
+
+NO_INHERITANCE_MARKER = '\u2205\u2205\u2205'
+
+UTC = datetime.timezone.utc
+LOCALTZ = localtime.LOCALTZ
+
+LC_TIME = default_locale('LC_TIME')
+
+
+def _localize(tz: datetime.tzinfo, dt: datetime.datetime) -> datetime.datetime:
+    # Support localizing with both pytz and zoneinfo tzinfos
+    # nothing to do
+    if dt.tzinfo is tz:
+        return dt
+
+    if hasattr(tz, 'localize'):  # pytz
+        return tz.localize(dt)
+
+    if dt.tzinfo is None:
+        # convert naive to localized
+        return dt.replace(tzinfo=tz)
+
+    # convert timezones
+    return dt.astimezone(tz)
+
+
+def _get_dt_and_tzinfo(dt_or_tzinfo: _DtOrTzinfo) -> tuple[datetime.datetime | None, datetime.tzinfo]:
+    """
+    Parse a `dt_or_tzinfo` value into a datetime and a tzinfo.
+
+    See the docs for this function's callers for semantics.
+
+    :rtype: tuple[datetime, tzinfo]
+    """
+    if dt_or_tzinfo is None:
+        dt = datetime.datetime.now()
+        tzinfo = LOCALTZ
+    elif isinstance(dt_or_tzinfo, str):
+        dt = None
+        tzinfo = get_timezone(dt_or_tzinfo)
+    elif isinstance(dt_or_tzinfo, int):
+        dt = None
+        tzinfo = UTC
+    elif isinstance(dt_or_tzinfo, (datetime.datetime, datetime.time)):
+        dt = _get_datetime(dt_or_tzinfo)
+        tzinfo = dt.tzinfo if dt.tzinfo is not None else UTC
+    else:
+        dt = None
+        tzinfo = dt_or_tzinfo
+    return dt, tzinfo
+
+
+def _get_tz_name(dt_or_tzinfo: _DtOrTzinfo) -> str:
+    """
+    Get the timezone name out of a time, datetime, or tzinfo object.
+
+    :rtype: str
+    """
+    dt, tzinfo = _get_dt_and_tzinfo(dt_or_tzinfo)
+    if hasattr(tzinfo, 'zone'):  # pytz object
+        return tzinfo.zone
+    elif hasattr(tzinfo, 'key') and tzinfo.key is not None:  # ZoneInfo object
+        return tzinfo.key
+    else:
+        return tzinfo.tzname(dt or datetime.datetime.now(UTC))
+
+
+def _get_datetime(instant: _Instant) -> datetime.datetime:
+    """
+    Get a datetime out of an "instant" (date, time, datetime, number).
+
+    .. warning:: The return values of this function may depend on the system clock.
+
+    If the instant is None, the current moment is used.
+    If the instant is a time, it's augmented with today's date.
+
+    Dates are converted to naive datetimes with midnight as the time component.
+
+    >>> from datetime import date, datetime
+    >>> _get_datetime(date(2015, 1, 1))
+    datetime.datetime(2015, 1, 1, 0, 0)
+
+    UNIX timestamps are converted to datetimes.
+
+    >>> _get_datetime(1400000000)
+    datetime.datetime(2014, 5, 13, 16, 53, 20)
+
+    Other values are passed through as-is.
+
+    >>> x = datetime(2015, 1, 1)
+    >>> _get_datetime(x) is x
+    True
+
+    :param instant: date, time, datetime, integer, float or None
+    :type instant: date|time|datetime|int|float|None
+    :return: a datetime
+    :rtype: datetime
+    """
+    if instant is None:
+        return datetime.datetime.now(UTC).replace(tzinfo=None)
+    elif isinstance(instant, (int, float)):
+        return datetime.datetime.fromtimestamp(instant, UTC).replace(tzinfo=None)
+    elif isinstance(instant, datetime.time):
+        return datetime.datetime.combine(datetime.date.today(), instant)
+    elif isinstance(instant, datetime.date) and not isinstance(instant, datetime.datetime):
+        return datetime.datetime.combine(instant, datetime.time())
+    # TODO (3.x): Add an assertion/type check for this fallthrough branch:
+    return instant
+
+
+def _ensure_datetime_tzinfo(dt: datetime.datetime, tzinfo: datetime.tzinfo | None = None) -> datetime.datetime:
+    """
+    Ensure the datetime passed has an attached tzinfo.
+
+    If the datetime is tz-naive to begin with, UTC is attached.
+
+    If a tzinfo is passed in, the datetime is normalized to that timezone.
+
+    >>> from datetime import datetime
+    >>> _get_tz_name(_ensure_datetime_tzinfo(datetime(2015, 1, 1)))
+    'UTC'
+
+    >>> tz = get_timezone("Europe/Stockholm")
+    >>> _ensure_datetime_tzinfo(datetime(2015, 1, 1, 13, 15, tzinfo=UTC), tzinfo=tz).hour
+    14
+
+    :param datetime: Datetime to augment.
+    :param tzinfo: optional tzinfo
+    :return: datetime with tzinfo
+    :rtype: datetime
+    """
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=UTC)
+    if tzinfo is not None:
+        dt = dt.astimezone(get_timezone(tzinfo))
+        if hasattr(tzinfo, 'normalize'):  # pytz
+            dt = tzinfo.normalize(dt)
+    return dt
+
+
+def _get_time(
+    time: datetime.time | datetime.datetime | None,
+    tzinfo: datetime.tzinfo | None = None,
+) -> datetime.time:
+    """
+    Get a timezoned time from a given instant.
+
+    .. warning:: The return values of this function may depend on the system clock.
+
+    :param time: time, datetime or None
+    :rtype: time
+    """
+    if time is None:
+        time = datetime.datetime.now(UTC)
+    elif isinstance(time, (int, float)):
+        time = datetime.datetime.fromtimestamp(time, UTC)
+
+    if time.tzinfo is None:
+        time = time.replace(tzinfo=UTC)
+
+    if isinstance(time, datetime.datetime):
+        if tzinfo is not None:
+            time = time.astimezone(tzinfo)
+            if hasattr(tzinfo, 'normalize'):  # pytz
+                time = tzinfo.normalize(time)
+        time = time.timetz()
+    elif tzinfo is not None:
+        time = time.replace(tzinfo=tzinfo)
+    return time
+
+
+def get_timezone(zone: str | datetime.tzinfo | None = None) -> datetime.tzinfo:
+    """Looks up a timezone by name and returns it.  The timezone object
+    returned comes from ``pytz`` or ``zoneinfo``, whichever is available.
+    It corresponds to the `tzinfo` interface and can be used with all of
+    the functions of Babel that operate with dates.
+
+    If a timezone is not known a :exc:`LookupError` is raised.  If `zone`
+    is ``None`` a local zone object is returned.
+
+    :param zone: the name of the timezone to look up.  If a timezone object
+                 itself is passed in, it's returned unchanged.
+    """
+    if zone is None:
+        return LOCALTZ
+    if not isinstance(zone, str):
+        return zone
+
+    if pytz:
+        try:
+            return pytz.timezone(zone)
+        except pytz.UnknownTimeZoneError as e:
+            exc = e
+    else:
+        assert zoneinfo
+        try:
+            return zoneinfo.ZoneInfo(zone)
+        except zoneinfo.ZoneInfoNotFoundError as e:
+            exc = e
+
+    raise LookupError(f"Unknown timezone {zone}") from exc
+
+
+def get_period_names(
+    width: Literal['abbreviated', 'narrow', 'wide'] = 'wide',
+    context: _Context = 'stand-alone',
+    locale: Locale | str | None = None,
+) -> LocaleDataDict:
+    """Return the names for day periods (AM/PM) used by the locale.
+
+    >>> get_period_names(locale='en_US')['am']
+    u'AM'
+
+    :param width: the width to use, one of "abbreviated", "narrow", or "wide"
+    :param context: the context, either "format" or "stand-alone"
+    :param locale: the `Locale` object, or a locale string. Defaults to the system time locale.
+    """
+    return Locale.parse(locale or LC_TIME).day_periods[context][width]
+
+
+def get_day_names(
+    width: Literal['abbreviated', 'narrow', 'short', 'wide'] = 'wide',
+    context: _Context = 'format',
+    locale: Locale | str | None = None,
+) -> LocaleDataDict:
+    """Return the day names used by the locale for the specified format.
+
+    >>> get_day_names('wide', locale='en_US')[1]
+    u'Tuesday'
+    >>> get_day_names('short', locale='en_US')[1]
+    u'Tu'
+    >>> get_day_names('abbreviated', locale='es')[1]
+    u'mar'
+    >>> get_day_names('narrow', context='stand-alone', locale='de_DE')[1]
+    u'D'
+
+    :param width: the width to use, one of "wide", "abbreviated", "short" or "narrow"
+    :param context: the context, either "format" or "stand-alone"
+    :param locale: the `Locale` object, or a locale string. Defaults to the system time locale.
+    """
+    return Locale.parse(locale or LC_TIME).days[context][width]
+
+
+def get_month_names(
+    width: Literal['abbreviated', 'narrow', 'wide'] = 'wide',
+    context: _Context = 'format',
+    locale: Locale | str | None = None,
+) -> LocaleDataDict:
+    """Return the month names used by the locale for the specified format.
+
+    >>> get_month_names('wide', locale='en_US')[1]
+    u'January'
+    >>> get_month_names('abbreviated', locale='es')[1]
+    u'ene'
+    >>> get_month_names('narrow', context='stand-alone', locale='de_DE')[1]
+    u'J'
+
+    :param width: the width to use, one of "wide", "abbreviated", or "narrow"
+    :param context: the context, either "format" or "stand-alone"
+    :param locale: the `Locale` object, or a locale string. Defaults to the system time locale.
+    """
+    return Locale.parse(locale or LC_TIME).months[context][width]
+
+
+def get_quarter_names(
+    width: Literal['abbreviated', 'narrow', 'wide'] = 'wide',
+    context: _Context = 'format',
+    locale: Locale | str | None = None,
+) -> LocaleDataDict:
+    """Return the quarter names used by the locale for the specified format.
+
+    >>> get_quarter_names('wide', locale='en_US')[1]
+    u'1st quarter'
+    >>> get_quarter_names('abbreviated', locale='de_DE')[1]
+    u'Q1'
+    >>> get_quarter_names('narrow', locale='de_DE')[1]
+    u'1'
+
+    :param width: the width to use, one of "wide", "abbreviated", or "narrow"
+    :param context: the context, either "format" or "stand-alone"
+    :param locale: the `Locale` object, or a locale string. Defaults to the system time locale.
+    """
+    return Locale.parse(locale or LC_TIME).quarters[context][width]
+
+
+def get_era_names(
+    width: Literal['abbreviated', 'narrow', 'wide'] = 'wide',
+    locale: Locale | str | None = None,
+) -> LocaleDataDict:
+    """Return the era names used by the locale for the specified format.
+
+    >>> get_era_names('wide', locale='en_US')[1]
+    u'Anno Domini'
+    >>> get_era_names('abbreviated', locale='de_DE')[1]
+    u'n. Chr.'
+
+    :param width: the width to use, either "wide", "abbreviated", or "narrow"
+    :param locale: the `Locale` object, or a locale string. Defaults to the system time locale.
+    """
+    return Locale.parse(locale or LC_TIME).eras[width]
+
+
+def get_date_format(
+    format: _PredefinedTimeFormat = 'medium',
+    locale: Locale | str | None = None,
+) -> DateTimePattern:
+    """Return the date formatting patterns used by the locale for the specified
+    format.
+
+    >>> get_date_format(locale='en_US')
+    <DateTimePattern u'MMM d, y'>
+    >>> get_date_format('full', locale='de_DE')
+    <DateTimePattern u'EEEE, d. MMMM y'>
+
+    :param format: the format to use, one of "full", "long", "medium", or
+                   "short"
+    :param locale: the `Locale` object, or a locale string. Defaults to the system time locale.
+    """
+    return Locale.parse(locale or LC_TIME).date_formats[format]
+
+
+def get_datetime_format(
+    format: _PredefinedTimeFormat = 'medium',
+    locale: Locale | str | None = None,
+) -> DateTimePattern:
+    """Return the datetime formatting patterns used by the locale for the
+    specified format.
+
+    >>> get_datetime_format(locale='en_US')
+    u'{1}, {0}'
+
+    :param format: the format to use, one of "full", "long", "medium", or
+                   "short"
+    :param locale: the `Locale` object, or a locale string. Defaults to the system time locale.
+    """
+    patterns = Locale.parse(locale or LC_TIME).datetime_formats
+    if format not in patterns:
+        format = None
+    return patterns[format]
+
+
+def get_time_format(
+    format: _PredefinedTimeFormat = 'medium',
+    locale: Locale | str | None = None,
+) -> DateTimePattern:
+    """Return the time formatting patterns used by the locale for the specified
+    format.
+
+    >>> get_time_format(locale='en_US')
+    <DateTimePattern u'h:mm:ss\u202fa'>
+    >>> get_time_format('full', locale='de_DE')
+    <DateTimePattern u'HH:mm:ss zzzz'>
+
+    :param format: the format to use, one of "full", "long", "medium", or
+                   "short"
+    :param locale: the `Locale` object, or a locale string. Defaults to the system time locale.
+    """
+    return Locale.parse(locale or LC_TIME).time_formats[format]
+
+
+def get_timezone_gmt(
+    datetime: _Instant = None,
+    width: Literal['long', 'short', 'iso8601', 'iso8601_short'] = 'long',
+    locale: Locale | str | None = None,
+    return_z: bool = False,
+) -> str:
+    """Return the timezone associated with the given `datetime` object formatted
+    as string indicating the offset from GMT.
+
+    >>> from datetime import datetime
+    >>> dt = datetime(2007, 4, 1, 15, 30)
+    >>> get_timezone_gmt(dt, locale='en')
+    u'GMT+00:00'
+    >>> get_timezone_gmt(dt, locale='en', return_z=True)
+    'Z'
+    >>> get_timezone_gmt(dt, locale='en', width='iso8601_short')
+    u'+00'
+    >>> tz = get_timezone('America/Los_Angeles')
+    >>> dt = _localize(tz, datetime(2007, 4, 1, 15, 30))
+    >>> get_timezone_gmt(dt, locale='en')
+    u'GMT-07:00'
+    >>> get_timezone_gmt(dt, 'short', locale='en')
+    u'-0700'
+    >>> get_timezone_gmt(dt, locale='en', width='iso8601_short')
+    u'-07'
+
+    The long format depends on the locale, for example in France the acronym
+    UTC string is used instead of GMT:
+
+    >>> get_timezone_gmt(dt, 'long', locale='fr_FR')
+    u'UTC-07:00'
+
+    .. versionadded:: 0.9
+
+    :param datetime: the ``datetime`` object; if `None`, the current date and
+                     time in UTC is used
+    :param width: either "long" or "short" or "iso8601" or "iso8601_short"
+    :param locale: the `Locale` object, or a locale string. Defaults to the system time locale.
+    :param return_z: True or False; Function returns indicator "Z"
+                     when local time offset is 0
+    """
+    datetime = _ensure_datetime_tzinfo(_get_datetime(datetime))
+    locale = Locale.parse(locale or LC_TIME)
+
+    offset = datetime.tzinfo.utcoffset(datetime)
+    seconds = offset.days * 24 * 60 * 60 + offset.seconds
+    hours, seconds = divmod(seconds, 3600)
+    if return_z and hours == 0 and seconds == 0:
+        return 'Z'
+    elif seconds == 0 and width == 'iso8601_short':
+        return '%+03d' % hours
+    elif width == 'short' or width == 'iso8601_short':
+        pattern = '%+03d%02d'
+    elif width == 'iso8601':
+        pattern = '%+03d:%02d'
+    else:
+        pattern = locale.zone_formats['gmt'] % '%+03d:%02d'
+    return pattern % (hours, seconds // 60)
+
+
+def get_timezone_location(
+    dt_or_tzinfo: _DtOrTzinfo = None,
+    locale: Locale | str | None = None,
+    return_city: bool = False,
+) -> str:
+    """Return a representation of the given timezone using "location format".
+
+    The result depends on both the local display name of the country and the
+    city associated with the time zone:
+
+    >>> tz = get_timezone('America/St_Johns')
+    >>> print(get_timezone_location(tz, locale='de_DE'))
+    Kanada (St. John’s) (Ortszeit)
+    >>> print(get_timezone_location(tz, locale='en'))
+    Canada (St. John’s) Time
+    >>> print(get_timezone_location(tz, locale='en', return_city=True))
+    St. John’s
+    >>> tz = get_timezone('America/Mexico_City')
+    >>> get_timezone_location(tz, locale='de_DE')
+    u'Mexiko (Mexiko-Stadt) (Ortszeit)'
+
+    If the timezone is associated with a country that uses only a single
+    timezone, just the localized country name is returned:
+
+    >>> tz = get_timezone('Europe/Berlin')
+    >>> get_timezone_name(tz, locale='de_DE')
+    u'Mitteleurop\\xe4ische Zeit'
+
+    .. versionadded:: 0.9
+
+    :param dt_or_tzinfo: the ``datetime`` or ``tzinfo`` object that determines
+                         the timezone; if `None`, the current date and time in
+                         UTC is assumed
+    :param locale: the `Locale` object, or a locale string. Defaults to the system time locale.
+    :param return_city: True or False, if True then return exemplar city (location)
+                        for the time zone
+    :return: the localized timezone name using location format
+
+    """
+    locale = Locale.parse(locale or LC_TIME)
+
+    zone = _get_tz_name(dt_or_tzinfo)
+
+    # Get the canonical time-zone code
+    zone = get_global('zone_aliases').get(zone, zone)
+
+    info = locale.time_zones.get(zone, {})
+
+    # Otherwise, if there is only one timezone for the country, return the
+    # localized country name
+    region_format = locale.zone_formats['region']
+    territory = get_global('zone_territories').get(zone)
+    if territory not in locale.territories:
+        territory = 'ZZ'  # invalid/unknown
+    territory_name = locale.territories[territory]
+    if not return_city and territory and len(get_global('territory_zones').get(territory, [])) == 1:
+        return region_format % territory_name
+
+    # Otherwise, include the city in the output
+    fallback_format = locale.zone_formats['fallback']
+    if 'city' in info:
+        city_name = info['city']
+    else:
+        metazone = get_global('meta_zones').get(zone)
+        metazone_info = locale.meta_zones.get(metazone, {})
+        if 'city' in metazone_info:
+            city_name = metazone_info['city']
+        elif '/' in zone:
+            city_name = zone.split('/', 1)[1].replace('_', ' ')
+        else:
+            city_name = zone.replace('_', ' ')
+
+    if return_city:
+        return city_name
+    return region_format % (fallback_format % {
+        '0': city_name,
+        '1': territory_name,
+    })
+
+
+def get_timezone_name(
+    dt_or_tzinfo: _DtOrTzinfo = None,
+    width: Literal['long', 'short'] = 'long',
+    uncommon: bool = False,
+    locale: Locale | str | None = None,
+    zone_variant: Literal['generic', 'daylight', 'standard'] | None = None,
+    return_zone: bool = False,
+) -> str:
+    r"""Return the localized display name for the given timezone. The timezone
+    may be specified using a ``datetime`` or `tzinfo` object.
+
+    >>> from datetime import time
+    >>> dt = time(15, 30, tzinfo=get_timezone('America/Los_Angeles'))
+    >>> get_timezone_name(dt, locale='en_US')  # doctest: +SKIP
+    u'Pacific Standard Time'
+    >>> get_timezone_name(dt, locale='en_US', return_zone=True)
+    'America/Los_Angeles'
+    >>> get_timezone_name(dt, width='short', locale='en_US')  # doctest: +SKIP
+    u'PST'
+
+    If this function gets passed only a `tzinfo` object and no concrete
+    `datetime`,  the returned display name is independent of daylight savings
+    time. This can be used for example for selecting timezones, or to set the
+    time of events that recur across DST changes:
+
+    >>> tz = get_timezone('America/Los_Angeles')
+    >>> get_timezone_name(tz, locale='en_US')
+    u'Pacific Time'
+    >>> get_timezone_name(tz, 'short', locale='en_US')
+    u'PT'
+
+    If no localized display name for the timezone is available, and the timezone
+    is associated with a country that uses only a single timezone, the name of
+    that country is returned, formatted according to the locale:
+
+    >>> tz = get_timezone('Europe/Berlin')
+    >>> get_timezone_name(tz, locale='de_DE')
+    u'Mitteleurop\xe4ische Zeit'
+    >>> get_timezone_name(tz, locale='pt_BR')
+    u'Hor\xe1rio da Europa Central'
+
+    On the other hand, if the country uses multiple timezones, the city is also
+    included in the representation:
+
+    >>> tz = get_timezone('America/St_Johns')
+    >>> get_timezone_name(tz, locale='de_DE')
+    u'Neufundland-Zeit'
+
+    Note that short format is currently not supported for all timezones and
+    all locales.  This is partially because not every timezone has a short
+    code in every locale.  In that case it currently falls back to the long
+    format.
+
+    For more information see `LDML Appendix J: Time Zone Display Names
+    <https://www.unicode.org/reports/tr35/#Time_Zone_Fallback>`_
+
+    .. versionadded:: 0.9
+
+    .. versionchanged:: 1.0
+       Added `zone_variant` support.
+
+    :param dt_or_tzinfo: the ``datetime`` or ``tzinfo`` object that determines
+                         the timezone; if a ``tzinfo`` object is used, the
+                         resulting display name will be generic, i.e.
+                         independent of daylight savings time; if `None`, the
+                         current date in UTC is assumed
+    :param width: either "long" or "short"
+    :param uncommon: deprecated and ignored
+    :param zone_variant: defines the zone variation to return.  By default the
+                           variation is defined from the datetime object
+                           passed in.  If no datetime object is passed in, the
+                           ``'generic'`` variation is assumed.  The following
+                           values are valid: ``'generic'``, ``'daylight'`` and
+                           ``'standard'``.
+    :param locale: the `Locale` object, or a locale string. Defaults to the system time locale.
+    :param return_zone: True or False. If true then function
+                        returns long time zone ID
+    """
+    dt, tzinfo = _get_dt_and_tzinfo(dt_or_tzinfo)
+    locale = Locale.parse(locale or LC_TIME)
+
+    zone = _get_tz_name(dt_or_tzinfo)
+
+    if zone_variant is None:
+        if dt is None:
+            zone_variant = 'generic'
+        else:
+            dst = tzinfo.dst(dt)
+            zone_variant = "daylight" if dst else "standard"
+    else:
+        if zone_variant not in ('generic', 'standard', 'daylight'):
+            raise ValueError('Invalid zone variation')
+
+    # Get the canonical time-zone code
+    zone = get_global('zone_aliases').get(zone, zone)
+    if return_zone:
+        return zone
+    info = locale.time_zones.get(zone, {})
+    # Try explicitly translated zone names first
+    if width in info and zone_variant in info[width]:
+        return info[width][zone_variant]
+
+    metazone = get_global('meta_zones').get(zone)
+    if metazone:
+        metazone_info = locale.meta_zones.get(metazone, {})
+        if width in metazone_info:
+            name = metazone_info[width].get(zone_variant)
+            if width == 'short' and name == NO_INHERITANCE_MARKER:
+                # If the short form is marked no-inheritance,
+                # try to fall back to the long name instead.
+                name = metazone_info.get('long', {}).get(zone_variant)
+            if name:
+                return name
+
+    # If we have a concrete datetime, we assume that the result can't be
+    # independent of daylight savings time, so we return the GMT offset
+    if dt is not None:
+        return get_timezone_gmt(dt, width=width, locale=locale)
+
+    return get_timezone_location(dt_or_tzinfo, locale=locale)
+
+
+def format_date(
+    date: datetime.date | None = None,
+    format: _PredefinedTimeFormat | str = 'medium',
+    locale: Locale | str | None = None,
+) -> str:
+    """Return a date formatted according to the given pattern.
+
+    >>> from datetime import date
+    >>> d = date(2007, 4, 1)
+    >>> format_date(d, locale='en_US')
+    u'Apr 1, 2007'
+    >>> format_date(d, format='full', locale='de_DE')
+    u'Sonntag, 1. April 2007'
+
+    If you don't want to use the locale default formats, you can specify a
+    custom date pattern:
+
+    >>> format_date(d, "EEE, MMM d, ''yy", locale='en')
+    u"Sun, Apr 1, '07"
+
+    :param date: the ``date`` or ``datetime`` object; if `None`, the current
+                 date is used
+    :param format: one of "full", "long", "medium", or "short", or a custom
+                   date/time pattern
+    :param locale: a `Locale` object or a locale identifier. Defaults to the system time locale.
+    """
+    if date is None:
+        date = datetime.date.today()
+    elif isinstance(date, datetime.datetime):
+        date = date.date()
+
+    locale = Locale.parse(locale or LC_TIME)
+    if format in ('full', 'long', 'medium', 'short'):
+        format = get_date_format(format, locale=locale)
+    pattern = parse_pattern(format)
+    return pattern.apply(date, locale)
+
+
+def format_datetime(
+    datetime: _Instant = None,
+    format: _PredefinedTimeFormat | str = 'medium',
+    tzinfo: datetime.tzinfo | None = None,
+    locale: Locale | str | None = None,
+) -> str:
+    r"""Return a date formatted according to the given pattern.
+
+    >>> from datetime import datetime
+    >>> dt = datetime(2007, 4, 1, 15, 30)
+    >>> format_datetime(dt, locale='en_US')
+    u'Apr 1, 2007, 3:30:00\u202fPM'
+
+    For any pattern requiring the display of the timezone:
+
+    >>> format_datetime(dt, 'full', tzinfo=get_timezone('Europe/Paris'),
+    ...                 locale='fr_FR')
+    'dimanche 1 avril 2007, 17:30:00 heure d’été d’Europe centrale'
+    >>> format_datetime(dt, "yyyy.MM.dd G 'at' HH:mm:ss zzz",
+    ...                 tzinfo=get_timezone('US/Eastern'), locale='en')
+    u'2007.04.01 AD at 11:30:00 EDT'
+
+    :param datetime: the `datetime` object; if `None`, the current date and
+                     time is used
+    :param format: one of "full", "long", "medium", or "short", or a custom
+                   date/time pattern
+    :param tzinfo: the timezone to apply to the time for display
+    :param locale: a `Locale` object or a locale identifier. Defaults to the system time locale.
+    """
+    datetime = _ensure_datetime_tzinfo(_get_datetime(datetime), tzinfo)
+
+    locale = Locale.parse(locale or LC_TIME)
+    if format in ('full', 'long', 'medium', 'short'):
+        return get_datetime_format(format, locale=locale) \
+            .replace("'", "") \
+            .replace('{0}', format_time(datetime, format, tzinfo=None,
+                                        locale=locale)) \
+            .replace('{1}', format_date(datetime, format, locale=locale))
+    else:
+        return parse_pattern(format).apply(datetime, locale)
+
+
+def format_time(
+    time: datetime.time | datetime.datetime | float | None = None,
+    format: _PredefinedTimeFormat | str = 'medium',
+    tzinfo: datetime.tzinfo | None = None,
+    locale: Locale | str | None = None,
+) -> str:
+    r"""Return a time formatted according to the given pattern.
+
+    >>> from datetime import datetime, time
+    >>> t = time(15, 30)
+    >>> format_time(t, locale='en_US')
+    u'3:30:00\u202fPM'
+    >>> format_time(t, format='short', locale='de_DE')
+    u'15:30'
+
+    If you don't want to use the locale default formats, you can specify a
+    custom time pattern:
+
+    >>> format_time(t, "hh 'o''clock' a", locale='en')
+    u"03 o'clock PM"
+
+    For any pattern requiring the display of the time-zone a
+    timezone has to be specified explicitly:
+
+    >>> t = datetime(2007, 4, 1, 15, 30)
+    >>> tzinfo = get_timezone('Europe/Paris')
+    >>> t = _localize(tzinfo, t)
+    >>> format_time(t, format='full', tzinfo=tzinfo, locale='fr_FR')
+    '15:30:00 heure d’été d’Europe centrale'
+    >>> format_time(t, "hh 'o''clock' a, zzzz", tzinfo=get_timezone('US/Eastern'),
+    ...             locale='en')
+    u"09 o'clock AM, Eastern Daylight Time"
+
+    As that example shows, when this function gets passed a
+    ``datetime.datetime`` value, the actual time in the formatted string is
+    adjusted to the timezone specified by the `tzinfo` parameter. If the
+    ``datetime`` is "naive" (i.e. it has no associated timezone information),
+    it is assumed to be in UTC.
+
+    These timezone calculations are **not** performed if the value is of type
+    ``datetime.time``, as without date information there's no way to determine
+    what a given time would translate to in a different timezone without
+    information about whether daylight savings time is in effect or not. This
+    means that time values are left as-is, and the value of the `tzinfo`
+    parameter is only used to display the timezone name if needed:
+
+    >>> t = time(15, 30)
+    >>> format_time(t, format='full', tzinfo=get_timezone('Europe/Paris'),
+    ...             locale='fr_FR')  # doctest: +SKIP
+    u'15:30:00 heure normale d\u2019Europe centrale'
+    >>> format_time(t, format='full', tzinfo=get_timezone('US/Eastern'),
+    ...             locale='en_US')  # doctest: +SKIP
+    u'3:30:00\u202fPM Eastern Standard Time'
+
+    :param time: the ``time`` or ``datetime`` object; if `None`, the current
+                 time in UTC is used
+    :param format: one of "full", "long", "medium", or "short", or a custom
+                   date/time pattern
+    :param tzinfo: the time-zone to apply to the time for display
+    :param locale: a `Locale` object or a locale identifier. Defaults to the system time locale.
+    """
+
+    # get reference date for if we need to find the right timezone variant
+    # in the pattern
+    ref_date = time.date() if isinstance(time, datetime.datetime) else None
+
+    time = _get_time(time, tzinfo)
+
+    locale = Locale.parse(locale or LC_TIME)
+    if format in ('full', 'long', 'medium', 'short'):
+        format = get_time_format(format, locale=locale)
+    return parse_pattern(format).apply(time, locale, reference_date=ref_date)
+
+
+def format_skeleton(
+    skeleton: str,
+    datetime: _Instant = None,
+    tzinfo: datetime.tzinfo | None = None,
+    fuzzy: bool = True,
+    locale: Locale | str | None = None,
+) -> str:
+    r"""Return a time and/or date formatted according to the given pattern.
+
+    The skeletons are defined in the CLDR data and provide more flexibility
+    than the simple short/long/medium formats, but are a bit harder to use.
+    The are defined using the date/time symbols without order or punctuation
+    and map to a suitable format for the given locale.
+
+    >>> from datetime import datetime
+    >>> t = datetime(2007, 4, 1, 15, 30)
+    >>> format_skeleton('MMMEd', t, locale='fr')
+    u'dim. 1 avr.'
+    >>> format_skeleton('MMMEd', t, locale='en')
+    u'Sun, Apr 1'
+    >>> format_skeleton('yMMd', t, locale='fi')  # yMMd is not in the Finnish locale; yMd gets used
+    u'1.4.2007'
+    >>> format_skeleton('yMMd', t, fuzzy=False, locale='fi')  # yMMd is not in the Finnish locale, an error is thrown
+    Traceback (most recent call last):
+        ...
+    KeyError: yMMd
+    >>> format_skeleton('GH', t, fuzzy=True, locale='fi_FI')  # GH is not in the Finnish locale and there is no close match, an error is thrown
+    Traceback (most recent call last):
+        ...
+    KeyError: None
+
+    After the skeleton is resolved to a pattern `format_datetime` is called so
+    all timezone processing etc is the same as for that.
+
+    :param skeleton: A date time skeleton as defined in the cldr data.
+    :param datetime: the ``time`` or ``datetime`` object; if `None`, the current
+                 time in UTC is used
+    :param tzinfo: the time-zone to apply to the time for display
+    :param fuzzy: If the skeleton is not found, allow choosing a skeleton that's
+                  close enough to it. If there is no close match, a `KeyError`
+                  is thrown.
+    :param locale: a `Locale` object or a locale identifier. Defaults to the system time locale.
+    """
+    locale = Locale.parse(locale or LC_TIME)
+    if fuzzy and skeleton not in locale.datetime_skeletons:
+        skeleton = match_skeleton(skeleton, locale.datetime_skeletons)
+    format = locale.datetime_skeletons[skeleton]
+    return format_datetime(datetime, format, tzinfo, locale)
+
+
+TIMEDELTA_UNITS: tuple[tuple[str, int], ...] = (
+    ('year', 3600 * 24 * 365),
+    ('month', 3600 * 24 * 30),
+    ('week', 3600 * 24 * 7),
+    ('day', 3600 * 24),
+    ('hour', 3600),
+    ('minute', 60),
+    ('second', 1),
+)
+
+
+def format_timedelta(
+    delta: datetime.timedelta | int,
+    granularity: Literal['year', 'month', 'week', 'day', 'hour', 'minute', 'second'] = 'second',
+    threshold: float = .85,
+    add_direction: bool = False,
+    format: Literal['narrow', 'short', 'medium', 'long'] = 'long',
+    locale: Locale | str | None = None,
+) -> str:
+    """Return a time delta according to the rules of the given locale.
+
+    >>> from datetime import timedelta
+    >>> format_timedelta(timedelta(weeks=12), locale='en_US')
+    u'3 months'
+    >>> format_timedelta(timedelta(seconds=1), locale='es')
+    u'1 segundo'
+
+    The granularity parameter can be provided to alter the lowest unit
+    presented, which defaults to a second.
+
+    >>> format_timedelta(timedelta(hours=3), granularity='day', locale='en_US')
+    u'1 day'
+
+    The threshold parameter can be used to determine at which value the
+    presentation switches to the next higher unit. A higher threshold factor
+    means the presentation will switch later. For example:
+
+    >>> format_timedelta(timedelta(hours=23), threshold=0.9, locale='en_US')
+    u'1 day'
+    >>> format_timedelta(timedelta(hours=23), threshold=1.1, locale='en_US')
+    u'23 hours'
+
+    In addition directional information can be provided that informs
+    the user if the date is in the past or in the future:
+
+    >>> format_timedelta(timedelta(hours=1), add_direction=True, locale='en')
+    u'in 1 hour'
+    >>> format_timedelta(timedelta(hours=-1), add_direction=True, locale='en')
+    u'1 hour ago'
+
+    The format parameter controls how compact or wide the presentation is:
+
+    >>> format_timedelta(timedelta(hours=3), format='short', locale='en')
+    u'3 hr'
+    >>> format_timedelta(timedelta(hours=3), format='narrow', locale='en')
+    u'3h'
+
+    :param delta: a ``timedelta`` object representing the time difference to
+                  format, or the delta in seconds as an `int` value
+    :param granularity: determines the smallest unit that should be displayed,
+                        the value can be one of "year", "month", "week", "day",
+                        "hour", "minute" or "second"
+    :param threshold: factor that determines at which point the presentation
+                      switches to the next higher unit
+    :param add_direction: if this flag is set to `True` the return value will
+                          include directional information.  For instance a
+                          positive timedelta will include the information about
+                          it being in the future, a negative will be information
+                          about the value being in the past.
+    :param format: the format, can be "narrow", "short" or "long". (
+                   "medium" is deprecated, currently converted to "long" to
+                   maintain compatibility)
+    :param locale: a `Locale` object or a locale identifier. Defaults to the system time locale.
+    """
+    if format not in ('narrow', 'short', 'medium', 'long'):
+        raise TypeError('Format must be one of "narrow", "short" or "long"')
+    if format == 'medium':
+        warnings.warn(
+            '"medium" value for format param of format_timedelta'
+            ' is deprecated. Use "long" instead',
+            category=DeprecationWarning,
+            stacklevel=2,
+        )
+        format = 'long'
+    if isinstance(delta, datetime.timedelta):
+        seconds = int((delta.days * 86400) + delta.seconds)
+    else:
+        seconds = delta
+    locale = Locale.parse(locale or LC_TIME)
+    date_fields = locale._data["date_fields"]
+    unit_patterns = locale._data["unit_patterns"]
+
+    def _iter_patterns(a_unit):
+        if add_direction:
+            # Try to find the length variant version first ("year-narrow")
+            # before falling back to the default.
+            unit_rel_patterns = (date_fields.get(f"{a_unit}-{format}") or date_fields[a_unit])
+            if seconds >= 0:
+                yield unit_rel_patterns['future']
+            else:
+                yield unit_rel_patterns['past']
+        a_unit = f"duration-{a_unit}"
+        unit_pats = unit_patterns.get(a_unit, {})
+        yield unit_pats.get(format)
+        # We do not support `<alias>` tags at all while ingesting CLDR data,
+        # so these aliases specified in `root.xml` are hard-coded here:
+        # <unitLength type="long"><alias source="locale" path="../unitLength[@type='short']"/></unitLength>
+        # <unitLength type="narrow"><alias source="locale" path="../unitLength[@type='short']"/></unitLength>
+        if format in ("long", "narrow"):
+            yield unit_pats.get("short")
+
+    for unit, secs_per_unit in TIMEDELTA_UNITS:
+        value = abs(seconds) / secs_per_unit
+        if value >= threshold or unit == granularity:
+            if unit == granularity and value > 0:
+                value = max(1, value)
+            value = int(round(value))
+            plural_form = locale.plural_form(value)
+            pattern = None
+            for patterns in _iter_patterns(unit):
+                if patterns is not None:
+                    pattern = patterns.get(plural_form) or patterns.get('other')
+                    if pattern:
+                        break
+            # This really should not happen
+            if pattern is None:
+                return ''
+            return pattern.replace('{0}', str(value))
+
+    return ''
+
+
+def _format_fallback_interval(
+    start: _Instant,
+    end: _Instant,
+    skeleton: str | None,
+    tzinfo: datetime.tzinfo | None,
+    locale: Locale,
+) -> str:
+    if skeleton in locale.datetime_skeletons:  # Use the given skeleton
+        format = lambda dt: format_skeleton(skeleton, dt, tzinfo, locale=locale)
+    elif all((isinstance(d, datetime.date) and not isinstance(d, datetime.datetime)) for d in (start, end)):  # Both are just dates
+        format = lambda dt: format_date(dt, locale=locale)
+    elif all((isinstance(d, datetime.time) and not isinstance(d, datetime.date)) for d in (start, end)):  # Both are times
+        format = lambda dt: format_time(dt, tzinfo=tzinfo, locale=locale)
+    else:
+        format = lambda dt: format_datetime(dt, tzinfo=tzinfo, locale=locale)
+
+    formatted_start = format(start)
+    formatted_end = format(end)
+
+    if formatted_start == formatted_end:
+        return format(start)
+
+    return (
+        locale.interval_formats.get(None, "{0}-{1}").
+        replace("{0}", formatted_start).
+        replace("{1}", formatted_end)
+    )
+
+
+def format_interval(
+    start: _Instant,
+    end: _Instant,
+    skeleton: str | None = None,
+    tzinfo: datetime.tzinfo | None = None,
+    fuzzy: bool = True,
+    locale: Locale | str | None = None,
+) -> str:
+    """
+    Format an interval between two instants according to the locale's rules.
+
+    >>> from datetime import date, time
+    >>> format_interval(date(2016, 1, 15), date(2016, 1, 17), "yMd", locale="fi")
+    u'15.\u201317.1.2016'
+
+    >>> format_interval(time(12, 12), time(16, 16), "Hm", locale="en_GB")
+    '12:12\u201316:16'
+
+    >>> format_interval(time(5, 12), time(16, 16), "hm", locale="en_US")
+    '5:12\u202fAM\u2009–\u20094:16\u202fPM'
+
+    >>> format_interval(time(16, 18), time(16, 24), "Hm", locale="it")
+    '16:18\u201316:24'
+
+    If the start instant equals the end instant, the interval is formatted like the instant.
+
+    >>> format_interval(time(16, 18), time(16, 18), "Hm", locale="it")
+    '16:18'
+
+    Unknown skeletons fall back to "default" formatting.
+
+    >>> format_interval(date(2015, 1, 1), date(2017, 1, 1), "wzq", locale="ja")
+    '2015/01/01\uff5e2017/01/01'
+
+    >>> format_interval(time(16, 18), time(16, 24), "xxx", locale="ja")
+    '16:18:00\uff5e16:24:00'
+
+    >>> format_interval(date(2016, 1, 15), date(2016, 1, 17), "xxx", locale="de")
+    '15.01.2016\u2009–\u200917.01.2016'
+
+    :param start: First instant (datetime/date/time)
+    :param end: Second instant (datetime/date/time)
+    :param skeleton: The "skeleton format" to use for formatting.
+    :param tzinfo: tzinfo to use (if none is already attached)
+    :param fuzzy: If the skeleton is not found, allow choosing a skeleton that's
+                  close enough to it.
+    :param locale: A locale object or identifier. Defaults to the system time locale.
+    :return: Formatted interval
+    """
+    locale = Locale.parse(locale or LC_TIME)
+
+    # NB: The quote comments below are from the algorithm description in
+    #     https://www.unicode.org/reports/tr35/tr35-dates.html#intervalFormats
+
+    # > Look for the intervalFormatItem element that matches the "skeleton",
+    # > starting in the current locale and then following the locale fallback
+    # > chain up to, but not including root.
+
+    interval_formats = locale.interval_formats
+
+    if skeleton not in interval_formats or not skeleton:
+        # > If no match was found from the previous step, check what the closest
+        # > match is in the fallback locale chain, as in availableFormats. That
+        # > is, this allows for adjusting the string value field's width,
+        # > including adjusting between "MMM" and "MMMM", and using different
+        # > variants of the same field, such as 'v' and 'z'.
+        if skeleton and fuzzy:
+            skeleton = match_skeleton(skeleton, interval_formats)
+        else:
+            skeleton = None
+        if not skeleton:  # Still no match whatsoever?
+            # > Otherwise, format the start and end datetime using the fallback pattern.
+            return _format_fallback_interval(start, end, skeleton, tzinfo, locale)
+
+    skel_formats = interval_formats[skeleton]
+
+    if start == end:
+        return format_skeleton(skeleton, start, tzinfo, fuzzy=fuzzy, locale=locale)
+
+    start = _ensure_datetime_tzinfo(_get_datetime(start), tzinfo=tzinfo)
+    end = _ensure_datetime_tzinfo(_get_datetime(end), tzinfo=tzinfo)
+
+    start_fmt = DateTimeFormat(start, locale=locale)
+    end_fmt = DateTimeFormat(end, locale=locale)
+
+    # > If a match is found from previous steps, compute the calendar field
+    # > with the greatest difference between start and end datetime. If there
+    # > is no difference among any of the fields in the pattern, format as a
+    # > single date using availableFormats, and return.
+
+    for field in PATTERN_CHAR_ORDER:  # These are in largest-to-smallest order
+        if field in skel_formats and start_fmt.extract(field) != end_fmt.extract(field):
+            # > If there is a match, use the pieces of the corresponding pattern to
+            # > format the start and end datetime, as above.
+            return "".join(
+                parse_pattern(pattern).apply(instant, locale)
+                for pattern, instant
+                in zip(skel_formats[field], (start, end))
+            )
+
+    # > Otherwise, format the start and end datetime using the fallback pattern.
+
+    return _format_fallback_interval(start, end, skeleton, tzinfo, locale)
+
+
+def get_period_id(
+    time: _Instant,
+    tzinfo: datetime.tzinfo | None = None,
+    type: Literal['selection'] | None = None,
+    locale: Locale | str | None = None,
+) -> str:
+    """
+    Get the day period ID for a given time.
+
+    This ID can be used as a key for the period name dictionary.
+
+    >>> from datetime import time
+    >>> get_period_names(locale="de")[get_period_id(time(7, 42), locale="de")]
+    u'Morgen'
+
+    >>> get_period_id(time(0), locale="en_US")
+    u'midnight'
+
+    >>> get_period_id(time(0), type="selection", locale="en_US")
+    u'night1'
+
+    :param time: The time to inspect.
+    :param tzinfo: The timezone for the time. See ``format_time``.
+    :param type: The period type to use. Either "selection" or None.
+                 The selection type is used for selecting among phrases such as
+                 “Your email arrived yesterday evening” or “Your email arrived last night”.
+    :param locale: the `Locale` object, or a locale string. Defaults to the system time locale.
+    :return: period ID. Something is always returned -- even if it's just "am" or "pm".
+    """
+    time = _get_time(time, tzinfo)
+    seconds_past_midnight = int(time.hour * 60 * 60 + time.minute * 60 + time.second)
+    locale = Locale.parse(locale or LC_TIME)
+
+    # The LDML rules state that the rules may not overlap, so iterating in arbitrary
+    # order should be alright, though `at` periods should be preferred.
+    rulesets = locale.day_period_rules.get(type, {}).items()
+
+    for rule_id, rules in rulesets:
+        for rule in rules:
+            if "at" in rule and rule["at"] == seconds_past_midnight:
+                return rule_id
+
+    for rule_id, rules in rulesets:
+        for rule in rules:
+            if "from" in rule and "before" in rule:
+                if rule["from"] < rule["before"]:
+                    if rule["from"] <= seconds_past_midnight < rule["before"]:
+                        return rule_id
+                else:
+                    # e.g. from="21:00" before="06:00"
+                    if rule["from"] <= seconds_past_midnight < 86400 or \
+                            0 <= seconds_past_midnight < rule["before"]:
+                        return rule_id
+
+            start_ok = end_ok = False
+
+            if "from" in rule and seconds_past_midnight >= rule["from"]:
+                start_ok = True
+            if "to" in rule and seconds_past_midnight <= rule["to"]:
+                # This rule type does not exist in the present CLDR data;
+                # excuse the lack of test coverage.
+                end_ok = True
+            if "before" in rule and seconds_past_midnight < rule["before"]:
+                end_ok = True
+            if "after" in rule:
+                raise NotImplementedError("'after' is deprecated as of CLDR 29.")
+
+            if start_ok and end_ok:
+                return rule_id
+
+    if seconds_past_midnight < 43200:
+        return "am"
+    else:
+        return "pm"
+
+
+class ParseError(ValueError):
+    pass
+
+
+def parse_date(
+    string: str,
+    locale: Locale | str | None = None,
+    format: _PredefinedTimeFormat | str = 'medium',
+) -> datetime.date:
+    """Parse a date from a string.
+
+    If an explicit format is provided, it is used to parse the date.
+
+    >>> parse_date('01.04.2004', format='dd.MM.yyyy')
+    datetime.date(2004, 4, 1)
+
+    If no format is given, or if it is one of "full", "long", "medium",
+    or "short", the function first tries to interpret the string as
+    ISO-8601 date format and then uses the date format for the locale
+    as a hint to determine the order in which the date fields appear in
+    the string.
+
+    >>> parse_date('4/1/04', locale='en_US')
+    datetime.date(2004, 4, 1)
+    >>> parse_date('01.04.2004', locale='de_DE')
+    datetime.date(2004, 4, 1)
+    >>> parse_date('2004-04-01', locale='en_US')
+    datetime.date(2004, 4, 1)
+    >>> parse_date('2004-04-01', locale='de_DE')
+    datetime.date(2004, 4, 1)
+    >>> parse_date('01.04.04', locale='de_DE', format='short')
+    datetime.date(2004, 4, 1)
+
+    :param string: the string containing the date
+    :param locale: a `Locale` object or a locale identifier
+    :param locale: a `Locale` object or a locale identifier. Defaults to the system time locale.
+    :param format: the format to use, either an explicit date format,
+                   or one of "full", "long", "medium", or "short"
+                   (see ``get_time_format``)
+    """
+    numbers = re.findall(r'(\d+)', string)
+    if not numbers:
+        raise ParseError("No numbers were found in input")
+
+    use_predefined_format = format in ('full', 'long', 'medium', 'short')
+    # we try ISO-8601 format first, meaning similar to formats
+    # extended YYYY-MM-DD or basic YYYYMMDD
+    iso_alike = re.match(r'^(\d{4})-?([01]\d)-?([0-3]\d)$',
+                         string, flags=re.ASCII)  # allow only ASCII digits
+    if iso_alike and use_predefined_format:
+        try:
+            return datetime.date(*map(int, iso_alike.groups()))
+        except ValueError:
+            pass  # a locale format might fit better, so let's continue
+
+    if use_predefined_format:
+        fmt = get_date_format(format=format, locale=locale)
+    else:
+        fmt = parse_pattern(format)
+    format_str = fmt.pattern.lower()
+    year_idx = format_str.index('y')
+    month_idx = format_str.find('m')
+    if month_idx < 0:
+        month_idx = format_str.index('l')
+    day_idx = format_str.index('d')
+
+    indexes = sorted([(year_idx, 'Y'), (month_idx, 'M'), (day_idx, 'D')])
+    indexes = {item[1]: idx for idx, item in enumerate(indexes)}
+
+    # FIXME: this currently only supports numbers, but should also support month
+    #        names, both in the requested locale, and english
+
+    year = numbers[indexes['Y']]
+    year = 2000 + int(year) if len(year) == 2 else int(year)
+    month = int(numbers[indexes['M']])
+    day = int(numbers[indexes['D']])
+    if month > 12:
+        month, day = day, month
+    return datetime.date(year, month, day)
+
+
+def parse_time(
+    string: str,
+    locale: Locale | str | None = None,
+    format: _PredefinedTimeFormat | str = 'medium',
+) -> datetime.time:
+    """Parse a time from a string.
+
+    This function uses the time format for the locale as a hint to determine
+    the order in which the time fields appear in the string.
+
+    If an explicit format is provided, the function will use it to parse
+    the time instead.
+
+    >>> parse_time('15:30:00', locale='en_US')
+    datetime.time(15, 30)
+    >>> parse_time('15:30:00', format='H:mm:ss')
+    datetime.time(15, 30)
+
+    :param string: the string containing the time
+    :param locale: a `Locale` object or a locale identifier. Defaults to the system time locale.
+    :param format: the format to use, either an explicit time format,
+                   or one of "full", "long", "medium", or "short"
+                   (see ``get_time_format``)
+    :return: the parsed time
+    :rtype: `time`
+    """
+    numbers = re.findall(r'(\d+)', string)
+    if not numbers:
+        raise ParseError("No numbers were found in input")
+
+    # TODO: try ISO format first?
+    if format in ('full', 'long', 'medium', 'short'):
+        fmt = get_time_format(format=format, locale=locale)
+    else:
+        fmt = parse_pattern(format)
+    format_str = fmt.pattern.lower()
+    hour_idx = format_str.find('h')
+    if hour_idx < 0:
+        hour_idx = format_str.index('k')
+    min_idx = format_str.index('m')
+    # format might not contain seconds
+    if (sec_idx := format_str.find('s')) < 0:
+        sec_idx = math.inf
+
+    indexes = sorted([(hour_idx, 'H'), (min_idx, 'M'), (sec_idx, 'S')])
+    indexes = {item[1]: idx for idx, item in enumerate(indexes)}
+
+    # TODO: support time zones
+
+    # Check if the format specifies a period to be used;
+    # if it does, look for 'pm' to figure out an offset.
+    hour_offset = 0
+    if 'a' in format_str and 'pm' in string.lower():
+        hour_offset = 12
+
+    # Parse up to three numbers from the string.
+    minute = second = 0
+    hour = int(numbers[indexes['H']]) + hour_offset
+    if len(numbers) > 1:
+        minute = int(numbers[indexes['M']])
+        if len(numbers) > 2:
+            second = int(numbers[indexes['S']])
+    return datetime.time(hour, minute, second)
+
+
+class DateTimePattern:
+
+    def __init__(self, pattern: str, format: DateTimeFormat):
+        self.pattern = pattern
+        self.format = format
+
+    def __repr__(self) -> str:
+        return f"<{type(self).__name__} {self.pattern!r}>"
+
+    def __str__(self) -> str:
+        pat = self.pattern
+        return pat
+
+    def __mod__(self, other: DateTimeFormat) -> str:
+        if not isinstance(other, DateTimeFormat):
+            return NotImplemented
+        return self.format % other
+
+    def apply(
+        self,
+        datetime: datetime.date | datetime.time,
+        locale: Locale | str | None,
+        reference_date: datetime.date | None = None,
+    ) -> str:
+        return self % DateTimeFormat(datetime, locale, reference_date)
+
+
+class DateTimeFormat:
+
+    def __init__(
+        self,
+        value: datetime.date | datetime.time,
+        locale: Locale | str,
+        reference_date: datetime.date | None = None,
+    ) -> None:
+        assert isinstance(value, (datetime.date, datetime.datetime, datetime.time))
+        if isinstance(value, (datetime.datetime, datetime.time)) and value.tzinfo is None:
+            value = value.replace(tzinfo=UTC)
+        self.value = value
+        self.locale = Locale.parse(locale)
+        self.reference_date = reference_date
+
+    def __getitem__(self, name: str) -> str:
+        char = name[0]
+        num = len(name)
+        if char == 'G':
+            return self.format_era(char, num)
+        elif char in ('y', 'Y', 'u'):
+            return self.format_year(char, num)
+        elif char in ('Q', 'q'):
+            return self.format_quarter(char, num)
+        elif char in ('M', 'L'):
+            return self.format_month(char, num)
+        elif char in ('w', 'W'):
+            return self.format_week(char, num)
+        elif char == 'd':
+            return self.format(self.value.day, num)
+        elif char == 'D':
+            return self.format_day_of_year(num)
+        elif char == 'F':
+            return self.format_day_of_week_in_month()
+        elif char in ('E', 'e', 'c'):
+            return self.format_weekday(char, num)
+        elif char in ('a', 'b', 'B'):
+            return self.format_period(char, num)
+        elif char == 'h':
+            if self.value.hour % 12 == 0:
+                return self.format(12, num)
+            else:
+                return self.format(self.value.hour % 12, num)
+        elif char == 'H':
+            return self.format(self.value.hour, num)
+        elif char == 'K':
+            return self.format(self.value.hour % 12, num)
+        elif char == 'k':
+            if self.value.hour == 0:
+                return self.format(24, num)
+            else:
+                return self.format(self.value.hour, num)
+        elif char == 'm':
+            return self.format(self.value.minute, num)
+        elif char == 's':
+            return self.format(self.value.second, num)
+        elif char == 'S':
+            return self.format_frac_seconds(num)
+        elif char == 'A':
+            return self.format_milliseconds_in_day(num)
+        elif char in ('z', 'Z', 'v', 'V', 'x', 'X', 'O'):
+            return self.format_timezone(char, num)
+        else:
+            raise KeyError(f"Unsupported date/time field {char!r}")
+
+    def extract(self, char: str) -> int:
+        char = str(char)[0]
+        if char == 'y':
+            return self.value.year
+        elif char == 'M':
+            return self.value.month
+        elif char == 'd':
+            return self.value.day
+        elif char == 'H':
+            return self.value.hour
+        elif char == 'h':
+            return self.value.hour % 12 or 12
+        elif char == 'm':
+            return self.value.minute
+        elif char == 'a':
+            return int(self.value.hour >= 12)  # 0 for am, 1 for pm
+        else:
+            raise NotImplementedError(f"Not implemented: extracting {char!r} from {self.value!r}")
+
+    def format_era(self, char: str, num: int) -> str:
+        width = {3: 'abbreviated', 4: 'wide', 5: 'narrow'}[max(3, num)]
+        era = int(self.value.year >= 0)
+        return get_era_names(width, self.locale)[era]
+
+    def format_year(self, char: str, num: int) -> str:
+        value = self.value.year
+        if char.isupper():
+            month = self.value.month
+            if month == 1 and self.value.day < 7 and self.get_week_of_year() >= 52:
+                value -= 1
+            elif month == 12 and self.value.day > 25 and self.get_week_of_year() <= 2:
+                value += 1
+        year = self.format(value, num)
+        if num == 2:
+            year = year[-2:]
+        return year
+
+    def format_quarter(self, char: str, num: int) -> str:
+        quarter = (self.value.month - 1) // 3 + 1
+        if num <= 2:
+            return '%0*d' % (num, quarter)
+        width = {3: 'abbreviated', 4: 'wide', 5: 'narrow'}[num]
+        context = {'Q': 'format', 'q': 'stand-alone'}[char]
+        return get_quarter_names(width, context, self.locale)[quarter]
+
+    def format_month(self, char: str, num: int) -> str:
+        if num <= 2:
+            return '%0*d' % (num, self.value.month)
+        width = {3: 'abbreviated', 4: 'wide', 5: 'narrow'}[num]
+        context = {'M': 'format', 'L': 'stand-alone'}[char]
+        return get_month_names(width, context, self.locale)[self.value.month]
+
+    def format_week(self, char: str, num: int) -> str:
+        if char.islower():  # week of year
+            week = self.get_week_of_year()
+            return self.format(week, num)
+        else:  # week of month
+            week = self.get_week_of_month()
+            return str(week)
+
+    def format_weekday(self, char: str = 'E', num: int = 4) -> str:
+        """
+        Return weekday from parsed datetime according to format pattern.
+
+        >>> from datetime import date
+        >>> format = DateTimeFormat(date(2016, 2, 28), Locale.parse('en_US'))
+        >>> format.format_weekday()
+        u'Sunday'
+
+        'E': Day of week - Use one through three letters for the abbreviated day name, four for the full (wide) name,
+             five for the narrow name, or six for the short name.
+        >>> format.format_weekday('E',2)
+        u'Sun'
+
+        'e': Local day of week. Same as E except adds a numeric value that will depend on the local starting day of the
+             week, using one or two letters. For this example, Monday is the first day of the week.
+        >>> format.format_weekday('e',2)
+        '01'
+
+        'c': Stand-Alone local day of week - Use one letter for the local numeric value (same as 'e'), three for the
+             abbreviated day name, four for the full (wide) name, five for the narrow name, or six for the short name.
+        >>> format.format_weekday('c',1)
+        '1'
+
+        :param char: pattern format character ('e','E','c')
+        :param num: count of format character
+
+        """
+        if num < 3:
+            if char.islower():
+                value = 7 - self.locale.first_week_day + self.value.weekday()
+                return self.format(value % 7 + 1, num)
+            num = 3
+        weekday = self.value.weekday()
+        width = {3: 'abbreviated', 4: 'wide', 5: 'narrow', 6: 'short'}[num]
+        context = "stand-alone" if char == "c" else "format"
+        return get_day_names(width, context, self.locale)[weekday]
+
+    def format_day_of_year(self, num: int) -> str:
+        return self.format(self.get_day_of_year(), num)
+
+    def format_day_of_week_in_month(self) -> str:
+        return str((self.value.day - 1) // 7 + 1)
+
+    def format_period(self, char: str, num: int) -> str:
+        """
+        Return period from parsed datetime according to format pattern.
+
+        >>> from datetime import datetime, time
+        >>> format = DateTimeFormat(time(13, 42), 'fi_FI')
+        >>> format.format_period('a', 1)
+        u'ip.'
+        >>> format.format_period('b', 1)
+        u'iltap.'
+        >>> format.format_period('b', 4)
+        u'iltapäivä'
+        >>> format.format_period('B', 4)
+        u'iltapäivällä'
+        >>> format.format_period('B', 5)
+        u'ip.'
+
+        >>> format = DateTimeFormat(datetime(2022, 4, 28, 6, 27), 'zh_Hant')
+        >>> format.format_period('a', 1)
+        u'上午'
+        >>> format.format_period('B', 1)
+        u'清晨'
+
+        :param char: pattern format character ('a', 'b', 'B')
+        :param num: count of format character
+
+        """
+        widths = [{3: 'abbreviated', 4: 'wide', 5: 'narrow'}[max(3, num)],
+                  'wide', 'narrow', 'abbreviated']
+        if char == 'a':
+            period = 'pm' if self.value.hour >= 12 else 'am'
+            context = 'format'
+        else:
+            period = get_period_id(self.value, locale=self.locale)
+            context = 'format' if char == 'B' else 'stand-alone'
+        for width in widths:
+            period_names = get_period_names(context=context, width=width, locale=self.locale)
+            if period in period_names:
+                return period_names[period]
+        raise ValueError(f"Could not format period {period} in {self.locale}")
+
+    def format_frac_seconds(self, num: int) -> str:
+        """ Return fractional seconds.
+
+        Rounds the time's microseconds to the precision given by the number \
+        of digits passed in.
+        """
+        value = self.value.microsecond / 1000000
+        return self.format(round(value, num) * 10**num, num)
+
+    def format_milliseconds_in_day(self, num):
+        msecs = self.value.microsecond // 1000 + self.value.second * 1000 + \
+            self.value.minute * 60000 + self.value.hour * 3600000
+        return self.format(msecs, num)
+
+    def format_timezone(self, char: str, num: int) -> str:
+        width = {3: 'short', 4: 'long', 5: 'iso8601'}[max(3, num)]
+
+        # It could be that we only receive a time to format, but also have a
+        # reference date which is important to distinguish between timezone
+        # variants (summer/standard time)
+        value = self.value
+        if self.reference_date:
+            value = datetime.datetime.combine(self.reference_date, self.value)
+
+        if char == 'z':
+            return get_timezone_name(value, width, locale=self.locale)
+        elif char == 'Z':
+            if num == 5:
+                return get_timezone_gmt(value, width, locale=self.locale, return_z=True)
+            return get_timezone_gmt(value, width, locale=self.locale)
+        elif char == 'O':
+            if num == 4:
+                return get_timezone_gmt(value, width, locale=self.locale)
+        # TODO: To add support for O:1
+        elif char == 'v':
+            return get_timezone_name(value.tzinfo, width,
+                                     locale=self.locale)
+        elif char == 'V':
+            if num == 1:
+                return get_timezone_name(value.tzinfo, width,
+                                         uncommon=True, locale=self.locale)
+            elif num == 2:
+                return get_timezone_name(value.tzinfo, locale=self.locale, return_zone=True)
+            elif num == 3:
+                return get_timezone_location(value.tzinfo, locale=self.locale, return_city=True)
+            return get_timezone_location(value.tzinfo, locale=self.locale)
+        # Included additional elif condition to add support for 'Xx' in timezone format
+        elif char == 'X':
+            if num == 1:
+                return get_timezone_gmt(value, width='iso8601_short', locale=self.locale,
+                                        return_z=True)
+            elif num in (2, 4):
+                return get_timezone_gmt(value, width='short', locale=self.locale,
+                                        return_z=True)
+            elif num in (3, 5):
+                return get_timezone_gmt(value, width='iso8601', locale=self.locale,
+                                        return_z=True)
+        elif char == 'x':
+            if num == 1:
+                return get_timezone_gmt(value, width='iso8601_short', locale=self.locale)
+            elif num in (2, 4):
+                return get_timezone_gmt(value, width='short', locale=self.locale)
+            elif num in (3, 5):
+                return get_timezone_gmt(value, width='iso8601', locale=self.locale)
+
+    def format(self, value: SupportsInt, length: int) -> str:
+        return '%0*d' % (length, value)
+
+    def get_day_of_year(self, date: datetime.date | None = None) -> int:
+        if date is None:
+            date = self.value
+        return (date - date.replace(month=1, day=1)).days + 1
+
+    def get_week_of_year(self) -> int:
+        """Return the week of the year."""
+        day_of_year = self.get_day_of_year(self.value)
+        week = self.get_week_number(day_of_year)
+        if week == 0:
+            date = datetime.date(self.value.year - 1, 12, 31)
+            week = self.get_week_number(self.get_day_of_year(date),
+                                        date.weekday())
+        elif week > 52:
+            weekday = datetime.date(self.value.year + 1, 1, 1).weekday()
+            if self.get_week_number(1, weekday) == 1 and \
+                    32 - (weekday - self.locale.first_week_day) % 7 <= self.value.day:
+                week = 1
+        return week
+
+    def get_week_of_month(self) -> int:
+        """Return the week of the month."""
+        return self.get_week_number(self.value.day)
+
+    def get_week_number(self, day_of_period: int, day_of_week: int | None = None) -> int:
+        """Return the number of the week of a day within a period. This may be
+        the week number in a year or the week number in a month.
+
+        Usually this will return a value equal to or greater than 1, but if the
+        first week of the period is so short that it actually counts as the last
+        week of the previous period, this function will return 0.
+
+        >>> date = datetime.date(2006, 1, 8)
+        >>> DateTimeFormat(date, 'de_DE').get_week_number(6)
+        1
+        >>> DateTimeFormat(date, 'en_US').get_week_number(6)
+        2
+
+        :param day_of_period: the number of the day in the period (usually
+                              either the day of month or the day of year)
+        :param day_of_week: the week day; if omitted, the week day of the
+                            current date is assumed
+        """
+        if day_of_week is None:
+            day_of_week = self.value.weekday()
+        first_day = (day_of_week - self.locale.first_week_day -
+                     day_of_period + 1) % 7
+        if first_day < 0:
+            first_day += 7
+        week_number = (day_of_period + first_day - 1) // 7
+        if 7 - first_day >= self.locale.min_week_days:
+            week_number += 1
+        return week_number
+
+
+PATTERN_CHARS: dict[str, list[int] | None] = {
+    'G': [1, 2, 3, 4, 5],                                               # era
+    'y': None, 'Y': None, 'u': None,                                    # year
+    'Q': [1, 2, 3, 4, 5], 'q': [1, 2, 3, 4, 5],                         # quarter
+    'M': [1, 2, 3, 4, 5], 'L': [1, 2, 3, 4, 5],                         # month
+    'w': [1, 2], 'W': [1],                                              # week
+    'd': [1, 2], 'D': [1, 2, 3], 'F': [1], 'g': None,                   # day
+    'E': [1, 2, 3, 4, 5, 6], 'e': [1, 2, 3, 4, 5, 6], 'c': [1, 3, 4, 5, 6],  # week day
+    'a': [1, 2, 3, 4, 5], 'b': [1, 2, 3, 4, 5], 'B': [1, 2, 3, 4, 5],   # period
+    'h': [1, 2], 'H': [1, 2], 'K': [1, 2], 'k': [1, 2],                 # hour
+    'm': [1, 2],                                                        # minute
+    's': [1, 2], 'S': None, 'A': None,                                  # second
+    'z': [1, 2, 3, 4], 'Z': [1, 2, 3, 4, 5], 'O': [1, 4], 'v': [1, 4],  # zone
+    'V': [1, 2, 3, 4], 'x': [1, 2, 3, 4, 5], 'X': [1, 2, 3, 4, 5],      # zone
+}
+
+#: The pattern characters declared in the Date Field Symbol Table
+#: (https://www.unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table)
+#: in order of decreasing magnitude.
+PATTERN_CHAR_ORDER = "GyYuUQqMLlwWdDFgEecabBChHKkjJmsSAzZOvVXx"
+
+
+def parse_pattern(pattern: str | DateTimePattern) -> DateTimePattern:
+    """Parse date, time, and datetime format patterns.
+
+    >>> parse_pattern("MMMMd").format
+    u'%(MMMM)s%(d)s'
+    >>> parse_pattern("MMM d, yyyy").format
+    u'%(MMM)s %(d)s, %(yyyy)s'
+
+    Pattern can contain literal strings in single quotes:
+
+    >>> parse_pattern("H:mm' Uhr 'z").format
+    u'%(H)s:%(mm)s Uhr %(z)s'
+
+    An actual single quote can be used by using two adjacent single quote
+    characters:
+
+    >>> parse_pattern("hh' o''clock'").format
+    u"%(hh)s o'clock"
+
+    :param pattern: the formatting pattern to parse
+    """
+    if isinstance(pattern, DateTimePattern):
+        return pattern
+    return _cached_parse_pattern(pattern)
+
+
+@lru_cache(maxsize=1024)
+def _cached_parse_pattern(pattern: str) -> DateTimePattern:
+    result = []
+
+    for tok_type, tok_value in tokenize_pattern(pattern):
+        if tok_type == "chars":
+            result.append(tok_value.replace('%', '%%'))
+        elif tok_type == "field":
+            fieldchar, fieldnum = tok_value
+            limit = PATTERN_CHARS[fieldchar]
+            if limit and fieldnum not in limit:
+                raise ValueError(f"Invalid length for field: {fieldchar * fieldnum!r}")
+            result.append('%%(%s)s' % (fieldchar * fieldnum))
+        else:
+            raise NotImplementedError(f"Unknown token type: {tok_type}")
+    return DateTimePattern(pattern, ''.join(result))
+
+
+def tokenize_pattern(pattern: str) -> list[tuple[str, str | tuple[str, int]]]:
+    """
+    Tokenize date format patterns.
+
+    Returns a list of (token_type, token_value) tuples.
+
+    ``token_type`` may be either "chars" or "field".
+
+    For "chars" tokens, the value is the literal value.
+
+    For "field" tokens, the value is a tuple of (field character, repetition count).
+
+    :param pattern: Pattern string
+    :type pattern: str
+    :rtype: list[tuple]
+    """
+    result = []
+    quotebuf = None
+    charbuf = []
+    fieldchar = ['']
+    fieldnum = [0]
+
+    def append_chars():
+        result.append(('chars', ''.join(charbuf).replace('\0', "'")))
+        del charbuf[:]
+
+    def append_field():
+        result.append(('field', (fieldchar[0], fieldnum[0])))
+        fieldchar[0] = ''
+        fieldnum[0] = 0
+
+    for char in pattern.replace("''", '\0'):
+        if quotebuf is None:
+            if char == "'":  # quote started
+                if fieldchar[0]:
+                    append_field()
+                elif charbuf:
+                    append_chars()
+                quotebuf = []
+            elif char in PATTERN_CHARS:
+                if charbuf:
+                    append_chars()
+                if char == fieldchar[0]:
+                    fieldnum[0] += 1
+                else:
+                    if fieldchar[0]:
+                        append_field()
+                    fieldchar[0] = char
+                    fieldnum[0] = 1
+            else:
+                if fieldchar[0]:
+                    append_field()
+                charbuf.append(char)
+
+        elif quotebuf is not None:
+            if char == "'":  # end of quote
+                charbuf.extend(quotebuf)
+                quotebuf = None
+            else:  # inside quote
+                quotebuf.append(char)
+
+    if fieldchar[0]:
+        append_field()
+    elif charbuf:
+        append_chars()
+
+    return result
+
+
+def untokenize_pattern(tokens: Iterable[tuple[str, str | tuple[str, int]]]) -> str:
+    """
+    Turn a date format pattern token stream back into a string.
+
+    This is the reverse operation of ``tokenize_pattern``.
+
+    :type tokens: Iterable[tuple]
+    :rtype: str
+    """
+    output = []
+    for tok_type, tok_value in tokens:
+        if tok_type == "field":
+            output.append(tok_value[0] * tok_value[1])
+        elif tok_type == "chars":
+            if not any(ch in PATTERN_CHARS for ch in tok_value):  # No need to quote
+                output.append(tok_value)
+            else:
+                output.append("'%s'" % tok_value.replace("'", "''"))
+    return "".join(output)
+
+
+def split_interval_pattern(pattern: str) -> list[str]:
+    """
+    Split an interval-describing datetime pattern into multiple pieces.
+
+    > The pattern is then designed to be broken up into two pieces by determining the first repeating field.
+    - https://www.unicode.org/reports/tr35/tr35-dates.html#intervalFormats
+
+    >>> split_interval_pattern(u'E d.M. \u2013 E d.M.')
+    [u'E d.M. \u2013 ', 'E d.M.']
+    >>> split_interval_pattern("Y 'text' Y 'more text'")
+    ["Y 'text '", "Y 'more text'"]
+    >>> split_interval_pattern(u"E, MMM d \u2013 E")
+    [u'E, MMM d \u2013 ', u'E']
+    >>> split_interval_pattern("MMM d")
+    ['MMM d']
+    >>> split_interval_pattern("y G")
+    ['y G']
+    >>> split_interval_pattern(u"MMM d \u2013 d")
+    [u'MMM d \u2013 ', u'd']
+
+    :param pattern: Interval pattern string
+    :return: list of "subpatterns"
+    """
+
+    seen_fields = set()
+    parts = [[]]
+
+    for tok_type, tok_value in tokenize_pattern(pattern):
+        if tok_type == "field":
+            if tok_value[0] in seen_fields:  # Repeated field
+                parts.append([])
+                seen_fields.clear()
+            seen_fields.add(tok_value[0])
+        parts[-1].append((tok_type, tok_value))
+
+    return [untokenize_pattern(tokens) for tokens in parts]
+
+
+def match_skeleton(skeleton: str, options: Iterable[str], allow_different_fields: bool = False) -> str | None:
+    """
+    Find the closest match for the given datetime skeleton among the options given.
+
+    This uses the rules outlined in the TR35 document.
+
+    >>> match_skeleton('yMMd', ('yMd', 'yMMMd'))
+    'yMd'
+
+    >>> match_skeleton('yMMd', ('jyMMd',), allow_different_fields=True)
+    'jyMMd'
+
+    >>> match_skeleton('yMMd', ('qyMMd',), allow_different_fields=False)
+
+    >>> match_skeleton('hmz', ('hmv',))
+    'hmv'
+
+    :param skeleton: The skeleton to match
+    :type skeleton: str
+    :param options: An iterable of other skeletons to match against
+    :type options: Iterable[str]
+    :param allow_different_fields: Whether to allow a match that uses different fields
+                                   than the skeleton requested.
+    :type allow_different_fields: bool
+
+    :return: The closest skeleton match, or if no match was found, None.
+    :rtype: str|None
+    """
+
+    # TODO: maybe implement pattern expansion?
+
+    # Based on the implementation in
+    # https://github.com/unicode-org/icu/blob/main/icu4j/main/core/src/main/java/com/ibm/icu/text/DateIntervalInfo.java
+
+    # Filter out falsy values and sort for stability; when `interval_formats` is passed in, there may be a None key.
+    options = sorted(option for option in options if option)
+
+    if 'z' in skeleton and not any('z' in option for option in options):
+        skeleton = skeleton.replace('z', 'v')
+    if 'k' in skeleton and not any('k' in option for option in options):
+        skeleton = skeleton.replace('k', 'H')
+    if 'K' in skeleton and not any('K' in option for option in options):
+        skeleton = skeleton.replace('K', 'h')
+    if 'a' in skeleton and not any('a' in option for option in options):
+        skeleton = skeleton.replace('a', '')
+    if 'b' in skeleton and not any('b' in option for option in options):
+        skeleton = skeleton.replace('b', '')
+
+    get_input_field_width = dict(t[1] for t in tokenize_pattern(skeleton) if t[0] == "field").get
+    best_skeleton = None
+    best_distance = None
+    for option in options:
+        get_opt_field_width = dict(t[1] for t in tokenize_pattern(option) if t[0] == "field").get
+        distance = 0
+        for field in PATTERN_CHARS:
+            input_width = get_input_field_width(field, 0)
+            opt_width = get_opt_field_width(field, 0)
+            if input_width == opt_width:
+                continue
+            if opt_width == 0 or input_width == 0:
+                if not allow_different_fields:  # This one is not okay
+                    option = None
+                    break
+                distance += 0x1000  # Magic weight constant for "entirely different fields"
+            elif field == 'M' and ((input_width > 2 and opt_width <= 2) or (input_width <= 2 and opt_width > 2)):
+                distance += 0x100  # Magic weight for "text turns into a number"
+            else:
+                distance += abs(input_width - opt_width)
+
+        if not option:  # We lost the option along the way (probably due to "allow_different_fields")
+            continue
+
+        if not best_skeleton or distance < best_distance:
+            best_skeleton = option
+            best_distance = distance
+
+        if distance == 0:  # Found a perfect match!
+            break
+
+    return best_skeleton

lib/python3.10/site-packages/babel/languages.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+from babel.core import get_global
+
+
+def get_official_languages(territory: str, regional: bool = False, de_facto: bool = False) -> tuple[str, ...]:
+    """
+    Get the official language(s) for the given territory.
+
+    The language codes, if any are known, are returned in order of descending popularity.
+
+    If the `regional` flag is set, then languages which are regionally official are also returned.
+
+    If the `de_facto` flag is set, then languages which are "de facto" official are also returned.
+
+    .. warning:: Note that the data is as up to date as the current version of the CLDR used
+                 by Babel.  If you need scientifically accurate information, use another source!
+
+    :param territory: Territory code
+    :type territory: str
+    :param regional: Whether to return regionally official languages too
+    :type regional: bool
+    :param de_facto: Whether to return de-facto official languages too
+    :type de_facto: bool
+    :return: Tuple of language codes
+    :rtype: tuple[str]
+    """
+
+    territory = str(territory).upper()
+    allowed_stati = {"official"}
+    if regional:
+        allowed_stati.add("official_regional")
+    if de_facto:
+        allowed_stati.add("de_facto_official")
+
+    languages = get_global("territory_languages").get(territory, {})
+    pairs = [
+        (info['population_percent'], language)
+        for language, info in languages.items()
+        if info.get('official_status') in allowed_stati
+    ]
+    pairs.sort(reverse=True)
+    return tuple(lang for _, lang in pairs)
+
+
+def get_territory_language_info(territory: str) -> dict[str, dict[str, float | str | None]]:
+    """
+    Get a dictionary of language information for a territory.
+
+    The dictionary is keyed by language code; the values are dicts with more information.
+
+    The following keys are currently known for the values:
+
+    * `population_percent`: The percentage of the territory's population speaking the
+                            language.
+    * `official_status`: An optional string describing the officiality status of the language.
+                         Known values are "official", "official_regional" and "de_facto_official".
+
+    .. warning:: Note that the data is as up to date as the current version of the CLDR used
+                 by Babel.  If you need scientifically accurate information, use another source!
+
+    .. note:: Note that the format of the dict returned may change between Babel versions.
+
+    See https://www.unicode.org/cldr/charts/latest/supplemental/territory_language_information.html
+
+    :param territory: Territory code
+    :type territory: str
+    :return: Language information dictionary
+    :rtype: dict[str, dict]
+    """
+    territory = str(territory).upper()
+    return get_global("territory_languages").get(territory, {}).copy()

lib/python3.10/site-packages/babel/lists.py

@@ -0,0 +1,132 @@
+"""
+    babel.lists
+    ~~~~~~~~~~~
+
+    Locale dependent formatting of lists.
+
+    The default locale for the functions in this module is determined by the
+    following environment variables, in that order:
+
+     * ``LC_ALL``, and
+     * ``LANG``
+
+    :copyright: (c) 2015-2025 by the Babel Team.
+    :license: BSD, see LICENSE for more details.
+"""
+from __future__ import annotations
+
+import warnings
+from collections.abc import Sequence
+from typing import Literal
+
+from babel.core import Locale, default_locale
+
+_DEFAULT_LOCALE = default_locale()  # TODO(3.0): Remove this.
+
+
+def __getattr__(name):
+    if name == "DEFAULT_LOCALE":
+        warnings.warn(
+            "The babel.lists.DEFAULT_LOCALE constant is deprecated and will be removed.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return _DEFAULT_LOCALE
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+def format_list(
+    lst: Sequence[str],
+    style: Literal['standard', 'standard-short', 'or', 'or-short', 'unit', 'unit-short', 'unit-narrow'] = 'standard',
+    locale: Locale | str | None = None,
+) -> str:
+    """
+    Format the items in `lst` as a list.
+
+    >>> format_list(['apples', 'oranges', 'pears'], locale='en')
+    u'apples, oranges, and pears'
+    >>> format_list(['apples', 'oranges', 'pears'], locale='zh')
+    u'apples\u3001oranges\u548cpears'
+    >>> format_list(['omena', 'peruna', 'aplari'], style='or', locale='fi')
+    u'omena, peruna tai aplari'
+
+    Not all styles are necessarily available in all locales.
+    The function will attempt to fall back to replacement styles according to the rules
+    set forth in the CLDR root XML file, and raise a ValueError if no suitable replacement
+    can be found.
+
+    The following text is verbatim from the Unicode TR35-49 spec [1].
+
+    * standard:
+      A typical 'and' list for arbitrary placeholders.
+      eg. "January, February, and March"
+    * standard-short:
+      A short version of an 'and' list, suitable for use with short or abbreviated placeholder values.
+      eg. "Jan., Feb., and Mar."
+    * or:
+      A typical 'or' list for arbitrary placeholders.
+      eg. "January, February, or March"
+    * or-short:
+      A short version of an 'or' list.
+      eg. "Jan., Feb., or Mar."
+    * unit:
+      A list suitable for wide units.
+      eg. "3 feet, 7 inches"
+    * unit-short:
+      A list suitable for short units
+      eg. "3 ft, 7 in"
+    * unit-narrow:
+      A list suitable for narrow units, where space on the screen is very limited.
+      eg. "3′ 7″"
+
+    [1]: https://www.unicode.org/reports/tr35/tr35-49/tr35-general.html#ListPatterns
+
+    :param lst: a sequence of items to format in to a list
+    :param style: the style to format the list with. See above for description.
+    :param locale: the locale. Defaults to the system locale.
+    """
+    locale = Locale.parse(locale or _DEFAULT_LOCALE)
+    if not lst:
+        return ''
+    if len(lst) == 1:
+        return lst[0]
+
+    patterns = _resolve_list_style(locale, style)
+
+    if len(lst) == 2 and '2' in patterns:
+        return patterns['2'].format(*lst)
+
+    result = patterns['start'].format(lst[0], lst[1])
+    for elem in lst[2:-1]:
+        result = patterns['middle'].format(result, elem)
+    result = patterns['end'].format(result, lst[-1])
+
+    return result
+
+
+# Based on CLDR 45's root.xml file's `<alias>`es.
+# The root file defines both `standard` and `or`,
+# so they're always available.
+# TODO: It would likely be better to use the
+#       babel.localedata.Alias mechanism for this,
+#       but I'm not quite sure how it's supposed to
+#       work with inheritance and data in the root.
+_style_fallbacks = {
+    "or-narrow": ["or-short", "or"],
+    "or-short": ["or"],
+    "standard-narrow": ["standard-short", "standard"],
+    "standard-short": ["standard"],
+    "unit": ["unit-short", "standard"],
+    "unit-narrow": ["unit-short", "unit", "standard"],
+    "unit-short": ["standard"],
+}
+
+
+def _resolve_list_style(locale: Locale, style: str):
+    for style in (style, *(_style_fallbacks.get(style, []))):  # noqa: B020
+        if style in locale.list_patterns:
+            return locale.list_patterns[style]
+    raise ValueError(
+        f"Locale {locale} does not support list formatting style {style!r} "
+        f"(supported are {sorted(locale.list_patterns)})",
+    )

lib/python3.10/site-packages/babel/localedata.py

@@ -0,0 +1,278 @@
+"""
+    babel.localedata
+    ~~~~~~~~~~~~~~~~
+
+    Low-level locale data access.
+
+    :note: The `Locale` class, which uses this module under the hood, provides a
+           more convenient interface for accessing the locale data.
+
+    :copyright: (c) 2013-2025 by the Babel Team.
+    :license: BSD, see LICENSE for more details.
+"""
+
+from __future__ import annotations
+
+import os
+import pickle
+import re
+import sys
+import threading
+from collections import abc
+from collections.abc import Iterator, Mapping, MutableMapping
+from functools import lru_cache
+from itertools import chain
+from typing import Any
+
+_cache: dict[str, Any] = {}
+_cache_lock = threading.RLock()
+_dirname = os.path.join(os.path.dirname(__file__), 'locale-data')
+_windows_reserved_name_re = re.compile("^(con|prn|aux|nul|com[0-9]|lpt[0-9])$", re.I)
+
+
+def normalize_locale(name: str) -> str | None:
+    """Normalize a locale ID by stripping spaces and apply proper casing.
+
+    Returns the normalized locale ID string or `None` if the ID is not
+    recognized.
+    """
+    if not name or not isinstance(name, str):
+        return None
+    name = name.strip().lower()
+    for locale_id in chain.from_iterable([_cache, locale_identifiers()]):
+        if name == locale_id.lower():
+            return locale_id
+
+
+def resolve_locale_filename(name: os.PathLike[str] | str) -> str:
+    """
+    Resolve a locale identifier to a `.dat` path on disk.
+    """
+
+    # Clean up any possible relative paths.
+    name = os.path.basename(name)
+
+    # Ensure we're not left with one of the Windows reserved names.
+    if sys.platform == "win32" and _windows_reserved_name_re.match(os.path.splitext(name)[0]):
+        raise ValueError(f"Name {name} is invalid on Windows")
+
+    # Build the path.
+    return os.path.join(_dirname, f"{name}.dat")
+
+
+def exists(name: str) -> bool:
+    """Check whether locale data is available for the given locale.
+
+    Returns `True` if it exists, `False` otherwise.
+
+    :param name: the locale identifier string
+    """
+    if not name or not isinstance(name, str):
+        return False
+    if name in _cache:
+        return True
+    file_found = os.path.exists(resolve_locale_filename(name))
+    return True if file_found else bool(normalize_locale(name))
+
+
+@lru_cache(maxsize=None)
+def locale_identifiers() -> list[str]:
+    """Return a list of all locale identifiers for which locale data is
+    available.
+
+    This data is cached after the first invocation.
+    You can clear the cache by calling `locale_identifiers.cache_clear()`.
+
+    .. versionadded:: 0.8.1
+
+    :return: a list of locale identifiers (strings)
+    """
+    return [
+        stem
+        for stem, extension in
+        (os.path.splitext(filename) for filename in os.listdir(_dirname))
+        if extension == '.dat' and stem != 'root'
+    ]
+
+
+def _is_non_likely_script(name: str) -> bool:
+    """Return whether the locale is of the form ``lang_Script``,
+    and the script is not the likely script for the language.
+
+    This implements the behavior of the ``nonlikelyScript`` value of the
+    ``localRules`` attribute for parent locales added in CLDR 45.
+    """
+    from babel.core import get_global, parse_locale
+
+    try:
+        lang, territory, script, variant, *rest = parse_locale(name)
+    except ValueError:
+        return False
+
+    if lang and script and not territory and not variant and not rest:
+        likely_subtag = get_global('likely_subtags').get(lang)
+        _, _, likely_script, *_ = parse_locale(likely_subtag)
+        return script != likely_script
+    return False
+
+
+def load(name: os.PathLike[str] | str, merge_inherited: bool = True) -> dict[str, Any]:
+    """Load the locale data for the given locale.
+
+    The locale data is a dictionary that contains much of the data defined by
+    the Common Locale Data Repository (CLDR). This data is stored as a
+    collection of pickle files inside the ``babel`` package.
+
+    >>> d = load('en_US')
+    >>> d['languages']['sv']
+    u'Swedish'
+
+    Note that the results are cached, and subsequent requests for the same
+    locale return the same dictionary:
+
+    >>> d1 = load('en_US')
+    >>> d2 = load('en_US')
+    >>> d1 is d2
+    True
+
+    :param name: the locale identifier string (or "root")
+    :param merge_inherited: whether the inherited data should be merged into
+                            the data of the requested locale
+    :raise `IOError`: if no locale data file is found for the given locale
+                      identifier, or one of the locales it inherits from
+    """
+    name = os.path.basename(name)
+    _cache_lock.acquire()
+    try:
+        data = _cache.get(name)
+        if not data:
+            # Load inherited data
+            if name == 'root' or not merge_inherited:
+                data = {}
+            else:
+                from babel.core import get_global
+                parent = get_global('parent_exceptions').get(name)
+                if not parent:
+                    if _is_non_likely_script(name):
+                        parent = 'root'
+                    else:
+                        parts = name.split('_')
+                        parent = "root" if len(parts) == 1 else "_".join(parts[:-1])
+                data = load(parent).copy()
+            filename = resolve_locale_filename(name)
+            with open(filename, 'rb') as fileobj:
+                if name != 'root' and merge_inherited:
+                    merge(data, pickle.load(fileobj))
+                else:
+                    data = pickle.load(fileobj)
+            _cache[name] = data
+        return data
+    finally:
+        _cache_lock.release()
+
+
+def merge(dict1: MutableMapping[Any, Any], dict2: Mapping[Any, Any]) -> None:
+    """Merge the data from `dict2` into the `dict1` dictionary, making copies
+    of nested dictionaries.
+
+    >>> d = {1: 'foo', 3: 'baz'}
+    >>> merge(d, {1: 'Foo', 2: 'Bar'})
+    >>> sorted(d.items())
+    [(1, 'Foo'), (2, 'Bar'), (3, 'baz')]
+
+    :param dict1: the dictionary to merge into
+    :param dict2: the dictionary containing the data that should be merged
+    """
+    for key, val2 in dict2.items():
+        if val2 is not None:
+            val1 = dict1.get(key)
+            if isinstance(val2, dict):
+                if val1 is None:
+                    val1 = {}
+                if isinstance(val1, Alias):
+                    val1 = (val1, val2)
+                elif isinstance(val1, tuple):
+                    alias, others = val1
+                    others = others.copy()
+                    merge(others, val2)
+                    val1 = (alias, others)
+                else:
+                    val1 = val1.copy()
+                    merge(val1, val2)
+            else:
+                val1 = val2
+            dict1[key] = val1
+
+
+class Alias:
+    """Representation of an alias in the locale data.
+
+    An alias is a value that refers to some other part of the locale data,
+    as specified by the `keys`.
+    """
+
+    def __init__(self, keys: tuple[str, ...]) -> None:
+        self.keys = tuple(keys)
+
+    def __repr__(self) -> str:
+        return f"<{type(self).__name__} {self.keys!r}>"
+
+    def resolve(self, data: Mapping[str | int | None, Any]) -> Mapping[str | int | None, Any]:
+        """Resolve the alias based on the given data.
+
+        This is done recursively, so if one alias resolves to a second alias,
+        that second alias will also be resolved.
+
+        :param data: the locale data
+        :type data: `dict`
+        """
+        base = data
+        for key in self.keys:
+            data = data[key]
+        if isinstance(data, Alias):
+            data = data.resolve(base)
+        elif isinstance(data, tuple):
+            alias, others = data
+            data = alias.resolve(base)
+        return data
+
+
+class LocaleDataDict(abc.MutableMapping):
+    """Dictionary wrapper that automatically resolves aliases to the actual
+    values.
+    """
+
+    def __init__(self, data: MutableMapping[str | int | None, Any], base: Mapping[str | int | None, Any] | None = None):
+        self._data = data
+        if base is None:
+            base = data
+        self.base = base
+
+    def __len__(self) -> int:
+        return len(self._data)
+
+    def __iter__(self) -> Iterator[str | int | None]:
+        return iter(self._data)
+
+    def __getitem__(self, key: str | int | None) -> Any:
+        orig = val = self._data[key]
+        if isinstance(val, Alias):  # resolve an alias
+            val = val.resolve(self.base)
+        if isinstance(val, tuple):  # Merge a partial dict with an alias
+            alias, others = val
+            val = alias.resolve(self.base).copy()
+            merge(val, others)
+        if isinstance(val, dict):  # Return a nested alias-resolving dict
+            val = LocaleDataDict(val, base=self.base)
+        if val is not orig:
+            self._data[key] = val
+        return val
+
+    def __setitem__(self, key: str | int | None, value: Any) -> None:
+        self._data[key] = value
+
+    def __delitem__(self, key: str | int | None) -> None:
+        del self._data[key]
+
+    def copy(self) -> LocaleDataDict:
+        return LocaleDataDict(self._data.copy(), base=self.base)

lib/python3.10/site-packages/babel/numbers.py

@@ -0,0 +1,1590 @@
+"""
+    babel.numbers
+    ~~~~~~~~~~~~~
+
+    Locale dependent formatting and parsing of numeric data.
+
+    The default locale for the functions in this module is determined by the
+    following environment variables, in that order:
+
+     * ``LC_MONETARY`` for currency related functions,
+     * ``LC_NUMERIC``, and
+     * ``LC_ALL``, and
+     * ``LANG``
+
+    :copyright: (c) 2013-2025 by the Babel Team.
+    :license: BSD, see LICENSE for more details.
+"""
+# TODO:
+#  Padding and rounding increments in pattern:
+#  - https://www.unicode.org/reports/tr35/ (Appendix G.6)
+from __future__ import annotations
+
+import datetime
+import decimal
+import re
+import warnings
+from typing import Any, Literal, cast, overload
+
+from babel.core import Locale, default_locale, get_global
+from babel.localedata import LocaleDataDict
+
+LC_MONETARY = default_locale(('LC_MONETARY', 'LC_NUMERIC'))
+LC_NUMERIC = default_locale('LC_NUMERIC')
+
+
+class UnknownCurrencyError(Exception):
+    """Exception thrown when a currency is requested for which no data is available.
+    """
+
+    def __init__(self, identifier: str) -> None:
+        """Create the exception.
+        :param identifier: the identifier string of the unsupported currency
+        """
+        Exception.__init__(self, f"Unknown currency {identifier!r}.")
+
+        #: The identifier of the locale that could not be found.
+        self.identifier = identifier
+
+
+def list_currencies(locale: Locale | str | None = None) -> set[str]:
+    """ Return a `set` of normalized currency codes.
+
+    .. versionadded:: 2.5.0
+
+    :param locale: filters returned currency codes by the provided locale.
+                   Expected to be a locale instance or code. If no locale is
+                   provided, returns the list of all currencies from all
+                   locales.
+    """
+    # Get locale-scoped currencies.
+    if locale:
+        return set(Locale.parse(locale).currencies)
+    return set(get_global('all_currencies'))
+
+
+def validate_currency(currency: str, locale: Locale | str | None = None) -> None:
+    """ Check the currency code is recognized by Babel.
+
+    Accepts a ``locale`` parameter for fined-grained validation, working as
+    the one defined above in ``list_currencies()`` method.
+
+    Raises a `UnknownCurrencyError` exception if the currency is unknown to Babel.
+    """
+    if currency not in list_currencies(locale):
+        raise UnknownCurrencyError(currency)
+
+
+def is_currency(currency: str, locale: Locale | str | None = None) -> bool:
+    """ Returns `True` only if a currency is recognized by Babel.
+
+    This method always return a Boolean and never raise.
+    """
+    if not currency or not isinstance(currency, str):
+        return False
+    try:
+        validate_currency(currency, locale)
+    except UnknownCurrencyError:
+        return False
+    return True
+
+
+def normalize_currency(currency: str, locale: Locale | str | None = None) -> str | None:
+    """Returns the normalized identifier of any currency code.
+
+    Accepts a ``locale`` parameter for fined-grained validation, working as
+    the one defined above in ``list_currencies()`` method.
+
+    Returns None if the currency is unknown to Babel.
+    """
+    if isinstance(currency, str):
+        currency = currency.upper()
+    if not is_currency(currency, locale):
+        return None
+    return currency
+
+
+def get_currency_name(
+    currency: str,
+    count: float | decimal.Decimal | None = None,
+    locale: Locale | str | None = None,
+) -> str:
+    """Return the name used by the locale for the specified currency.
+
+    >>> get_currency_name('USD', locale='en_US')
+    u'US Dollar'
+
+    .. versionadded:: 0.9.4
+
+    :param currency: the currency code.
+    :param count: the optional count.  If provided the currency name
+                  will be pluralized to that number if possible.
+    :param locale: the `Locale` object or locale identifier.
+                   Defaults to the system currency locale or numeric locale.
+    """
+    loc = Locale.parse(locale or LC_MONETARY)
+    if count is not None:
+        try:
+            plural_form = loc.plural_form(count)
+        except (OverflowError, ValueError):
+            plural_form = 'other'
+        plural_names = loc._data['currency_names_plural']
+        if currency in plural_names:
+            currency_plural_names = plural_names[currency]
+            if plural_form in currency_plural_names:
+                return currency_plural_names[plural_form]
+            if 'other' in currency_plural_names:
+                return currency_plural_names['other']
+    return loc.currencies.get(currency, currency)
+
+
+def get_currency_symbol(currency: str, locale: Locale | str | None = None) -> str:
+    """Return the symbol used by the locale for the specified currency.
+
+    >>> get_currency_symbol('USD', locale='en_US')
+    u'$'
+
+    :param currency: the currency code.
+    :param locale: the `Locale` object or locale identifier.
+                   Defaults to the system currency locale or numeric locale.
+    """
+    return Locale.parse(locale or LC_MONETARY).currency_symbols.get(currency, currency)
+
+
+def get_currency_precision(currency: str) -> int:
+    """Return currency's precision.
+
+    Precision is the number of decimals found after the decimal point in the
+    currency's format pattern.
+
+    .. versionadded:: 2.5.0
+
+    :param currency: the currency code.
+    """
+    precisions = get_global('currency_fractions')
+    return precisions.get(currency, precisions['DEFAULT'])[0]
+
+
+def get_currency_unit_pattern(
+    currency: str,  # TODO: unused?!
+    count: float | decimal.Decimal | None = None,
+    locale: Locale | str | None = None,
+) -> str:
+    """
+    Return the unit pattern used for long display of a currency value
+    for a given locale.
+    This is a string containing ``{0}`` where the numeric part
+    should be substituted and ``{1}`` where the currency long display
+    name should be substituted.
+
+    >>> get_currency_unit_pattern('USD', locale='en_US', count=10)
+    u'{0} {1}'
+
+    .. versionadded:: 2.7.0
+
+    :param currency: the currency code.
+    :param count: the optional count.  If provided the unit
+                  pattern for that number will be returned.
+    :param locale: the `Locale` object or locale identifier.
+                   Defaults to the system currency locale or numeric locale.
+    """
+    loc = Locale.parse(locale or LC_MONETARY)
+    if count is not None:
+        plural_form = loc.plural_form(count)
+        try:
+            return loc._data['currency_unit_patterns'][plural_form]
+        except LookupError:
+            # Fall back to 'other'
+            pass
+
+    return loc._data['currency_unit_patterns']['other']
+
+
+@overload
+def get_territory_currencies(
+    territory: str,
+    start_date: datetime.date | None = ...,
+    end_date: datetime.date | None = ...,
+    tender: bool = ...,
+    non_tender: bool = ...,
+    include_details: Literal[False] = ...,
+) -> list[str]:
+    ...  # pragma: no cover
+
+
+@overload
+def get_territory_currencies(
+    territory: str,
+    start_date: datetime.date | None = ...,
+    end_date: datetime.date | None = ...,
+    tender: bool = ...,
+    non_tender: bool = ...,
+    include_details: Literal[True] = ...,
+) -> list[dict[str, Any]]:
+    ...  # pragma: no cover
+
+
+def get_territory_currencies(
+    territory: str,
+    start_date: datetime.date | None = None,
+    end_date: datetime.date | None = None,
+    tender: bool = True,
+    non_tender: bool = False,
+    include_details: bool = False,
+) -> list[str] | list[dict[str, Any]]:
+    """Returns the list of currencies for the given territory that are valid for
+    the given date range.  In addition to that the currency database
+    distinguishes between tender and non-tender currencies.  By default only
+    tender currencies are returned.
+
+    The return value is a list of all currencies roughly ordered by the time
+    of when the currency became active.  The longer the currency is being in
+    use the more to the left of the list it will be.
+
+    The start date defaults to today.  If no end date is given it will be the
+    same as the start date.  Otherwise a range can be defined.  For instance
+    this can be used to find the currencies in use in Austria between 1995 and
+    2011:
+
+    >>> from datetime import date
+    >>> get_territory_currencies('AT', date(1995, 1, 1), date(2011, 1, 1))
+    ['ATS', 'EUR']
+
+    Likewise it's also possible to find all the currencies in use on a
+    single date:
+
+    >>> get_territory_currencies('AT', date(1995, 1, 1))
+    ['ATS']
+    >>> get_territory_currencies('AT', date(2011, 1, 1))
+    ['EUR']
+
+    By default the return value only includes tender currencies.  This
+    however can be changed:
+
+    >>> get_territory_currencies('US')
+    ['USD']
+    >>> get_territory_currencies('US', tender=False, non_tender=True,
+    ...                          start_date=date(2014, 1, 1))
+    ['USN', 'USS']
+
+    .. versionadded:: 2.0
+
+    :param territory: the name of the territory to find the currency for.
+    :param start_date: the start date.  If not given today is assumed.
+    :param end_date: the end date.  If not given the start date is assumed.
+    :param tender: controls whether tender currencies should be included.
+    :param non_tender: controls whether non-tender currencies should be
+                       included.
+    :param include_details: if set to `True`, instead of returning currency
+                            codes the return value will be dictionaries
+                            with detail information.  In that case each
+                            dictionary will have the keys ``'currency'``,
+                            ``'from'``, ``'to'``, and ``'tender'``.
+    """
+    currencies = get_global('territory_currencies')
+    if start_date is None:
+        start_date = datetime.date.today()
+    elif isinstance(start_date, datetime.datetime):
+        start_date = start_date.date()
+    if end_date is None:
+        end_date = start_date
+    elif isinstance(end_date, datetime.datetime):
+        end_date = end_date.date()
+
+    curs = currencies.get(territory.upper(), ())
+    # TODO: validate that the territory exists
+
+    def _is_active(start, end):
+        return (start is None or start <= end_date) and \
+               (end is None or end >= start_date)
+
+    result = []
+    for currency_code, start, end, is_tender in curs:
+        if start:
+            start = datetime.date(*start)
+        if end:
+            end = datetime.date(*end)
+        if ((is_tender and tender) or
+                (not is_tender and non_tender)) and _is_active(start, end):
+            if include_details:
+                result.append({
+                    'currency': currency_code,
+                    'from': start,
+                    'to': end,
+                    'tender': is_tender,
+                })
+            else:
+                result.append(currency_code)
+
+    return result
+
+
+def _get_numbering_system(locale: Locale, numbering_system: Literal["default"] | str = "latn") -> str:
+    if numbering_system == "default":
+        return locale.default_numbering_system
+    else:
+        return numbering_system
+
+
+def _get_number_symbols(
+    locale: Locale,
+    *,
+    numbering_system: Literal["default"] | str = "latn",
+) -> LocaleDataDict:
+    numbering_system = _get_numbering_system(locale, numbering_system)
+    try:
+        return locale.number_symbols[numbering_system]
+    except KeyError as error:
+        raise UnsupportedNumberingSystemError(f"Unknown numbering system {numbering_system} for Locale {locale}.") from error
+
+
+class UnsupportedNumberingSystemError(Exception):
+    """Exception thrown when an unsupported numbering system is requested for the given Locale."""
+    pass
+
+
+def get_decimal_symbol(
+    locale: Locale | str | None = None,
+    *,
+    numbering_system: Literal["default"] | str = "latn",
+) -> str:
+    """Return the symbol used by the locale to separate decimal fractions.
+
+    >>> get_decimal_symbol('en_US')
+    u'.'
+    >>> get_decimal_symbol('ar_EG', numbering_system='default')
+    u'٫'
+    >>> get_decimal_symbol('ar_EG', numbering_system='latn')
+    u'.'
+
+    :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
+    :param numbering_system: The numbering system used for fetching the symbol. Defaults to "latn".
+                             The special value "default" will use the default numbering system of the locale.
+    :raise `UnsupportedNumberingSystemError`: If the numbering system is not supported by the locale.
+    """
+    locale = Locale.parse(locale or LC_NUMERIC)
+    return _get_number_symbols(locale, numbering_system=numbering_system).get('decimal', '.')
+
+
+def get_plus_sign_symbol(
+    locale: Locale | str | None = None,
+    *,
+    numbering_system: Literal["default"] | str = "latn",
+) -> str:
+    """Return the plus sign symbol used by the current locale.
+
+    >>> get_plus_sign_symbol('en_US')
+    u'+'
+    >>> get_plus_sign_symbol('ar_EG', numbering_system='default')
+    u'\u061c+'
+    >>> get_plus_sign_symbol('ar_EG', numbering_system='latn')
+    u'\u200e+'
+
+    :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
+    :param numbering_system: The numbering system used for fetching the symbol. Defaults to "latn".
+                             The special value "default" will use the default numbering system of the locale.
+    :raise `UnsupportedNumberingSystemError`: if the numbering system is not supported by the locale.
+    """
+    locale = Locale.parse(locale or LC_NUMERIC)
+    return _get_number_symbols(locale, numbering_system=numbering_system).get('plusSign', '+')
+
+
+def get_minus_sign_symbol(
+    locale: Locale | str | None = None,
+    *,
+    numbering_system: Literal["default"] | str = "latn",
+) -> str:
+    """Return the plus sign symbol used by the current locale.
+
+    >>> get_minus_sign_symbol('en_US')
+    u'-'
+    >>> get_minus_sign_symbol('ar_EG', numbering_system='default')
+    u'\u061c-'
+    >>> get_minus_sign_symbol('ar_EG', numbering_system='latn')
+    u'\u200e-'
+
+    :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
+    :param numbering_system: The numbering system used for fetching the symbol. Defaults to "latn".
+                             The special value "default" will use the default numbering system of the locale.
+    :raise `UnsupportedNumberingSystemError`: if the numbering system is not supported by the locale.
+    """
+    locale = Locale.parse(locale or LC_NUMERIC)
+    return _get_number_symbols(locale, numbering_system=numbering_system).get('minusSign', '-')
+
+
+def get_exponential_symbol(
+    locale: Locale | str | None = None,
+    *,
+    numbering_system: Literal["default"] | str = "latn",
+) -> str:
+    """Return the symbol used by the locale to separate mantissa and exponent.
+
+    >>> get_exponential_symbol('en_US')
+    u'E'
+    >>> get_exponential_symbol('ar_EG', numbering_system='default')
+    u'أس'
+    >>> get_exponential_symbol('ar_EG', numbering_system='latn')
+    u'E'
+
+    :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
+    :param numbering_system: The numbering system used for fetching the symbol. Defaults to "latn".
+                             The special value "default" will use the default numbering system of the locale.
+    :raise `UnsupportedNumberingSystemError`: if the numbering system is not supported by the locale.
+    """
+    locale = Locale.parse(locale or LC_NUMERIC)
+    return _get_number_symbols(locale, numbering_system=numbering_system).get('exponential', 'E')
+
+
+def get_group_symbol(
+    locale: Locale | str | None = None,
+    *,
+    numbering_system: Literal["default"] | str = "latn",
+) -> str:
+    """Return the symbol used by the locale to separate groups of thousands.
+
+    >>> get_group_symbol('en_US')
+    u','
+    >>> get_group_symbol('ar_EG', numbering_system='default')
+    u'٬'
+    >>> get_group_symbol('ar_EG', numbering_system='latn')
+    u','
+
+    :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
+    :param numbering_system: The numbering system used for fetching the symbol. Defaults to "latn".
+                             The special value "default" will use the default numbering system of the locale.
+    :raise `UnsupportedNumberingSystemError`: if the numbering system is not supported by the locale.
+    """
+    locale = Locale.parse(locale or LC_NUMERIC)
+    return _get_number_symbols(locale, numbering_system=numbering_system).get('group', ',')
+
+
+def get_infinity_symbol(
+    locale: Locale | str | None = None,
+    *,
+    numbering_system: Literal["default"] | str = "latn",
+) -> str:
+    """Return the symbol used by the locale to represent infinity.
+
+    >>> get_infinity_symbol('en_US')
+    u'∞'
+    >>> get_infinity_symbol('ar_EG', numbering_system='default')
+    u'∞'
+    >>> get_infinity_symbol('ar_EG', numbering_system='latn')
+    u'∞'
+
+    :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
+    :param numbering_system: The numbering system used for fetching the symbol. Defaults to "latn".
+                             The special value "default" will use the default numbering system of the locale.
+    :raise `UnsupportedNumberingSystemError`: if the numbering system is not supported by the locale.
+    """
+    locale = Locale.parse(locale or LC_NUMERIC)
+    return _get_number_symbols(locale, numbering_system=numbering_system).get('infinity', '∞')
+
+
+def format_number(number: float | decimal.Decimal | str, locale: Locale | str | None = None) -> str:
+    """Return the given number formatted for a specific locale.
+
+    >>> format_number(1099, locale='en_US')  # doctest: +SKIP
+    u'1,099'
+    >>> format_number(1099, locale='de_DE')  # doctest: +SKIP
+    u'1.099'
+
+    .. deprecated:: 2.6.0
+
+       Use babel.numbers.format_decimal() instead.
+
+    :param number: the number to format
+    :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
+
+
+    """
+    warnings.warn('Use babel.numbers.format_decimal() instead.', DeprecationWarning, stacklevel=2)
+    return format_decimal(number, locale=locale)
+
+
+def get_decimal_precision(number: decimal.Decimal) -> int:
+    """Return maximum precision of a decimal instance's fractional part.
+
+    Precision is extracted from the fractional part only.
+    """
+    # Copied from: https://github.com/mahmoud/boltons/pull/59
+    assert isinstance(number, decimal.Decimal)
+    decimal_tuple = number.normalize().as_tuple()
+    # Note: DecimalTuple.exponent can be 'n' (qNaN), 'N' (sNaN), or 'F' (Infinity)
+    if not isinstance(decimal_tuple.exponent, int) or decimal_tuple.exponent >= 0:
+        return 0
+    return abs(decimal_tuple.exponent)
+
+
+def get_decimal_quantum(precision: int | decimal.Decimal) -> decimal.Decimal:
+    """Return minimal quantum of a number, as defined by precision."""
+    assert isinstance(precision, (int, decimal.Decimal))
+    return decimal.Decimal(10) ** (-precision)
+
+
+def format_decimal(
+    number: float | decimal.Decimal | str,
+    format: str | NumberPattern | None = None,
+    locale: Locale | str | None = None,
+    decimal_quantization: bool = True,
+    group_separator: bool = True,
+    *,
+    numbering_system: Literal["default"] | str = "latn",
+) -> str:
+    """Return the given decimal number formatted for a specific locale.
+
+    >>> format_decimal(1.2345, locale='en_US')
+    u'1.234'
+    >>> format_decimal(1.2346, locale='en_US')
+    u'1.235'
+    >>> format_decimal(-1.2346, locale='en_US')
+    u'-1.235'
+    >>> format_decimal(1.2345, locale='sv_SE')
+    u'1,234'
+    >>> format_decimal(1.2345, locale='de')
+    u'1,234'
+    >>> format_decimal(1.2345, locale='ar_EG', numbering_system='default')
+    u'1٫234'
+    >>> format_decimal(1.2345, locale='ar_EG', numbering_system='latn')
+    u'1.234'
+
+    The appropriate thousands grouping and the decimal separator are used for
+    each locale:
+
+    >>> format_decimal(12345.5, locale='en_US')
+    u'12,345.5'
+
+    By default the locale is allowed to truncate and round a high-precision
+    number by forcing its format pattern onto the decimal part. You can bypass
+    this behavior with the `decimal_quantization` parameter:
+
+    >>> format_decimal(1.2346, locale='en_US')
+    u'1.235'
+    >>> format_decimal(1.2346, locale='en_US', decimal_quantization=False)
+    u'1.2346'
+    >>> format_decimal(12345.67, locale='fr_CA', group_separator=False)
+    u'12345,67'
+    >>> format_decimal(12345.67, locale='en_US', group_separator=True)
+    u'12,345.67'
+
+    :param number: the number to format
+    :param format:
+    :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
+    :param decimal_quantization: Truncate and round high-precision numbers to
+                                 the format pattern. Defaults to `True`.
+    :param group_separator: Boolean to switch group separator on/off in a locale's
+                            number format.
+    :param numbering_system: The numbering system used for formatting number symbols. Defaults to "latn".
+                             The special value "default" will use the default numbering system of the locale.
+    :raise `UnsupportedNumberingSystemError`: If the numbering system is not supported by the locale.
+    """
+    locale = Locale.parse(locale or LC_NUMERIC)
+    if format is None:
+        format = locale.decimal_formats[format]
+    pattern = parse_pattern(format)
+    return pattern.apply(
+        number, locale, decimal_quantization=decimal_quantization, group_separator=group_separator, numbering_system=numbering_system)
+
+
+def format_compact_decimal(
+    number: float | decimal.Decimal | str,
+    *,
+    format_type: Literal["short", "long"] = "short",
+    locale: Locale | str | None = None,
+    fraction_digits: int = 0,
+    numbering_system: Literal["default"] | str = "latn",
+) -> str:
+    """Return the given decimal number formatted for a specific locale in compact form.
+
+    >>> format_compact_decimal(12345, format_type="short", locale='en_US')
+    u'12K'
+    >>> format_compact_decimal(12345, format_type="long", locale='en_US')
+    u'12 thousand'
+    >>> format_compact_decimal(12345, format_type="short", locale='en_US', fraction_digits=2)
+    u'12.34K'
+    >>> format_compact_decimal(1234567, format_type="short", locale="ja_JP")
+    u'123万'
+    >>> format_compact_decimal(2345678, format_type="long", locale="mk")
+    u'2 милиони'
+    >>> format_compact_decimal(21000000, format_type="long", locale="mk")
+    u'21 милион'
+    >>> format_compact_decimal(12345, format_type="short", locale='ar_EG', fraction_digits=2, numbering_system='default')
+    u'12٫34\xa0ألف'
+
+    :param number: the number to format
+    :param format_type: Compact format to use ("short" or "long")
+    :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
+    :param fraction_digits: Number of digits after the decimal point to use. Defaults to `0`.
+    :param numbering_system: The numbering system used for formatting number symbols. Defaults to "latn".
+                             The special value "default" will use the default numbering system of the locale.
+    :raise `UnsupportedNumberingSystemError`: If the numbering system is not supported by the locale.
+    """
+    locale = Locale.parse(locale or LC_NUMERIC)
+    compact_format = locale.compact_decimal_formats[format_type]
+    number, format = _get_compact_format(number, compact_format, locale, fraction_digits)
+    # Did not find a format, fall back.
+    if format is None:
+        format = locale.decimal_formats[None]
+    pattern = parse_pattern(format)
+    return pattern.apply(number, locale, decimal_quantization=False, numbering_system=numbering_system)
+
+
+def _get_compact_format(
+    number: float | decimal.Decimal | str,
+    compact_format: LocaleDataDict,
+    locale: Locale,
+    fraction_digits: int,
+) -> tuple[decimal.Decimal, NumberPattern | None]:
+    """Returns the number after dividing by the unit and the format pattern to use.
+    The algorithm is described here:
+    https://www.unicode.org/reports/tr35/tr35-45/tr35-numbers.html#Compact_Number_Formats.
+    """
+    if not isinstance(number, decimal.Decimal):
+        number = decimal.Decimal(str(number))
+    if number.is_nan() or number.is_infinite():
+        return number, None
+    format = None
+    for magnitude in sorted([int(m) for m in compact_format["other"]], reverse=True):
+        if abs(number) >= magnitude:
+            # check the pattern using "other" as the amount
+            format = compact_format["other"][str(magnitude)]
+            pattern = parse_pattern(format).pattern
+            # if the pattern is "0", we do not divide the number
+            if pattern == "0":
+                break
+            # otherwise, we need to divide the number by the magnitude but remove zeros
+            # equal to the number of 0's in the pattern minus 1
+            number = cast(decimal.Decimal, number / (magnitude // (10 ** (pattern.count("0") - 1))))
+            # round to the number of fraction digits requested
+            rounded = round(number, fraction_digits)
+            # if the remaining number is singular, use the singular format
+            plural_form = locale.plural_form(abs(number))
+            if plural_form not in compact_format:
+                plural_form = "other"
+            if number == 1 and "1" in compact_format:
+                plural_form = "1"
+            format = compact_format[plural_form][str(magnitude)]
+            number = rounded
+            break
+    return number, format
+
+
+class UnknownCurrencyFormatError(KeyError):
+    """Exception raised when an unknown currency format is requested."""
+
+
+def format_currency(
+    number: float | decimal.Decimal | str,
+    currency: str,
+    format: str | NumberPattern | None = None,
+    locale: Locale | str | None = None,
+    currency_digits: bool = True,
+    format_type: Literal["name", "standard", "accounting"] = "standard",
+    decimal_quantization: bool = True,
+    group_separator: bool = True,
+    *,
+    numbering_system: Literal["default"] | str = "latn",
+) -> str:
+    """Return formatted currency value.
+
+    >>> format_currency(1099.98, 'USD', locale='en_US')
+    '$1,099.98'
+    >>> format_currency(1099.98, 'USD', locale='es_CO')
+    u'US$1.099,98'
+    >>> format_currency(1099.98, 'EUR', locale='de_DE')
+    u'1.099,98\\xa0\\u20ac'
+    >>> format_currency(1099.98, 'EGP', locale='ar_EG', numbering_system='default')
+    u'\u200f1٬099٫98\xa0ج.م.\u200f'
+
+    The format can also be specified explicitly.  The currency is
+    placed with the '¤' sign.  As the sign gets repeated the format
+    expands (¤ being the symbol, ¤¤ is the currency abbreviation and
+    ¤¤¤ is the full name of the currency):
+
+    >>> format_currency(1099.98, 'EUR', u'\xa4\xa4 #,##0.00', locale='en_US')
+    u'EUR 1,099.98'
+    >>> format_currency(1099.98, 'EUR', u'#,##0.00 \xa4\xa4\xa4', locale='en_US')
+    u'1,099.98 euros'
+
+    Currencies usually have a specific number of decimal digits. This function
+    favours that information over the given format:
+
+    >>> format_currency(1099.98, 'JPY', locale='en_US')
+    u'\\xa51,100'
+    >>> format_currency(1099.98, 'COP', u'#,##0.00', locale='es_ES')
+    u'1.099,98'
+
+    However, the number of decimal digits can be overridden from the currency
+    information, by setting the last parameter to ``False``:
+
+    >>> format_currency(1099.98, 'JPY', locale='en_US', currency_digits=False)
+    u'\\xa51,099.98'
+    >>> format_currency(1099.98, 'COP', u'#,##0.00', locale='es_ES', currency_digits=False)
+    u'1.099,98'
+
+    If a format is not specified the type of currency format to use
+    from the locale can be specified:
+
+    >>> format_currency(1099.98, 'EUR', locale='en_US', format_type='standard')
+    u'\\u20ac1,099.98'
+
+    When the given currency format type is not available, an exception is
+    raised:
+
+    >>> format_currency('1099.98', 'EUR', locale='root', format_type='unknown')
+    Traceback (most recent call last):
+        ...
+    UnknownCurrencyFormatError: "'unknown' is not a known currency format type"
+
+    >>> format_currency(101299.98, 'USD', locale='en_US', group_separator=False)
+    u'$101299.98'
+
+    >>> format_currency(101299.98, 'USD', locale='en_US', group_separator=True)
+    u'$101,299.98'
+
+    You can also pass format_type='name' to use long display names. The order of
+    the number and currency name, along with the correct localized plural form
+    of the currency name, is chosen according to locale:
+
+    >>> format_currency(1, 'USD', locale='en_US', format_type='name')
+    u'1.00 US dollar'
+    >>> format_currency(1099.98, 'USD', locale='en_US', format_type='name')
+    u'1,099.98 US dollars'
+    >>> format_currency(1099.98, 'USD', locale='ee', format_type='name')
+    u'us ga dollar 1,099.98'
+
+    By default the locale is allowed to truncate and round a high-precision
+    number by forcing its format pattern onto the decimal part. You can bypass
+    this behavior with the `decimal_quantization` parameter:
+
+    >>> format_currency(1099.9876, 'USD', locale='en_US')
+    u'$1,099.99'
+    >>> format_currency(1099.9876, 'USD', locale='en_US', decimal_quantization=False)
+    u'$1,099.9876'
+
+    :param number: the number to format
+    :param currency: the currency code
+    :param format: the format string to use
+    :param locale: the `Locale` object or locale identifier.
+                   Defaults to the system currency locale or numeric locale.
+    :param currency_digits: use the currency's natural number of decimal digits
+    :param format_type: the currency format type to use
+    :param decimal_quantization: Truncate and round high-precision numbers to
+                                 the format pattern. Defaults to `True`.
+    :param group_separator: Boolean to switch group separator on/off in a locale's
+                            number format.
+    :param numbering_system: The numbering system used for formatting number symbols. Defaults to "latn".
+                             The special value "default" will use the default numbering system of the locale.
+    :raise `UnsupportedNumberingSystemError`: If the numbering system is not supported by the locale.
+    """
+    locale = Locale.parse(locale or LC_MONETARY)
+
+    if format_type == 'name':
+        return _format_currency_long_name(
+            number,
+            currency,
+            locale=locale,
+            format=format,
+            currency_digits=currency_digits,
+            decimal_quantization=decimal_quantization,
+            group_separator=group_separator,
+            numbering_system=numbering_system,
+        )
+
+    if format:
+        pattern = parse_pattern(format)
+    else:
+        try:
+            pattern = locale.currency_formats[format_type]
+        except KeyError:
+            raise UnknownCurrencyFormatError(f"{format_type!r} is not a known currency format type") from None
+
+    return pattern.apply(
+        number, locale, currency=currency, currency_digits=currency_digits,
+        decimal_quantization=decimal_quantization, group_separator=group_separator, numbering_system=numbering_system)
+
+
+def _format_currency_long_name(
+    number: float | decimal.Decimal | str,
+    currency: str,
+    *,
+    locale: Locale,
+    format: str | NumberPattern | None,
+    currency_digits: bool,
+    decimal_quantization: bool,
+    group_separator: bool,
+    numbering_system: Literal["default"] | str,
+) -> str:
+    # Algorithm described here:
+    # https://www.unicode.org/reports/tr35/tr35-numbers.html#Currencies
+
+    # Step 1.
+    # There are no examples of items with explicit count (0 or 1) in current
+    # locale data. So there is no point implementing that.
+    # Step 2.
+
+    # Correct number to numeric type, important for looking up plural rules:
+    number_n = float(number) if isinstance(number, str) else number
+
+    # Step 3.
+    unit_pattern = get_currency_unit_pattern(currency, count=number_n, locale=locale)
+
+    # Step 4.
+    display_name = get_currency_name(currency, count=number_n, locale=locale)
+
+    # Step 5.
+    if not format:
+        format = locale.decimal_formats[None]
+
+    pattern = parse_pattern(format)
+
+    number_part = pattern.apply(
+        number, locale, currency=currency, currency_digits=currency_digits,
+        decimal_quantization=decimal_quantization, group_separator=group_separator, numbering_system=numbering_system)
+
+    return unit_pattern.format(number_part, display_name)
+
+
+def format_compact_currency(
+    number: float | decimal.Decimal | str,
+    currency: str,
+    *,
+    format_type: Literal["short"] = "short",
+    locale: Locale | str | None = None,
+    fraction_digits: int = 0,
+    numbering_system: Literal["default"] | str = "latn",
+) -> str:
+    """Format a number as a currency value in compact form.
+
+    >>> format_compact_currency(12345, 'USD', locale='en_US')
+    u'$12K'
+    >>> format_compact_currency(123456789, 'USD', locale='en_US', fraction_digits=2)
+    u'$123.46M'
+    >>> format_compact_currency(123456789, 'EUR', locale='de_DE', fraction_digits=1)
+    '123,5\xa0Mio.\xa0€'
+
+    :param number: the number to format
+    :param currency: the currency code
+    :param format_type: the compact format type to use. Defaults to "short".
+    :param locale: the `Locale` object or locale identifier.
+                   Defaults to the system currency locale or numeric locale.
+    :param fraction_digits: Number of digits after the decimal point to use. Defaults to `0`.
+    :param numbering_system: The numbering system used for formatting number symbols. Defaults to "latn".
+                             The special value "default" will use the default numbering system of the locale.
+    :raise `UnsupportedNumberingSystemError`: If the numbering system is not supported by the locale.
+    """
+    locale = Locale.parse(locale or LC_MONETARY)
+    try:
+        compact_format = locale.compact_currency_formats[format_type]
+    except KeyError as error:
+        raise UnknownCurrencyFormatError(f"{format_type!r} is not a known compact currency format type") from error
+    number, format = _get_compact_format(number, compact_format, locale, fraction_digits)
+    # Did not find a format, fall back.
+    if format is None or "¤" not in str(format):
+        # find first format that has a currency symbol
+        for magnitude in compact_format['other']:
+            format = compact_format['other'][magnitude].pattern
+            if '¤' not in format:
+                continue
+            # remove characters that are not the currency symbol, 0's or spaces
+            format = re.sub(r'[^0\s\¤]', '', format)
+            # compress adjacent spaces into one
+            format = re.sub(r'(\s)\s+', r'\1', format).strip()
+            break
+    if format is None:
+        raise ValueError('No compact currency format found for the given number and locale.')
+    pattern = parse_pattern(format)
+    return pattern.apply(number, locale, currency=currency, currency_digits=False, decimal_quantization=False,
+                         numbering_system=numbering_system)
+
+
+def format_percent(
+    number: float | decimal.Decimal | str,
+    format: str | NumberPattern | None = None,
+    locale: Locale | str | None = None,
+    decimal_quantization: bool = True,
+    group_separator: bool = True,
+    *,
+    numbering_system: Literal["default"] | str = "latn",
+) -> str:
+    """Return formatted percent value for a specific locale.
+
+    >>> format_percent(0.34, locale='en_US')
+    u'34%'
+    >>> format_percent(25.1234, locale='en_US')
+    u'2,512%'
+    >>> format_percent(25.1234, locale='sv_SE')
+    u'2\\xa0512\\xa0%'
+    >>> format_percent(25.1234, locale='ar_EG', numbering_system='default')
+    u'2٬512%'
+
+    The format pattern can also be specified explicitly:
+
+    >>> format_percent(25.1234, u'#,##0\u2030', locale='en_US')
+    u'25,123\u2030'
+
+    By default the locale is allowed to truncate and round a high-precision
+    number by forcing its format pattern onto the decimal part. You can bypass
+    this behavior with the `decimal_quantization` parameter:
+
+    >>> format_percent(23.9876, locale='en_US')
+    u'2,399%'
+    >>> format_percent(23.9876, locale='en_US', decimal_quantization=False)
+    u'2,398.76%'
+
+    >>> format_percent(229291.1234, locale='pt_BR', group_separator=False)
+    u'22929112%'
+
+    >>> format_percent(229291.1234, locale='pt_BR', group_separator=True)
+    u'22.929.112%'
+
+    :param number: the percent number to format
+    :param format:
+    :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
+    :param decimal_quantization: Truncate and round high-precision numbers to
+                                 the format pattern. Defaults to `True`.
+    :param group_separator: Boolean to switch group separator on/off in a locale's
+                            number format.
+    :param numbering_system: The numbering system used for formatting number symbols. Defaults to "latn".
+                             The special value "default" will use the default numbering system of the locale.
+    :raise `UnsupportedNumberingSystemError`: If the numbering system is not supported by the locale.
+    """
+    locale = Locale.parse(locale or LC_NUMERIC)
+    if not format:
+        format = locale.percent_formats[None]
+    pattern = parse_pattern(format)
+    return pattern.apply(
+        number, locale, decimal_quantization=decimal_quantization, group_separator=group_separator,
+        numbering_system=numbering_system,
+    )
+
+
+def format_scientific(
+    number: float | decimal.Decimal | str,
+    format: str | NumberPattern | None = None,
+    locale: Locale | str | None = None,
+    decimal_quantization: bool = True,
+    *,
+    numbering_system: Literal["default"] | str = "latn",
+) -> str:
+    """Return value formatted in scientific notation for a specific locale.
+
+    >>> format_scientific(10000, locale='en_US')
+    u'1E4'
+    >>> format_scientific(10000, locale='ar_EG', numbering_system='default')
+    u'1أس4'
+
+    The format pattern can also be specified explicitly:
+
+    >>> format_scientific(1234567, u'##0.##E00', locale='en_US')
+    u'1.23E06'
+
+    By default the locale is allowed to truncate and round a high-precision
+    number by forcing its format pattern onto the decimal part. You can bypass
+    this behavior with the `decimal_quantization` parameter:
+
+    >>> format_scientific(1234.9876, u'#.##E0', locale='en_US')
+    u'1.23E3'
+    >>> format_scientific(1234.9876, u'#.##E0', locale='en_US', decimal_quantization=False)
+    u'1.2349876E3'
+
+    :param number: the number to format
+    :param format:
+    :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
+    :param decimal_quantization: Truncate and round high-precision numbers to
+                                 the format pattern. Defaults to `True`.
+    :param numbering_system: The numbering system used for formatting number symbols. Defaults to "latn".
+                             The special value "default" will use the default numbering system of the locale.
+    :raise `UnsupportedNumberingSystemError`: If the numbering system is not supported by the locale.
+    """
+    locale = Locale.parse(locale or LC_NUMERIC)
+    if not format:
+        format = locale.scientific_formats[None]
+    pattern = parse_pattern(format)
+    return pattern.apply(
+        number, locale, decimal_quantization=decimal_quantization, numbering_system=numbering_system)
+
+
+class NumberFormatError(ValueError):
+    """Exception raised when a string cannot be parsed into a number."""
+
+    def __init__(self, message: str, suggestions: list[str] | None = None) -> None:
+        super().__init__(message)
+        #: a list of properly formatted numbers derived from the invalid input
+        self.suggestions = suggestions
+
+
+SPACE_CHARS = {
+    ' ',  # space
+    '\xa0',  # no-break space
+    '\u202f',  # narrow no-break space
+}
+
+SPACE_CHARS_RE = re.compile('|'.join(SPACE_CHARS))
+
+
+def parse_number(
+    string: str,
+    locale: Locale | str | None = None,
+    *,
+    numbering_system: Literal["default"] | str = "latn",
+) -> int:
+    """Parse localized number string into an integer.
+
+    >>> parse_number('1,099', locale='en_US')
+    1099
+    >>> parse_number('1.099', locale='de_DE')
+    1099
+
+    When the given string cannot be parsed, an exception is raised:
+
+    >>> parse_number('1.099,98', locale='de')
+    Traceback (most recent call last):
+        ...
+    NumberFormatError: '1.099,98' is not a valid number
+
+    :param string: the string to parse
+    :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
+    :param numbering_system: The numbering system used for formatting number symbols. Defaults to "latn".
+                             The special value "default" will use the default numbering system of the locale.
+    :return: the parsed number
+    :raise `NumberFormatError`: if the string can not be converted to a number
+    :raise `UnsupportedNumberingSystemError`: if the numbering system is not supported by the locale.
+    """
+    group_symbol = get_group_symbol(locale, numbering_system=numbering_system)
+
+    if (
+        group_symbol in SPACE_CHARS and  # if the grouping symbol is a kind of space,
+        group_symbol not in string and  # and the string to be parsed does not contain it,
+        SPACE_CHARS_RE.search(string)  # but it does contain any other kind of space instead,
+    ):
+        # ... it's reasonable to assume it is taking the place of the grouping symbol.
+        string = SPACE_CHARS_RE.sub(group_symbol, string)
+
+    try:
+        return int(string.replace(group_symbol, ''))
+    except ValueError as ve:
+        raise NumberFormatError(f"{string!r} is not a valid number") from ve
+
+
+def parse_decimal(
+    string: str,
+    locale: Locale | str | None = None,
+    strict: bool = False,
+    *,
+    numbering_system: Literal["default"] | str = "latn",
+) -> decimal.Decimal:
+    """Parse localized decimal string into a decimal.
+
+    >>> parse_decimal('1,099.98', locale='en_US')
+    Decimal('1099.98')
+    >>> parse_decimal('1.099,98', locale='de')
+    Decimal('1099.98')
+    >>> parse_decimal('12 345,123', locale='ru')
+    Decimal('12345.123')
+    >>> parse_decimal('1٬099٫98', locale='ar_EG', numbering_system='default')
+    Decimal('1099.98')
+
+    When the given string cannot be parsed, an exception is raised:
+
+    >>> parse_decimal('2,109,998', locale='de')
+    Traceback (most recent call last):
+        ...
+    NumberFormatError: '2,109,998' is not a valid decimal number
+
+    If `strict` is set to `True` and the given string contains a number
+    formatted in an irregular way, an exception is raised:
+
+    >>> parse_decimal('30.00', locale='de', strict=True)
+    Traceback (most recent call last):
+        ...
+    NumberFormatError: '30.00' is not a properly formatted decimal number. Did you mean '3.000'? Or maybe '30,00'?
+
+    >>> parse_decimal('0.00', locale='de', strict=True)
+    Traceback (most recent call last):
+        ...
+    NumberFormatError: '0.00' is not a properly formatted decimal number. Did you mean '0'?
+
+    :param string: the string to parse
+    :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
+    :param strict: controls whether numbers formatted in a weird way are
+                   accepted or rejected
+    :param numbering_system: The numbering system used for formatting number symbols. Defaults to "latn".
+                             The special value "default" will use the default numbering system of the locale.
+    :raise NumberFormatError: if the string can not be converted to a
+                              decimal number
+    :raise UnsupportedNumberingSystemError: if the numbering system is not supported by the locale.
+    """
+    locale = Locale.parse(locale or LC_NUMERIC)
+    group_symbol = get_group_symbol(locale, numbering_system=numbering_system)
+    decimal_symbol = get_decimal_symbol(locale, numbering_system=numbering_system)
+
+    if not strict and (
+        group_symbol in SPACE_CHARS and  # if the grouping symbol is a kind of space,
+        group_symbol not in string and  # and the string to be parsed does not contain it,
+        SPACE_CHARS_RE.search(string)  # but it does contain any other kind of space instead,
+    ):
+        # ... it's reasonable to assume it is taking the place of the grouping symbol.
+        string = SPACE_CHARS_RE.sub(group_symbol, string)
+
+    try:
+        parsed = decimal.Decimal(string.replace(group_symbol, '')
+                                       .replace(decimal_symbol, '.'))
+    except decimal.InvalidOperation as exc:
+        raise NumberFormatError(f"{string!r} is not a valid decimal number") from exc
+    if strict and group_symbol in string:
+        proper = format_decimal(parsed, locale=locale, decimal_quantization=False, numbering_system=numbering_system)
+        if string != proper and proper != _remove_trailing_zeros_after_decimal(string, decimal_symbol):
+            try:
+                parsed_alt = decimal.Decimal(string.replace(decimal_symbol, '')
+                                                   .replace(group_symbol, '.'))
+            except decimal.InvalidOperation as exc:
+                raise NumberFormatError(
+                    f"{string!r} is not a properly formatted decimal number. "
+                    f"Did you mean {proper!r}?",
+                    suggestions=[proper],
+                ) from exc
+            else:
+                proper_alt = format_decimal(
+                    parsed_alt,
+                    locale=locale,
+                    decimal_quantization=False,
+                    numbering_system=numbering_system,
+                )
+                if proper_alt == proper:
+                    raise NumberFormatError(
+                        f"{string!r} is not a properly formatted decimal number. "
+                        f"Did you mean {proper!r}?",
+                        suggestions=[proper],
+                    )
+                else:
+                    raise NumberFormatError(
+                        f"{string!r} is not a properly formatted decimal number. "
+                        f"Did you mean {proper!r}? Or maybe {proper_alt!r}?",
+                        suggestions=[proper, proper_alt],
+                    )
+    return parsed
+
+
+def _remove_trailing_zeros_after_decimal(string: str, decimal_symbol: str) -> str:
+    """
+    Remove trailing zeros from the decimal part of a numeric string.
+
+    This function takes a string representing a numeric value and a decimal symbol.
+    It removes any trailing zeros that appear after the decimal symbol in the number.
+    If the decimal part becomes empty after removing trailing zeros, the decimal symbol
+    is also removed. If the string does not contain the decimal symbol, it is returned unchanged.
+
+    :param string: The numeric string from which to remove trailing zeros.
+    :type string: str
+    :param decimal_symbol: The symbol used to denote the decimal point.
+    :type decimal_symbol: str
+    :return: The numeric string with trailing zeros removed from its decimal part.
+    :rtype: str
+
+    Example:
+    >>> _remove_trailing_zeros_after_decimal("123.4500", ".")
+    '123.45'
+    >>> _remove_trailing_zeros_after_decimal("100.000", ".")
+    '100'
+    >>> _remove_trailing_zeros_after_decimal("100", ".")
+    '100'
+    """
+    integer_part, _, decimal_part = string.partition(decimal_symbol)
+
+    if decimal_part:
+        decimal_part = decimal_part.rstrip("0")
+        if decimal_part:
+            return integer_part + decimal_symbol + decimal_part
+        return integer_part
+
+    return string
+
+
+PREFIX_END = r'[^0-9@#.,]'
+NUMBER_TOKEN = r'[0-9@#.,E+]'
+
+PREFIX_PATTERN = r"(?P<prefix>(?:'[^']*'|%s)*)" % PREFIX_END
+NUMBER_PATTERN = r"(?P<number>%s*)" % NUMBER_TOKEN
+SUFFIX_PATTERN = r"(?P<suffix>.*)"
+
+number_re = re.compile(f"{PREFIX_PATTERN}{NUMBER_PATTERN}{SUFFIX_PATTERN}")
+
+
+def parse_grouping(p: str) -> tuple[int, int]:
+    """Parse primary and secondary digit grouping
+
+    >>> parse_grouping('##')
+    (1000, 1000)
+    >>> parse_grouping('#,###')
+    (3, 3)
+    >>> parse_grouping('#,####,###')
+    (3, 4)
+    """
+    width = len(p)
+    g1 = p.rfind(',')
+    if g1 == -1:
+        return 1000, 1000
+    g1 = width - g1 - 1
+    g2 = p[:-g1 - 1].rfind(',')
+    if g2 == -1:
+        return g1, g1
+    g2 = width - g1 - g2 - 2
+    return g1, g2
+
+
+def parse_pattern(pattern: NumberPattern | str) -> NumberPattern:
+    """Parse number format patterns"""
+    if isinstance(pattern, NumberPattern):
+        return pattern
+
+    def _match_number(pattern):
+        rv = number_re.search(pattern)
+        if rv is None:
+            raise ValueError(f"Invalid number pattern {pattern!r}")
+        return rv.groups()
+
+    pos_pattern = pattern
+
+    # Do we have a negative subpattern?
+    if ';' in pattern:
+        pos_pattern, neg_pattern = pattern.split(';', 1)
+        pos_prefix, number, pos_suffix = _match_number(pos_pattern)
+        neg_prefix, _, neg_suffix = _match_number(neg_pattern)
+    else:
+        pos_prefix, number, pos_suffix = _match_number(pos_pattern)
+        neg_prefix = f"-{pos_prefix}"
+        neg_suffix = pos_suffix
+    if 'E' in number:
+        number, exp = number.split('E', 1)
+    else:
+        exp = None
+    if '@' in number and '.' in number and '0' in number:
+        raise ValueError('Significant digit patterns can not contain "@" or "0"')
+    if '.' in number:
+        integer, fraction = number.rsplit('.', 1)
+    else:
+        integer = number
+        fraction = ''
+
+    def parse_precision(p):
+        """Calculate the min and max allowed digits"""
+        min = max = 0
+        for c in p:
+            if c in '@0':
+                min += 1
+                max += 1
+            elif c == '#':
+                max += 1
+            elif c == ',':
+                continue
+            else:
+                break
+        return min, max
+
+    int_prec = parse_precision(integer)
+    frac_prec = parse_precision(fraction)
+    if exp:
+        exp_plus = exp.startswith('+')
+        exp = exp.lstrip('+')
+        exp_prec = parse_precision(exp)
+    else:
+        exp_plus = None
+        exp_prec = None
+    grouping = parse_grouping(integer)
+    return NumberPattern(pattern, (pos_prefix, neg_prefix),
+                         (pos_suffix, neg_suffix), grouping,
+                         int_prec, frac_prec,
+                         exp_prec, exp_plus, number)
+
+
+class NumberPattern:
+
+    def __init__(
+        self,
+        pattern: str,
+        prefix: tuple[str, str],
+        suffix: tuple[str, str],
+        grouping: tuple[int, int],
+        int_prec: tuple[int, int],
+        frac_prec: tuple[int, int],
+        exp_prec: tuple[int, int] | None,
+        exp_plus: bool | None,
+        number_pattern: str | None = None,
+    ) -> None:
+        # Metadata of the decomposed parsed pattern.
+        self.pattern = pattern
+        self.prefix = prefix
+        self.suffix = suffix
+        self.number_pattern = number_pattern
+        self.grouping = grouping
+        self.int_prec = int_prec
+        self.frac_prec = frac_prec
+        self.exp_prec = exp_prec
+        self.exp_plus = exp_plus
+        self.scale = self.compute_scale()
+
+    def __repr__(self) -> str:
+        return f"<{type(self).__name__} {self.pattern!r}>"
+
+    def compute_scale(self) -> Literal[0, 2, 3]:
+        """Return the scaling factor to apply to the number before rendering.
+
+        Auto-set to a factor of 2 or 3 if presence of a ``%`` or ``‰`` sign is
+        detected in the prefix or suffix of the pattern. Default is to not mess
+        with the scale at all and keep it to 0.
+        """
+        scale = 0
+        if '%' in ''.join(self.prefix + self.suffix):
+            scale = 2
+        elif '‰' in ''.join(self.prefix + self.suffix):
+            scale = 3
+        return scale
+
+    def scientific_notation_elements(
+        self,
+        value: decimal.Decimal,
+        locale: Locale | str | None,
+        *,
+        numbering_system: Literal["default"] | str = "latn",
+    ) -> tuple[decimal.Decimal, int, str]:
+        """ Returns normalized scientific notation components of a value.
+        """
+        # Normalize value to only have one lead digit.
+        exp = value.adjusted()
+        value = value * get_decimal_quantum(exp)
+        assert value.adjusted() == 0
+
+        # Shift exponent and value by the minimum number of leading digits
+        # imposed by the rendering pattern. And always make that number
+        # greater or equal to 1.
+        lead_shift = max([1, min(self.int_prec)]) - 1
+        exp = exp - lead_shift
+        value = value * get_decimal_quantum(-lead_shift)
+
+        # Get exponent sign symbol.
+        exp_sign = ''
+        if exp < 0:
+            exp_sign = get_minus_sign_symbol(locale, numbering_system=numbering_system)
+        elif self.exp_plus:
+            exp_sign = get_plus_sign_symbol(locale, numbering_system=numbering_system)
+
+        # Normalize exponent value now that we have the sign.
+        exp = abs(exp)
+
+        return value, exp, exp_sign
+
+    def apply(
+        self,
+        value: float | decimal.Decimal | str,
+        locale: Locale | str | None,
+        currency: str | None = None,
+        currency_digits: bool = True,
+        decimal_quantization: bool = True,
+        force_frac: tuple[int, int] | None = None,
+        group_separator: bool = True,
+        *,
+        numbering_system: Literal["default"] | str = "latn",
+    ):
+        """Renders into a string a number following the defined pattern.
+
+        Forced decimal quantization is active by default so we'll produce a
+        number string that is strictly following CLDR pattern definitions.
+
+        :param value: The value to format. If this is not a Decimal object,
+                      it will be cast to one.
+        :type value: decimal.Decimal|float|int
+        :param locale: The locale to use for formatting.
+        :type locale: str|babel.core.Locale
+        :param currency: Which currency, if any, to format as.
+        :type currency: str|None
+        :param currency_digits: Whether or not to use the currency's precision.
+                                If false, the pattern's precision is used.
+        :type currency_digits: bool
+        :param decimal_quantization: Whether decimal numbers should be forcibly
+                                     quantized to produce a formatted output
+                                     strictly matching the CLDR definition for
+                                     the locale.
+        :type decimal_quantization: bool
+        :param force_frac: DEPRECATED - a forced override for `self.frac_prec`
+                           for a single formatting invocation.
+        :param group_separator: Whether to use the locale's number group separator.
+        :param numbering_system: The numbering system used for formatting number symbols. Defaults to "latn".
+                                 The special value "default" will use the default numbering system of the locale.
+        :return: Formatted decimal string.
+        :rtype: str
+        :raise UnsupportedNumberingSystemError: If the numbering system is not supported by the locale.
+        """
+        if not isinstance(value, decimal.Decimal):
+            value = decimal.Decimal(str(value))
+
+        value = value.scaleb(self.scale)
+
+        # Separate the absolute value from its sign.
+        is_negative = int(value.is_signed())
+        value = abs(value).normalize()
+
+        # Prepare scientific notation metadata.
+        if self.exp_prec:
+            value, exp, exp_sign = self.scientific_notation_elements(value, locale, numbering_system=numbering_system)
+
+        # Adjust the precision of the fractional part and force it to the
+        # currency's if necessary.
+        if force_frac:
+            # TODO (3.x?): Remove this parameter
+            warnings.warn(
+                'The force_frac parameter to NumberPattern.apply() is deprecated.',
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            frac_prec = force_frac
+        elif currency and currency_digits:
+            frac_prec = (get_currency_precision(currency), ) * 2
+        else:
+            frac_prec = self.frac_prec
+
+        # Bump decimal precision to the natural precision of the number if it
+        # exceeds the one we're about to use. This adaptative precision is only
+        # triggered if the decimal quantization is disabled or if a scientific
+        # notation pattern has a missing mandatory fractional part (as in the
+        # default '#E0' pattern). This special case has been extensively
+        # discussed at https://github.com/python-babel/babel/pull/494#issuecomment-307649969 .
+        if not decimal_quantization or (self.exp_prec and frac_prec == (0, 0)):
+            frac_prec = (frac_prec[0], max([frac_prec[1], get_decimal_precision(value)]))
+
+        # Render scientific notation.
+        if self.exp_prec:
+            number = ''.join([
+                self._quantize_value(value, locale, frac_prec, group_separator, numbering_system=numbering_system),
+                get_exponential_symbol(locale, numbering_system=numbering_system),
+                exp_sign,  # type: ignore  # exp_sign is always defined here
+                self._format_int(str(exp), self.exp_prec[0], self.exp_prec[1], locale, numbering_system=numbering_system),  # type: ignore  # exp is always defined here
+            ])
+
+        # Is it a significant digits pattern?
+        elif '@' in self.pattern:
+            text = self._format_significant(value,
+                                            self.int_prec[0],
+                                            self.int_prec[1])
+            a, sep, b = text.partition(".")
+            number = self._format_int(a, 0, 1000, locale, numbering_system=numbering_system)
+            if sep:
+                number += get_decimal_symbol(locale, numbering_system=numbering_system) + b
+
+        # A normal number pattern.
+        else:
+            number = self._quantize_value(value, locale, frac_prec, group_separator, numbering_system=numbering_system)
+
+        retval = ''.join([
+            self.prefix[is_negative],
+            number if self.number_pattern != '' else '',
+            self.suffix[is_negative]])
+
+        if '¤' in retval and currency is not None:
+            retval = retval.replace('¤¤¤', get_currency_name(currency, value, locale))
+            retval = retval.replace('¤¤', currency.upper())
+            retval = retval.replace('¤', get_currency_symbol(currency, locale))
+
+        # remove single quotes around text, except for doubled single quotes
+        # which are replaced with a single quote
+        retval = re.sub(r"'([^']*)'", lambda m: m.group(1) or "'", retval)
+
+        return retval
+
+    #
+    # This is one tricky piece of code.  The idea is to rely as much as possible
+    # on the decimal module to minimize the amount of code.
+    #
+    # Conceptually, the implementation of this method can be summarized in the
+    # following steps:
+    #
+    #   - Move or shift the decimal point (i.e. the exponent) so the maximum
+    #     amount of significant digits fall into the integer part (i.e. to the
+    #     left of the decimal point)
+    #
+    #   - Round the number to the nearest integer, discarding all the fractional
+    #     part which contained extra digits to be eliminated
+    #
+    #   - Convert the rounded integer to a string, that will contain the final
+    #     sequence of significant digits already trimmed to the maximum
+    #
+    #   - Restore the original position of the decimal point, potentially
+    #     padding with zeroes on either side
+    #
+    def _format_significant(self, value: decimal.Decimal, minimum: int, maximum: int) -> str:
+        exp = value.adjusted()
+        scale = maximum - 1 - exp
+        digits = str(value.scaleb(scale).quantize(decimal.Decimal(1)))
+        if scale <= 0:
+            result = digits + '0' * -scale
+        else:
+            intpart = digits[:-scale]
+            i = len(intpart)
+            j = i + max(minimum - i, 0)
+            result = "{intpart}.{pad:0<{fill}}{fracpart}{fracextra}".format(
+                intpart=intpart or '0',
+                pad='',
+                fill=-min(exp + 1, 0),
+                fracpart=digits[i:j],
+                fracextra=digits[j:].rstrip('0'),
+            ).rstrip('.')
+        return result
+
+    def _format_int(
+        self,
+        value: str,
+        min: int,
+        max: int,
+        locale: Locale | str | None,
+        *,
+        numbering_system: Literal["default"] | str,
+    ) -> str:
+        width = len(value)
+        if width < min:
+            value = '0' * (min - width) + value
+        gsize = self.grouping[0]
+        ret = ''
+        symbol = get_group_symbol(locale, numbering_system=numbering_system)
+        while len(value) > gsize:
+            ret = symbol + value[-gsize:] + ret
+            value = value[:-gsize]
+            gsize = self.grouping[1]
+        return value + ret
+
+    def _quantize_value(
+        self,
+        value: decimal.Decimal,
+        locale: Locale | str | None,
+        frac_prec: tuple[int, int],
+        group_separator: bool,
+        *,
+        numbering_system: Literal["default"] | str,
+    ) -> str:
+        # If the number is +/-Infinity, we can't quantize it
+        if value.is_infinite():
+            return get_infinity_symbol(locale, numbering_system=numbering_system)
+        quantum = get_decimal_quantum(frac_prec[1])
+        rounded = value.quantize(quantum)
+        a, sep, b = f"{rounded:f}".partition(".")
+        integer_part = a
+        if group_separator:
+            integer_part = self._format_int(a, self.int_prec[0], self.int_prec[1], locale, numbering_system=numbering_system)
+        number = integer_part + self._format_frac(b or '0', locale=locale, force_frac=frac_prec, numbering_system=numbering_system)
+        return number
+
+    def _format_frac(
+        self,
+        value: str,
+        locale: Locale | str | None,
+        force_frac: tuple[int, int] | None = None,
+        *,
+        numbering_system: Literal["default"] | str,
+    ) -> str:
+        min, max = force_frac or self.frac_prec
+        if len(value) < min:
+            value += ('0' * (min - len(value)))
+        if max == 0 or (min == 0 and int(value) == 0):
+            return ''
+        while len(value) > min and value[-1] == '0':
+            value = value[:-1]
+        return get_decimal_symbol(locale, numbering_system=numbering_system) + value

lib/python3.10/site-packages/babel/plural.py

@@ -0,0 +1,637 @@
+"""
+    babel.numbers
+    ~~~~~~~~~~~~~
+
+    CLDR Plural support.  See UTS #35.
+
+    :copyright: (c) 2013-2025 by the Babel Team.
+    :license: BSD, see LICENSE for more details.
+"""
+from __future__ import annotations
+
+import decimal
+import re
+from collections.abc import Iterable, Mapping
+from typing import Any, Callable, Literal
+
+_plural_tags = ('zero', 'one', 'two', 'few', 'many', 'other')
+_fallback_tag = 'other'
+
+
+def extract_operands(source: float | decimal.Decimal) -> tuple[decimal.Decimal | int, int, int, int, int, int, Literal[0], Literal[0]]:
+    """Extract operands from a decimal, a float or an int, according to `CLDR rules`_.
+
+    The result is an 8-tuple (n, i, v, w, f, t, c, e), where those symbols are as follows:
+
+    ====== ===============================================================
+    Symbol Value
+    ------ ---------------------------------------------------------------
+    n      absolute value of the source number (integer and decimals).
+    i      integer digits of n.
+    v      number of visible fraction digits in n, with trailing zeros.
+    w      number of visible fraction digits in n, without trailing zeros.
+    f      visible fractional digits in n, with trailing zeros.
+    t      visible fractional digits in n, without trailing zeros.
+    c      compact decimal exponent value: exponent of the power of 10 used in compact decimal formatting.
+    e      currently, synonym for ‘c’. however, may be redefined in the future.
+    ====== ===============================================================
+
+    .. _`CLDR rules`: https://www.unicode.org/reports/tr35/tr35-61/tr35-numbers.html#Operands
+
+    :param source: A real number
+    :type source: int|float|decimal.Decimal
+    :return: A n-i-v-w-f-t-c-e tuple
+    :rtype: tuple[decimal.Decimal, int, int, int, int, int, int, int]
+    """
+    n = abs(source)
+    i = int(n)
+    if isinstance(n, float):
+        if i == n:
+            n = i
+        else:
+            # Cast the `float` to a number via the string representation.
+            # This is required for Python 2.6 anyway (it will straight out fail to
+            # do the conversion otherwise), and it's highly unlikely that the user
+            # actually wants the lossless conversion behavior (quoting the Python
+            # documentation):
+            # > If value is a float, the binary floating point value is losslessly
+            # > converted to its exact decimal equivalent.
+            # > This conversion can often require 53 or more digits of precision.
+            # Should the user want that behavior, they can simply pass in a pre-
+            # converted `Decimal` instance of desired accuracy.
+            n = decimal.Decimal(str(n))
+
+    if isinstance(n, decimal.Decimal):
+        dec_tuple = n.as_tuple()
+        exp = dec_tuple.exponent
+        fraction_digits = dec_tuple.digits[exp:] if exp < 0 else ()
+        trailing = ''.join(str(d) for d in fraction_digits)
+        no_trailing = trailing.rstrip('0')
+        v = len(trailing)
+        w = len(no_trailing)
+        f = int(trailing or 0)
+        t = int(no_trailing or 0)
+    else:
+        v = w = f = t = 0
+    c = e = 0  # TODO: c and e are not supported
+    return n, i, v, w, f, t, c, e
+
+
+class PluralRule:
+    """Represents a set of language pluralization rules.  The constructor
+    accepts a list of (tag, expr) tuples or a dict of `CLDR rules`_. The
+    resulting object is callable and accepts one parameter with a positive or
+    negative number (both integer and float) for the number that indicates the
+    plural form for a string and returns the tag for the format:
+
+    >>> rule = PluralRule({'one': 'n is 1'})
+    >>> rule(1)
+    'one'
+    >>> rule(2)
+    'other'
+
+    Currently the CLDR defines these tags: zero, one, two, few, many and
+    other where other is an implicit default.  Rules should be mutually
+    exclusive; for a given numeric value, only one rule should apply (i.e.
+    the condition should only be true for one of the plural rule elements.
+
+    .. _`CLDR rules`: https://www.unicode.org/reports/tr35/tr35-33/tr35-numbers.html#Language_Plural_Rules
+    """
+
+    __slots__ = ('abstract', '_func')
+
+    def __init__(self, rules: Mapping[str, str] | Iterable[tuple[str, str]]) -> None:
+        """Initialize the rule instance.
+
+        :param rules: a list of ``(tag, expr)``) tuples with the rules
+                      conforming to UTS #35 or a dict with the tags as keys
+                      and expressions as values.
+        :raise RuleError: if the expression is malformed
+        """
+        if isinstance(rules, Mapping):
+            rules = rules.items()
+        found = set()
+        self.abstract: list[tuple[str, Any]] = []
+        for key, expr in sorted(rules):
+            if key not in _plural_tags:
+                raise ValueError(f"unknown tag {key!r}")
+            elif key in found:
+                raise ValueError(f"tag {key!r} defined twice")
+            found.add(key)
+            ast = _Parser(expr).ast
+            if ast:
+                self.abstract.append((key, ast))
+
+    def __repr__(self) -> str:
+        rules = self.rules
+        args = ", ".join([f"{tag}: {rules[tag]}" for tag in _plural_tags if tag in rules])
+        return f"<{type(self).__name__} {args!r}>"
+
+    @classmethod
+    def parse(cls, rules: Mapping[str, str] | Iterable[tuple[str, str]] | PluralRule) -> PluralRule:
+        """Create a `PluralRule` instance for the given rules.  If the rules
+        are a `PluralRule` object, that object is returned.
+
+        :param rules: the rules as list or dict, or a `PluralRule` object
+        :raise RuleError: if the expression is malformed
+        """
+        if isinstance(rules, PluralRule):
+            return rules
+        return cls(rules)
+
+    @property
+    def rules(self) -> Mapping[str, str]:
+        """The `PluralRule` as a dict of unicode plural rules.
+
+        >>> rule = PluralRule({'one': 'n is 1'})
+        >>> rule.rules
+        {'one': 'n is 1'}
+        """
+        _compile = _UnicodeCompiler().compile
+        return {tag: _compile(ast) for tag, ast in self.abstract}
+
+    @property
+    def tags(self) -> frozenset[str]:
+        """A set of explicitly defined tags in this rule.  The implicit default
+        ``'other'`` rules is not part of this set unless there is an explicit
+        rule for it.
+        """
+        return frozenset(i[0] for i in self.abstract)
+
+    def __getstate__(self) -> list[tuple[str, Any]]:
+        return self.abstract
+
+    def __setstate__(self, abstract: list[tuple[str, Any]]) -> None:
+        self.abstract = abstract
+
+    def __call__(self, n: float | decimal.Decimal) -> str:
+        if not hasattr(self, '_func'):
+            self._func = to_python(self)
+        return self._func(n)
+
+
+def to_javascript(rule: Mapping[str, str] | Iterable[tuple[str, str]] | PluralRule) -> str:
+    """Convert a list/dict of rules or a `PluralRule` object into a JavaScript
+    function.  This function depends on no external library:
+
+    >>> to_javascript({'one': 'n is 1'})
+    "(function(n) { return (n == 1) ? 'one' : 'other'; })"
+
+    Implementation detail: The function generated will probably evaluate
+    expressions involved into range operations multiple times.  This has the
+    advantage that external helper functions are not required and is not a
+    big performance hit for these simple calculations.
+
+    :param rule: the rules as list or dict, or a `PluralRule` object
+    :raise RuleError: if the expression is malformed
+    """
+    to_js = _JavaScriptCompiler().compile
+    result = ['(function(n) { return ']
+    for tag, ast in PluralRule.parse(rule).abstract:
+        result.append(f"{to_js(ast)} ? {tag!r} : ")
+    result.append('%r; })' % _fallback_tag)
+    return ''.join(result)
+
+
+def to_python(rule: Mapping[str, str] | Iterable[tuple[str, str]] | PluralRule) -> Callable[[float | decimal.Decimal], str]:
+    """Convert a list/dict of rules or a `PluralRule` object into a regular
+    Python function.  This is useful in situations where you need a real
+    function and don't are about the actual rule object:
+
+    >>> func = to_python({'one': 'n is 1', 'few': 'n in 2..4'})
+    >>> func(1)
+    'one'
+    >>> func(3)
+    'few'
+    >>> func = to_python({'one': 'n in 1,11', 'few': 'n in 3..10,13..19'})
+    >>> func(11)
+    'one'
+    >>> func(15)
+    'few'
+
+    :param rule: the rules as list or dict, or a `PluralRule` object
+    :raise RuleError: if the expression is malformed
+    """
+    namespace = {
+        'IN': in_range_list,
+        'WITHIN': within_range_list,
+        'MOD': cldr_modulo,
+        'extract_operands': extract_operands,
+    }
+    to_python_func = _PythonCompiler().compile
+    result = [
+        'def evaluate(n):',
+        ' n, i, v, w, f, t, c, e = extract_operands(n)',
+    ]
+    for tag, ast in PluralRule.parse(rule).abstract:
+        # the str() call is to coerce the tag to the native string.  It's
+        # a limited ascii restricted set of tags anyways so that is fine.
+        result.append(f" if ({to_python_func(ast)}): return {str(tag)!r}")
+    result.append(f" return {_fallback_tag!r}")
+    code = compile('\n'.join(result), '<rule>', 'exec')
+    eval(code, namespace)
+    return namespace['evaluate']
+
+
+def to_gettext(rule: Mapping[str, str] | Iterable[tuple[str, str]] | PluralRule) -> str:
+    """The plural rule as gettext expression.  The gettext expression is
+    technically limited to integers and returns indices rather than tags.
+
+    >>> to_gettext({'one': 'n is 1', 'two': 'n is 2'})
+    'nplurals=3; plural=((n == 1) ? 0 : (n == 2) ? 1 : 2);'
+
+    :param rule: the rules as list or dict, or a `PluralRule` object
+    :raise RuleError: if the expression is malformed
+    """
+    rule = PluralRule.parse(rule)
+
+    used_tags = rule.tags | {_fallback_tag}
+    _compile = _GettextCompiler().compile
+    _get_index = [tag for tag in _plural_tags if tag in used_tags].index
+
+    result = [f"nplurals={len(used_tags)}; plural=("]
+    for tag, ast in rule.abstract:
+        result.append(f"{_compile(ast)} ? {_get_index(tag)} : ")
+    result.append(f"{_get_index(_fallback_tag)});")
+    return ''.join(result)
+
+
+def in_range_list(num: float | decimal.Decimal, range_list: Iterable[Iterable[float | decimal.Decimal]]) -> bool:
+    """Integer range list test.  This is the callback for the "in" operator
+    of the UTS #35 pluralization rule language:
+
+    >>> in_range_list(1, [(1, 3)])
+    True
+    >>> in_range_list(3, [(1, 3)])
+    True
+    >>> in_range_list(3, [(1, 3), (5, 8)])
+    True
+    >>> in_range_list(1.2, [(1, 4)])
+    False
+    >>> in_range_list(10, [(1, 4)])
+    False
+    >>> in_range_list(10, [(1, 4), (6, 8)])
+    False
+    """
+    return num == int(num) and within_range_list(num, range_list)
+
+
+def within_range_list(num: float | decimal.Decimal, range_list: Iterable[Iterable[float | decimal.Decimal]]) -> bool:
+    """Float range test.  This is the callback for the "within" operator
+    of the UTS #35 pluralization rule language:
+
+    >>> within_range_list(1, [(1, 3)])
+    True
+    >>> within_range_list(1.0, [(1, 3)])
+    True
+    >>> within_range_list(1.2, [(1, 4)])
+    True
+    >>> within_range_list(8.8, [(1, 4), (7, 15)])
+    True
+    >>> within_range_list(10, [(1, 4)])
+    False
+    >>> within_range_list(10.5, [(1, 4), (20, 30)])
+    False
+    """
+    return any(min_ <= num <= max_ for min_, max_ in range_list)
+
+
+def cldr_modulo(a: float, b: float) -> float:
+    """Javaish modulo.  This modulo operator returns the value with the sign
+    of the dividend rather than the divisor like Python does:
+
+    >>> cldr_modulo(-3, 5)
+    -3
+    >>> cldr_modulo(-3, -5)
+    -3
+    >>> cldr_modulo(3, 5)
+    3
+    """
+    reverse = 0
+    if a < 0:
+        a *= -1
+        reverse = 1
+    if b < 0:
+        b *= -1
+    rv = a % b
+    if reverse:
+        rv *= -1
+    return rv
+
+
+class RuleError(Exception):
+    """Raised if a rule is malformed."""
+
+
+_VARS = {
+    'n',  # absolute value of the source number.
+    'i',  # integer digits of n.
+    'v',  # number of visible fraction digits in n, with trailing zeros.*
+    'w',  # number of visible fraction digits in n, without trailing zeros.*
+    'f',  # visible fraction digits in n, with trailing zeros.*
+    't',  # visible fraction digits in n, without trailing zeros.*
+    'c',  # compact decimal exponent value: exponent of the power of 10 used in compact decimal formatting.
+    'e',  # currently, synonym for `c`. however, may be redefined in the future.
+}
+
+_RULES: list[tuple[str | None, re.Pattern[str]]] = [
+    (None, re.compile(r'\s+', re.UNICODE)),
+    ('word', re.compile(fr'\b(and|or|is|(?:with)?in|not|mod|[{"".join(_VARS)}])\b')),
+    ('value', re.compile(r'\d+')),
+    ('symbol', re.compile(r'%|,|!=|=')),
+    ('ellipsis', re.compile(r'\.{2,3}|\u2026', re.UNICODE)),  # U+2026: ELLIPSIS
+]
+
+
+def tokenize_rule(s: str) -> list[tuple[str, str]]:
+    s = s.split('@')[0]
+    result: list[tuple[str, str]] = []
+    pos = 0
+    end = len(s)
+    while pos < end:
+        for tok, rule in _RULES:
+            match = rule.match(s, pos)
+            if match is not None:
+                pos = match.end()
+                if tok:
+                    result.append((tok, match.group()))
+                break
+        else:
+            raise RuleError(f"malformed CLDR pluralization rule.  Got unexpected {s[pos]!r}")
+    return result[::-1]
+
+
+def test_next_token(
+    tokens: list[tuple[str, str]],
+    type_: str,
+    value: str | None = None,
+) -> list[tuple[str, str]] | bool:
+    return tokens and tokens[-1][0] == type_ and \
+        (value is None or tokens[-1][1] == value)
+
+
+def skip_token(tokens: list[tuple[str, str]], type_: str, value: str | None = None):
+    if test_next_token(tokens, type_, value):
+        return tokens.pop()
+
+
+def value_node(value: int) -> tuple[Literal['value'], tuple[int]]:
+    return 'value', (value, )
+
+
+def ident_node(name: str) -> tuple[str, tuple[()]]:
+    return name, ()
+
+
+def range_list_node(
+    range_list: Iterable[Iterable[float | decimal.Decimal]],
+) -> tuple[Literal['range_list'], Iterable[Iterable[float | decimal.Decimal]]]:
+    return 'range_list', range_list
+
+
+def negate(rv: tuple[Any, ...]) -> tuple[Literal['not'], tuple[tuple[Any, ...]]]:
+    return 'not', (rv,)
+
+
+class _Parser:
+    """Internal parser.  This class can translate a single rule into an abstract
+    tree of tuples. It implements the following grammar::
+
+        condition     = and_condition ('or' and_condition)*
+                        ('@integer' samples)?
+                        ('@decimal' samples)?
+        and_condition = relation ('and' relation)*
+        relation      = is_relation | in_relation | within_relation
+        is_relation   = expr 'is' ('not')? value
+        in_relation   = expr (('not')? 'in' | '=' | '!=') range_list
+        within_relation = expr ('not')? 'within' range_list
+        expr          = operand (('mod' | '%') value)?
+        operand       = 'n' | 'i' | 'f' | 't' | 'v' | 'w'
+        range_list    = (range | value) (',' range_list)*
+        value         = digit+
+        digit         = 0|1|2|3|4|5|6|7|8|9
+        range         = value'..'value
+        samples       = sampleRange (',' sampleRange)* (',' ('…'|'...'))?
+        sampleRange   = decimalValue '~' decimalValue
+        decimalValue  = value ('.' value)?
+
+    - Whitespace can occur between or around any of the above tokens.
+    - Rules should be mutually exclusive; for a given numeric value, only one
+      rule should apply (i.e. the condition should only be true for one of
+      the plural rule elements).
+    - The in and within relations can take comma-separated lists, such as:
+      'n in 3,5,7..15'.
+    - Samples are ignored.
+
+    The translator parses the expression on instantiation into an attribute
+    called `ast`.
+    """
+
+    def __init__(self, string):
+        self.tokens = tokenize_rule(string)
+        if not self.tokens:
+            # If the pattern is only samples, it's entirely possible
+            # no stream of tokens whatsoever is generated.
+            self.ast = None
+            return
+        self.ast = self.condition()
+        if self.tokens:
+            raise RuleError(f"Expected end of rule, got {self.tokens[-1][1]!r}")
+
+    def expect(self, type_, value=None, term=None):
+        token = skip_token(self.tokens, type_, value)
+        if token is not None:
+            return token
+        if term is None:
+            term = repr(value is None and type_ or value)
+        if not self.tokens:
+            raise RuleError(f"expected {term} but end of rule reached")
+        raise RuleError(f"expected {term} but got {self.tokens[-1][1]!r}")
+
+    def condition(self):
+        op = self.and_condition()
+        while skip_token(self.tokens, 'word', 'or'):
+            op = 'or', (op, self.and_condition())
+        return op
+
+    def and_condition(self):
+        op = self.relation()
+        while skip_token(self.tokens, 'word', 'and'):
+            op = 'and', (op, self.relation())
+        return op
+
+    def relation(self):
+        left = self.expr()
+        if skip_token(self.tokens, 'word', 'is'):
+            return skip_token(self.tokens, 'word', 'not') and 'isnot' or 'is', \
+                (left, self.value())
+        negated = skip_token(self.tokens, 'word', 'not')
+        method = 'in'
+        if skip_token(self.tokens, 'word', 'within'):
+            method = 'within'
+        else:
+            if not skip_token(self.tokens, 'word', 'in'):
+                if negated:
+                    raise RuleError('Cannot negate operator based rules.')
+                return self.newfangled_relation(left)
+        rv = 'relation', (method, left, self.range_list())
+        return negate(rv) if negated else rv
+
+    def newfangled_relation(self, left):
+        if skip_token(self.tokens, 'symbol', '='):
+            negated = False
+        elif skip_token(self.tokens, 'symbol', '!='):
+            negated = True
+        else:
+            raise RuleError('Expected "=" or "!=" or legacy relation')
+        rv = 'relation', ('in', left, self.range_list())
+        return negate(rv) if negated else rv
+
+    def range_or_value(self):
+        left = self.value()
+        if skip_token(self.tokens, 'ellipsis'):
+            return left, self.value()
+        else:
+            return left, left
+
+    def range_list(self):
+        range_list = [self.range_or_value()]
+        while skip_token(self.tokens, 'symbol', ','):
+            range_list.append(self.range_or_value())
+        return range_list_node(range_list)
+
+    def expr(self):
+        word = skip_token(self.tokens, 'word')
+        if word is None or word[1] not in _VARS:
+            raise RuleError('Expected identifier variable')
+        name = word[1]
+        if skip_token(self.tokens, 'word', 'mod'):
+            return 'mod', ((name, ()), self.value())
+        elif skip_token(self.tokens, 'symbol', '%'):
+            return 'mod', ((name, ()), self.value())
+        return ident_node(name)
+
+    def value(self):
+        return value_node(int(self.expect('value')[1]))
+
+
+def _binary_compiler(tmpl):
+    """Compiler factory for the `_Compiler`."""
+    return lambda self, left, right: tmpl % (self.compile(left), self.compile(right))
+
+
+def _unary_compiler(tmpl):
+    """Compiler factory for the `_Compiler`."""
+    return lambda self, x: tmpl % self.compile(x)
+
+
+compile_zero = lambda x: '0'
+
+
+class _Compiler:
+    """The compilers are able to transform the expressions into multiple
+    output formats.
+    """
+
+    def compile(self, arg):
+        op, args = arg
+        return getattr(self, f"compile_{op}")(*args)
+
+    compile_n = lambda x: 'n'
+    compile_i = lambda x: 'i'
+    compile_v = lambda x: 'v'
+    compile_w = lambda x: 'w'
+    compile_f = lambda x: 'f'
+    compile_t = lambda x: 't'
+    compile_c = lambda x: 'c'
+    compile_e = lambda x: 'e'
+    compile_value = lambda x, v: str(v)
+    compile_and = _binary_compiler('(%s && %s)')
+    compile_or = _binary_compiler('(%s || %s)')
+    compile_not = _unary_compiler('(!%s)')
+    compile_mod = _binary_compiler('(%s %% %s)')
+    compile_is = _binary_compiler('(%s == %s)')
+    compile_isnot = _binary_compiler('(%s != %s)')
+
+    def compile_relation(self, method, expr, range_list):
+        raise NotImplementedError()
+
+
+class _PythonCompiler(_Compiler):
+    """Compiles an expression to Python."""
+
+    compile_and = _binary_compiler('(%s and %s)')
+    compile_or = _binary_compiler('(%s or %s)')
+    compile_not = _unary_compiler('(not %s)')
+    compile_mod = _binary_compiler('MOD(%s, %s)')
+
+    def compile_relation(self, method, expr, range_list):
+        ranges = ",".join([f"({self.compile(a)}, {self.compile(b)})" for (a, b) in range_list[1]])
+        return f"{method.upper()}({self.compile(expr)}, [{ranges}])"
+
+
+class _GettextCompiler(_Compiler):
+    """Compile into a gettext plural expression."""
+
+    compile_i = _Compiler.compile_n
+    compile_v = compile_zero
+    compile_w = compile_zero
+    compile_f = compile_zero
+    compile_t = compile_zero
+
+    def compile_relation(self, method, expr, range_list):
+        rv = []
+        expr = self.compile(expr)
+        for item in range_list[1]:
+            if item[0] == item[1]:
+                rv.append(f"({expr} == {self.compile(item[0])})")
+            else:
+                min, max = map(self.compile, item)
+                rv.append(f"({expr} >= {min} && {expr} <= {max})")
+        return f"({' || '.join(rv)})"
+
+
+class _JavaScriptCompiler(_GettextCompiler):
+    """Compiles the expression to plain of JavaScript."""
+
+    # XXX: presently javascript does not support any of the
+    # fraction support and basically only deals with integers.
+    compile_i = lambda x: 'parseInt(n, 10)'
+    compile_v = compile_zero
+    compile_w = compile_zero
+    compile_f = compile_zero
+    compile_t = compile_zero
+
+    def compile_relation(self, method, expr, range_list):
+        code = _GettextCompiler.compile_relation(
+            self, method, expr, range_list)
+        if method == 'in':
+            expr = self.compile(expr)
+            code = f"(parseInt({expr}, 10) == {expr} && {code})"
+        return code
+
+
+class _UnicodeCompiler(_Compiler):
+    """Returns a unicode pluralization rule again."""
+
+    # XXX: this currently spits out the old syntax instead of the new
+    # one.  We can change that, but it will break a whole bunch of stuff
+    # for users I suppose.
+
+    compile_is = _binary_compiler('%s is %s')
+    compile_isnot = _binary_compiler('%s is not %s')
+    compile_and = _binary_compiler('%s and %s')
+    compile_or = _binary_compiler('%s or %s')
+    compile_mod = _binary_compiler('%s mod %s')
+
+    def compile_not(self, relation):
+        return self.compile_relation(*relation[1], negated=True)
+
+    def compile_relation(self, method, expr, range_list, negated=False):
+        ranges = []
+        for item in range_list[1]:
+            if item[0] == item[1]:
+                ranges.append(self.compile(item[0]))
+            else:
+                ranges.append(f"{self.compile(item[0])}..{self.compile(item[1])}")
+        return f"{self.compile(expr)}{' not' if negated else ''} {method} {','.join(ranges)}"

lib/python3.10/site-packages/babel/py.typed

@@ -0,0 +1 @@
+# Marker file for PEP 561. This package uses inline types.

lib/python3.10/site-packages/babel/support.py

@@ -0,0 +1,726 @@
+"""
+    babel.support
+    ~~~~~~~~~~~~~
+
+    Several classes and functions that help with integrating and using Babel
+    in applications.
+
+    .. note: the code in this module is not used by Babel itself
+
+    :copyright: (c) 2013-2025 by the Babel Team.
+    :license: BSD, see LICENSE for more details.
+"""
+from __future__ import annotations
+
+import gettext
+import locale
+import os
+from collections.abc import Iterator
+from typing import TYPE_CHECKING, Any, Callable, Iterable, Literal
+
+from babel.core import Locale
+from babel.dates import format_date, format_datetime, format_time, format_timedelta
+from babel.numbers import (
+    format_compact_currency,
+    format_compact_decimal,
+    format_currency,
+    format_decimal,
+    format_percent,
+    format_scientific,
+)
+
+if TYPE_CHECKING:
+    import datetime as _datetime
+    from decimal import Decimal
+
+    from babel.dates import _PredefinedTimeFormat
+
+
+class Format:
+    """Wrapper class providing the various date and number formatting functions
+    bound to a specific locale and time-zone.
+
+    >>> from babel.util import UTC
+    >>> from datetime import date
+    >>> fmt = Format('en_US', UTC)
+    >>> fmt.date(date(2007, 4, 1))
+    u'Apr 1, 2007'
+    >>> fmt.decimal(1.2345)
+    u'1.234'
+    """
+
+    def __init__(
+        self,
+        locale: Locale | str,
+        tzinfo: _datetime.tzinfo | None = None,
+        *,
+        numbering_system: Literal["default"] | str = "latn",
+    ) -> None:
+        """Initialize the formatter.
+
+        :param locale: the locale identifier or `Locale` instance
+        :param tzinfo: the time-zone info (a `tzinfo` instance or `None`)
+        :param numbering_system: The numbering system used for formatting number symbols. Defaults to "latn".
+                                 The special value "default" will use the default numbering system of the locale.
+        """
+        self.locale = Locale.parse(locale)
+        self.tzinfo = tzinfo
+        self.numbering_system = numbering_system
+
+    def date(
+        self,
+        date: _datetime.date | None = None,
+        format: _PredefinedTimeFormat | str = 'medium',
+    ) -> str:
+        """Return a date formatted according to the given pattern.
+
+        >>> from datetime import date
+        >>> fmt = Format('en_US')
+        >>> fmt.date(date(2007, 4, 1))
+        u'Apr 1, 2007'
+        """
+        return format_date(date, format, locale=self.locale)
+
+    def datetime(
+        self,
+        datetime: _datetime.date | None = None,
+        format: _PredefinedTimeFormat | str = 'medium',
+    ) -> str:
+        """Return a date and time formatted according to the given pattern.
+
+        >>> from datetime import datetime
+        >>> from babel.dates import get_timezone
+        >>> fmt = Format('en_US', tzinfo=get_timezone('US/Eastern'))
+        >>> fmt.datetime(datetime(2007, 4, 1, 15, 30))
+        u'Apr 1, 2007, 11:30:00\u202fAM'
+        """
+        return format_datetime(datetime, format, tzinfo=self.tzinfo, locale=self.locale)
+
+    def time(
+        self,
+        time: _datetime.time | _datetime.datetime | None = None,
+        format: _PredefinedTimeFormat | str = 'medium',
+    ) -> str:
+        """Return a time formatted according to the given pattern.
+
+        >>> from datetime import datetime
+        >>> from babel.dates import get_timezone
+        >>> fmt = Format('en_US', tzinfo=get_timezone('US/Eastern'))
+        >>> fmt.time(datetime(2007, 4, 1, 15, 30))
+        u'11:30:00\u202fAM'
+        """
+        return format_time(time, format, tzinfo=self.tzinfo, locale=self.locale)
+
+    def timedelta(
+        self,
+        delta: _datetime.timedelta | int,
+        granularity: Literal["year", "month", "week", "day", "hour", "minute", "second"] = "second",
+        threshold: float = 0.85,
+        format: Literal["narrow", "short", "medium", "long"] = "long",
+        add_direction: bool = False,
+    ) -> str:
+        """Return a time delta according to the rules of the given locale.
+
+        >>> from datetime import timedelta
+        >>> fmt = Format('en_US')
+        >>> fmt.timedelta(timedelta(weeks=11))
+        u'3 months'
+        """
+        return format_timedelta(delta, granularity=granularity,
+                                threshold=threshold,
+                                format=format, add_direction=add_direction,
+                                locale=self.locale)
+
+    def number(self, number: float | Decimal | str) -> str:
+        """Return an integer number formatted for the locale.
+
+        >>> fmt = Format('en_US')
+        >>> fmt.number(1099)
+        u'1,099'
+        """
+        return format_decimal(number, locale=self.locale, numbering_system=self.numbering_system)
+
+    def decimal(self, number: float | Decimal | str, format: str | None = None) -> str:
+        """Return a decimal number formatted for the locale.
+
+        >>> fmt = Format('en_US')
+        >>> fmt.decimal(1.2345)
+        u'1.234'
+        """
+        return format_decimal(number, format, locale=self.locale, numbering_system=self.numbering_system)
+
+    def compact_decimal(
+        self,
+        number: float | Decimal | str,
+        format_type: Literal['short', 'long'] = 'short',
+        fraction_digits: int = 0,
+    ) -> str:
+        """Return a number formatted in compact form for the locale.
+
+        >>> fmt = Format('en_US')
+        >>> fmt.compact_decimal(123456789)
+        u'123M'
+        >>> fmt.compact_decimal(1234567, format_type='long', fraction_digits=2)
+        '1.23 million'
+        """
+        return format_compact_decimal(
+            number,
+            format_type=format_type,
+            fraction_digits=fraction_digits,
+            locale=self.locale,
+            numbering_system=self.numbering_system,
+        )
+
+    def currency(self, number: float | Decimal | str, currency: str) -> str:
+        """Return a number in the given currency formatted for the locale.
+        """
+        return format_currency(number, currency, locale=self.locale, numbering_system=self.numbering_system)
+
+    def compact_currency(
+        self,
+        number: float | Decimal | str,
+        currency: str,
+        format_type: Literal['short'] = 'short',
+        fraction_digits: int = 0,
+    ) -> str:
+        """Return a number in the given currency formatted for the locale
+        using the compact number format.
+
+        >>> Format('en_US').compact_currency(1234567, "USD", format_type='short', fraction_digits=2)
+        '$1.23M'
+        """
+        return format_compact_currency(number, currency, format_type=format_type, fraction_digits=fraction_digits,
+                                       locale=self.locale, numbering_system=self.numbering_system)
+
+    def percent(self, number: float | Decimal | str, format: str | None = None) -> str:
+        """Return a number formatted as percentage for the locale.
+
+        >>> fmt = Format('en_US')
+        >>> fmt.percent(0.34)
+        u'34%'
+        """
+        return format_percent(number, format, locale=self.locale, numbering_system=self.numbering_system)
+
+    def scientific(self, number: float | Decimal | str) -> str:
+        """Return a number formatted using scientific notation for the locale.
+        """
+        return format_scientific(number, locale=self.locale, numbering_system=self.numbering_system)
+
+
+class LazyProxy:
+    """Class for proxy objects that delegate to a specified function to evaluate
+    the actual object.
+
+    >>> def greeting(name='world'):
+    ...     return 'Hello, %s!' % name
+    >>> lazy_greeting = LazyProxy(greeting, name='Joe')
+    >>> print(lazy_greeting)
+    Hello, Joe!
+    >>> u'  ' + lazy_greeting
+    u'  Hello, Joe!'
+    >>> u'(%s)' % lazy_greeting
+    u'(Hello, Joe!)'
+
+    This can be used, for example, to implement lazy translation functions that
+    delay the actual translation until the string is actually used. The
+    rationale for such behavior is that the locale of the user may not always
+    be available. In web applications, you only know the locale when processing
+    a request.
+
+    The proxy implementation attempts to be as complete as possible, so that
+    the lazy objects should mostly work as expected, for example for sorting:
+
+    >>> greetings = [
+    ...     LazyProxy(greeting, 'world'),
+    ...     LazyProxy(greeting, 'Joe'),
+    ...     LazyProxy(greeting, 'universe'),
+    ... ]
+    >>> greetings.sort()
+    >>> for greeting in greetings:
+    ...     print(greeting)
+    Hello, Joe!
+    Hello, universe!
+    Hello, world!
+    """
+    __slots__ = ['_func', '_args', '_kwargs', '_value', '_is_cache_enabled', '_attribute_error']
+
+    if TYPE_CHECKING:
+        _func: Callable[..., Any]
+        _args: tuple[Any, ...]
+        _kwargs: dict[str, Any]
+        _is_cache_enabled: bool
+        _value: Any
+        _attribute_error: AttributeError | None
+
+    def __init__(self, func: Callable[..., Any], *args: Any, enable_cache: bool = True, **kwargs: Any) -> None:
+        # Avoid triggering our own __setattr__ implementation
+        object.__setattr__(self, '_func', func)
+        object.__setattr__(self, '_args', args)
+        object.__setattr__(self, '_kwargs', kwargs)
+        object.__setattr__(self, '_is_cache_enabled', enable_cache)
+        object.__setattr__(self, '_value', None)
+        object.__setattr__(self, '_attribute_error', None)
+
+    @property
+    def value(self) -> Any:
+        if self._value is None:
+            try:
+                value = self._func(*self._args, **self._kwargs)
+            except AttributeError as error:
+                object.__setattr__(self, '_attribute_error', error)
+                raise
+
+            if not self._is_cache_enabled:
+                return value
+            object.__setattr__(self, '_value', value)
+        return self._value
+
+    def __contains__(self, key: object) -> bool:
+        return key in self.value
+
+    def __bool__(self) -> bool:
+        return bool(self.value)
+
+    def __dir__(self) -> list[str]:
+        return dir(self.value)
+
+    def __iter__(self) -> Iterator[Any]:
+        return iter(self.value)
+
+    def __len__(self) -> int:
+        return len(self.value)
+
+    def __str__(self) -> str:
+        return str(self.value)
+
+    def __add__(self, other: object) -> Any:
+        return self.value + other
+
+    def __radd__(self, other: object) -> Any:
+        return other + self.value
+
+    def __mod__(self, other: object) -> Any:
+        return self.value % other
+
+    def __rmod__(self, other: object) -> Any:
+        return other % self.value
+
+    def __mul__(self, other: object) -> Any:
+        return self.value * other
+
+    def __rmul__(self, other: object) -> Any:
+        return other * self.value
+
+    def __call__(self, *args: Any, **kwargs: Any) -> Any:
+        return self.value(*args, **kwargs)
+
+    def __lt__(self, other: object) -> bool:
+        return self.value < other
+
+    def __le__(self, other: object) -> bool:
+        return self.value <= other
+
+    def __eq__(self, other: object) -> bool:
+        return self.value == other
+
+    def __ne__(self, other: object) -> bool:
+        return self.value != other
+
+    def __gt__(self, other: object) -> bool:
+        return self.value > other
+
+    def __ge__(self, other: object) -> bool:
+        return self.value >= other
+
+    def __delattr__(self, name: str) -> None:
+        delattr(self.value, name)
+
+    def __getattr__(self, name: str) -> Any:
+        if self._attribute_error is not None:
+            raise self._attribute_error
+        return getattr(self.value, name)
+
+    def __setattr__(self, name: str, value: Any) -> None:
+        setattr(self.value, name, value)
+
+    def __delitem__(self, key: Any) -> None:
+        del self.value[key]
+
+    def __getitem__(self, key: Any) -> Any:
+        return self.value[key]
+
+    def __setitem__(self, key: Any, value: Any) -> None:
+        self.value[key] = value
+
+    def __copy__(self) -> LazyProxy:
+        return LazyProxy(
+            self._func,
+            enable_cache=self._is_cache_enabled,
+            *self._args,  # noqa: B026
+            **self._kwargs,
+        )
+
+    def __deepcopy__(self, memo: Any) -> LazyProxy:
+        from copy import deepcopy
+        return LazyProxy(
+            deepcopy(self._func, memo),
+            enable_cache=deepcopy(self._is_cache_enabled, memo),
+            *deepcopy(self._args, memo),  # noqa: B026
+            **deepcopy(self._kwargs, memo),
+        )
+
+
+class NullTranslations(gettext.NullTranslations):
+
+    if TYPE_CHECKING:
+        _info: dict[str, str]
+        _fallback: NullTranslations | None
+
+    DEFAULT_DOMAIN = None
+
+    def __init__(self, fp: gettext._TranslationsReader | None = None) -> None:
+        """Initialize a simple translations class which is not backed by a
+        real catalog. Behaves similar to gettext.NullTranslations but also
+        offers Babel's on *gettext methods (e.g. 'dgettext()').
+
+        :param fp: a file-like object (ignored in this class)
+        """
+        # These attributes are set by gettext.NullTranslations when a catalog
+        # is parsed (fp != None). Ensure that they are always present because
+        # some *gettext methods (including '.gettext()') rely on the attributes.
+        self._catalog: dict[tuple[str, Any] | str, str] = {}
+        self.plural: Callable[[float | Decimal], int] = lambda n: int(n != 1)
+        super().__init__(fp=fp)
+        self.files = list(filter(None, [getattr(fp, 'name', None)]))
+        self.domain = self.DEFAULT_DOMAIN
+        self._domains: dict[str, NullTranslations] = {}
+
+    def dgettext(self, domain: str, message: str) -> str:
+        """Like ``gettext()``, but look the message up in the specified
+        domain.
+        """
+        return self._domains.get(domain, self).gettext(message)
+
+    def ldgettext(self, domain: str, message: str) -> str:
+        """Like ``lgettext()``, but look the message up in the specified
+        domain.
+        """
+        import warnings
+        warnings.warn(
+            'ldgettext() is deprecated, use dgettext() instead',
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self._domains.get(domain, self).lgettext(message)
+
+    def udgettext(self, domain: str, message: str) -> str:
+        """Like ``ugettext()``, but look the message up in the specified
+        domain.
+        """
+        return self._domains.get(domain, self).ugettext(message)
+    # backward compatibility with 0.9
+    dugettext = udgettext
+
+    def dngettext(self, domain: str, singular: str, plural: str, num: int) -> str:
+        """Like ``ngettext()``, but look the message up in the specified
+        domain.
+        """
+        return self._domains.get(domain, self).ngettext(singular, plural, num)
+
+    def ldngettext(self, domain: str, singular: str, plural: str, num: int) -> str:
+        """Like ``lngettext()``, but look the message up in the specified
+        domain.
+        """
+        import warnings
+        warnings.warn(
+            'ldngettext() is deprecated, use dngettext() instead',
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self._domains.get(domain, self).lngettext(singular, plural, num)
+
+    def udngettext(self, domain: str, singular: str, plural: str, num: int) -> str:
+        """Like ``ungettext()`` but look the message up in the specified
+        domain.
+        """
+        return self._domains.get(domain, self).ungettext(singular, plural, num)
+    # backward compatibility with 0.9
+    dungettext = udngettext
+
+    # Most of the downwards code, until it gets included in stdlib, from:
+    #    https://bugs.python.org/file10036/gettext-pgettext.patch
+    #
+    # The encoding of a msgctxt and a msgid in a .mo file is
+    # msgctxt + "\x04" + msgid (gettext version >= 0.15)
+    CONTEXT_ENCODING = '%s\x04%s'
+
+    def pgettext(self, context: str, message: str) -> str | object:
+        """Look up the `context` and `message` id in the catalog and return the
+        corresponding message string, as an 8-bit string encoded with the
+        catalog's charset encoding, if known.  If there is no entry in the
+        catalog for the `message` id and `context` , and a fallback has been
+        set, the look up is forwarded to the fallback's ``pgettext()``
+        method. Otherwise, the `message` id is returned.
+        """
+        ctxt_msg_id = self.CONTEXT_ENCODING % (context, message)
+        missing = object()
+        tmsg = self._catalog.get(ctxt_msg_id, missing)
+        if tmsg is missing:
+            tmsg = self._catalog.get((ctxt_msg_id, self.plural(1)), missing)
+        if tmsg is not missing:
+            return tmsg
+        if self._fallback:
+            return self._fallback.pgettext(context, message)
+        return message
+
+    def lpgettext(self, context: str, message: str) -> str | bytes | object:
+        """Equivalent to ``pgettext()``, but the translation is returned in the
+        preferred system encoding, if no other encoding was explicitly set with
+        ``bind_textdomain_codeset()``.
+        """
+        import warnings
+        warnings.warn(
+            'lpgettext() is deprecated, use pgettext() instead',
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        tmsg = self.pgettext(context, message)
+        encoding = getattr(self, "_output_charset", None) or locale.getpreferredencoding()
+        return tmsg.encode(encoding) if isinstance(tmsg, str) else tmsg
+
+    def npgettext(self, context: str, singular: str, plural: str, num: int) -> str:
+        """Do a plural-forms lookup of a message id.  `singular` is used as the
+        message id for purposes of lookup in the catalog, while `num` is used to
+        determine which plural form to use.  The returned message string is an
+        8-bit string encoded with the catalog's charset encoding, if known.
+
+        If the message id for `context` is not found in the catalog, and a
+        fallback is specified, the request is forwarded to the fallback's
+        ``npgettext()`` method.  Otherwise, when ``num`` is 1 ``singular`` is
+        returned, and ``plural`` is returned in all other cases.
+        """
+        ctxt_msg_id = self.CONTEXT_ENCODING % (context, singular)
+        try:
+            tmsg = self._catalog[(ctxt_msg_id, self.plural(num))]
+            return tmsg
+        except KeyError:
+            if self._fallback:
+                return self._fallback.npgettext(context, singular, plural, num)
+            if num == 1:
+                return singular
+            else:
+                return plural
+
+    def lnpgettext(self, context: str, singular: str, plural: str, num: int) -> str | bytes:
+        """Equivalent to ``npgettext()``, but the translation is returned in the
+        preferred system encoding, if no other encoding was explicitly set with
+        ``bind_textdomain_codeset()``.
+        """
+        import warnings
+        warnings.warn(
+            'lnpgettext() is deprecated, use npgettext() instead',
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        ctxt_msg_id = self.CONTEXT_ENCODING % (context, singular)
+        try:
+            tmsg = self._catalog[(ctxt_msg_id, self.plural(num))]
+            encoding = getattr(self, "_output_charset", None) or locale.getpreferredencoding()
+            return tmsg.encode(encoding)
+        except KeyError:
+            if self._fallback:
+                return self._fallback.lnpgettext(context, singular, plural, num)
+            if num == 1:
+                return singular
+            else:
+                return plural
+
+    def upgettext(self, context: str, message: str) -> str:
+        """Look up the `context` and `message` id in the catalog and return the
+        corresponding message string, as a Unicode string.  If there is no entry
+        in the catalog for the `message` id and `context`, and a fallback has
+        been set, the look up is forwarded to the fallback's ``upgettext()``
+        method.  Otherwise, the `message` id is returned.
+        """
+        ctxt_message_id = self.CONTEXT_ENCODING % (context, message)
+        missing = object()
+        tmsg = self._catalog.get(ctxt_message_id, missing)
+        if tmsg is missing:
+            if self._fallback:
+                return self._fallback.upgettext(context, message)
+            return str(message)
+        assert isinstance(tmsg, str)
+        return tmsg
+
+    def unpgettext(self, context: str, singular: str, plural: str, num: int) -> str:
+        """Do a plural-forms lookup of a message id.  `singular` is used as the
+        message id for purposes of lookup in the catalog, while `num` is used to
+        determine which plural form to use.  The returned message string is a
+        Unicode string.
+
+        If the message id for `context` is not found in the catalog, and a
+        fallback is specified, the request is forwarded to the fallback's
+        ``unpgettext()`` method.  Otherwise, when `num` is 1 `singular` is
+        returned, and `plural` is returned in all other cases.
+        """
+        ctxt_message_id = self.CONTEXT_ENCODING % (context, singular)
+        try:
+            tmsg = self._catalog[(ctxt_message_id, self.plural(num))]
+        except KeyError:
+            if self._fallback:
+                return self._fallback.unpgettext(context, singular, plural, num)
+            tmsg = str(singular) if num == 1 else str(plural)
+        return tmsg
+
+    def dpgettext(self, domain: str, context: str, message: str) -> str | object:
+        """Like `pgettext()`, but look the message up in the specified
+        `domain`.
+        """
+        return self._domains.get(domain, self).pgettext(context, message)
+
+    def udpgettext(self, domain: str, context: str, message: str) -> str:
+        """Like `upgettext()`, but look the message up in the specified
+        `domain`.
+        """
+        return self._domains.get(domain, self).upgettext(context, message)
+    # backward compatibility with 0.9
+    dupgettext = udpgettext
+
+    def ldpgettext(self, domain: str, context: str, message: str) -> str | bytes | object:
+        """Equivalent to ``dpgettext()``, but the translation is returned in the
+        preferred system encoding, if no other encoding was explicitly set with
+        ``bind_textdomain_codeset()``.
+        """
+        return self._domains.get(domain, self).lpgettext(context, message)
+
+    def dnpgettext(self, domain: str, context: str, singular: str, plural: str, num: int) -> str:
+        """Like ``npgettext``, but look the message up in the specified
+        `domain`.
+        """
+        return self._domains.get(domain, self).npgettext(context, singular,
+                                                         plural, num)
+
+    def udnpgettext(self, domain: str, context: str, singular: str, plural: str, num: int) -> str:
+        """Like ``unpgettext``, but look the message up in the specified
+        `domain`.
+        """
+        return self._domains.get(domain, self).unpgettext(context, singular,
+                                                          plural, num)
+    # backward compatibility with 0.9
+    dunpgettext = udnpgettext
+
+    def ldnpgettext(self, domain: str, context: str, singular: str, plural: str, num: int) -> str | bytes:
+        """Equivalent to ``dnpgettext()``, but the translation is returned in
+        the preferred system encoding, if no other encoding was explicitly set
+        with ``bind_textdomain_codeset()``.
+        """
+        return self._domains.get(domain, self).lnpgettext(context, singular,
+                                                          plural, num)
+
+    ugettext = gettext.NullTranslations.gettext
+    ungettext = gettext.NullTranslations.ngettext
+
+
+class Translations(NullTranslations, gettext.GNUTranslations):
+    """An extended translation catalog class."""
+
+    DEFAULT_DOMAIN = 'messages'
+
+    def __init__(self, fp: gettext._TranslationsReader | None = None, domain: str | None = None):
+        """Initialize the translations catalog.
+
+        :param fp: the file-like object the translation should be read from
+        :param domain: the message domain (default: 'messages')
+        """
+        super().__init__(fp=fp)
+        self.domain = domain or self.DEFAULT_DOMAIN
+
+    ugettext = gettext.GNUTranslations.gettext
+    ungettext = gettext.GNUTranslations.ngettext
+
+    @classmethod
+    def load(
+        cls,
+        dirname: str | os.PathLike[str] | None = None,
+        locales: Iterable[str | Locale] | Locale | str | None = None,
+        domain: str | None = None,
+    ) -> NullTranslations:
+        """Load translations from the given directory.
+
+        :param dirname: the directory containing the ``MO`` files
+        :param locales: the list of locales in order of preference (items in
+                        this list can be either `Locale` objects or locale
+                        strings)
+        :param domain: the message domain (default: 'messages')
+        """
+        if not domain:
+            domain = cls.DEFAULT_DOMAIN
+        filename = gettext.find(domain, dirname, _locales_to_names(locales))
+        if not filename:
+            return NullTranslations()
+        with open(filename, 'rb') as fp:
+            return cls(fp=fp, domain=domain)
+
+    def __repr__(self) -> str:
+        version = self._info.get('project-id-version')
+        return f'<{type(self).__name__}: "{version}">'
+
+    def add(self, translations: Translations, merge: bool = True):
+        """Add the given translations to the catalog.
+
+        If the domain of the translations is different than that of the
+        current catalog, they are added as a catalog that is only accessible
+        by the various ``d*gettext`` functions.
+
+        :param translations: the `Translations` instance with the messages to
+                             add
+        :param merge: whether translations for message domains that have
+                      already been added should be merged with the existing
+                      translations
+        """
+        domain = getattr(translations, 'domain', self.DEFAULT_DOMAIN)
+        if merge and domain == self.domain:
+            return self.merge(translations)
+
+        existing = self._domains.get(domain)
+        if merge and isinstance(existing, Translations):
+            existing.merge(translations)
+        else:
+            translations.add_fallback(self)
+            self._domains[domain] = translations
+
+        return self
+
+    def merge(self, translations: Translations):
+        """Merge the given translations into the catalog.
+
+        Message translations in the specified catalog override any messages
+        with the same identifier in the existing catalog.
+
+        :param translations: the `Translations` instance with the messages to
+                             merge
+        """
+        if isinstance(translations, gettext.GNUTranslations):
+            self._catalog.update(translations._catalog)
+            if isinstance(translations, Translations):
+                self.files.extend(translations.files)
+
+        return self
+
+
+def _locales_to_names(
+    locales: Iterable[str | Locale] | Locale | str | None,
+) -> list[str] | None:
+    """Normalize a `locales` argument to a list of locale names.
+
+    :param locales: the list of locales in order of preference (items in
+                    this list can be either `Locale` objects or locale
+                    strings)
+    """
+    if locales is None:
+        return None
+    if isinstance(locales, Locale):
+        return [str(locales)]
+    if isinstance(locales, str):
+        return [locales]
+    return [str(locale) for locale in locales]

lib/python3.10/site-packages/babel/units.py

@@ -0,0 +1,340 @@
+from __future__ import annotations
+
+import decimal
+from typing import Literal
+
+from babel.core import Locale
+from babel.numbers import LC_NUMERIC, format_decimal
+
+
+class UnknownUnitError(ValueError):
+    def __init__(self, unit: str, locale: Locale) -> None:
+        ValueError.__init__(self, f"{unit} is not a known unit in {locale}")
+
+
+def get_unit_name(
+    measurement_unit: str,
+    length: Literal['short', 'long', 'narrow'] = 'long',
+    locale: Locale | str | None = None,
+) -> str | None:
+    """
+    Get the display name for a measurement unit in the given locale.
+
+    >>> get_unit_name("radian", locale="en")
+    'radians'
+
+    Unknown units will raise exceptions:
+
+    >>> get_unit_name("battery", locale="fi")
+    Traceback (most recent call last):
+        ...
+    UnknownUnitError: battery/long is not a known unit/length in fi
+
+    :param measurement_unit: the code of a measurement unit.
+                             Known units can be found in the CLDR Unit Validity XML file:
+                             https://unicode.org/repos/cldr/tags/latest/common/validity/unit.xml
+
+    :param length: "short", "long" or "narrow"
+    :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
+    :return: The unit display name, or None.
+    """
+    locale = Locale.parse(locale or LC_NUMERIC)
+    unit = _find_unit_pattern(measurement_unit, locale=locale)
+    if not unit:
+        raise UnknownUnitError(unit=measurement_unit, locale=locale)
+    return locale.unit_display_names.get(unit, {}).get(length)
+
+
+def _find_unit_pattern(unit_id: str, locale: Locale | str | None = None) -> str | None:
+    """
+    Expand a unit into a qualified form.
+
+    Known units can be found in the CLDR Unit Validity XML file:
+    https://unicode.org/repos/cldr/tags/latest/common/validity/unit.xml
+
+    >>> _find_unit_pattern("radian", locale="en")
+    'angle-radian'
+
+    Unknown values will return None.
+
+    >>> _find_unit_pattern("horse", locale="en")
+
+    :param unit_id: the code of a measurement unit.
+    :return: A key to the `unit_patterns` mapping, or None.
+    """
+    locale = Locale.parse(locale or LC_NUMERIC)
+    unit_patterns: dict[str, str] = locale._data["unit_patterns"]
+    if unit_id in unit_patterns:
+        return unit_id
+    for unit_pattern in sorted(unit_patterns, key=len):
+        if unit_pattern.endswith(unit_id):
+            return unit_pattern
+    return None
+
+
+def format_unit(
+    value: str | float | decimal.Decimal,
+    measurement_unit: str,
+    length: Literal['short', 'long', 'narrow'] = 'long',
+    format: str | None = None,
+    locale: Locale | str | None = None,
+    *,
+    numbering_system: Literal["default"] | str = "latn",
+) -> str:
+    """Format a value of a given unit.
+
+    Values are formatted according to the locale's usual pluralization rules
+    and number formats.
+
+    >>> format_unit(12, 'length-meter', locale='ro_RO')
+    u'12 metri'
+    >>> format_unit(15.5, 'length-mile', locale='fi_FI')
+    u'15,5 mailia'
+    >>> format_unit(1200, 'pressure-millimeter-ofhg', locale='nb')
+    u'1\\xa0200 millimeter kvikks\\xf8lv'
+    >>> format_unit(270, 'ton', locale='en')
+    u'270 tons'
+    >>> format_unit(1234.5, 'kilogram', locale='ar_EG', numbering_system='default')
+    u'1٬234٫5 كيلوغرام'
+
+    Number formats may be overridden with the ``format`` parameter.
+
+    >>> import decimal
+    >>> format_unit(decimal.Decimal("-42.774"), 'temperature-celsius', 'short', format='#.0', locale='fr')
+    u'-42,8\\u202f\\xb0C'
+
+    The locale's usual pluralization rules are respected.
+
+    >>> format_unit(1, 'length-meter', locale='ro_RO')
+    u'1 metru'
+    >>> format_unit(0, 'length-mile', locale='cy')
+    u'0 mi'
+    >>> format_unit(1, 'length-mile', locale='cy')
+    u'1 filltir'
+    >>> format_unit(3, 'length-mile', locale='cy')
+    u'3 milltir'
+
+    >>> format_unit(15, 'length-horse', locale='fi')
+    Traceback (most recent call last):
+        ...
+    UnknownUnitError: length-horse is not a known unit in fi
+
+    .. versionadded:: 2.2.0
+
+    :param value: the value to format. If this is a string, no number formatting will be attempted.
+    :param measurement_unit: the code of a measurement unit.
+                             Known units can be found in the CLDR Unit Validity XML file:
+                             https://unicode.org/repos/cldr/tags/latest/common/validity/unit.xml
+    :param length: "short", "long" or "narrow"
+    :param format: An optional format, as accepted by `format_decimal`.
+    :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
+    :param numbering_system: The numbering system used for formatting number symbols. Defaults to "latn".
+                             The special value "default" will use the default numbering system of the locale.
+    :raise `UnsupportedNumberingSystemError`: If the numbering system is not supported by the locale.
+    """
+    locale = Locale.parse(locale or LC_NUMERIC)
+
+    q_unit = _find_unit_pattern(measurement_unit, locale=locale)
+    if not q_unit:
+        raise UnknownUnitError(unit=measurement_unit, locale=locale)
+    unit_patterns = locale._data["unit_patterns"][q_unit].get(length, {})
+
+    if isinstance(value, str):  # Assume the value is a preformatted singular.
+        formatted_value = value
+        plural_form = "one"
+    else:
+        formatted_value = format_decimal(value, format, locale, numbering_system=numbering_system)
+        plural_form = locale.plural_form(value)
+
+    if plural_form in unit_patterns:
+        return unit_patterns[plural_form].format(formatted_value)
+
+    # Fall back to a somewhat bad representation.
+    # nb: This is marked as no-cover, as the current CLDR seemingly has no way for this to happen.
+    fallback_name = get_unit_name(measurement_unit, length=length, locale=locale)  # pragma: no cover
+    return f"{formatted_value} {fallback_name or measurement_unit}"  # pragma: no cover
+
+
+def _find_compound_unit(
+    numerator_unit: str,
+    denominator_unit: str,
+    locale: Locale | str | None = None,
+) -> str | None:
+    """
+    Find a predefined compound unit pattern.
+
+    Used internally by format_compound_unit.
+
+    >>> _find_compound_unit("kilometer", "hour", locale="en")
+    'speed-kilometer-per-hour'
+
+    >>> _find_compound_unit("mile", "gallon", locale="en")
+    'consumption-mile-per-gallon'
+
+    If no predefined compound pattern can be found, `None` is returned.
+
+    >>> _find_compound_unit("gallon", "mile", locale="en")
+
+    >>> _find_compound_unit("horse", "purple", locale="en")
+
+    :param numerator_unit: The numerator unit's identifier
+    :param denominator_unit: The denominator unit's identifier
+    :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
+    :return: A key to the `unit_patterns` mapping, or None.
+    :rtype: str|None
+    """
+    locale = Locale.parse(locale or LC_NUMERIC)
+
+    # Qualify the numerator and denominator units.  This will turn possibly partial
+    # units like "kilometer" or "hour" into actual units like "length-kilometer" and
+    # "duration-hour".
+
+    resolved_numerator_unit = _find_unit_pattern(numerator_unit, locale=locale)
+    resolved_denominator_unit = _find_unit_pattern(denominator_unit, locale=locale)
+
+    # If either was not found, we can't possibly build a suitable compound unit either.
+    if not (resolved_numerator_unit and resolved_denominator_unit):
+        return None
+
+    # Since compound units are named "speed-kilometer-per-hour", we'll have to slice off
+    # the quantities (i.e. "length", "duration") from both qualified units.
+
+    bare_numerator_unit = resolved_numerator_unit.split("-", 1)[-1]
+    bare_denominator_unit = resolved_denominator_unit.split("-", 1)[-1]
+
+    # Now we can try and rebuild a compound unit specifier, then qualify it:
+
+    return _find_unit_pattern(f"{bare_numerator_unit}-per-{bare_denominator_unit}", locale=locale)
+
+
+def format_compound_unit(
+    numerator_value: str | float | decimal.Decimal,
+    numerator_unit: str | None = None,
+    denominator_value: str | float | decimal.Decimal = 1,
+    denominator_unit: str | None = None,
+    length: Literal["short", "long", "narrow"] = "long",
+    format: str | None = None,
+    locale: Locale | str | None = None,
+    *,
+    numbering_system: Literal["default"] | str = "latn",
+) -> str | None:
+    """
+    Format a compound number value, i.e. "kilometers per hour" or similar.
+
+    Both unit specifiers are optional to allow for formatting of arbitrary values still according
+    to the locale's general "per" formatting specifier.
+
+    >>> format_compound_unit(7, denominator_value=11, length="short", locale="pt")
+    '7/11'
+
+    >>> format_compound_unit(150, "kilometer", denominator_unit="hour", locale="sv")
+    '150 kilometer per timme'
+
+    >>> format_compound_unit(150, "kilowatt", denominator_unit="year", locale="fi")
+    '150 kilowattia / vuosi'
+
+    >>> format_compound_unit(32.5, "ton", 15, denominator_unit="hour", locale="en")
+    '32.5 tons per 15 hours'
+
+    >>> format_compound_unit(1234.5, "ton", 15, denominator_unit="hour", locale="ar_EG", numbering_system="arab")
+    '1٬234٫5 طن لكل 15 ساعة'
+
+    >>> format_compound_unit(160, denominator_unit="square-meter", locale="fr")
+    '160 par m\\xe8tre carr\\xe9'
+
+    >>> format_compound_unit(4, "meter", "ratakisko", length="short", locale="fi")
+    '4 m/ratakisko'
+
+    >>> format_compound_unit(35, "minute", denominator_unit="nautical-mile", locale="sv")
+    '35 minuter per nautisk mil'
+
+    >>> from babel.numbers import format_currency
+    >>> format_compound_unit(format_currency(35, "JPY", locale="de"), denominator_unit="liter", locale="de")
+    '35\\xa0\\xa5 pro Liter'
+
+    See https://www.unicode.org/reports/tr35/tr35-general.html#perUnitPatterns
+
+    :param numerator_value: The numerator value. This may be a string,
+                            in which case it is considered preformatted and the unit is ignored.
+    :param numerator_unit: The numerator unit. See `format_unit`.
+    :param denominator_value: The denominator value. This may be a string,
+                              in which case it is considered preformatted and the unit is ignored.
+    :param denominator_unit: The denominator unit. See `format_unit`.
+    :param length: The formatting length. "short", "long" or "narrow"
+    :param format: An optional format, as accepted by `format_decimal`.
+    :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
+    :param numbering_system: The numbering system used for formatting number symbols. Defaults to "latn".
+                             The special value "default" will use the default numbering system of the locale.
+    :return: A formatted compound value.
+    :raise `UnsupportedNumberingSystemError`: If the numbering system is not supported by the locale.
+    """
+    locale = Locale.parse(locale or LC_NUMERIC)
+
+    # Look for a specific compound unit first...
+
+    if numerator_unit and denominator_unit and denominator_value == 1:
+        compound_unit = _find_compound_unit(numerator_unit, denominator_unit, locale=locale)
+        if compound_unit:
+            return format_unit(
+                numerator_value,
+                compound_unit,
+                length=length,
+                format=format,
+                locale=locale,
+                numbering_system=numbering_system,
+            )
+
+    # ... failing that, construct one "by hand".
+
+    if isinstance(numerator_value, str):  # Numerator is preformatted
+        formatted_numerator = numerator_value
+    elif numerator_unit:  # Numerator has unit
+        formatted_numerator = format_unit(
+            numerator_value,
+            numerator_unit,
+            length=length,
+            format=format,
+            locale=locale,
+            numbering_system=numbering_system,
+        )
+    else:  # Unitless numerator
+        formatted_numerator = format_decimal(
+            numerator_value,
+            format=format,
+            locale=locale,
+            numbering_system=numbering_system,
+        )
+
+    if isinstance(denominator_value, str):  # Denominator is preformatted
+        formatted_denominator = denominator_value
+    elif denominator_unit:  # Denominator has unit
+        if denominator_value == 1:  # support perUnitPatterns when the denominator is 1
+            denominator_unit = _find_unit_pattern(denominator_unit, locale=locale)
+            per_pattern = locale._data["unit_patterns"].get(denominator_unit, {}).get(length, {}).get("per")
+            if per_pattern:
+                return per_pattern.format(formatted_numerator)
+            # See TR-35's per-unit pattern algorithm, point 3.2.
+            # For denominator 1, we replace the value to be formatted with the empty string;
+            # this will make `format_unit` return " second" instead of "1 second".
+            denominator_value = ""
+
+        formatted_denominator = format_unit(
+            denominator_value,
+            measurement_unit=(denominator_unit or ""),
+            length=length,
+            format=format,
+            locale=locale,
+            numbering_system=numbering_system,
+        ).strip()
+    else:  # Bare denominator
+        formatted_denominator = format_decimal(
+            denominator_value,
+            format=format,
+            locale=locale,
+            numbering_system=numbering_system,
+        )
+
+    # TODO: this doesn't support "compound_variations" (or "prefix"), and will fall back to the "x/y" representation
+    per_pattern = locale._data["compound_unit_patterns"].get("per", {}).get(length, {}).get("compound", "{0}/{1}")
+
+    return per_pattern.format(formatted_numerator, formatted_denominator)

lib/python3.10/site-packages/babel/util.py

@@ -0,0 +1,296 @@
+"""
+    babel.util
+    ~~~~~~~~~~
+
+    Various utility classes and functions.
+
+    :copyright: (c) 2013-2025 by the Babel Team.
+    :license: BSD, see LICENSE for more details.
+"""
+from __future__ import annotations
+
+import codecs
+import datetime
+import os
+import re
+import textwrap
+import warnings
+from collections.abc import Generator, Iterable
+from typing import IO, Any, TypeVar
+
+from babel import dates, localtime
+
+missing = object()
+
+_T = TypeVar("_T")
+
+
+def distinct(iterable: Iterable[_T]) -> Generator[_T, None, None]:
+    """Yield all items in an iterable collection that are distinct.
+
+    Unlike when using sets for a similar effect, the original ordering of the
+    items in the collection is preserved by this function.
+
+    >>> print(list(distinct([1, 2, 1, 3, 4, 4])))
+    [1, 2, 3, 4]
+    >>> print(list(distinct('foobar')))
+    ['f', 'o', 'b', 'a', 'r']
+
+    :param iterable: the iterable collection providing the data
+    """
+    seen = set()
+    for item in iter(iterable):
+        if item not in seen:
+            yield item
+            seen.add(item)
+
+
+# Regexp to match python magic encoding line
+PYTHON_MAGIC_COMMENT_re = re.compile(
+    br'[ \t\f]* \# .* coding[=:][ \t]*([-\w.]+)', re.VERBOSE)
+
+
+def parse_encoding(fp: IO[bytes]) -> str | None:
+    """Deduce the encoding of a source file from magic comment.
+
+    It does this in the same way as the `Python interpreter`__
+
+    .. __: https://docs.python.org/3.4/reference/lexical_analysis.html#encoding-declarations
+
+    The ``fp`` argument should be a seekable file object.
+
+    (From Jeff Dairiki)
+    """
+    pos = fp.tell()
+    fp.seek(0)
+    try:
+        line1 = fp.readline()
+        has_bom = line1.startswith(codecs.BOM_UTF8)
+        if has_bom:
+            line1 = line1[len(codecs.BOM_UTF8):]
+
+        m = PYTHON_MAGIC_COMMENT_re.match(line1)
+        if not m:
+            try:
+                import ast
+                ast.parse(line1.decode('latin-1'))
+            except (ImportError, SyntaxError, UnicodeEncodeError):
+                # Either it's a real syntax error, in which case the source is
+                # not valid python source, or line2 is a continuation of line1,
+                # in which case we don't want to scan line2 for a magic
+                # comment.
+                pass
+            else:
+                line2 = fp.readline()
+                m = PYTHON_MAGIC_COMMENT_re.match(line2)
+
+        if has_bom:
+            if m:
+                magic_comment_encoding = m.group(1).decode('latin-1')
+                if magic_comment_encoding != 'utf-8':
+                    raise SyntaxError(f"encoding problem: {magic_comment_encoding} with BOM")
+            return 'utf-8'
+        elif m:
+            return m.group(1).decode('latin-1')
+        else:
+            return None
+    finally:
+        fp.seek(pos)
+
+
+PYTHON_FUTURE_IMPORT_re = re.compile(
+    r'from\s+__future__\s+import\s+\(*(.+)\)*')
+
+
+def parse_future_flags(fp: IO[bytes], encoding: str = 'latin-1') -> int:
+    """Parse the compiler flags by :mod:`__future__` from the given Python
+    code.
+    """
+    import __future__
+    pos = fp.tell()
+    fp.seek(0)
+    flags = 0
+    try:
+        body = fp.read().decode(encoding)
+
+        # Fix up the source to be (hopefully) parsable by regexpen.
+        # This will likely do untoward things if the source code itself is broken.
+
+        # (1) Fix `import (\n...` to be `import (...`.
+        body = re.sub(r'import\s*\([\r\n]+', 'import (', body)
+        # (2) Join line-ending commas with the next line.
+        body = re.sub(r',\s*[\r\n]+', ', ', body)
+        # (3) Remove backslash line continuations.
+        body = re.sub(r'\\\s*[\r\n]+', ' ', body)
+
+        for m in PYTHON_FUTURE_IMPORT_re.finditer(body):
+            names = [x.strip().strip('()') for x in m.group(1).split(',')]
+            for name in names:
+                feature = getattr(__future__, name, None)
+                if feature:
+                    flags |= feature.compiler_flag
+    finally:
+        fp.seek(pos)
+    return flags
+
+
+def pathmatch(pattern: str, filename: str) -> bool:
+    """Extended pathname pattern matching.
+
+    This function is similar to what is provided by the ``fnmatch`` module in
+    the Python standard library, but:
+
+     * can match complete (relative or absolute) path names, and not just file
+       names, and
+     * also supports a convenience pattern ("**") to match files at any
+       directory level.
+
+    Examples:
+
+    >>> pathmatch('**.py', 'bar.py')
+    True
+    >>> pathmatch('**.py', 'foo/bar/baz.py')
+    True
+    >>> pathmatch('**.py', 'templates/index.html')
+    False
+
+    >>> pathmatch('./foo/**.py', 'foo/bar/baz.py')
+    True
+    >>> pathmatch('./foo/**.py', 'bar/baz.py')
+    False
+
+    >>> pathmatch('^foo/**.py', 'foo/bar/baz.py')
+    True
+    >>> pathmatch('^foo/**.py', 'bar/baz.py')
+    False
+
+    >>> pathmatch('**/templates/*.html', 'templates/index.html')
+    True
+    >>> pathmatch('**/templates/*.html', 'templates/foo/bar.html')
+    False
+
+    :param pattern: the glob pattern
+    :param filename: the path name of the file to match against
+    """
+    symbols = {
+        '?': '[^/]',
+        '?/': '[^/]/',
+        '*': '[^/]+',
+        '*/': '[^/]+/',
+        '**/': '(?:.+/)*?',
+        '**': '(?:.+/)*?[^/]+',
+    }
+
+    if pattern.startswith('^'):
+        buf = ['^']
+        pattern = pattern[1:]
+    elif pattern.startswith('./'):
+        buf = ['^']
+        pattern = pattern[2:]
+    else:
+        buf = []
+
+    for idx, part in enumerate(re.split('([?*]+/?)', pattern)):
+        if idx % 2:
+            buf.append(symbols[part])
+        elif part:
+            buf.append(re.escape(part))
+    match = re.match(f"{''.join(buf)}$", filename.replace(os.sep, "/"))
+    return match is not None
+
+
+class TextWrapper(textwrap.TextWrapper):
+    wordsep_re = re.compile(
+        r'(\s+|'                                  # any whitespace
+        r'(?<=[\w\!\"\'\&\.\,\?])-{2,}(?=\w))',   # em-dash
+    )
+
+    # e.g. '\u2068foo bar.py\u2069:42'
+    _enclosed_filename_re = re.compile(r'(\u2068[^\u2068]+?\u2069(?::-?\d+)?)')
+
+    def _split(self, text):
+        """Splits the text into indivisible chunks while ensuring that file names
+        containing spaces are not broken up.
+        """
+        enclosed_filename_start = '\u2068'
+        if enclosed_filename_start not in text:
+            # There are no file names which contain spaces, fallback to the default implementation
+            return super()._split(text)
+
+        chunks = []
+        for chunk in re.split(self._enclosed_filename_re, text):
+            if chunk.startswith(enclosed_filename_start):
+                chunks.append(chunk)
+            else:
+                chunks.extend(super()._split(chunk))
+        return [c for c in chunks if c]
+
+
+def wraptext(text: str, width: int = 70, initial_indent: str = '', subsequent_indent: str = '') -> list[str]:
+    """Simple wrapper around the ``textwrap.wrap`` function in the standard
+    library. This version does not wrap lines on hyphens in words. It also
+    does not wrap PO file locations containing spaces.
+
+    :param text: the text to wrap
+    :param width: the maximum line width
+    :param initial_indent: string that will be prepended to the first line of
+                           wrapped output
+    :param subsequent_indent: string that will be prepended to all lines save
+                              the first of wrapped output
+    """
+    warnings.warn(
+        "`babel.util.wraptext` is deprecated and will be removed in a future version of Babel. "
+        "If you need this functionality, use the `babel.util.TextWrapper` class directly.",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    wrapper = TextWrapper(width=width, initial_indent=initial_indent,
+                          subsequent_indent=subsequent_indent,
+                          break_long_words=False)
+    return wrapper.wrap(text)
+
+
+# TODO (Babel 3.x): Remove this re-export
+odict = dict
+
+
+class FixedOffsetTimezone(datetime.tzinfo):
+    """Fixed offset in minutes east from UTC."""
+
+    def __init__(self, offset: float, name: str | None = None) -> None:
+
+        self._offset = datetime.timedelta(minutes=offset)
+        if name is None:
+            name = 'Etc/GMT%+d' % offset
+        self.zone = name
+
+    def __str__(self) -> str:
+        return self.zone
+
+    def __repr__(self) -> str:
+        return f'<FixedOffset "{self.zone}" {self._offset}>'
+
+    def utcoffset(self, dt: datetime.datetime) -> datetime.timedelta:
+        return self._offset
+
+    def tzname(self, dt: datetime.datetime) -> str:
+        return self.zone
+
+    def dst(self, dt: datetime.datetime) -> datetime.timedelta:
+        return ZERO
+
+
+# Export the localtime functionality here because that's
+# where it was in the past.
+# TODO(3.0): remove these aliases
+UTC = dates.UTC
+LOCALTZ = dates.LOCALTZ
+get_localzone = localtime.get_localzone
+STDOFFSET = localtime.STDOFFSET
+DSTOFFSET = localtime.DSTOFFSET
+DSTDIFF = localtime.DSTDIFF
+ZERO = localtime.ZERO
+
+
+def _cmp(a: Any, b: Any):
+    return (a > b) - (a < b)

lib/python3.10/site-packages/colorama/__init__.py

@@ -0,0 +1,7 @@
+# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file.
+from .initialise import init, deinit, reinit, colorama_text, just_fix_windows_console
+from .ansi import Fore, Back, Style, Cursor
+from .ansitowin32 import AnsiToWin32
+
+__version__ = '0.4.6'
+

lib/python3.10/site-packages/colorama/ansi.py

@@ -0,0 +1,102 @@
+# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file.
+'''
+This module generates ANSI character codes to printing colors to terminals.
+See: http://en.wikipedia.org/wiki/ANSI_escape_code
+'''
+
+CSI = '\033['
+OSC = '\033]'
+BEL = '\a'
+
+
+def code_to_chars(code):
+    return CSI + str(code) + 'm'
+
+def set_title(title):
+    return OSC + '2;' + title + BEL
+
+def clear_screen(mode=2):
+    return CSI + str(mode) + 'J'
+
+def clear_line(mode=2):
+    return CSI + str(mode) + 'K'
+
+
+class AnsiCodes(object):
+    def __init__(self):
+        # the subclasses declare class attributes which are numbers.
+        # Upon instantiation we define instance attributes, which are the same
+        # as the class attributes but wrapped with the ANSI escape sequence
+        for name in dir(self):
+            if not name.startswith('_'):
+                value = getattr(self, name)
+                setattr(self, name, code_to_chars(value))
+
+
+class AnsiCursor(object):
+    def UP(self, n=1):
+        return CSI + str(n) + 'A'
+    def DOWN(self, n=1):
+        return CSI + str(n) + 'B'
+    def FORWARD(self, n=1):
+        return CSI + str(n) + 'C'
+    def BACK(self, n=1):
+        return CSI + str(n) + 'D'
+    def POS(self, x=1, y=1):
+        return CSI + str(y) + ';' + str(x) + 'H'
+
+
+class AnsiFore(AnsiCodes):
+    BLACK           = 30
+    RED             = 31
+    GREEN           = 32
+    YELLOW          = 33
+    BLUE            = 34
+    MAGENTA         = 35
+    CYAN            = 36
+    WHITE           = 37
+    RESET           = 39
+
+    # These are fairly well supported, but not part of the standard.
+    LIGHTBLACK_EX   = 90
+    LIGHTRED_EX     = 91
+    LIGHTGREEN_EX   = 92
+    LIGHTYELLOW_EX  = 93
+    LIGHTBLUE_EX    = 94
+    LIGHTMAGENTA_EX = 95
+    LIGHTCYAN_EX    = 96
+    LIGHTWHITE_EX   = 97
+
+
+class AnsiBack(AnsiCodes):
+    BLACK           = 40
+    RED             = 41
+    GREEN           = 42
+    YELLOW          = 43
+    BLUE            = 44
+    MAGENTA         = 45
+    CYAN            = 46
+    WHITE           = 47
+    RESET           = 49
+
+    # These are fairly well supported, but not part of the standard.
+    LIGHTBLACK_EX   = 100
+    LIGHTRED_EX     = 101
+    LIGHTGREEN_EX   = 102
+    LIGHTYELLOW_EX  = 103
+    LIGHTBLUE_EX    = 104
+    LIGHTMAGENTA_EX = 105
+    LIGHTCYAN_EX    = 106
+    LIGHTWHITE_EX   = 107
+
+
+class AnsiStyle(AnsiCodes):
+    BRIGHT    = 1
+    DIM       = 2
+    NORMAL    = 22
+    RESET_ALL = 0
+
+Fore   = AnsiFore()
+Back   = AnsiBack()
+Style  = AnsiStyle()
+Cursor = AnsiCursor()

lib/python3.10/site-packages/colorama/ansitowin32.py

@@ -0,0 +1,277 @@
+# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file.
+import re
+import sys
+import os
+
+from .ansi import AnsiFore, AnsiBack, AnsiStyle, Style, BEL
+from .winterm import enable_vt_processing, WinTerm, WinColor, WinStyle
+from .win32 import windll, winapi_test
+
+
+winterm = None
+if windll is not None:
+    winterm = WinTerm()
+
+
+class StreamWrapper(object):
+    '''
+    Wraps a stream (such as stdout), acting as a transparent proxy for all
+    attribute access apart from method 'write()', which is delegated to our
+    Converter instance.
+    '''
+    def __init__(self, wrapped, converter):
+        # double-underscore everything to prevent clashes with names of
+        # attributes on the wrapped stream object.
+        self.__wrapped = wrapped
+        self.__convertor = converter
+
+    def __getattr__(self, name):
+        return getattr(self.__wrapped, name)
+
+    def __enter__(self, *args, **kwargs):
+        # special method lookup bypasses __getattr__/__getattribute__, see
+        # https://stackoverflow.com/questions/12632894/why-doesnt-getattr-work-with-exit
+        # thus, contextlib magic methods are not proxied via __getattr__
+        return self.__wrapped.__enter__(*args, **kwargs)
+
+    def __exit__(self, *args, **kwargs):
+        return self.__wrapped.__exit__(*args, **kwargs)
+
+    def __setstate__(self, state):
+        self.__dict__ = state
+
+    def __getstate__(self):
+        return self.__dict__
+
+    def write(self, text):
+        self.__convertor.write(text)
+
+    def isatty(self):
+        stream = self.__wrapped
+        if 'PYCHARM_HOSTED' in os.environ:
+            if stream is not None and (stream is sys.__stdout__ or stream is sys.__stderr__):
+                return True
+        try:
+            stream_isatty = stream.isatty
+        except AttributeError:
+            return False
+        else:
+            return stream_isatty()
+
+    @property
+    def closed(self):
+        stream = self.__wrapped
+        try:
+            return stream.closed
+        # AttributeError in the case that the stream doesn't support being closed
+        # ValueError for the case that the stream has already been detached when atexit runs
+        except (AttributeError, ValueError):
+            return True
+
+
+class AnsiToWin32(object):
+    '''
+    Implements a 'write()' method which, on Windows, will strip ANSI character
+    sequences from the text, and if outputting to a tty, will convert them into
+    win32 function calls.
+    '''
+    ANSI_CSI_RE = re.compile('\001?\033\\[((?:\\d|;)*)([a-zA-Z])\002?')   # Control Sequence Introducer
+    ANSI_OSC_RE = re.compile('\001?\033\\]([^\a]*)(\a)\002?')             # Operating System Command
+
+    def __init__(self, wrapped, convert=None, strip=None, autoreset=False):
+        # The wrapped stream (normally sys.stdout or sys.stderr)
+        self.wrapped = wrapped
+
+        # should we reset colors to defaults after every .write()
+        self.autoreset = autoreset
+
+        # create the proxy wrapping our output stream
+        self.stream = StreamWrapper(wrapped, self)
+
+        on_windows = os.name == 'nt'
+        # We test if the WinAPI works, because even if we are on Windows
+        # we may be using a terminal that doesn't support the WinAPI
+        # (e.g. Cygwin Terminal). In this case it's up to the terminal
+        # to support the ANSI codes.
+        conversion_supported = on_windows and winapi_test()
+        try:
+            fd = wrapped.fileno()
+        except Exception:
+            fd = -1
+        system_has_native_ansi = not on_windows or enable_vt_processing(fd)
+        have_tty = not self.stream.closed and self.stream.isatty()
+        need_conversion = conversion_supported and not system_has_native_ansi
+
+        # should we strip ANSI sequences from our output?
+        if strip is None:
+            strip = need_conversion or not have_tty
+        self.strip = strip
+
+        # should we should convert ANSI sequences into win32 calls?
+        if convert is None:
+            convert = need_conversion and have_tty
+        self.convert = convert
+
+        # dict of ansi codes to win32 functions and parameters
+        self.win32_calls = self.get_win32_calls()
+
+        # are we wrapping stderr?
+        self.on_stderr = self.wrapped is sys.stderr
+
+    def should_wrap(self):
+        '''
+        True if this class is actually needed. If false, then the output
+        stream will not be affected, nor will win32 calls be issued, so
+        wrapping stdout is not actually required. This will generally be
+        False on non-Windows platforms, unless optional functionality like
+        autoreset has been requested using kwargs to init()
+        '''
+        return self.convert or self.strip or self.autoreset
+
+    def get_win32_calls(self):
+        if self.convert and winterm:
+            return {
+                AnsiStyle.RESET_ALL: (winterm.reset_all, ),
+                AnsiStyle.BRIGHT: (winterm.style, WinStyle.BRIGHT),
+                AnsiStyle.DIM: (winterm.style, WinStyle.NORMAL),
+                AnsiStyle.NORMAL: (winterm.style, WinStyle.NORMAL),
+                AnsiFore.BLACK: (winterm.fore, WinColor.BLACK),
+                AnsiFore.RED: (winterm.fore, WinColor.RED),
+                AnsiFore.GREEN: (winterm.fore, WinColor.GREEN),
+                AnsiFore.YELLOW: (winterm.fore, WinColor.YELLOW),
+                AnsiFore.BLUE: (winterm.fore, WinColor.BLUE),
+                AnsiFore.MAGENTA: (winterm.fore, WinColor.MAGENTA),
+                AnsiFore.CYAN: (winterm.fore, WinColor.CYAN),
+                AnsiFore.WHITE: (winterm.fore, WinColor.GREY),
+                AnsiFore.RESET: (winterm.fore, ),
+                AnsiFore.LIGHTBLACK_EX: (winterm.fore, WinColor.BLACK, True),
+                AnsiFore.LIGHTRED_EX: (winterm.fore, WinColor.RED, True),
+                AnsiFore.LIGHTGREEN_EX: (winterm.fore, WinColor.GREEN, True),
+                AnsiFore.LIGHTYELLOW_EX: (winterm.fore, WinColor.YELLOW, True),
+                AnsiFore.LIGHTBLUE_EX: (winterm.fore, WinColor.BLUE, True),
+                AnsiFore.LIGHTMAGENTA_EX: (winterm.fore, WinColor.MAGENTA, True),
+                AnsiFore.LIGHTCYAN_EX: (winterm.fore, WinColor.CYAN, True),
+                AnsiFore.LIGHTWHITE_EX: (winterm.fore, WinColor.GREY, True),
+                AnsiBack.BLACK: (winterm.back, WinColor.BLACK),
+                AnsiBack.RED: (winterm.back, WinColor.RED),
+                AnsiBack.GREEN: (winterm.back, WinColor.GREEN),
+                AnsiBack.YELLOW: (winterm.back, WinColor.YELLOW),
+                AnsiBack.BLUE: (winterm.back, WinColor.BLUE),
+                AnsiBack.MAGENTA: (winterm.back, WinColor.MAGENTA),
+                AnsiBack.CYAN: (winterm.back, WinColor.CYAN),
+                AnsiBack.WHITE: (winterm.back, WinColor.GREY),
+                AnsiBack.RESET: (winterm.back, ),
+                AnsiBack.LIGHTBLACK_EX: (winterm.back, WinColor.BLACK, True),
+                AnsiBack.LIGHTRED_EX: (winterm.back, WinColor.RED, True),
+                AnsiBack.LIGHTGREEN_EX: (winterm.back, WinColor.GREEN, True),
+                AnsiBack.LIGHTYELLOW_EX: (winterm.back, WinColor.YELLOW, True),
+                AnsiBack.LIGHTBLUE_EX: (winterm.back, WinColor.BLUE, True),
+                AnsiBack.LIGHTMAGENTA_EX: (winterm.back, WinColor.MAGENTA, True),
+                AnsiBack.LIGHTCYAN_EX: (winterm.back, WinColor.CYAN, True),
+                AnsiBack.LIGHTWHITE_EX: (winterm.back, WinColor.GREY, True),
+            }
+        return dict()
+
+    def write(self, text):
+        if self.strip or self.convert:
+            self.write_and_convert(text)
+        else:
+            self.wrapped.write(text)
+            self.wrapped.flush()
+        if self.autoreset:
+            self.reset_all()
+
+
+    def reset_all(self):
+        if self.convert:
+            self.call_win32('m', (0,))
+        elif not self.strip and not self.stream.closed:
+            self.wrapped.write(Style.RESET_ALL)
+
+
+    def write_and_convert(self, text):
+        '''
+        Write the given text to our wrapped stream, stripping any ANSI
+        sequences from the text, and optionally converting them into win32
+        calls.
+        '''
+        cursor = 0
+        text = self.convert_osc(text)
+        for match in self.ANSI_CSI_RE.finditer(text):
+            start, end = match.span()
+            self.write_plain_text(text, cursor, start)
+            self.convert_ansi(*match.groups())
+            cursor = end
+        self.write_plain_text(text, cursor, len(text))
+
+
+    def write_plain_text(self, text, start, end):
+        if start < end:
+            self.wrapped.write(text[start:end])
+            self.wrapped.flush()
+
+
+    def convert_ansi(self, paramstring, command):
+        if self.convert:
+            params = self.extract_params(command, paramstring)
+            self.call_win32(command, params)
+
+
+    def extract_params(self, command, paramstring):
+        if command in 'Hf':
+            params = tuple(int(p) if len(p) != 0 else 1 for p in paramstring.split(';'))
+            while len(params) < 2:
+                # defaults:
+                params = params + (1,)
+        else:
+            params = tuple(int(p) for p in paramstring.split(';') if len(p) != 0)
+            if len(params) == 0:
+                # defaults:
+                if command in 'JKm':
+                    params = (0,)
+                elif command in 'ABCD':
+                    params = (1,)
+
+        return params
+
+
+    def call_win32(self, command, params):
+        if command == 'm':
+            for param in params:
+                if param in self.win32_calls:
+                    func_args = self.win32_calls[param]
+                    func = func_args[0]
+                    args = func_args[1:]
+                    kwargs = dict(on_stderr=self.on_stderr)
+                    func(*args, **kwargs)
+        elif command in 'J':
+            winterm.erase_screen(params[0], on_stderr=self.on_stderr)
+        elif command in 'K':
+            winterm.erase_line(params[0], on_stderr=self.on_stderr)
+        elif command in 'Hf':     # cursor position - absolute
+            winterm.set_cursor_position(params, on_stderr=self.on_stderr)
+        elif command in 'ABCD':   # cursor position - relative
+            n = params[0]
+            # A - up, B - down, C - forward, D - back
+            x, y = {'A': (0, -n), 'B': (0, n), 'C': (n, 0), 'D': (-n, 0)}[command]
+            winterm.cursor_adjust(x, y, on_stderr=self.on_stderr)
+
+
+    def convert_osc(self, text):
+        for match in self.ANSI_OSC_RE.finditer(text):
+            start, end = match.span()
+            text = text[:start] + text[end:]
+            paramstring, command = match.groups()
+            if command == BEL:
+                if paramstring.count(";") == 1:
+                    params = paramstring.split(";")
+                    # 0 - change title and icon (we will only change title)
+                    # 1 - change icon (we don't support this)
+                    # 2 - change title
+                    if params[0] in '02':
+                        winterm.set_title(params[1])
+        return text
+
+
+    def flush(self):
+        self.wrapped.flush()

lib/python3.10/site-packages/colorama/initialise.py

@@ -0,0 +1,121 @@
+# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file.
+import atexit
+import contextlib
+import sys
+
+from .ansitowin32 import AnsiToWin32
+
+
+def _wipe_internal_state_for_tests():
+    global orig_stdout, orig_stderr
+    orig_stdout = None
+    orig_stderr = None
+
+    global wrapped_stdout, wrapped_stderr
+    wrapped_stdout = None
+    wrapped_stderr = None
+
+    global atexit_done
+    atexit_done = False
+
+    global fixed_windows_console
+    fixed_windows_console = False
+
+    try:
+        # no-op if it wasn't registered
+        atexit.unregister(reset_all)
+    except AttributeError:
+        # python 2: no atexit.unregister. Oh well, we did our best.
+        pass
+
+
+def reset_all():
+    if AnsiToWin32 is not None:    # Issue #74: objects might become None at exit
+        AnsiToWin32(orig_stdout).reset_all()
+
+
+def init(autoreset=False, convert=None, strip=None, wrap=True):
+
+    if not wrap and any([autoreset, convert, strip]):
+        raise ValueError('wrap=False conflicts with any other arg=True')
+
+    global wrapped_stdout, wrapped_stderr
+    global orig_stdout, orig_stderr
+
+    orig_stdout = sys.stdout
+    orig_stderr = sys.stderr
+
+    if sys.stdout is None:
+        wrapped_stdout = None
+    else:
+        sys.stdout = wrapped_stdout = \
+            wrap_stream(orig_stdout, convert, strip, autoreset, wrap)
+    if sys.stderr is None:
+        wrapped_stderr = None
+    else:
+        sys.stderr = wrapped_stderr = \
+            wrap_stream(orig_stderr, convert, strip, autoreset, wrap)
+
+    global atexit_done
+    if not atexit_done:
+        atexit.register(reset_all)
+        atexit_done = True
+
+
+def deinit():
+    if orig_stdout is not None:
+        sys.stdout = orig_stdout
+    if orig_stderr is not None:
+        sys.stderr = orig_stderr
+
+
+def just_fix_windows_console():
+    global fixed_windows_console
+
+    if sys.platform != "win32":
+        return
+    if fixed_windows_console:
+        return
+    if wrapped_stdout is not None or wrapped_stderr is not None:
+        # Someone already ran init() and it did stuff, so we won't second-guess them
+        return
+
+    # On newer versions of Windows, AnsiToWin32.__init__ will implicitly enable the
+    # native ANSI support in the console as a side-effect. We only need to actually
+    # replace sys.stdout/stderr if we're in the old-style conversion mode.
+    new_stdout = AnsiToWin32(sys.stdout, convert=None, strip=None, autoreset=False)
+    if new_stdout.convert:
+        sys.stdout = new_stdout
+    new_stderr = AnsiToWin32(sys.stderr, convert=None, strip=None, autoreset=False)
+    if new_stderr.convert:
+        sys.stderr = new_stderr
+
+    fixed_windows_console = True
+
+@contextlib.contextmanager
+def colorama_text(*args, **kwargs):
+    init(*args, **kwargs)
+    try:
+        yield
+    finally:
+        deinit()
+
+
+def reinit():
+    if wrapped_stdout is not None:
+        sys.stdout = wrapped_stdout
+    if wrapped_stderr is not None:
+        sys.stderr = wrapped_stderr
+
+
+def wrap_stream(stream, convert, strip, autoreset, wrap):
+    if wrap:
+        wrapper = AnsiToWin32(stream,
+            convert=convert, strip=strip, autoreset=autoreset)
+        if wrapper.should_wrap():
+            stream = wrapper.stream
+    return stream
+
+
+# Use this for initial setup as well, to reduce code duplication
+_wipe_internal_state_for_tests()

lib/python3.10/site-packages/colorama/win32.py

@@ -0,0 +1,180 @@
+# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file.
+
+# from winbase.h
+STDOUT = -11
+STDERR = -12
+
+ENABLE_VIRTUAL_TERMINAL_PROCESSING = 0x0004
+
+try:
+    import ctypes
+    from ctypes import LibraryLoader
+    windll = LibraryLoader(ctypes.WinDLL)
+    from ctypes import wintypes
+except (AttributeError, ImportError):
+    windll = None
+    SetConsoleTextAttribute = lambda *_: None
+    winapi_test = lambda *_: None
+else:
+    from ctypes import byref, Structure, c_char, POINTER
+
+    COORD = wintypes._COORD
+
+    class CONSOLE_SCREEN_BUFFER_INFO(Structure):
+        """struct in wincon.h."""
+        _fields_ = [
+            ("dwSize", COORD),
+            ("dwCursorPosition", COORD),
+            ("wAttributes", wintypes.WORD),
+            ("srWindow", wintypes.SMALL_RECT),
+            ("dwMaximumWindowSize", COORD),
+        ]
+        def __str__(self):
+            return '(%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d)' % (
+                self.dwSize.Y, self.dwSize.X
+                , self.dwCursorPosition.Y, self.dwCursorPosition.X
+                , self.wAttributes
+                , self.srWindow.Top, self.srWindow.Left, self.srWindow.Bottom, self.srWindow.Right
+                , self.dwMaximumWindowSize.Y, self.dwMaximumWindowSize.X
+            )
+
+    _GetStdHandle = windll.kernel32.GetStdHandle
+    _GetStdHandle.argtypes = [
+        wintypes.DWORD,
+    ]
+    _GetStdHandle.restype = wintypes.HANDLE
+
+    _GetConsoleScreenBufferInfo = windll.kernel32.GetConsoleScreenBufferInfo
+    _GetConsoleScreenBufferInfo.argtypes = [
+        wintypes.HANDLE,
+        POINTER(CONSOLE_SCREEN_BUFFER_INFO),
+    ]
+    _GetConsoleScreenBufferInfo.restype = wintypes.BOOL
+
+    _SetConsoleTextAttribute = windll.kernel32.SetConsoleTextAttribute
+    _SetConsoleTextAttribute.argtypes = [
+        wintypes.HANDLE,
+        wintypes.WORD,
+    ]
+    _SetConsoleTextAttribute.restype = wintypes.BOOL
+
+    _SetConsoleCursorPosition = windll.kernel32.SetConsoleCursorPosition
+    _SetConsoleCursorPosition.argtypes = [
+        wintypes.HANDLE,
+        COORD,
+    ]
+    _SetConsoleCursorPosition.restype = wintypes.BOOL
+
+    _FillConsoleOutputCharacterA = windll.kernel32.FillConsoleOutputCharacterA
+    _FillConsoleOutputCharacterA.argtypes = [
+        wintypes.HANDLE,
+        c_char,
+        wintypes.DWORD,
+        COORD,
+        POINTER(wintypes.DWORD),
+    ]
+    _FillConsoleOutputCharacterA.restype = wintypes.BOOL
+
+    _FillConsoleOutputAttribute = windll.kernel32.FillConsoleOutputAttribute
+    _FillConsoleOutputAttribute.argtypes = [
+        wintypes.HANDLE,
+        wintypes.WORD,
+        wintypes.DWORD,
+        COORD,
+        POINTER(wintypes.DWORD),
+    ]
+    _FillConsoleOutputAttribute.restype = wintypes.BOOL
+
+    _SetConsoleTitleW = windll.kernel32.SetConsoleTitleW
+    _SetConsoleTitleW.argtypes = [
+        wintypes.LPCWSTR
+    ]
+    _SetConsoleTitleW.restype = wintypes.BOOL
+
+    _GetConsoleMode = windll.kernel32.GetConsoleMode
+    _GetConsoleMode.argtypes = [
+        wintypes.HANDLE,
+        POINTER(wintypes.DWORD)
+    ]
+    _GetConsoleMode.restype = wintypes.BOOL
+
+    _SetConsoleMode = windll.kernel32.SetConsoleMode
+    _SetConsoleMode.argtypes = [
+        wintypes.HANDLE,
+        wintypes.DWORD
+    ]
+    _SetConsoleMode.restype = wintypes.BOOL
+
+    def _winapi_test(handle):
+        csbi = CONSOLE_SCREEN_BUFFER_INFO()
+        success = _GetConsoleScreenBufferInfo(
+            handle, byref(csbi))
+        return bool(success)
+
+    def winapi_test():
+        return any(_winapi_test(h) for h in
+                   (_GetStdHandle(STDOUT), _GetStdHandle(STDERR)))
+
+    def GetConsoleScreenBufferInfo(stream_id=STDOUT):
+        handle = _GetStdHandle(stream_id)
+        csbi = CONSOLE_SCREEN_BUFFER_INFO()
+        success = _GetConsoleScreenBufferInfo(
+            handle, byref(csbi))
+        return csbi
+
+    def SetConsoleTextAttribute(stream_id, attrs):
+        handle = _GetStdHandle(stream_id)
+        return _SetConsoleTextAttribute(handle, attrs)
+
+    def SetConsoleCursorPosition(stream_id, position, adjust=True):
+        position = COORD(*position)
+        # If the position is out of range, do nothing.
+        if position.Y <= 0 or position.X <= 0:
+            return
+        # Adjust for Windows' SetConsoleCursorPosition:
+        #    1. being 0-based, while ANSI is 1-based.
+        #    2. expecting (x,y), while ANSI uses (y,x).
+        adjusted_position = COORD(position.Y - 1, position.X - 1)
+        if adjust:
+            # Adjust for viewport's scroll position
+            sr = GetConsoleScreenBufferInfo(STDOUT).srWindow
+            adjusted_position.Y += sr.Top
+            adjusted_position.X += sr.Left
+        # Resume normal processing
+        handle = _GetStdHandle(stream_id)
+        return _SetConsoleCursorPosition(handle, adjusted_position)
+
+    def FillConsoleOutputCharacter(stream_id, char, length, start):
+        handle = _GetStdHandle(stream_id)
+        char = c_char(char.encode())
+        length = wintypes.DWORD(length)
+        num_written = wintypes.DWORD(0)
+        # Note that this is hard-coded for ANSI (vs wide) bytes.
+        success = _FillConsoleOutputCharacterA(
+            handle, char, length, start, byref(num_written))
+        return num_written.value
+
+    def FillConsoleOutputAttribute(stream_id, attr, length, start):
+        ''' FillConsoleOutputAttribute( hConsole, csbi.wAttributes, dwConSize, coordScreen, &cCharsWritten )'''
+        handle = _GetStdHandle(stream_id)
+        attribute = wintypes.WORD(attr)
+        length = wintypes.DWORD(length)
+        num_written = wintypes.DWORD(0)
+        # Note that this is hard-coded for ANSI (vs wide) bytes.
+        return _FillConsoleOutputAttribute(
+            handle, attribute, length, start, byref(num_written))
+
+    def SetConsoleTitle(title):
+        return _SetConsoleTitleW(title)
+
+    def GetConsoleMode(handle):
+        mode = wintypes.DWORD()
+        success = _GetConsoleMode(handle, byref(mode))
+        if not success:
+            raise ctypes.WinError()
+        return mode.value
+
+    def SetConsoleMode(handle, mode):
+        success = _SetConsoleMode(handle, mode)
+        if not success:
+            raise ctypes.WinError()

lib/python3.10/site-packages/colorama/winterm.py

@@ -0,0 +1,195 @@
+# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file.
+try:
+    from msvcrt import get_osfhandle
+except ImportError:
+    def get_osfhandle(_):
+        raise OSError("This isn't windows!")
+
+
+from . import win32
+
+# from wincon.h
+class WinColor(object):
+    BLACK   = 0
+    BLUE    = 1
+    GREEN   = 2
+    CYAN    = 3
+    RED     = 4
+    MAGENTA = 5
+    YELLOW  = 6
+    GREY    = 7
+
+# from wincon.h
+class WinStyle(object):
+    NORMAL              = 0x00 # dim text, dim background
+    BRIGHT              = 0x08 # bright text, dim background
+    BRIGHT_BACKGROUND   = 0x80 # dim text, bright background
+
+class WinTerm(object):
+
+    def __init__(self):
+        self._default = win32.GetConsoleScreenBufferInfo(win32.STDOUT).wAttributes
+        self.set_attrs(self._default)
+        self._default_fore = self._fore
+        self._default_back = self._back
+        self._default_style = self._style
+        # In order to emulate LIGHT_EX in windows, we borrow the BRIGHT style.
+        # So that LIGHT_EX colors and BRIGHT style do not clobber each other,
+        # we track them separately, since LIGHT_EX is overwritten by Fore/Back
+        # and BRIGHT is overwritten by Style codes.
+        self._light = 0
+
+    def get_attrs(self):
+        return self._fore + self._back * 16 + (self._style | self._light)
+
+    def set_attrs(self, value):
+        self._fore = value & 7
+        self._back = (value >> 4) & 7
+        self._style = value & (WinStyle.BRIGHT | WinStyle.BRIGHT_BACKGROUND)
+
+    def reset_all(self, on_stderr=None):
+        self.set_attrs(self._default)
+        self.set_console(attrs=self._default)
+        self._light = 0
+
+    def fore(self, fore=None, light=False, on_stderr=False):
+        if fore is None:
+            fore = self._default_fore
+        self._fore = fore
+        # Emulate LIGHT_EX with BRIGHT Style
+        if light:
+            self._light |= WinStyle.BRIGHT
+        else:
+            self._light &= ~WinStyle.BRIGHT
+        self.set_console(on_stderr=on_stderr)
+
+    def back(self, back=None, light=False, on_stderr=False):
+        if back is None:
+            back = self._default_back
+        self._back = back
+        # Emulate LIGHT_EX with BRIGHT_BACKGROUND Style
+        if light:
+            self._light |= WinStyle.BRIGHT_BACKGROUND
+        else:
+            self._light &= ~WinStyle.BRIGHT_BACKGROUND
+        self.set_console(on_stderr=on_stderr)
+
+    def style(self, style=None, on_stderr=False):
+        if style is None:
+            style = self._default_style
+        self._style = style
+        self.set_console(on_stderr=on_stderr)
+
+    def set_console(self, attrs=None, on_stderr=False):
+        if attrs is None:
+            attrs = self.get_attrs()
+        handle = win32.STDOUT
+        if on_stderr:
+            handle = win32.STDERR
+        win32.SetConsoleTextAttribute(handle, attrs)
+
+    def get_position(self, handle):
+        position = win32.GetConsoleScreenBufferInfo(handle).dwCursorPosition
+        # Because Windows coordinates are 0-based,
+        # and win32.SetConsoleCursorPosition expects 1-based.
+        position.X += 1
+        position.Y += 1
+        return position
+
+    def set_cursor_position(self, position=None, on_stderr=False):
+        if position is None:
+            # I'm not currently tracking the position, so there is no default.
+            # position = self.get_position()
+            return
+        handle = win32.STDOUT
+        if on_stderr:
+            handle = win32.STDERR
+        win32.SetConsoleCursorPosition(handle, position)
+
+    def cursor_adjust(self, x, y, on_stderr=False):
+        handle = win32.STDOUT
+        if on_stderr:
+            handle = win32.STDERR
+        position = self.get_position(handle)
+        adjusted_position = (position.Y + y, position.X + x)
+        win32.SetConsoleCursorPosition(handle, adjusted_position, adjust=False)
+
+    def erase_screen(self, mode=0, on_stderr=False):
+        # 0 should clear from the cursor to the end of the screen.
+        # 1 should clear from the cursor to the beginning of the screen.
+        # 2 should clear the entire screen, and move cursor to (1,1)
+        handle = win32.STDOUT
+        if on_stderr:
+            handle = win32.STDERR
+        csbi = win32.GetConsoleScreenBufferInfo(handle)
+        # get the number of character cells in the current buffer
+        cells_in_screen = csbi.dwSize.X * csbi.dwSize.Y
+        # get number of character cells before current cursor position
+        cells_before_cursor = csbi.dwSize.X * csbi.dwCursorPosition.Y + csbi.dwCursorPosition.X
+        if mode == 0:
+            from_coord = csbi.dwCursorPosition
+            cells_to_erase = cells_in_screen - cells_before_cursor
+        elif mode == 1:
+            from_coord = win32.COORD(0, 0)
+            cells_to_erase = cells_before_cursor
+        elif mode == 2:
+            from_coord = win32.COORD(0, 0)
+            cells_to_erase = cells_in_screen
+        else:
+            # invalid mode
+            return
+        # fill the entire screen with blanks
+        win32.FillConsoleOutputCharacter(handle, ' ', cells_to_erase, from_coord)
+        # now set the buffer's attributes accordingly
+        win32.FillConsoleOutputAttribute(handle, self.get_attrs(), cells_to_erase, from_coord)
+        if mode == 2:
+            # put the cursor where needed
+            win32.SetConsoleCursorPosition(handle, (1, 1))
+
+    def erase_line(self, mode=0, on_stderr=False):
+        # 0 should clear from the cursor to the end of the line.
+        # 1 should clear from the cursor to the beginning of the line.
+        # 2 should clear the entire line.
+        handle = win32.STDOUT
+        if on_stderr:
+            handle = win32.STDERR
+        csbi = win32.GetConsoleScreenBufferInfo(handle)
+        if mode == 0:
+            from_coord = csbi.dwCursorPosition
+            cells_to_erase = csbi.dwSize.X - csbi.dwCursorPosition.X
+        elif mode == 1:
+            from_coord = win32.COORD(0, csbi.dwCursorPosition.Y)
+            cells_to_erase = csbi.dwCursorPosition.X
+        elif mode == 2:
+            from_coord = win32.COORD(0, csbi.dwCursorPosition.Y)
+            cells_to_erase = csbi.dwSize.X
+        else:
+            # invalid mode
+            return
+        # fill the entire screen with blanks
+        win32.FillConsoleOutputCharacter(handle, ' ', cells_to_erase, from_coord)
+        # now set the buffer's attributes accordingly
+        win32.FillConsoleOutputAttribute(handle, self.get_attrs(), cells_to_erase, from_coord)
+
+    def set_title(self, title):
+        win32.SetConsoleTitle(title)
+
+
+def enable_vt_processing(fd):
+    if win32.windll is None or not win32.winapi_test():
+        return False
+
+    try:
+        handle = get_osfhandle(fd)
+        mode = win32.GetConsoleMode(handle)
+        win32.SetConsoleMode(
+            handle,
+            mode | win32.ENABLE_VIRTUAL_TERMINAL_PROCESSING,
+        )
+
+        mode = win32.GetConsoleMode(handle)
+        if mode & win32.ENABLE_VIRTUAL_TERMINAL_PROCESSING:
+            return True
+    # Can get TypeError in testsuite where 'fd' is a Mock()
+    except (OSError, TypeError):
+        return False

lib/python3.10/site-packages/cryptography/hazmat/backends/__init__.py

@@ -0,0 +1,13 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def default_backend() -> Any:
+    from cryptography.hazmat.backends.openssl.backend import backend
+
+    return backend

lib/python3.10/site-packages/cryptography/hazmat/backends/openssl/__init__.py

@@ -0,0 +1,9 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+from __future__ import annotations
+
+from cryptography.hazmat.backends.openssl.backend import backend
+
+__all__ = ["backend"]

lib/python3.10/site-packages/cryptography/hazmat/backends/openssl/backend.py

@@ -0,0 +1,285 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+from __future__ import annotations
+
+from cryptography.hazmat.bindings._rust import openssl as rust_openssl
+from cryptography.hazmat.bindings.openssl import binding
+from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.primitives._asymmetric import AsymmetricPadding
+from cryptography.hazmat.primitives.asymmetric import ec
+from cryptography.hazmat.primitives.asymmetric import utils as asym_utils
+from cryptography.hazmat.primitives.asymmetric.padding import (
+    MGF1,
+    OAEP,
+    PSS,
+    PKCS1v15,
+)
+from cryptography.hazmat.primitives.ciphers import (
+    CipherAlgorithm,
+)
+from cryptography.hazmat.primitives.ciphers.algorithms import (
+    AES,
+)
+from cryptography.hazmat.primitives.ciphers.modes import (
+    CBC,
+    Mode,
+)
+
+
+class Backend:
+    """
+    OpenSSL API binding interfaces.
+    """
+
+    name = "openssl"
+
+    # TripleDES encryption is disallowed/deprecated throughout 2023 in
+    # FIPS 140-3. To keep it simple we denylist any use of TripleDES (TDEA).
+    _fips_ciphers = (AES,)
+    # Sometimes SHA1 is still permissible. That logic is contained
+    # within the various *_supported methods.
+    _fips_hashes = (
+        hashes.SHA224,
+        hashes.SHA256,
+        hashes.SHA384,
+        hashes.SHA512,
+        hashes.SHA512_224,
+        hashes.SHA512_256,
+        hashes.SHA3_224,
+        hashes.SHA3_256,
+        hashes.SHA3_384,
+        hashes.SHA3_512,
+        hashes.SHAKE128,
+        hashes.SHAKE256,
+    )
+    _fips_ecdh_curves = (
+        ec.SECP224R1,
+        ec.SECP256R1,
+        ec.SECP384R1,
+        ec.SECP521R1,
+    )
+    _fips_rsa_min_key_size = 2048
+    _fips_rsa_min_public_exponent = 65537
+    _fips_dsa_min_modulus = 1 << 2048
+    _fips_dh_min_key_size = 2048
+    _fips_dh_min_modulus = 1 << _fips_dh_min_key_size
+
+    def __init__(self) -> None:
+        self._binding = binding.Binding()
+        self._ffi = self._binding.ffi
+        self._lib = self._binding.lib
+        self._fips_enabled = rust_openssl.is_fips_enabled()
+
+    def __repr__(self) -> str:
+        return (
+            f"<OpenSSLBackend(version: {self.openssl_version_text()}, "
+            f"FIPS: {self._fips_enabled}, "
+            f"Legacy: {rust_openssl._legacy_provider_loaded})>"
+        )
+
+    def openssl_assert(self, ok: bool) -> None:
+        return binding._openssl_assert(ok)
+
+    def _enable_fips(self) -> None:
+        # This function enables FIPS mode for OpenSSL 3.0.0 on installs that
+        # have the FIPS provider installed properly.
+        rust_openssl.enable_fips(rust_openssl._providers)
+        assert rust_openssl.is_fips_enabled()
+        self._fips_enabled = rust_openssl.is_fips_enabled()
+
+    def openssl_version_text(self) -> str:
+        """
+        Friendly string name of the loaded OpenSSL library. This is not
+        necessarily the same version as it was compiled against.
+
+        Example: OpenSSL 3.2.1 30 Jan 2024
+        """
+        return rust_openssl.openssl_version_text()
+
+    def openssl_version_number(self) -> int:
+        return rust_openssl.openssl_version()
+
+    def hash_supported(self, algorithm: hashes.HashAlgorithm) -> bool:
+        if self._fips_enabled and not isinstance(algorithm, self._fips_hashes):
+            return False
+
+        return rust_openssl.hashes.hash_supported(algorithm)
+
+    def signature_hash_supported(
+        self, algorithm: hashes.HashAlgorithm
+    ) -> bool:
+        # Dedicated check for hashing algorithm use in message digest for
+        # signatures, e.g. RSA PKCS#1 v1.5 SHA1 (sha1WithRSAEncryption).
+        if self._fips_enabled and isinstance(algorithm, hashes.SHA1):
+            return False
+        return self.hash_supported(algorithm)
+
+    def scrypt_supported(self) -> bool:
+        if self._fips_enabled:
+            return False
+        else:
+            return hasattr(rust_openssl.kdf.Scrypt, "derive")
+
+    def argon2_supported(self) -> bool:
+        if self._fips_enabled:
+            return False
+        else:
+            return hasattr(rust_openssl.kdf.Argon2id, "derive")
+
+    def hmac_supported(self, algorithm: hashes.HashAlgorithm) -> bool:
+        # FIPS mode still allows SHA1 for HMAC
+        if self._fips_enabled and isinstance(algorithm, hashes.SHA1):
+            return True
+
+        return self.hash_supported(algorithm)
+
+    def cipher_supported(self, cipher: CipherAlgorithm, mode: Mode) -> bool:
+        if self._fips_enabled:
+            # FIPS mode requires AES. TripleDES is disallowed/deprecated in
+            # FIPS 140-3.
+            if not isinstance(cipher, self._fips_ciphers):
+                return False
+
+        return rust_openssl.ciphers.cipher_supported(cipher, mode)
+
+    def pbkdf2_hmac_supported(self, algorithm: hashes.HashAlgorithm) -> bool:
+        return self.hmac_supported(algorithm)
+
+    def _consume_errors(self) -> list[rust_openssl.OpenSSLError]:
+        return rust_openssl.capture_error_stack()
+
+    def _oaep_hash_supported(self, algorithm: hashes.HashAlgorithm) -> bool:
+        if self._fips_enabled and isinstance(algorithm, hashes.SHA1):
+            return False
+
+        return isinstance(
+            algorithm,
+            (
+                hashes.SHA1,
+                hashes.SHA224,
+                hashes.SHA256,
+                hashes.SHA384,
+                hashes.SHA512,
+            ),
+        )
+
+    def rsa_padding_supported(self, padding: AsymmetricPadding) -> bool:
+        if isinstance(padding, PKCS1v15):
+            return True
+        elif isinstance(padding, PSS) and isinstance(padding._mgf, MGF1):
+            # SHA1 is permissible in MGF1 in FIPS even when SHA1 is blocked
+            # as signature algorithm.
+            if self._fips_enabled and isinstance(
+                padding._mgf._algorithm, hashes.SHA1
+            ):
+                return True
+            else:
+                return self.hash_supported(padding._mgf._algorithm)
+        elif isinstance(padding, OAEP) and isinstance(padding._mgf, MGF1):
+            return self._oaep_hash_supported(
+                padding._mgf._algorithm
+            ) and self._oaep_hash_supported(padding._algorithm)
+        else:
+            return False
+
+    def rsa_encryption_supported(self, padding: AsymmetricPadding) -> bool:
+        if self._fips_enabled and isinstance(padding, PKCS1v15):
+            return False
+        else:
+            return self.rsa_padding_supported(padding)
+
+    def dsa_supported(self) -> bool:
+        return (
+            not rust_openssl.CRYPTOGRAPHY_IS_BORINGSSL
+            and not self._fips_enabled
+        )
+
+    def dsa_hash_supported(self, algorithm: hashes.HashAlgorithm) -> bool:
+        if not self.dsa_supported():
+            return False
+        return self.signature_hash_supported(algorithm)
+
+    def cmac_algorithm_supported(self, algorithm) -> bool:
+        return self.cipher_supported(
+            algorithm, CBC(b"\x00" * algorithm.block_size)
+        )
+
+    def elliptic_curve_supported(self, curve: ec.EllipticCurve) -> bool:
+        if self._fips_enabled and not isinstance(
+            curve, self._fips_ecdh_curves
+        ):
+            return False
+
+        return rust_openssl.ec.curve_supported(curve)
+
+    def elliptic_curve_signature_algorithm_supported(
+        self,
+        signature_algorithm: ec.EllipticCurveSignatureAlgorithm,
+        curve: ec.EllipticCurve,
+    ) -> bool:
+        # We only support ECDSA right now.
+        if not isinstance(signature_algorithm, ec.ECDSA):
+            return False
+
+        return self.elliptic_curve_supported(curve) and (
+            isinstance(signature_algorithm.algorithm, asym_utils.Prehashed)
+            or self.hash_supported(signature_algorithm.algorithm)
+        )
+
+    def elliptic_curve_exchange_algorithm_supported(
+        self, algorithm: ec.ECDH, curve: ec.EllipticCurve
+    ) -> bool:
+        return self.elliptic_curve_supported(curve) and isinstance(
+            algorithm, ec.ECDH
+        )
+
+    def dh_supported(self) -> bool:
+        return not rust_openssl.CRYPTOGRAPHY_IS_BORINGSSL
+
+    def dh_x942_serialization_supported(self) -> bool:
+        return self._lib.Cryptography_HAS_EVP_PKEY_DHX == 1
+
+    def x25519_supported(self) -> bool:
+        if self._fips_enabled:
+            return False
+        return True
+
+    def x448_supported(self) -> bool:
+        if self._fips_enabled:
+            return False
+        return (
+            not rust_openssl.CRYPTOGRAPHY_IS_LIBRESSL
+            and not rust_openssl.CRYPTOGRAPHY_IS_BORINGSSL
+        )
+
+    def ed25519_supported(self) -> bool:
+        if self._fips_enabled:
+            return False
+        return True
+
+    def ed448_supported(self) -> bool:
+        if self._fips_enabled:
+            return False
+        return (
+            not rust_openssl.CRYPTOGRAPHY_IS_LIBRESSL
+            and not rust_openssl.CRYPTOGRAPHY_IS_BORINGSSL
+        )
+
+    def ecdsa_deterministic_supported(self) -> bool:
+        return (
+            rust_openssl.CRYPTOGRAPHY_OPENSSL_320_OR_GREATER
+            and not self._fips_enabled
+        )
+
+    def poly1305_supported(self) -> bool:
+        if self._fips_enabled:
+            return False
+        return True
+
+    def pkcs7_supported(self) -> bool:
+        return not rust_openssl.CRYPTOGRAPHY_IS_BORINGSSL
+
+
+backend = Backend()

lib/python3.10/site-packages/cryptography/hazmat/bindings/__init__.py

@@ -0,0 +1,3 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.

lib/python3.10/site-packages/cryptography/hazmat/bindings/_rust/__init__.pyi

@@ -0,0 +1,28 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import typing
+
+from cryptography.hazmat.primitives import padding
+
+def check_ansix923_padding(data: bytes) -> bool: ...
+
+class PKCS7PaddingContext(padding.PaddingContext):
+    def __init__(self, block_size: int) -> None: ...
+    def update(self, data: bytes) -> bytes: ...
+    def finalize(self) -> bytes: ...
+
+class PKCS7UnpaddingContext(padding.PaddingContext):
+    def __init__(self, block_size: int) -> None: ...
+    def update(self, data: bytes) -> bytes: ...
+    def finalize(self) -> bytes: ...
+
+class ObjectIdentifier:
+    def __init__(self, val: str) -> None: ...
+    @property
+    def dotted_string(self) -> str: ...
+    @property
+    def _name(self) -> str: ...
+
+T = typing.TypeVar("T")

lib/python3.10/site-packages/cryptography/hazmat/bindings/_rust/_openssl.pyi

@@ -0,0 +1,8 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import typing
+
+lib = typing.Any
+ffi = typing.Any

lib/python3.10/site-packages/cryptography/hazmat/bindings/_rust/asn1.pyi

@@ -0,0 +1,7 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+def decode_dss_signature(signature: bytes) -> tuple[int, int]: ...
+def encode_dss_signature(r: int, s: int) -> bytes: ...
+def parse_spki_for_data(data: bytes) -> bytes: ...

lib/python3.10/site-packages/cryptography/hazmat/bindings/_rust/exceptions.pyi

@@ -0,0 +1,17 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+class _Reasons:
+    BACKEND_MISSING_INTERFACE: _Reasons
+    UNSUPPORTED_HASH: _Reasons
+    UNSUPPORTED_CIPHER: _Reasons
+    UNSUPPORTED_PADDING: _Reasons
+    UNSUPPORTED_MGF: _Reasons
+    UNSUPPORTED_PUBLIC_KEY_ALGORITHM: _Reasons
+    UNSUPPORTED_ELLIPTIC_CURVE: _Reasons
+    UNSUPPORTED_SERIALIZATION: _Reasons
+    UNSUPPORTED_X509: _Reasons
+    UNSUPPORTED_EXCHANGE_ALGORITHM: _Reasons
+    UNSUPPORTED_DIFFIE_HELLMAN: _Reasons
+    UNSUPPORTED_MAC: _Reasons

lib/python3.10/site-packages/cryptography/hazmat/bindings/_rust/ocsp.pyi

@@ -0,0 +1,117 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import datetime
+import typing
+
+from cryptography import x509
+from cryptography.hazmat.primitives import hashes, serialization
+from cryptography.hazmat.primitives.asymmetric.types import PrivateKeyTypes
+from cryptography.x509 import ocsp
+
+class OCSPRequest:
+    @property
+    def issuer_key_hash(self) -> bytes: ...
+    @property
+    def issuer_name_hash(self) -> bytes: ...
+    @property
+    def hash_algorithm(self) -> hashes.HashAlgorithm: ...
+    @property
+    def serial_number(self) -> int: ...
+    def public_bytes(self, encoding: serialization.Encoding) -> bytes: ...
+    @property
+    def extensions(self) -> x509.Extensions: ...
+
+class OCSPResponse:
+    @property
+    def responses(self) -> typing.Iterator[OCSPSingleResponse]: ...
+    @property
+    def response_status(self) -> ocsp.OCSPResponseStatus: ...
+    @property
+    def signature_algorithm_oid(self) -> x509.ObjectIdentifier: ...
+    @property
+    def signature_hash_algorithm(
+        self,
+    ) -> hashes.HashAlgorithm | None: ...
+    @property
+    def signature(self) -> bytes: ...
+    @property
+    def tbs_response_bytes(self) -> bytes: ...
+    @property
+    def certificates(self) -> list[x509.Certificate]: ...
+    @property
+    def responder_key_hash(self) -> bytes | None: ...
+    @property
+    def responder_name(self) -> x509.Name | None: ...
+    @property
+    def produced_at(self) -> datetime.datetime: ...
+    @property
+    def produced_at_utc(self) -> datetime.datetime: ...
+    @property
+    def certificate_status(self) -> ocsp.OCSPCertStatus: ...
+    @property
+    def revocation_time(self) -> datetime.datetime | None: ...
+    @property
+    def revocation_time_utc(self) -> datetime.datetime | None: ...
+    @property
+    def revocation_reason(self) -> x509.ReasonFlags | None: ...
+    @property
+    def this_update(self) -> datetime.datetime: ...
+    @property
+    def this_update_utc(self) -> datetime.datetime: ...
+    @property
+    def next_update(self) -> datetime.datetime | None: ...
+    @property
+    def next_update_utc(self) -> datetime.datetime | None: ...
+    @property
+    def issuer_key_hash(self) -> bytes: ...
+    @property
+    def issuer_name_hash(self) -> bytes: ...
+    @property
+    def hash_algorithm(self) -> hashes.HashAlgorithm: ...
+    @property
+    def serial_number(self) -> int: ...
+    @property
+    def extensions(self) -> x509.Extensions: ...
+    @property
+    def single_extensions(self) -> x509.Extensions: ...
+    def public_bytes(self, encoding: serialization.Encoding) -> bytes: ...
+
+class OCSPSingleResponse:
+    @property
+    def certificate_status(self) -> ocsp.OCSPCertStatus: ...
+    @property
+    def revocation_time(self) -> datetime.datetime | None: ...
+    @property
+    def revocation_time_utc(self) -> datetime.datetime | None: ...
+    @property
+    def revocation_reason(self) -> x509.ReasonFlags | None: ...
+    @property
+    def this_update(self) -> datetime.datetime: ...
+    @property
+    def this_update_utc(self) -> datetime.datetime: ...
+    @property
+    def next_update(self) -> datetime.datetime | None: ...
+    @property
+    def next_update_utc(self) -> datetime.datetime | None: ...
+    @property
+    def issuer_key_hash(self) -> bytes: ...
+    @property
+    def issuer_name_hash(self) -> bytes: ...
+    @property
+    def hash_algorithm(self) -> hashes.HashAlgorithm: ...
+    @property
+    def serial_number(self) -> int: ...
+
+def load_der_ocsp_request(data: bytes) -> ocsp.OCSPRequest: ...
+def load_der_ocsp_response(data: bytes) -> ocsp.OCSPResponse: ...
+def create_ocsp_request(
+    builder: ocsp.OCSPRequestBuilder,
+) -> ocsp.OCSPRequest: ...
+def create_ocsp_response(
+    status: ocsp.OCSPResponseStatus,
+    builder: ocsp.OCSPResponseBuilder | None,
+    private_key: PrivateKeyTypes | None,
+    hash_algorithm: hashes.HashAlgorithm | None,
+) -> ocsp.OCSPResponse: ...

lib/python3.10/site-packages/cryptography/hazmat/bindings/_rust/openssl/__init__.pyi

@@ -0,0 +1,72 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import typing
+
+from cryptography.hazmat.bindings._rust.openssl import (
+    aead,
+    ciphers,
+    cmac,
+    dh,
+    dsa,
+    ec,
+    ed448,
+    ed25519,
+    hashes,
+    hmac,
+    kdf,
+    keys,
+    poly1305,
+    rsa,
+    x448,
+    x25519,
+)
+
+__all__ = [
+    "aead",
+    "ciphers",
+    "cmac",
+    "dh",
+    "dsa",
+    "ec",
+    "ed448",
+    "ed25519",
+    "hashes",
+    "hmac",
+    "kdf",
+    "keys",
+    "openssl_version",
+    "openssl_version_text",
+    "poly1305",
+    "raise_openssl_error",
+    "rsa",
+    "x448",
+    "x25519",
+]
+
+CRYPTOGRAPHY_IS_LIBRESSL: bool
+CRYPTOGRAPHY_IS_BORINGSSL: bool
+CRYPTOGRAPHY_OPENSSL_300_OR_GREATER: bool
+CRYPTOGRAPHY_OPENSSL_309_OR_GREATER: bool
+CRYPTOGRAPHY_OPENSSL_320_OR_GREATER: bool
+
+class Providers: ...
+
+_legacy_provider_loaded: bool
+_providers: Providers
+
+def openssl_version() -> int: ...
+def openssl_version_text() -> str: ...
+def raise_openssl_error() -> typing.NoReturn: ...
+def capture_error_stack() -> list[OpenSSLError]: ...
+def is_fips_enabled() -> bool: ...
+def enable_fips(providers: Providers) -> None: ...
+
+class OpenSSLError:
+    @property
+    def lib(self) -> int: ...
+    @property
+    def reason(self) -> int: ...
+    @property
+    def reason_text(self) -> bytes: ...

lib/python3.10/site-packages/cryptography/hazmat/bindings/_rust/openssl/aead.pyi

@@ -0,0 +1,103 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+class AESGCM:
+    def __init__(self, key: bytes) -> None: ...
+    @staticmethod
+    def generate_key(key_size: int) -> bytes: ...
+    def encrypt(
+        self,
+        nonce: bytes,
+        data: bytes,
+        associated_data: bytes | None,
+    ) -> bytes: ...
+    def decrypt(
+        self,
+        nonce: bytes,
+        data: bytes,
+        associated_data: bytes | None,
+    ) -> bytes: ...
+
+class ChaCha20Poly1305:
+    def __init__(self, key: bytes) -> None: ...
+    @staticmethod
+    def generate_key() -> bytes: ...
+    def encrypt(
+        self,
+        nonce: bytes,
+        data: bytes,
+        associated_data: bytes | None,
+    ) -> bytes: ...
+    def decrypt(
+        self,
+        nonce: bytes,
+        data: bytes,
+        associated_data: bytes | None,
+    ) -> bytes: ...
+
+class AESCCM:
+    def __init__(self, key: bytes, tag_length: int = 16) -> None: ...
+    @staticmethod
+    def generate_key(key_size: int) -> bytes: ...
+    def encrypt(
+        self,
+        nonce: bytes,
+        data: bytes,
+        associated_data: bytes | None,
+    ) -> bytes: ...
+    def decrypt(
+        self,
+        nonce: bytes,
+        data: bytes,
+        associated_data: bytes | None,
+    ) -> bytes: ...
+
+class AESSIV:
+    def __init__(self, key: bytes) -> None: ...
+    @staticmethod
+    def generate_key(key_size: int) -> bytes: ...
+    def encrypt(
+        self,
+        data: bytes,
+        associated_data: list[bytes] | None,
+    ) -> bytes: ...
+    def decrypt(
+        self,
+        data: bytes,
+        associated_data: list[bytes] | None,
+    ) -> bytes: ...
+
+class AESOCB3:
+    def __init__(self, key: bytes) -> None: ...
+    @staticmethod
+    def generate_key(key_size: int) -> bytes: ...
+    def encrypt(
+        self,
+        nonce: bytes,
+        data: bytes,
+        associated_data: bytes | None,
+    ) -> bytes: ...
+    def decrypt(
+        self,
+        nonce: bytes,
+        data: bytes,
+        associated_data: bytes | None,
+    ) -> bytes: ...
+
+class AESGCMSIV:
+    def __init__(self, key: bytes) -> None: ...
+    @staticmethod
+    def generate_key(key_size: int) -> bytes: ...
+    def encrypt(
+        self,
+        nonce: bytes,
+        data: bytes,
+        associated_data: bytes | None,
+    ) -> bytes: ...
+    def decrypt(
+        self,
+        nonce: bytes,
+        data: bytes,
+        associated_data: bytes | None,
+    ) -> bytes: ...

lib/python3.10/site-packages/cryptography/hazmat/bindings/_rust/openssl/ciphers.pyi

@@ -0,0 +1,38 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import typing
+
+from cryptography.hazmat.primitives import ciphers
+from cryptography.hazmat.primitives.ciphers import modes
+
+@typing.overload
+def create_encryption_ctx(
+    algorithm: ciphers.CipherAlgorithm, mode: modes.ModeWithAuthenticationTag
+) -> ciphers.AEADEncryptionContext: ...
+@typing.overload
+def create_encryption_ctx(
+    algorithm: ciphers.CipherAlgorithm, mode: modes.Mode
+) -> ciphers.CipherContext: ...
+@typing.overload
+def create_decryption_ctx(
+    algorithm: ciphers.CipherAlgorithm, mode: modes.ModeWithAuthenticationTag
+) -> ciphers.AEADDecryptionContext: ...
+@typing.overload
+def create_decryption_ctx(
+    algorithm: ciphers.CipherAlgorithm, mode: modes.Mode
+) -> ciphers.CipherContext: ...
+def cipher_supported(
+    algorithm: ciphers.CipherAlgorithm, mode: modes.Mode
+) -> bool: ...
+def _advance(
+    ctx: ciphers.AEADEncryptionContext | ciphers.AEADDecryptionContext, n: int
+) -> None: ...
+def _advance_aad(
+    ctx: ciphers.AEADEncryptionContext | ciphers.AEADDecryptionContext, n: int
+) -> None: ...
+
+class CipherContext: ...
+class AEADEncryptionContext: ...
+class AEADDecryptionContext: ...

lib/python3.10/site-packages/cryptography/hazmat/bindings/_rust/openssl/cmac.pyi

@@ -0,0 +1,18 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import typing
+
+from cryptography.hazmat.primitives import ciphers
+
+class CMAC:
+    def __init__(
+        self,
+        algorithm: ciphers.BlockCipherAlgorithm,
+        backend: typing.Any = None,
+    ) -> None: ...
+    def update(self, data: bytes) -> None: ...
+    def finalize(self) -> bytes: ...
+    def verify(self, signature: bytes) -> None: ...
+    def copy(self) -> CMAC: ...

lib/python3.10/site-packages/cryptography/hazmat/bindings/_rust/openssl/dh.pyi

@@ -0,0 +1,51 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import typing
+
+from cryptography.hazmat.primitives.asymmetric import dh
+
+MIN_MODULUS_SIZE: int
+
+class DHPrivateKey: ...
+class DHPublicKey: ...
+class DHParameters: ...
+
+class DHPrivateNumbers:
+    def __init__(self, x: int, public_numbers: DHPublicNumbers) -> None: ...
+    def private_key(self, backend: typing.Any = None) -> dh.DHPrivateKey: ...
+    @property
+    def x(self) -> int: ...
+    @property
+    def public_numbers(self) -> DHPublicNumbers: ...
+
+class DHPublicNumbers:
+    def __init__(
+        self, y: int, parameter_numbers: DHParameterNumbers
+    ) -> None: ...
+    def public_key(self, backend: typing.Any = None) -> dh.DHPublicKey: ...
+    @property
+    def y(self) -> int: ...
+    @property
+    def parameter_numbers(self) -> DHParameterNumbers: ...
+
+class DHParameterNumbers:
+    def __init__(self, p: int, g: int, q: int | None = None) -> None: ...
+    def parameters(self, backend: typing.Any = None) -> dh.DHParameters: ...
+    @property
+    def p(self) -> int: ...
+    @property
+    def g(self) -> int: ...
+    @property
+    def q(self) -> int | None: ...
+
+def generate_parameters(
+    generator: int, key_size: int, backend: typing.Any = None
+) -> dh.DHParameters: ...
+def from_pem_parameters(
+    data: bytes, backend: typing.Any = None
+) -> dh.DHParameters: ...
+def from_der_parameters(
+    data: bytes, backend: typing.Any = None
+) -> dh.DHParameters: ...

lib/python3.10/site-packages/cryptography/hazmat/bindings/_rust/openssl/dsa.pyi

@@ -0,0 +1,41 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import typing
+
+from cryptography.hazmat.primitives.asymmetric import dsa
+
+class DSAPrivateKey: ...
+class DSAPublicKey: ...
+class DSAParameters: ...
+
+class DSAPrivateNumbers:
+    def __init__(self, x: int, public_numbers: DSAPublicNumbers) -> None: ...
+    @property
+    def x(self) -> int: ...
+    @property
+    def public_numbers(self) -> DSAPublicNumbers: ...
+    def private_key(self, backend: typing.Any = None) -> dsa.DSAPrivateKey: ...
+
+class DSAPublicNumbers:
+    def __init__(
+        self, y: int, parameter_numbers: DSAParameterNumbers
+    ) -> None: ...
+    @property
+    def y(self) -> int: ...
+    @property
+    def parameter_numbers(self) -> DSAParameterNumbers: ...
+    def public_key(self, backend: typing.Any = None) -> dsa.DSAPublicKey: ...
+
+class DSAParameterNumbers:
+    def __init__(self, p: int, q: int, g: int) -> None: ...
+    @property
+    def p(self) -> int: ...
+    @property
+    def q(self) -> int: ...
+    @property
+    def g(self) -> int: ...
+    def parameters(self, backend: typing.Any = None) -> dsa.DSAParameters: ...
+
+def generate_parameters(key_size: int) -> dsa.DSAParameters: ...

lib/python3.10/site-packages/cryptography/hazmat/bindings/_rust/openssl/ec.pyi

@@ -0,0 +1,52 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import typing
+
+from cryptography.hazmat.primitives.asymmetric import ec
+
+class ECPrivateKey: ...
+class ECPublicKey: ...
+
+class EllipticCurvePrivateNumbers:
+    def __init__(
+        self, private_value: int, public_numbers: EllipticCurvePublicNumbers
+    ) -> None: ...
+    def private_key(
+        self, backend: typing.Any = None
+    ) -> ec.EllipticCurvePrivateKey: ...
+    @property
+    def private_value(self) -> int: ...
+    @property
+    def public_numbers(self) -> EllipticCurvePublicNumbers: ...
+
+class EllipticCurvePublicNumbers:
+    def __init__(self, x: int, y: int, curve: ec.EllipticCurve) -> None: ...
+    def public_key(
+        self, backend: typing.Any = None
+    ) -> ec.EllipticCurvePublicKey: ...
+    @property
+    def x(self) -> int: ...
+    @property
+    def y(self) -> int: ...
+    @property
+    def curve(self) -> ec.EllipticCurve: ...
+    def __eq__(self, other: object) -> bool: ...
+
+def curve_supported(curve: ec.EllipticCurve) -> bool: ...
+def generate_private_key(
+    curve: ec.EllipticCurve, backend: typing.Any = None
+) -> ec.EllipticCurvePrivateKey: ...
+def from_private_numbers(
+    numbers: ec.EllipticCurvePrivateNumbers,
+) -> ec.EllipticCurvePrivateKey: ...
+def from_public_numbers(
+    numbers: ec.EllipticCurvePublicNumbers,
+) -> ec.EllipticCurvePublicKey: ...
+def from_public_bytes(
+    curve: ec.EllipticCurve, data: bytes
+) -> ec.EllipticCurvePublicKey: ...
+def derive_private_key(
+    private_value: int, curve: ec.EllipticCurve
+) -> ec.EllipticCurvePrivateKey: ...

lib/python3.10/site-packages/cryptography/hazmat/bindings/_rust/openssl/ed25519.pyi

@@ -0,0 +1,12 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+from cryptography.hazmat.primitives.asymmetric import ed25519
+
+class Ed25519PrivateKey: ...
+class Ed25519PublicKey: ...
+
+def generate_key() -> ed25519.Ed25519PrivateKey: ...
+def from_private_bytes(data: bytes) -> ed25519.Ed25519PrivateKey: ...
+def from_public_bytes(data: bytes) -> ed25519.Ed25519PublicKey: ...

lib/python3.10/site-packages/cryptography/hazmat/bindings/_rust/openssl/ed448.pyi

@@ -0,0 +1,12 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+from cryptography.hazmat.primitives.asymmetric import ed448
+
+class Ed448PrivateKey: ...
+class Ed448PublicKey: ...
+
+def generate_key() -> ed448.Ed448PrivateKey: ...
+def from_private_bytes(data: bytes) -> ed448.Ed448PrivateKey: ...
+def from_public_bytes(data: bytes) -> ed448.Ed448PublicKey: ...

lib/python3.10/site-packages/cryptography/hazmat/bindings/_rust/openssl/hashes.pyi

@@ -0,0 +1,19 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import typing
+
+from cryptography.hazmat.primitives import hashes
+
+class Hash(hashes.HashContext):
+    def __init__(
+        self, algorithm: hashes.HashAlgorithm, backend: typing.Any = None
+    ) -> None: ...
+    @property
+    def algorithm(self) -> hashes.HashAlgorithm: ...
+    def update(self, data: bytes) -> None: ...
+    def finalize(self) -> bytes: ...
+    def copy(self) -> Hash: ...
+
+def hash_supported(algorithm: hashes.HashAlgorithm) -> bool: ...

lib/python3.10/site-packages/cryptography/hazmat/bindings/_rust/openssl/hmac.pyi

@@ -0,0 +1,21 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import typing
+
+from cryptography.hazmat.primitives import hashes
+
+class HMAC(hashes.HashContext):
+    def __init__(
+        self,
+        key: bytes,
+        algorithm: hashes.HashAlgorithm,
+        backend: typing.Any = None,
+    ) -> None: ...
+    @property
+    def algorithm(self) -> hashes.HashAlgorithm: ...
+    def update(self, data: bytes) -> None: ...
+    def finalize(self) -> bytes: ...
+    def verify(self, signature: bytes) -> None: ...
+    def copy(self) -> HMAC: ...

lib/python3.10/site-packages/cryptography/hazmat/bindings/_rust/openssl/kdf.pyi

@@ -0,0 +1,43 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import typing
+
+from cryptography.hazmat.primitives.hashes import HashAlgorithm
+
+def derive_pbkdf2_hmac(
+    key_material: bytes,
+    algorithm: HashAlgorithm,
+    salt: bytes,
+    iterations: int,
+    length: int,
+) -> bytes: ...
+
+class Scrypt:
+    def __init__(
+        self,
+        salt: bytes,
+        length: int,
+        n: int,
+        r: int,
+        p: int,
+        backend: typing.Any = None,
+    ) -> None: ...
+    def derive(self, key_material: bytes) -> bytes: ...
+    def verify(self, key_material: bytes, expected_key: bytes) -> None: ...
+
+class Argon2id:
+    def __init__(
+        self,
+        *,
+        salt: bytes,
+        length: int,
+        iterations: int,
+        lanes: int,
+        memory_cost: int,
+        ad: bytes | None = None,
+        secret: bytes | None = None,
+    ) -> None: ...
+    def derive(self, key_material: bytes) -> bytes: ...
+    def verify(self, key_material: bytes, expected_key: bytes) -> None: ...

lib/python3.10/site-packages/cryptography/hazmat/bindings/_rust/openssl/keys.pyi

@@ -0,0 +1,33 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import typing
+
+from cryptography.hazmat.primitives.asymmetric.types import (
+    PrivateKeyTypes,
+    PublicKeyTypes,
+)
+
+def load_der_private_key(
+    data: bytes,
+    password: bytes | None,
+    backend: typing.Any = None,
+    *,
+    unsafe_skip_rsa_key_validation: bool = False,
+) -> PrivateKeyTypes: ...
+def load_pem_private_key(
+    data: bytes,
+    password: bytes | None,
+    backend: typing.Any = None,
+    *,
+    unsafe_skip_rsa_key_validation: bool = False,
+) -> PrivateKeyTypes: ...
+def load_der_public_key(
+    data: bytes,
+    backend: typing.Any = None,
+) -> PublicKeyTypes: ...
+def load_pem_public_key(
+    data: bytes,
+    backend: typing.Any = None,
+) -> PublicKeyTypes: ...

lib/python3.10/site-packages/cryptography/hazmat/bindings/_rust/openssl/poly1305.pyi

@@ -0,0 +1,13 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+class Poly1305:
+    def __init__(self, key: bytes) -> None: ...
+    @staticmethod
+    def generate_tag(key: bytes, data: bytes) -> bytes: ...
+    @staticmethod
+    def verify_tag(key: bytes, data: bytes, tag: bytes) -> None: ...
+    def update(self, data: bytes) -> None: ...
+    def finalize(self) -> bytes: ...
+    def verify(self, tag: bytes) -> None: ...

lib/python3.10/site-packages/cryptography/hazmat/bindings/_rust/openssl/rsa.pyi

@@ -0,0 +1,55 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import typing
+
+from cryptography.hazmat.primitives.asymmetric import rsa
+
+class RSAPrivateKey: ...
+class RSAPublicKey: ...
+
+class RSAPrivateNumbers:
+    def __init__(
+        self,
+        p: int,
+        q: int,
+        d: int,
+        dmp1: int,
+        dmq1: int,
+        iqmp: int,
+        public_numbers: RSAPublicNumbers,
+    ) -> None: ...
+    @property
+    def p(self) -> int: ...
+    @property
+    def q(self) -> int: ...
+    @property
+    def d(self) -> int: ...
+    @property
+    def dmp1(self) -> int: ...
+    @property
+    def dmq1(self) -> int: ...
+    @property
+    def iqmp(self) -> int: ...
+    @property
+    def public_numbers(self) -> RSAPublicNumbers: ...
+    def private_key(
+        self,
+        backend: typing.Any = None,
+        *,
+        unsafe_skip_rsa_key_validation: bool = False,
+    ) -> rsa.RSAPrivateKey: ...
+
+class RSAPublicNumbers:
+    def __init__(self, e: int, n: int) -> None: ...
+    @property
+    def n(self) -> int: ...
+    @property
+    def e(self) -> int: ...
+    def public_key(self, backend: typing.Any = None) -> rsa.RSAPublicKey: ...
+
+def generate_private_key(
+    public_exponent: int,
+    key_size: int,
+) -> rsa.RSAPrivateKey: ...

lib/python3.10/site-packages/cryptography/hazmat/bindings/_rust/openssl/x25519.pyi

@@ -0,0 +1,12 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+from cryptography.hazmat.primitives.asymmetric import x25519
+
+class X25519PrivateKey: ...
+class X25519PublicKey: ...
+
+def generate_key() -> x25519.X25519PrivateKey: ...
+def from_private_bytes(data: bytes) -> x25519.X25519PrivateKey: ...
+def from_public_bytes(data: bytes) -> x25519.X25519PublicKey: ...

lib/python3.10/site-packages/cryptography/hazmat/bindings/_rust/openssl/x448.pyi

@@ -0,0 +1,12 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+from cryptography.hazmat.primitives.asymmetric import x448
+
+class X448PrivateKey: ...
+class X448PublicKey: ...
+
+def generate_key() -> x448.X448PrivateKey: ...
+def from_private_bytes(data: bytes) -> x448.X448PrivateKey: ...
+def from_public_bytes(data: bytes) -> x448.X448PublicKey: ...

lib/python3.10/site-packages/cryptography/hazmat/bindings/_rust/pkcs12.pyi

@@ -0,0 +1,46 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import typing
+
+from cryptography import x509
+from cryptography.hazmat.primitives.asymmetric.types import PrivateKeyTypes
+from cryptography.hazmat.primitives.serialization import (
+    KeySerializationEncryption,
+)
+from cryptography.hazmat.primitives.serialization.pkcs12 import (
+    PKCS12KeyAndCertificates,
+    PKCS12PrivateKeyTypes,
+)
+
+class PKCS12Certificate:
+    def __init__(
+        self, cert: x509.Certificate, friendly_name: bytes | None
+    ) -> None: ...
+    @property
+    def friendly_name(self) -> bytes | None: ...
+    @property
+    def certificate(self) -> x509.Certificate: ...
+
+def load_key_and_certificates(
+    data: bytes,
+    password: bytes | None,
+    backend: typing.Any = None,
+) -> tuple[
+    PrivateKeyTypes | None,
+    x509.Certificate | None,
+    list[x509.Certificate],
+]: ...
+def load_pkcs12(
+    data: bytes,
+    password: bytes | None,
+    backend: typing.Any = None,
+) -> PKCS12KeyAndCertificates: ...
+def serialize_key_and_certificates(
+    name: bytes | None,
+    key: PKCS12PrivateKeyTypes | None,
+    cert: x509.Certificate | None,
+    cas: typing.Iterable[x509.Certificate | PKCS12Certificate] | None,
+    encryption_algorithm: KeySerializationEncryption,
+) -> bytes: ...

lib/python3.10/site-packages/cryptography/hazmat/bindings/_rust/pkcs7.pyi

@@ -0,0 +1,49 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import typing
+
+from cryptography import x509
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric import rsa
+from cryptography.hazmat.primitives.serialization import pkcs7
+
+def serialize_certificates(
+    certs: list[x509.Certificate],
+    encoding: serialization.Encoding,
+) -> bytes: ...
+def encrypt_and_serialize(
+    builder: pkcs7.PKCS7EnvelopeBuilder,
+    encoding: serialization.Encoding,
+    options: typing.Iterable[pkcs7.PKCS7Options],
+) -> bytes: ...
+def sign_and_serialize(
+    builder: pkcs7.PKCS7SignatureBuilder,
+    encoding: serialization.Encoding,
+    options: typing.Iterable[pkcs7.PKCS7Options],
+) -> bytes: ...
+def decrypt_der(
+    data: bytes,
+    certificate: x509.Certificate,
+    private_key: rsa.RSAPrivateKey,
+    options: typing.Iterable[pkcs7.PKCS7Options],
+) -> bytes: ...
+def decrypt_pem(
+    data: bytes,
+    certificate: x509.Certificate,
+    private_key: rsa.RSAPrivateKey,
+    options: typing.Iterable[pkcs7.PKCS7Options],
+) -> bytes: ...
+def decrypt_smime(
+    data: bytes,
+    certificate: x509.Certificate,
+    private_key: rsa.RSAPrivateKey,
+    options: typing.Iterable[pkcs7.PKCS7Options],
+) -> bytes: ...
+def load_pem_pkcs7_certificates(
+    data: bytes,
+) -> list[x509.Certificate]: ...
+def load_der_pkcs7_certificates(
+    data: bytes,
+) -> list[x509.Certificate]: ...

lib/python3.10/site-packages/cryptography/hazmat/bindings/_rust/test_support.pyi

@@ -0,0 +1,22 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+from cryptography import x509
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.serialization import pkcs7
+
+class TestCertificate:
+    not_after_tag: int
+    not_before_tag: int
+    issuer_value_tags: list[int]
+    subject_value_tags: list[int]
+
+def test_parse_certificate(data: bytes) -> TestCertificate: ...
+def pkcs7_verify(
+    encoding: serialization.Encoding,
+    sig: bytes,
+    msg: bytes | None,
+    certs: list[x509.Certificate],
+    options: list[pkcs7.PKCS7Options],
+) -> None: ...