From d6a3528d319e474f7a824050f7311e585ab810b2 Mon Sep 17 00:00:00 2001
From: Jonah Lawrence <jonah@freshidea.com>
Date: Wed, 2 Nov 2022 02:53:12 +0000
Subject: [PATCH 01/53] docs(changes): Fix broken issue links

---
 CHANGES.rst | 30 +++++++++++++++---------------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/CHANGES.rst b/CHANGES.rst
index cb09f4f74..949d16dd7 100644
--- a/CHANGES.rst
+++ b/CHANGES.rst
@@ -13,35 +13,35 @@ Upcoming deprecation
 Improvements
 ~~~~~~~~~~~~
 
-* Support for hex escapes in JavaScript string literals :gh:`#877` - Przemyslaw Wegrzyn
-* Add support for formatting decimals in compact form :gh:`#909` - Jonah Lawrence
-* Adapt parse_date to handle ISO dates in ASCII format :gh:`#842` - Eric L.
-* Use `ast` instead of `eval` for Python string extraction :gh:`#915` - Aarni Koskela
+* Support for hex escapes in JavaScript string literals :gh:`877` - Przemyslaw Wegrzyn
+* Add support for formatting decimals in compact form :gh:`909` - Jonah Lawrence
+* Adapt parse_date to handle ISO dates in ASCII format :gh:`842` - Eric L.
+* Use `ast` instead of `eval` for Python string extraction :gh:`915` - Aarni Koskela
     * This also enables extraction from static f-strings.
       F-strings with expressions are silently ignored (but won't raise an error as they used to).
 
 Infrastructure
 ~~~~~~~~~~~~~~
 
-* Tests: Use regular asserts and ``pytest.raises()`` :gh:`#875` – Aarni Koskela
-* Wheels are now built in GitHub Actions :gh:`#888` – Aarni Koskela
-* Small improvements to the CLDR downloader script :gh:`#894` – Aarni Koskela
-* Remove antiquated `__nonzero__` methods :gh:`#896` - Nikita Sobolev
-* Remove superfluous `__unicode__` declarations :gh:`#905` - Lukas Juhrich
-* Mark package compatible with Python 3.11 :gh:`#913` - Aarni Koskela
-* Quiesce pytest warnings :gh:`#916` - Aarni Koskela
+* Tests: Use regular asserts and ``pytest.raises()`` :gh:`875` – Aarni Koskela
+* Wheels are now built in GitHub Actions :gh:`888` – Aarni Koskela
+* Small improvements to the CLDR downloader script :gh:`894` – Aarni Koskela
+* Remove antiquated `__nonzero__` methods :gh:`896` - Nikita Sobolev
+* Remove superfluous `__unicode__` declarations :gh:`905` - Lukas Juhrich
+* Mark package compatible with Python 3.11 :gh:`913` - Aarni Koskela
+* Quiesce pytest warnings :gh:`916` - Aarni Koskela
 
 Bugfixes
 ~~~~~~~~
 
-* Use email.Message for pofile header parsing instead of the deprecated ``cgi.parse_header`` function. :gh:`#876` – Aarni Koskela
-* Remove determining time zone via systemsetup on macOS :gh:`#914` - Aarni Koskela
+* Use email.Message for pofile header parsing instead of the deprecated ``cgi.parse_header`` function. :gh:`876` – Aarni Koskela
+* Remove determining time zone via systemsetup on macOS :gh:`914` - Aarni Koskela
 
 Documentation
 ~~~~~~~~~~~~~
 
-* Update Python versions in documentation :gh:`#898` - Raphael Nestler
-* Align BSD-3 license with OSI template :gh:`#912` - Lukas Kahwe Smith
+* Update Python versions in documentation :gh:`898` - Raphael Nestler
+* Align BSD-3 license with OSI template :gh:`912` - Lukas Kahwe Smith
 
 Version 2.10.3
 --------------

From f7af1b72e765278b3431de3f3b92c6b9a189b18e Mon Sep 17 00:00:00 2001
From: Aarni Koskela <akx@iki.fi>
Date: Wed, 2 Nov 2022 08:25:47 +0200
Subject: [PATCH 02/53] Update docs build configuration (#924)

* Use Python 3.11
* Use Sphinx 5 (and update extlinks configuration)
* Use Python 3 intersphinx mapping
* Install Babel from the build directory

Refs https://github.com/python-babel/babel/issues/920
---
 .readthedocs.yml      | 13 ++++++++++---
 docs/conf.py          |  6 +++---
 docs/requirements.txt |  2 +-
 3 files changed, 14 insertions(+), 7 deletions(-)

diff --git a/.readthedocs.yml b/.readthedocs.yml
index a4a09ac65..cc83f360b 100644
--- a/.readthedocs.yml
+++ b/.readthedocs.yml
@@ -3,10 +3,17 @@
 version: 2
 
 build:
-  os: ubuntu-20.04
+  os: ubuntu-22.04
   tools:
-    python: "3.9"
-
+    python: "3.11"
+  jobs:
+    pre_build:
+      # Replace any Babel version something may have pulled in
+      # with the copy we're working on.  We'll also need to build
+      # the data files at that point, or date formatting _within_
+      # Sphinx will fail.
+      - pip install -e .
+      - make import-cldr
 sphinx:
    configuration: docs/conf.py
 
diff --git a/docs/conf.py b/docs/conf.py
index 24c6ce217..c0e23894b 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -251,10 +251,10 @@
 #texinfo_show_urls = 'footnote'
 
 intersphinx_mapping = {
-    'https://docs.python.org/2/': None,
+    'https://docs.python.org/3/': None,
 }
 
 extlinks = {
-    'gh': ('https://github.com/python-babel/babel/issues/%s', '#'),
-    'trac': ('http://babel.edgewall.org/ticket/%s', 'ticket #'),
+    'gh': ('https://github.com/python-babel/babel/issues/%s', '#%s'),
+    'trac': ('http://babel.edgewall.org/ticket/%s', 'ticket #%s'),
 }
diff --git a/docs/requirements.txt b/docs/requirements.txt
index aaedb2115..c133306c7 100644
--- a/docs/requirements.txt
+++ b/docs/requirements.txt
@@ -1 +1 @@
-Sphinx~=4.4.0
+Sphinx~=5.3.0

From 103c214dcf57e53f8f18b30f59947c9752c18ab2 Mon Sep 17 00:00:00 2001
From: Jonah Lawrence <jonah@freshidea.com>
Date: Wed, 2 Nov 2022 00:35:41 -0600
Subject: [PATCH 03/53] feat: Add `Format.compact_decimal` utility (#921)

---
 babel/support.py      | 13 ++++++++++++-
 tests/test_support.py |  5 +++++
 2 files changed, 17 insertions(+), 1 deletion(-)

diff --git a/babel/support.py b/babel/support.py
index 80e93400d..3efc0036b 100644
--- a/babel/support.py
+++ b/babel/support.py
@@ -18,7 +18,7 @@
 from babel.dates import format_date, format_datetime, format_time, \
     format_timedelta
 from babel.numbers import format_decimal, format_currency, \
-    format_percent, format_scientific
+    format_percent, format_scientific, format_compact_decimal
 
 
 class Format:
@@ -108,6 +108,17 @@ def decimal(self, number, format=None):
         """
         return format_decimal(number, format, locale=self.locale)
 
+    def compact_decimal(self, number, format_type='short', fraction_digits=0):
+        """Return a number formatted in compact form for the locale.
+
+        >>> fmt = Format('en_US')
+        >>> fmt.compact_decimal(123456789)
+        u'123M'
+        """
+        return format_compact_decimal(number, format_type=format_type,
+                                      fraction_digits=fraction_digits,
+                                      locale=self.locale)
+
     def currency(self, number, currency):
         """Return a number in the given currency formatted for the locale.
         """
diff --git a/tests/test_support.py b/tests/test_support.py
index 2d8e9332d..93ad37e4a 100644
--- a/tests/test_support.py
+++ b/tests/test_support.py
@@ -329,6 +329,11 @@ def test_format_decimal():
     assert fmt.decimal(1.2345) == '1.234'
 
 
+def test_format_compact_decimal():
+    fmt = support.Format('en_US')
+    assert fmt.compact_decimal(1234567, format_type='long', fraction_digits=2) == '1.23 million'
+
+
 def test_format_percent():
     fmt = support.Format('en_US')
     assert fmt.percent(0.34) == '34%'

From 3add2c141783b1f590c753f475b8cba64d15cd0c Mon Sep 17 00:00:00 2001
From: Aarni Koskela <akx@iki.fi>
Date: Wed, 2 Nov 2022 08:36:42 +0200
Subject: [PATCH 04/53] Remove vestigial Python 2 `long` check (#925)

---
 babel/numbers.py | 9 +--------
 1 file changed, 1 insertion(+), 8 deletions(-)

diff --git a/babel/numbers.py b/babel/numbers.py
index 373a9bd16..8a341c4fa 100644
--- a/babel/numbers.py
+++ b/babel/numbers.py
@@ -24,13 +24,6 @@
 
 from babel.core import default_locale, Locale, get_global
 
-try:
-    # Python 2
-    long
-except NameError:
-    # Python 3
-    long = int
-
 
 LC_NUMERIC = default_locale('LC_NUMERIC')
 
@@ -371,7 +364,7 @@ def get_decimal_precision(number):
 
 def get_decimal_quantum(precision):
     """Return minimal quantum of a number, as defined by precision."""
-    assert isinstance(precision, (int, long, decimal.Decimal))
+    assert isinstance(precision, (int, decimal.Decimal))
     return decimal.Decimal(10) ** (-precision)
 
 

From 5fcc2535f96bfce9c1a1ecf9d19a976b9bf6ab6b Mon Sep 17 00:00:00 2001
From: Jonah Lawrence <jonah@freshidea.com>
Date: Fri, 4 Nov 2022 09:16:24 -0600
Subject: [PATCH 05/53] feat: Support for short compact currency formats (#926)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Jun Omae (大前 潤) <42682+jun66j5@users.noreply.github.com>
---
 babel/core.py          | 12 ++++++++++
 babel/numbers.py       | 53 ++++++++++++++++++++++++++++++++++++++----
 babel/support.py       |  9 ++++++-
 docs/api/numbers.rst   |  2 ++
 scripts/import_cldr.py | 21 ++++++++++++-----
 tests/test_numbers.py  | 29 +++++++++++++++++++++++
 tests/test_support.py  |  5 ++++
 7 files changed, 119 insertions(+), 12 deletions(-)

diff --git a/babel/core.py b/babel/core.py
index 220cbaf0a..2a01c309f 100644
--- a/babel/core.py
+++ b/babel/core.py
@@ -590,6 +590,18 @@ def currency_formats(self):
         """
         return self._data['currency_formats']
 
+    @property
+    def compact_currency_formats(self):
+        """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):
         """Locale patterns for percent number formatting.
diff --git a/babel/numbers.py b/babel/numbers.py
index 8a341c4fa..8baf110b8 100644
--- a/babel/numbers.py
+++ b/babel/numbers.py
@@ -440,18 +440,21 @@ def format_compact_decimal(number, *, format_type="short", locale=LC_NUMERIC, fr
     :param fraction_digits: Number of digits after the decimal point to use. Defaults to `0`.
     """
     locale = Locale.parse(locale)
-    number, format = _get_compact_format(number, format_type, locale, fraction_digits)
+    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.get(None)
     pattern = parse_pattern(format)
     return pattern.apply(number, locale, decimal_quantization=False)
 
 
-def _get_compact_format(number, format_type, locale, fraction_digits=0):
+def _get_compact_format(number, compact_format, locale, fraction_digits=0):
     """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.
     """
     format = None
-    compact_format = locale.compact_decimal_formats[format_type]
     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
@@ -470,8 +473,6 @@ def _get_compact_format(number, format_type, locale, fraction_digits=0):
             plural_form = plural_form if plural_form in compact_format else "other"
             format = compact_format[plural_form][str(magnitude)]
             break
-    if format is None:  # Did not find a format, fall back.
-        format = locale.decimal_formats.get(None)
     return number, format
 
 
@@ -624,6 +625,44 @@ def _format_currency_long_name(
     return unit_pattern.format(number_part, display_name)
 
 
+def format_compact_currency(number, currency, *, format_type="short", locale=LC_NUMERIC, fraction_digits=0):
+    u"""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
+    :param fraction_digits: Number of digits after the decimal point to use. Defaults to `0`.
+    """
+    locale = Locale.parse(locale)
+    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
+    pattern = parse_pattern(format)
+    return pattern.apply(number, locale, currency=currency, currency_digits=False, decimal_quantization=False)
+
+
 def format_percent(
         number, format=None, locale=LC_NUMERIC, decimal_quantization=True, group_separator=True):
     """Return formatted percent value for a specific locale.
@@ -1082,6 +1121,10 @@ def apply(
             retval = retval.replace(u'¤¤', currency.upper())
             retval = retval.replace(u'¤', 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
 
     #
diff --git a/babel/support.py b/babel/support.py
index 3efc0036b..50f275274 100644
--- a/babel/support.py
+++ b/babel/support.py
@@ -17,7 +17,7 @@
 from babel.core import Locale
 from babel.dates import format_date, format_datetime, format_time, \
     format_timedelta
-from babel.numbers import format_decimal, format_currency, \
+from babel.numbers import format_decimal, format_currency, format_compact_currency, \
     format_percent, format_scientific, format_compact_decimal
 
 
@@ -124,6 +124,13 @@ def currency(self, number, currency):
         """
         return format_currency(number, currency, locale=self.locale)
 
+    def compact_currency(self, number, currency, format_type='short', fraction_digits=0):
+        """Return a number in the given currency formatted for the locale
+        using the compact number format.
+        """
+        return format_compact_currency(number, currency, format_type=format_type,
+                                        fraction_digits=fraction_digits, locale=self.locale)
+
     def percent(self, number, format=None):
         """Return a number formatted as percentage for the locale.
 
diff --git a/docs/api/numbers.rst b/docs/api/numbers.rst
index eac569206..d3ab8b116 100644
--- a/docs/api/numbers.rst
+++ b/docs/api/numbers.rst
@@ -17,6 +17,8 @@ Number Formatting
 
 .. autofunction:: format_currency
 
+.. autofunction:: format_compact_currency
+
 .. autofunction:: format_percent
 
 .. autofunction:: format_scientific
diff --git a/scripts/import_cldr.py b/scripts/import_cldr.py
index 92dd27234..097840cec 100755
--- a/scripts/import_cldr.py
+++ b/scripts/import_cldr.py
@@ -915,10 +915,6 @@ def parse_currency_formats(data, tree):
             curr_length_type = length_elem.attrib.get('type')
             for elem in length_elem.findall('currencyFormat'):
                 type = elem.attrib.get('type')
-                if curr_length_type:
-                    # Handle `<currencyFormatLength type="short">`, etc.
-                    # TODO(3.x): use nested dicts instead of colon-separated madness
-                    type = '%s:%s' % (type, curr_length_type)
                 if _should_skip_elem(elem, type, currency_formats):
                     continue
                 for child in elem.iter():
@@ -928,8 +924,21 @@ def parse_currency_formats(data, tree):
                                              child.attrib['path'])
                         )
                     elif child.tag == 'pattern':
-                        pattern = str(child.text)
-                        currency_formats[type] = numbers.parse_pattern(pattern)
+                        pattern_type = child.attrib.get('type')
+                        pattern = numbers.parse_pattern(str(child.text))
+                        if pattern_type:
+                            # This is a compact currency format, see:
+                            # https://www.unicode.org/reports/tr35/tr35-45/tr35-numbers.html#Compact_Number_Formats
+
+                            # These are mapped into a `compact_currency_formats` dictionary
+                            # with the format {length: {count: {multiplier: pattern}}}.
+                            compact_currency_formats = data.setdefault('compact_currency_formats', {})
+                            length_map = compact_currency_formats.setdefault(curr_length_type, {})
+                            length_count_map = length_map.setdefault(child.attrib['count'], {})
+                            length_count_map[pattern_type] = pattern
+                        else:
+                            # Regular currency format
+                            currency_formats[type] = pattern
 
 
 def parse_currency_unit_patterns(data, tree):
diff --git a/tests/test_numbers.py b/tests/test_numbers.py
index 1b955c95e..bb6c4e84e 100644
--- a/tests/test_numbers.py
+++ b/tests/test_numbers.py
@@ -422,6 +422,27 @@ def test_format_currency_format_type():
             == u'1.099,98')
 
 
+def test_format_compact_currency():
+    assert numbers.format_compact_currency(1, 'USD', locale='en_US', format_type="short") == u'$1'
+    assert numbers.format_compact_currency(999, 'USD', locale='en_US', format_type="short") == u'$999'
+    assert numbers.format_compact_currency(123456789, 'USD', locale='en_US', format_type="short") == u'$123M'
+    assert numbers.format_compact_currency(123456789, 'USD', locale='en_US', fraction_digits=2, format_type="short") == u'$123.46M'
+    assert numbers.format_compact_currency(-123456789, 'USD', locale='en_US', fraction_digits=2, format_type="short") == u'-$123.46M'
+    assert numbers.format_compact_currency(1, 'JPY', locale='ja_JP', format_type="short") == u'￥1'
+    assert numbers.format_compact_currency(1234, 'JPY', locale='ja_JP', format_type="short") == u'￥1234'
+    assert numbers.format_compact_currency(123456, 'JPY', locale='ja_JP', format_type="short") == u'￥12万'
+    assert numbers.format_compact_currency(123456, 'JPY', locale='ja_JP', format_type="short", fraction_digits=2) == u'￥12.35万'
+    assert numbers.format_compact_currency(123, 'EUR', locale='yav', format_type="short") == '123\xa0€'
+    assert numbers.format_compact_currency(12345, 'EUR', locale='yav', format_type="short") == '12K\xa0€'
+    assert numbers.format_compact_currency(123456789, 'EUR', locale='de_DE', fraction_digits=1) == '123,5\xa0Mio.\xa0€'
+
+
+def test_format_compact_currency_invalid_format_type():
+    with pytest.raises(numbers.UnknownCurrencyFormatError):
+        numbers.format_compact_currency(1099.98, 'USD', locale='en_US',
+                                format_type='unknown')
+
+
 @pytest.mark.parametrize('input_value, expected_value', [
     ('10000', '$10,000.00'),
     ('1', '$1.00'),
@@ -696,3 +717,11 @@ def test_parse_decimal_nbsp_heuristics():
 
 def test_very_small_decimal_no_quantization():
     assert numbers.format_decimal(decimal.Decimal('1E-7'), locale='en', decimal_quantization=False) == '0.0000001'
+
+
+def test_single_quotes_in_pattern():
+    assert numbers.format_decimal(123, "'@0.#'00'@01'", locale='en') == '@0.#120@01'
+
+    assert numbers.format_decimal(123, "'$'''0", locale='en') == "$'123"
+
+    assert numbers.format_decimal(12, "'#'0 o''clock", locale='en') == "#12 o'clock"
diff --git a/tests/test_support.py b/tests/test_support.py
index 93ad37e4a..944710751 100644
--- a/tests/test_support.py
+++ b/tests/test_support.py
@@ -334,6 +334,11 @@ def test_format_compact_decimal():
     assert fmt.compact_decimal(1234567, format_type='long', fraction_digits=2) == '1.23 million'
 
 
+def test_format_compact_currency():
+    fmt = support.Format('en_US')
+    assert fmt.compact_currency(1234567, "USD", format_type='short', fraction_digits=2) == '$1.23M'
+
+
 def test_format_percent():
     fmt = support.Format('en_US')
     assert fmt.percent(0.34) == '34%'

From eb647ba3fa0ba580c4a44b9507f5e74c037a1f0c Mon Sep 17 00:00:00 2001
From: Aarni Koskela <akx@iki.fi>
Date: Wed, 23 Nov 2022 13:22:01 +0200
Subject: [PATCH 06/53] Drop support for EOL Python 3.6 (#919)

---
 .github/workflows/test.yml | 2 +-
 docs/dev.rst               | 2 +-
 setup.py                   | 3 +--
 tox.ini                    | 3 +--
 4 files changed, 4 insertions(+), 6 deletions(-)

diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index f8764b580..491581677 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -16,7 +16,7 @@ jobs:
     strategy:
       matrix:
         os: ["ubuntu-20.04", "windows-2022", "macos-11"]
-        python-version: ["3.6", "3.7", "3.8", "3.9", "3.10", "3.11", "pypy-3.7"]
+        python-version: ["3.7", "3.8", "3.9", "3.10", "3.11", "pypy-3.7"]
     env:
       BABEL_CLDR_NO_DOWNLOAD_PROGRESS: "1"
       BABEL_CLDR_QUIET: "1"
diff --git a/docs/dev.rst b/docs/dev.rst
index c3627249c..1c4453d8e 100644
--- a/docs/dev.rst
+++ b/docs/dev.rst
@@ -30,7 +30,7 @@ Python Versions
 
 At the moment the following Python versions should be supported:
 
-*   Python 3.6 and up
+*   Python 3.7 and up
 *   PyPy 3.7 and up
 
 Unicode
diff --git a/setup.py b/setup.py
index 6744277a7..06caa6a64 100755
--- a/setup.py
+++ b/setup.py
@@ -47,7 +47,6 @@ def run(self):
         'Programming Language :: Python',
         'Programming Language :: Python :: 3',
         'Programming Language :: Python :: 3 :: Only',
-        'Programming Language :: Python :: 3.6',
         'Programming Language :: Python :: 3.7',
         'Programming Language :: Python :: 3.8',
         'Programming Language :: Python :: 3.9',
@@ -57,7 +56,7 @@ def run(self):
         'Programming Language :: Python :: Implementation :: PyPy',
         'Topic :: Software Development :: Libraries :: Python Modules',
     ],
-    python_requires='>=3.6',
+    python_requires='>=3.7',
     packages=['babel', 'babel.messages', 'babel.localtime'],
     include_package_data=True,
     install_requires=[
diff --git a/tox.ini b/tox.ini
index 97b6bc09c..8b640015d 100644
--- a/tox.ini
+++ b/tox.ini
@@ -1,6 +1,6 @@
 [tox]
 envlist =
-    py{36,37,38,39,310,311}
+    py{37,38,39,310,311}
     pypy3
 
 [testenv]
@@ -22,7 +22,6 @@ passenv =
 [gh-actions]
 python =
     pypy3: pypy3
-    3.6: py36
     3.7: py37
     3.8: py38
     3.9: py39

From 896c2ea72818011bc0e8bd84151b0b10935fd4fa Mon Sep 17 00:00:00 2001
From: Jonah Lawrence <jonah@freshidea.com>
Date: Wed, 23 Nov 2022 04:25:49 -0700
Subject: [PATCH 07/53] Cast number to Decimal in _get_compact_format (#930)

* fix rounding modes by using Decimal instead of float
---
 babel/numbers.py | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/babel/numbers.py b/babel/numbers.py
index 8baf110b8..6c9ab24b0 100644
--- a/babel/numbers.py
+++ b/babel/numbers.py
@@ -426,7 +426,7 @@ def format_compact_decimal(number, *, format_type="short", locale=LC_NUMERIC, fr
     >>> 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.35K'
+    u'12.34K'
     >>> format_compact_decimal(1234567, format_type="short", locale="ja_JP")
     u'123万'
     >>> format_compact_decimal(2345678, format_type="long", locale="mk")
@@ -454,6 +454,8 @@ def _get_compact_format(number, compact_format, locale, fraction_digits=0):
     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))
     format = None
     for magnitude in sorted([int(m) for m in compact_format["other"]], reverse=True):
         if abs(number) >= magnitude:
@@ -465,7 +467,7 @@ def _get_compact_format(number, compact_format, locale, fraction_digits=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 = number / (magnitude / (10 ** (pattern.count("0") - 1)))
+            number = number / (magnitude // (10 ** (pattern.count("0") - 1)))
             # round to the number of fraction digits requested
             number = round(number, fraction_digits)
             # if the remaining number is singular, use the singular format

From a45e25e3125f6ee0a9f32387545df318b0b3b2d0 Mon Sep 17 00:00:00 2001
From: Aarni Koskela <akx@iki.fi>
Date: Wed, 23 Nov 2022 13:33:10 +0200
Subject: [PATCH 08/53] Replace %/.format/concatenation with f-strings where
 feasible (#927)

Original conversion suggestions via flynt, edited by hand.
---
 babel/core.py                   | 15 ++++----
 babel/dates.py                  | 27 ++++++--------
 babel/lists.py                  |  9 +++--
 babel/localedata.py             |  6 ++--
 babel/localtime/_win32.py       |  4 +--
 babel/messages/catalog.py       | 32 ++++++++---------
 babel/messages/checkers.py      |  2 +-
 babel/messages/extract.py       | 13 ++++---
 babel/messages/frontend.py      | 36 +++++++++----------
 babel/messages/pofile.py        | 36 +++++++------------
 babel/numbers.py                | 47 +++++++++++++------------
 babel/plural.py                 | 62 ++++++++++++---------------------
 babel/support.py                |  4 +--
 babel/units.py                  | 10 +++---
 babel/util.py                   |  8 ++---
 scripts/generate_authors.py     |  2 +-
 scripts/import_cldr.py          | 17 ++++-----
 setup.py                        |  2 +-
 tests/messages/test_catalog.py  |  4 +--
 tests/messages/test_frontend.py | 13 +++----
 tests/messages/test_pofile.py   |  2 +-
 tests/test_core.py              |  3 +-
 tests/test_plural.py            |  2 +-
 tests/test_support.py           |  9 ++---
 24 files changed, 161 insertions(+), 204 deletions(-)

diff --git a/babel/core.py b/babel/core.py
index 2a01c309f..825af8132 100644
--- a/babel/core.py
+++ b/babel/core.py
@@ -98,7 +98,7 @@ def __init__(self, identifier):
 
         :param identifier: the identifier string of the unsupported locale
         """
-        Exception.__init__(self, 'unknown locale %r' % identifier)
+        Exception.__init__(self, f"unknown locale {identifier!r}")
 
         #: The identifier of the locale that could not be found.
         self.identifier = identifier
@@ -262,7 +262,7 @@ def parse(cls, identifier, sep='_', resolve_likely_subtags=True):
         elif isinstance(identifier, Locale):
             return identifier
         elif not isinstance(identifier, str):
-            raise TypeError('Unexpected value for identifier: %r' % (identifier,))
+            raise TypeError(f"Unexpected value for identifier: {identifier!r}")
 
         parts = parse_locale(identifier, sep=sep)
         input_id = get_locale_identifier(parts)
@@ -349,9 +349,8 @@ def __repr__(self):
         for key in ('territory', 'script', 'variant'):
             value = getattr(self, key)
             if value is not None:
-                parameters.append('%s=%r' % (key, value))
-        parameter_string = '%r' % self.language + ', '.join(parameters)
-        return 'Locale(%s)' % parameter_string
+                parameters.append(f"{key}={value!r}")
+        return f"Locale({self.language!r}{', '.join(parameters)})"
 
     def __str__(self):
         return get_locale_identifier((self.language, self.territory,
@@ -388,7 +387,7 @@ def get_display_name(self, locale=None):
                 details.append(locale.variants.get(self.variant))
             details = filter(None, details)
             if details:
-                retval += ' (%s)' % u', '.join(details)
+                retval += f" ({', '.join(details)})"
         return retval
 
     display_name = property(get_display_name, doc="""\
@@ -1120,7 +1119,7 @@ def parse_locale(identifier, sep='_'):
     parts = identifier.split(sep)
     lang = parts.pop(0).lower()
     if not lang.isalpha():
-        raise ValueError('expected only letters, got %r' % lang)
+        raise ValueError(f"expected only letters, got {lang!r}")
 
     script = territory = variant = None
     if parts:
@@ -1139,7 +1138,7 @@ def parse_locale(identifier, sep='_'):
             variant = parts.pop().upper()
 
     if parts:
-        raise ValueError('%r is not a valid locale identifier' % identifier)
+        raise ValueError(f"{identifier!r} is not a valid locale identifier")
 
     return lang, territory, script, variant
 
diff --git a/babel/dates.py b/babel/dates.py
index 8228bef88..e9f6f6dd2 100644
--- a/babel/dates.py
+++ b/babel/dates.py
@@ -203,7 +203,7 @@ def get_timezone(zone=None):
     try:
         return _pytz.timezone(zone)
     except _pytz.UnknownTimeZoneError:
-        raise LookupError('Unknown timezone %s' % zone)
+        raise LookupError(f"Unknown timezone {zone}")
 
 
 def get_next_timezone_transition(zone=None, dt=None):
@@ -312,11 +312,7 @@ def to_offset(self):
         return int(self.to_tzinfo._utcoffset.total_seconds())
 
     def __repr__(self):
-        return '<TimezoneTransition %s -> %s (%s)>' % (
-            self.from_tz,
-            self.to_tz,
-            self.activates,
-        )
+        return f"<TimezoneTransition {self.from_tz} -> {self.to_tz} ({self.activates})>"
 
 
 def get_period_names(width='wide', context='stand-alone', locale=LC_TIME):
@@ -958,7 +954,7 @@ def _iter_patterns(a_unit):
                 yield unit_rel_patterns['future']
             else:
                 yield unit_rel_patterns['past']
-        a_unit = 'duration-' + a_unit
+        a_unit = f"duration-{a_unit}"
         yield locale._data['unit_patterns'].get(a_unit, {}).get(format)
 
     for unit, secs_per_unit in TIMEDELTA_UNITS:
@@ -1293,7 +1289,7 @@ def __init__(self, pattern, format):
         self.format = format
 
     def __repr__(self):
-        return '<%s %r>' % (type(self).__name__, self.pattern)
+        return f"<{type(self).__name__} {self.pattern!r}>"
 
     def __str__(self):
         pat = self.pattern
@@ -1365,7 +1361,7 @@ def __getitem__(self, name):
         elif char in ('z', 'Z', 'v', 'V', 'x', 'X', 'O'):
             return self.format_timezone(char, num)
         else:
-            raise KeyError('Unsupported date/time field %r' % char)
+            raise KeyError(f"Unsupported date/time field {char!r}")
 
     def extract(self, char):
         char = str(char)[0]
@@ -1384,7 +1380,7 @@ def extract(self, char):
         elif char == 'a':
             return int(self.value.hour >= 12)  # 0 for am, 1 for pm
         else:
-            raise NotImplementedError("Not implemented: extracting %r from %r" % (char, self.value))
+            raise NotImplementedError(f"Not implemented: extracting {char!r} from {self.value!r}")
 
     def format_era(self, char, num):
         width = {3: 'abbreviated', 4: 'wide', 5: 'narrow'}[max(3, num)]
@@ -1429,7 +1425,7 @@ def format_week(self, char, num):
             if week == 0:
                 date = self.value - timedelta(days=self.value.day)
                 week = self.get_week_number(date.day, date.weekday())
-            return '%d' % week
+            return str(week)
 
     def format_weekday(self, char='E', num=4):
         """
@@ -1475,7 +1471,7 @@ def format_day_of_year(self, num):
         return self.format(self.get_day_of_year(), num)
 
     def format_day_of_week_in_month(self):
-        return '%d' % ((self.value.day - 1) // 7 + 1)
+        return str((self.value.day - 1) // 7 + 1)
 
     def format_period(self, char, num):
         """
@@ -1517,7 +1513,7 @@ def format_period(self, char, num):
             period_names = get_period_names(context=context, width=width, locale=self.locale)
             if period in period_names:
                 return period_names[period]
-        raise ValueError('Could not format period %s in %s' % (period, self.locale))
+        raise ValueError(f"Could not format period {period} in {self.locale}")
 
     def format_frac_seconds(self, num):
         """ Return fractional seconds.
@@ -1689,11 +1685,10 @@ def parse_pattern(pattern):
             fieldchar, fieldnum = tok_value
             limit = PATTERN_CHARS[fieldchar]
             if limit and fieldnum not in limit:
-                raise ValueError('Invalid length for field: %r'
-                                 % (fieldchar * fieldnum))
+                raise ValueError(f"Invalid length for field: {fieldchar * fieldnum!r}")
             result.append('%%(%s)s' % (fieldchar * fieldnum))
         else:
-            raise NotImplementedError("Unknown token type: %s" % tok_type)
+            raise NotImplementedError(f"Unknown token type: {tok_type}")
 
     _pattern_cache[pattern] = pat = DateTimePattern(pattern, u''.join(result))
     return pat
diff --git a/babel/lists.py b/babel/lists.py
index 11cc7d725..ea983efe0 100644
--- a/babel/lists.py
+++ b/babel/lists.py
@@ -68,11 +68,10 @@ def format_list(lst, style='standard', locale=DEFAULT_LOCALE):
         return lst[0]
 
     if style not in locale.list_patterns:
-        raise ValueError('Locale %s does not support list formatting style %r (supported are %s)' % (
-            locale,
-            style,
-            list(sorted(locale.list_patterns)),
-        ))
+        raise ValueError(
+            f'Locale {locale} does not support list formatting style {style!r} '
+            f'(supported are {sorted(locale.list_patterns)})'
+        )
     patterns = locale.list_patterns[style]
 
     if len(lst) == 2:
diff --git a/babel/localedata.py b/babel/localedata.py
index 14e6bcdf4..8ec8f4aaa 100644
--- a/babel/localedata.py
+++ b/babel/localedata.py
@@ -50,10 +50,10 @@ def resolve_locale_filename(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("Name %s is invalid on Windows" % name)
+        raise ValueError(f"Name {name} is invalid on Windows")
 
     # Build the path.
-    return os.path.join(_dirname, '%s.dat' % name)
+    return os.path.join(_dirname, f"{name}.dat")
 
 
 def exists(name):
@@ -194,7 +194,7 @@ def __init__(self, keys):
         self.keys = tuple(keys)
 
     def __repr__(self):
-        return '<%s %r>' % (type(self).__name__, self.keys)
+        return f"<{type(self).__name__} {self.keys!r}>"
 
     def resolve(self, data):
         """Resolve the alias based on the given data.
diff --git a/babel/localtime/_win32.py b/babel/localtime/_win32.py
index 09b87b14e..a4f6d557a 100644
--- a/babel/localtime/_win32.py
+++ b/babel/localtime/_win32.py
@@ -77,11 +77,11 @@ def get_localzone_name():
     if timezone is None:
         # Nope, that didn't work. Try adding 'Standard Time',
         # it seems to work a lot of times:
-        timezone = tz_names.get(tzkeyname + ' Standard Time')
+        timezone = tz_names.get(f"{tzkeyname} Standard Time")
 
     # Return what we have.
     if timezone is None:
-        raise pytz.UnknownTimeZoneError('Can not find timezone ' + tzkeyname)
+        raise pytz.UnknownTimeZoneError(f"Can not find timezone {tzkeyname}")
 
     return timezone
 
diff --git a/babel/messages/catalog.py b/babel/messages/catalog.py
index e43a28c02..22ce66067 100644
--- a/babel/messages/catalog.py
+++ b/babel/messages/catalog.py
@@ -49,7 +49,7 @@ def _parse_datetime_header(value):
         hours_offset_s, mins_offset_s = rest[:2], rest[2:]
 
         # Make them all integers
-        plus_minus = int(plus_minus_s + '1')
+        plus_minus = int(f"{plus_minus_s}1")
         hours_offset = int(hours_offset_s)
         mins_offset = int(mins_offset_s)
 
@@ -108,8 +108,7 @@ def __init__(self, id, string=u'', locations=(), flags=(), auto_comments=(),
         self.context = context
 
     def __repr__(self):
-        return '<%s %r (flags: %r)>' % (type(self).__name__, self.id,
-                                        list(self.flags))
+        return f"<{type(self).__name__} {self.id!r} (flags: {list(self.flags)!r})>"
 
     def __cmp__(self, other):
         """Compare Messages, taking into account plural ids"""
@@ -312,7 +311,7 @@ def _set_locale(self, locale):
                 self._locale = None
             return
 
-        raise TypeError('`locale` must be a Locale, a locale identifier string, or None; got %r' % locale)
+        raise TypeError(f"`locale` must be a Locale, a locale identifier string, or None; got {locale!r}")
 
     def _get_locale(self):
         return self._locale
@@ -334,7 +333,7 @@ def _get_header_comment(self):
                          .replace('ORGANIZATION', self.copyright_holder)
         locale_name = (self.locale.english_name if self.locale else self.locale_identifier)
         if locale_name:
-            comment = comment.replace('Translations template', '%s translations' % locale_name)
+            comment = comment.replace("Translations template", f"{locale_name} translations")
         return comment
 
     def _set_header_comment(self, string):
@@ -375,8 +374,7 @@ def _set_header_comment(self, string):
 
     def _get_mime_headers(self):
         headers = []
-        headers.append(('Project-Id-Version',
-                        '%s %s' % (self.project, self.version)))
+        headers.append(("Project-Id-Version", f"{self.project} {self.version}"))
         headers.append(('Report-Msgid-Bugs-To', self.msgid_bugs_address))
         headers.append(('POT-Creation-Date',
                         format_datetime(self.creation_date, 'yyyy-MM-dd HH:mmZ',
@@ -399,10 +397,9 @@ def _get_mime_headers(self):
         if self.locale is not None:
             headers.append(('Plural-Forms', self.plural_forms))
         headers.append(('MIME-Version', '1.0'))
-        headers.append(('Content-Type',
-                        'text/plain; charset=%s' % self.charset))
+        headers.append(("Content-Type", f"text/plain; charset={self.charset}"))
         headers.append(('Content-Transfer-Encoding', '8bit'))
-        headers.append(('Generated-By', 'Babel %s\n' % VERSION))
+        headers.append(("Generated-By", f"Babel {VERSION}\n"))
         return headers
 
     def _force_text(self, s, encoding='utf-8', errors='strict'):
@@ -434,7 +431,7 @@ def _set_mime_headers(self, headers):
                 if 'charset' in params:
                     self.charset = params['charset'].lower()
             elif name == 'plural-forms':
-                params = parse_separated_header(' ;' + value)
+                params = parse_separated_header(f" ;{value}")
                 self._num_plurals = int(params.get('nplurals', 2))
                 self._plural_expr = params.get('plural', '(n != 1)')
             elif name == 'pot-creation-date':
@@ -541,7 +538,7 @@ def plural_forms(self):
         'nplurals=2; plural=(n > 1);'
 
         :type: `str`"""
-        return 'nplurals=%s; plural=%s;' % (self.num_plurals, self.plural_expr)
+        return f"nplurals={self.num_plurals}; plural={self.plural_expr};"
 
     def __contains__(self, id):
         """Return whether the catalog has a message with the specified ID."""
@@ -560,7 +557,7 @@ def __iter__(self):
         :rtype: ``iterator``"""
         buf = []
         for name, value in self.mime_headers:
-            buf.append('%s: %s' % (name, value))
+            buf.append(f"{name}: {value}")
         flags = set()
         if self.fuzzy:
             flags |= {'fuzzy'}
@@ -571,8 +568,8 @@ def __iter__(self):
     def __repr__(self):
         locale = ''
         if self.locale:
-            locale = ' %s' % self.locale
-        return '<%s %r%s>' % (type(self).__name__, self.domain, locale)
+            locale = f" {self.locale}"
+        return f"<{type(self).__name__} {self.domain!r}{locale}>"
 
     def __delitem__(self, id):
         """Delete the message with the specified ID."""
@@ -626,13 +623,12 @@ def __setitem__(self, id, message):
         elif id == '':
             # special treatment for the header message
             self.mime_headers = message_from_string(message.string).items()
-            self.header_comment = '\n'.join([('# %s' % c).rstrip() for c
-                                             in message.user_comments])
+            self.header_comment = "\n".join([f"# {c}".rstrip() for c in message.user_comments])
             self.fuzzy = message.fuzzy
         else:
             if isinstance(id, (list, tuple)):
                 assert isinstance(message.string, (list, tuple)), \
-                    'Expected sequence but got %s' % type(message.string)
+                    f"Expected sequence but got {type(message.string)}"
             self._messages[key] = message
 
     def add(self, id, string=None, locations=(), flags=(), auto_comments=(),
diff --git a/babel/messages/checkers.py b/babel/messages/checkers.py
index 4292c02d3..2706c5bfe 100644
--- a/babel/messages/checkers.py
+++ b/babel/messages/checkers.py
@@ -144,7 +144,7 @@ def _check_positional(results):
         type_map = dict(a)
         for name, typechar in b:
             if name not in type_map:
-                raise TranslationError('unknown named placeholder %r' % name)
+                raise TranslationError(f'unknown named placeholder {name!r}')
             elif not _compatible(typechar, type_map[name]):
                 raise TranslationError('incompatible format for '
                                        'placeholder %r: '
diff --git a/babel/messages/extract.py b/babel/messages/extract.py
index 74e57a181..4f0f649b3 100644
--- a/babel/messages/extract.py
+++ b/babel/messages/extract.py
@@ -42,9 +42,6 @@
 
 DEFAULT_MAPPING = [('**.py', 'python')]
 
-empty_msgid_warning = (
-    '%s: warning: Empty msgid.  It is reserved by GNU gettext: gettext("") '
-    'returns the header entry with meta information, not the empty string.')
 
 
 def _strip_comment_tags(comments, tags):
@@ -332,7 +329,7 @@ def extract(method, fileobj, keywords=DEFAULT_KEYWORDS, comment_tags=(),
             func = builtin.get(method)
 
     if func is None:
-        raise ValueError('Unknown extraction method %r' % method)
+        raise ValueError(f"Unknown extraction method {method!r}")
 
     results = func(fileobj, keywords.keys(), comment_tags,
                    options=options or {})
@@ -377,9 +374,11 @@ def extract(method, fileobj, keywords=DEFAULT_KEYWORDS, comment_tags=(),
             first_msg_index = spec[0] - 1
         if not messages[first_msg_index]:
             # An empty string msgid isn't valid, emit a warning
-            where = '%s:%i' % (hasattr(fileobj, 'name') and
-                               fileobj.name or '(unknown)', lineno)
-            sys.stderr.write((empty_msgid_warning % where) + '\n')
+            filename = (getattr(fileobj, "name", None) or "(unknown)")
+            sys.stderr.write(
+                f"{filename}:{lineno}: warning: Empty msgid.  It is reserved by GNU gettext: gettext(\"\") "
+                f"returns the header entry with meta information, not the empty string.\n"
+            )
             continue
 
         messages = tuple(msgs)
diff --git a/babel/messages/frontend.py b/babel/messages/frontend.py
index 6e09d1095..c42cdc2e2 100644
--- a/babel/messages/frontend.py
+++ b/babel/messages/frontend.py
@@ -191,7 +191,7 @@ def run(self):
             for catalog, errors in self._run_domain(domain).items():
                 n_errors += len(errors)
         if n_errors:
-            self.log.error('%d errors encountered.' % n_errors)
+            self.log.error('%d errors encountered.', n_errors)
         return (1 if n_errors else 0)
 
     def _run_domain(self, domain):
@@ -203,19 +203,19 @@ def _run_domain(self, domain):
                 po_files.append((self.locale,
                                  os.path.join(self.directory, self.locale,
                                               'LC_MESSAGES',
-                                              domain + '.po')))
+                                              f"{domain}.po")))
                 mo_files.append(os.path.join(self.directory, self.locale,
                                              'LC_MESSAGES',
-                                             domain + '.mo'))
+                                             f"{domain}.mo"))
             else:
                 for locale in os.listdir(self.directory):
                     po_file = os.path.join(self.directory, locale,
-                                           'LC_MESSAGES', domain + '.po')
+                                           'LC_MESSAGES', f"{domain}.po")
                     if os.path.exists(po_file):
                         po_files.append((locale, po_file))
                         mo_files.append(os.path.join(self.directory, locale,
                                                      'LC_MESSAGES',
-                                                     domain + '.mo'))
+                                                     f"{domain}.mo"))
         else:
             po_files.append((self.locale, self.input_file))
             if self.output_file:
@@ -223,7 +223,7 @@ def _run_domain(self, domain):
             else:
                 mo_files.append(os.path.join(self.directory, self.locale,
                                              'LC_MESSAGES',
-                                             domain + '.mo'))
+                                             f"{domain}.mo"))
 
         if not po_files:
             raise OptionError('no message catalogs found')
@@ -451,7 +451,7 @@ def finalize_options(self):
 
         for path in self.input_paths:
             if not os.path.exists(path):
-                raise OptionError("Input path: %s does not exist" % path)
+                raise OptionError(f"Input path: {path} does not exist")
 
         self.add_comments = listify_value(self.add_comments or (), ",")
 
@@ -498,8 +498,8 @@ def callback(filename, method, options):
 
                     optstr = ''
                     if options:
-                        optstr = ' (%s)' % ', '.join(['%s="%s"' % (k, v) for
-                                                      k, v in options.items()])
+                        opt_values = ", ".join(f'{k}="{v}"' for k, v in options.items())
+                        optstr = f" ({opt_values})"
                     self.log.info('extracting messages from %s%s', filepath, optstr)
 
                 if os.path.isfile(path):
@@ -640,7 +640,7 @@ def finalize_options(self):
             raise OptionError('you must specify the output directory')
         if not self.output_file:
             self.output_file = os.path.join(self.output_dir, self.locale,
-                                            'LC_MESSAGES', self.domain + '.po')
+                                            'LC_MESSAGES', f"{self.domain}.po")
 
         if not os.path.exists(os.path.dirname(self.output_file)):
             os.makedirs(os.path.dirname(self.output_file))
@@ -782,12 +782,12 @@ def run(self):
                 po_files.append((self.locale,
                                  os.path.join(self.output_dir, self.locale,
                                               'LC_MESSAGES',
-                                              self.domain + '.po')))
+                                              f"{self.domain}.po")))
             else:
                 for locale in os.listdir(self.output_dir):
                     po_file = os.path.join(self.output_dir, locale,
                                            'LC_MESSAGES',
-                                           self.domain + '.po')
+                                           f"{self.domain}.po")
                     if os.path.exists(po_file):
                         po_files.append((locale, po_file))
         else:
@@ -889,7 +889,7 @@ class CommandLineInterface:
     """
 
     usage = '%%prog %s [options] %s'
-    version = '%%prog %s' % VERSION
+    version = f'%prog {VERSION}'
     commands = {
         'compile': 'compile message catalogs to MO files',
         'extract': 'extract messages from source files and generate a POT file',
@@ -949,7 +949,7 @@ def run(self, argv=None):
 
         cmdname = args[0]
         if cmdname not in self.commands:
-            self.parser.error('unknown command "%s"' % cmdname)
+            self.parser.error(f'unknown command "{cmdname}"')
 
         cmdinst = self._configure_command(cmdname, args[1:])
         return cmdinst.run()
@@ -997,14 +997,14 @@ def _configure_command(self, cmdname, argv):
         as_args = getattr(cmdclass, "as_args", ())
         for long, short, help in cmdclass.user_options:
             name = long.strip("=")
-            default = getattr(cmdinst, name.replace('-', '_'))
-            strs = ["--%s" % name]
+            default = getattr(cmdinst, name.replace("-", "_"))
+            strs = [f"--{name}"]
             if short:
-                strs.append("-%s" % short)
+                strs.append(f"-{short}")
             strs.extend(cmdclass.option_aliases.get(name, ()))
             choices = cmdclass.option_choices.get(name, None)
             if name == as_args:
-                parser.usage += "<%s>" % name
+                parser.usage += f"<{name}>"
             elif name in cmdclass.boolean_options:
                 parser.add_option(*strs, action="store_true", help=help)
             elif name in cmdclass.multiple_value_options:
diff --git a/babel/messages/pofile.py b/babel/messages/pofile.py
index 00e084447..a213b2237 100644
--- a/babel/messages/pofile.py
+++ b/babel/messages/pofile.py
@@ -318,10 +318,7 @@ def _invalid_pofile(self, line, lineno, msg):
         if self.abort_invalid:
             raise PoFileError(msg, self.catalog, line, lineno)
         print("WARNING:", msg)
-        # `line` is guaranteed to be unicode so u"{}"-interpolating would always
-        # succeed, but on Python < 2 if not in a TTY, `sys.stdout.encoding`
-        # is `None`, unicode may not be printable so we `repr()` to ASCII.
-        print(u"WARNING: Problem on line {0}: {1}".format(lineno + 1, repr(line)))
+        print(f"WARNING: Problem on line {lineno + 1}: {line!r}")
 
 
 def read_po(fileobj, locale=None, domain=None, ignore_obsolete=False, charset=None, abort_invalid=False):
@@ -525,34 +522,26 @@ def _write_comment(comment, prefix=''):
         else:
             _width = 76
         for line in wraptext(comment, _width):
-            _write('#%s %s\n' % (prefix, line.strip()))
+            _write(f"#{prefix} {line.strip()}\n")
 
     def _write_message(message, prefix=''):
         if isinstance(message.id, (list, tuple)):
             if message.context:
-                _write('%smsgctxt %s\n' % (prefix,
-                                           _normalize(message.context, prefix)))
-            _write('%smsgid %s\n' % (prefix, _normalize(message.id[0], prefix)))
-            _write('%smsgid_plural %s\n' % (
-                prefix, _normalize(message.id[1], prefix)
-            ))
+                _write(f"{prefix}msgctxt {_normalize(message.context, prefix)}\n")
+            _write(f"{prefix}msgid {_normalize(message.id[0], prefix)}\n")
+            _write(f"{prefix}msgid_plural {_normalize(message.id[1], prefix)}\n")
 
             for idx in range(catalog.num_plurals):
                 try:
                     string = message.string[idx]
                 except IndexError:
                     string = ''
-                _write('%smsgstr[%d] %s\n' % (
-                    prefix, idx, _normalize(string, prefix)
-                ))
+                _write(f"{prefix}msgstr[{idx:d}] {_normalize(string, prefix)}\n")
         else:
             if message.context:
-                _write('%smsgctxt %s\n' % (prefix,
-                                           _normalize(message.context, prefix)))
-            _write('%smsgid %s\n' % (prefix, _normalize(message.id, prefix)))
-            _write('%smsgstr %s\n' % (
-                prefix, _normalize(message.string or '', prefix)
-            ))
+                _write(f"{prefix}msgctxt {_normalize(message.context, prefix)}\n")
+            _write(f"{prefix}msgid {_normalize(message.id, prefix)}\n")
+            _write(f"{prefix}msgstr {_normalize(message.string or '', prefix)}\n")
 
     sort_by = None
     if sort_output:
@@ -571,7 +560,7 @@ def _write_message(message, prefix=''):
                     lines += wraptext(line, width=width,
                                       subsequent_indent='# ')
                 comment_header = u'\n'.join(lines)
-            _write(comment_header + u'\n')
+            _write(f"{comment_header}\n")
 
         for comment in message.user_comments:
             _write_comment(comment)
@@ -592,10 +581,9 @@ def _write_message(message, prefix=''):
                 locations = message.locations
 
             for filename, lineno in locations:
+                location = filename.replace(os.sep, '/')
                 if lineno and include_lineno:
-                    location = u'%s:%d' % (filename.replace(os.sep, '/'), lineno)
-                else:
-                    location = u'%s' % filename.replace(os.sep, '/')
+                    location = f"{location}:{lineno:d}"
                 if location not in locs:
                     locs.append(location)
             _write_comment(' '.join(locs), prefix=':')
diff --git a/babel/numbers.py b/babel/numbers.py
index 6c9ab24b0..2221e95a1 100644
--- a/babel/numbers.py
+++ b/babel/numbers.py
@@ -36,7 +36,7 @@ def __init__(self, identifier):
         """Create the exception.
         :param identifier: the identifier string of the unsupported currency
         """
-        Exception.__init__(self, 'Unknown currency %r.' % identifier)
+        Exception.__init__(self, f"Unknown currency {identifier!r}.")
 
         #: The identifier of the locale that could not be found.
         self.identifier = identifier
@@ -583,8 +583,7 @@ def format_currency(
         try:
             pattern = locale.currency_formats[format_type]
         except KeyError:
-            raise UnknownCurrencyFormatError(
-                "%r is not a known currency format type" % format_type)
+            raise UnknownCurrencyFormatError(f"{format_type!r} is not a known currency format type")
 
     return pattern.apply(
         number, locale, currency=currency, currency_digits=currency_digits,
@@ -779,7 +778,7 @@ def parse_number(string, locale=LC_NUMERIC):
     try:
         return int(string.replace(get_group_symbol(locale), ''))
     except ValueError:
-        raise NumberFormatError('%r is not a valid number' % string)
+        raise NumberFormatError(f"{string!r} is not a valid number")
 
 
 def parse_decimal(string, locale=LC_NUMERIC, strict=False):
@@ -835,7 +834,7 @@ def parse_decimal(string, locale=LC_NUMERIC, strict=False):
         parsed = decimal.Decimal(string.replace(group_symbol, '')
                                        .replace(decimal_symbol, '.'))
     except decimal.InvalidOperation:
-        raise NumberFormatError('%r is not a valid decimal number' % string)
+        raise NumberFormatError(f"{string!r} is not a valid decimal number")
     if strict and group_symbol in string:
         proper = format_decimal(parsed, locale=locale, decimal_quantization=False)
         if string != proper and string.rstrip('0') != (proper + decimal_symbol):
@@ -843,22 +842,25 @@ def parse_decimal(string, locale=LC_NUMERIC, strict=False):
                 parsed_alt = decimal.Decimal(string.replace(decimal_symbol, '')
                                                    .replace(group_symbol, '.'))
             except decimal.InvalidOperation:
-                raise NumberFormatError((
-                    "%r is not a properly formatted decimal number. Did you mean %r?" %
-                    (string, proper)
-                ), suggestions=[proper])
+                raise NumberFormatError(
+                    f"{string!r} is not a properly formatted decimal number. "
+                    f"Did you mean {proper!r}?",
+                    suggestions=[proper],
+                )
             else:
                 proper_alt = format_decimal(parsed_alt, locale=locale, decimal_quantization=False)
                 if proper_alt == proper:
-                    raise NumberFormatError((
-                            "%r is not a properly formatted decimal number. Did you mean %r?" %
-                            (string, proper)
-                    ), suggestions=[proper])
+                    raise NumberFormatError(
+                        f"{string!r} is not a properly formatted decimal number. "
+                        f"Did you mean {proper!r}?",
+                        suggestions=[proper],
+                    )
                 else:
-                    raise NumberFormatError((
-                        "%r is not a properly formatted decimal number. Did you mean %r? Or maybe %r?" %
-                        (string, proper, proper_alt)
-                    ), suggestions=[proper, proper_alt])
+                    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
 
 
@@ -869,8 +871,7 @@ def parse_decimal(string, locale=LC_NUMERIC, strict=False):
 NUMBER_PATTERN = r"(?P<number>%s*)" % NUMBER_TOKEN
 SUFFIX_PATTERN = r"(?P<suffix>.*)"
 
-number_re = re.compile(r"%s%s%s" % (PREFIX_PATTERN, NUMBER_PATTERN,
-                                    SUFFIX_PATTERN))
+number_re = re.compile(f"{PREFIX_PATTERN}{NUMBER_PATTERN}{SUFFIX_PATTERN}")
 
 
 def parse_grouping(p):
@@ -903,7 +904,7 @@ def parse_pattern(pattern):
     def _match_number(pattern):
         rv = number_re.search(pattern)
         if rv is None:
-            raise ValueError('Invalid number pattern %r' % pattern)
+            raise ValueError(f"Invalid number pattern {pattern!r}")
         return rv.groups()
 
     pos_pattern = pattern
@@ -915,7 +916,7 @@ def _match_number(pattern):
         neg_prefix, _, neg_suffix = _match_number(neg_pattern)
     else:
         pos_prefix, number, pos_suffix = _match_number(pos_pattern)
-        neg_prefix = '-' + pos_prefix
+        neg_prefix = f"-{pos_prefix}"
         neg_suffix = pos_suffix
     if 'E' in number:
         number, exp = number.split('E', 1)
@@ -978,7 +979,7 @@ def __init__(self, pattern, prefix, suffix, grouping,
         self.scale = self.compute_scale()
 
     def __repr__(self):
-        return '<%s %r>' % (type(self).__name__, self.pattern)
+        return f"<{type(self).__name__} {self.pattern!r}>"
 
     def compute_scale(self):
         """Return the scaling factor to apply to the number before rendering.
@@ -1184,7 +1185,7 @@ def _format_int(self, value, min, max, locale):
     def _quantize_value(self, value, locale, frac_prec, group_separator):
         quantum = get_decimal_quantum(frac_prec[1])
         rounded = value.quantize(quantum)
-        a, sep, b = "{:f}".format(rounded).partition(".")
+        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)
diff --git a/babel/plural.py b/babel/plural.py
index d3dc22d32..712acec6b 100644
--- a/babel/plural.py
+++ b/babel/plural.py
@@ -111,9 +111,9 @@ def __init__(self, rules):
         self.abstract = []
         for key, expr in sorted(list(rules)):
             if key not in _plural_tags:
-                raise ValueError('unknown tag %r' % key)
+                raise ValueError(f"unknown tag {key!r}")
             elif key in found:
-                raise ValueError('tag %r defined twice' % key)
+                raise ValueError(f"tag {key!r} defined twice")
             found.add(key)
             ast = _Parser(expr).ast
             if ast:
@@ -121,11 +121,8 @@ def __init__(self, rules):
 
     def __repr__(self):
         rules = self.rules
-        return '<%s %r>' % (
-            type(self).__name__,
-            ', '.join(['%s: %s' % (tag, rules[tag]) for tag in _plural_tags
-                       if tag in 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):
@@ -185,7 +182,7 @@ def to_javascript(rule):
     to_js = _JavaScriptCompiler().compile
     result = ['(function(n) { return ']
     for tag, ast in PluralRule.parse(rule).abstract:
-        result.append('%s ? %r : ' % (to_js(ast), tag))
+        result.append(f"{to_js(ast)} ? {tag!r} : ")
     result.append('%r; })' % _fallback_tag)
     return ''.join(result)
 
@@ -223,8 +220,8 @@ def to_python(rule):
     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(' if (%s): return %r' % (to_python_func(ast), str(tag)))
-    result.append(' return %r' % _fallback_tag)
+        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']
@@ -246,10 +243,10 @@ def to_gettext(rule):
     _compile = _GettextCompiler().compile
     _get_index = [tag for tag in _plural_tags if tag in used_tags].index
 
-    result = ['nplurals=%d; plural=(' % len(used_tags)]
+    result = [f"nplurals={len(used_tags)}; plural=("]
     for tag, ast in rule.abstract:
-        result.append('%s ? %d : ' % (_compile(ast), _get_index(tag)))
-    result.append('%d);' % _get_index(_fallback_tag))
+        result.append(f"{_compile(ast)} ? {_get_index(tag)} : ")
+    result.append(f"{_get_index(_fallback_tag)});")
     return ''.join(result)
 
 
@@ -427,8 +424,7 @@ def __init__(self, string):
             return
         self.ast = self.condition()
         if self.tokens:
-            raise RuleError('Expected end of rule, got %r' %
-                            self.tokens[-1][1])
+            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)
@@ -437,8 +433,8 @@ def expect(self, type_, value=None, term=None):
         if term is None:
             term = repr(value is None and type_ or value)
         if not self.tokens:
-            raise RuleError('expected %s but end of rule reached' % term)
-        raise RuleError('expected %s but got %r' % (term, self.tokens[-1][1]))
+            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()
@@ -527,7 +523,7 @@ class _Compiler:
 
     def compile(self, arg):
         op, args = arg
-        return getattr(self, 'compile_' + op)(*args)
+        return getattr(self, f"compile_{op}")(*args)
 
     compile_n = lambda x: 'n'
     compile_i = lambda x: 'i'
@@ -558,11 +554,8 @@ class _PythonCompiler(_Compiler):
     compile_mod = _binary_compiler('MOD(%s, %s)')
 
     def compile_relation(self, method, expr, range_list):
-        compile_range_list = '[%s]' % ','.join(
-            ['(%s, %s)' % tuple(map(self.compile, range_))
-             for range_ in range_list[1]])
-        return '%s(%s, %s)' % (method.upper(), self.compile(expr),
-                               compile_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):
@@ -579,19 +572,11 @@ def compile_relation(self, method, expr, range_list):
         expr = self.compile(expr)
         for item in range_list[1]:
             if item[0] == item[1]:
-                rv.append('(%s == %s)' % (
-                    expr,
-                    self.compile(item[0])
-                ))
+                rv.append(f"({expr} == {self.compile(item[0])})")
             else:
                 min, max = map(self.compile, item)
-                rv.append('(%s >= %s && %s <= %s)' % (
-                    expr,
-                    min,
-                    expr,
-                    max
-                ))
-        return '(%s)' % ' || '.join(rv)
+                rv.append(f"({expr} >= {min} && {expr} <= {max})")
+        return f"({' || '.join(rv)})"
 
 
 class _JavaScriptCompiler(_GettextCompiler):
@@ -610,7 +595,7 @@ def compile_relation(self, method, expr, range_list):
             self, method, expr, range_list)
         if method == 'in':
             expr = self.compile(expr)
-            code = '(parseInt(%s, 10) == %s && %s)' % (expr, expr, code)
+            code = f"(parseInt({expr}, 10) == {expr} && {code})"
         return code
 
 
@@ -636,8 +621,5 @@ def compile_relation(self, method, expr, range_list, negated=False):
             if item[0] == item[1]:
                 ranges.append(self.compile(item[0]))
             else:
-                ranges.append('%s..%s' % tuple(map(self.compile, item)))
-        return '%s%s %s %s' % (
-            self.compile(expr), negated and ' not' or '',
-            method, ','.join(ranges)
-        )
+                ranges.append(f"{self.compile(item[0])}..{self.compile(item[1])}")
+        return f"{self.compile(expr)}{' not' if negated else ''} {method} {','.join(ranges)}"
diff --git a/babel/support.py b/babel/support.py
index 50f275274..8cebd7d97 100644
--- a/babel/support.py
+++ b/babel/support.py
@@ -577,8 +577,8 @@ def load(cls, dirname=None, locales=None, domain=None):
             return cls(fp=fp, domain=domain)
 
     def __repr__(self):
-        return '<%s: "%s">' % (type(self).__name__,
-                               self._info.get('project-id-version'))
+        version = self._info.get('project-id-version')
+        return f'<{type(self).__name__}: "{version}">'
 
     def add(self, translations, merge=True):
         """Add the given translations to the catalog.
diff --git a/babel/units.py b/babel/units.py
index 8a9ec7d38..f8f267579 100644
--- a/babel/units.py
+++ b/babel/units.py
@@ -4,7 +4,7 @@
 
 class UnknownUnitError(ValueError):
     def __init__(self, unit, locale):
-        ValueError.__init__(self, "%s is not a known unit in %s" % (unit, locale))
+        ValueError.__init__(self, f"{unit} is not a known unit in {locale}")
 
 
 def get_unit_name(measurement_unit, length='long', locale=LC_NUMERIC):
@@ -128,10 +128,8 @@ def format_unit(value, measurement_unit, length='long', format=None, locale=LC_N
 
     # 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.
-    return '%s %s' % (  # pragma: no cover
-        formatted_value,
-        (get_unit_name(measurement_unit, length=length, locale=locale) or measurement_unit)
-    )
+    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, denominator_unit, locale=LC_NUMERIC):
@@ -179,7 +177,7 @@ def _find_compound_unit(numerator_unit, denominator_unit, locale=LC_NUMERIC):
 
     # Now we can try and rebuild a compound unit specifier, then qualify it:
 
-    return _find_unit_pattern("%s-per-%s" % (bare_numerator_unit, bare_denominator_unit), locale=locale)
+    return _find_unit_pattern(f"{bare_numerator_unit}-per-{bare_denominator_unit}", locale=locale)
 
 
 def format_compound_unit(
diff --git a/babel/util.py b/babel/util.py
index f628844ab..0436b9ee4 100644
--- a/babel/util.py
+++ b/babel/util.py
@@ -82,9 +82,7 @@ def parse_encoding(fp):
             if m:
                 magic_comment_encoding = m.group(1).decode('latin-1')
                 if magic_comment_encoding != 'utf-8':
-                    raise SyntaxError(
-                        'encoding problem: {0} with BOM'.format(
-                            magic_comment_encoding))
+                    raise SyntaxError(f"encoding problem: {magic_comment_encoding} with BOM")
             return 'utf-8'
         elif m:
             return m.group(1).decode('latin-1')
@@ -191,7 +189,7 @@ def pathmatch(pattern, filename):
             buf.append(symbols[part])
         elif part:
             buf.append(re.escape(part))
-    match = re.match(''.join(buf) + '$', filename.replace(os.sep, '/'))
+    match = re.match(f"{''.join(buf)}$", filename.replace(os.sep, "/"))
     return match is not None
 
 
@@ -236,7 +234,7 @@ def __str__(self):
         return self.zone
 
     def __repr__(self):
-        return '<FixedOffset "%s" %s>' % (self.zone, self._offset)
+        return f'<FixedOffset "{self.zone}" {self._offset}>'
 
     def utcoffset(self, dt):
         return self._offset
diff --git a/scripts/generate_authors.py b/scripts/generate_authors.py
index 409f24e36..e2e3addcd 100644
--- a/scripts/generate_authors.py
+++ b/scripts/generate_authors.py
@@ -13,7 +13,7 @@ def get_sorted_authors_list():
 
 
 def get_authors_file_content():
-    author_list = '\n'.join('- %s' % a for a in get_sorted_authors_list())
+    author_list = "\n".join(f"- {a}" for a in get_sorted_authors_list())
 
     return '''
 Babel is written and maintained by the Babel team and various contributors:
diff --git a/scripts/import_cldr.py b/scripts/import_cldr.py
index 097840cec..5de707c89 100755
--- a/scripts/import_cldr.py
+++ b/scripts/import_cldr.py
@@ -156,7 +156,8 @@ def write_datafile(path, data, dump_json=False):
         pickle.dump(data, outfile, 2)
     if dump_json:
         import json
-        with open(path + '.json', 'w') as outfile:
+
+        with open(f"{path}.json", "w") as outfile:
             json.dump(data, outfile, indent=4, default=debug_repr)
 
 
@@ -358,8 +359,8 @@ def _process_local_datas(sup, srcdir, destdir, force=False, dump_json=False):
         if ext != '.xml':
             continue
 
-        full_filename = os.path.join(srcdir, 'main', filename)
-        data_filename = os.path.join(destdir, 'locale-data', stem + '.dat')
+        full_filename = os.path.join(srcdir, "main", filename)
+        data_filename = os.path.join(destdir, "locale-data", f"{stem}.dat")
 
         data = {}
         if not (force or need_conversion(data_filename, data, full_filename)):
@@ -434,10 +435,10 @@ def _process_local_datas(sup, srcdir, destdir, force=False, dump_json=False):
 
         unsupported_number_systems_string = ', '.join(sorted(data.pop('unsupported_number_systems')))
         if unsupported_number_systems_string:
-            log.warning('%s: unsupported number systems were ignored: %s' % (
-                locale_id,
-                unsupported_number_systems_string,
-            ))
+            log.warning(
+                f"{locale_id}: unsupported number systems were ignored: "
+                f"{unsupported_number_systems_string}"
+            )
 
         write_datafile(data_filename, data, dump_json=dump_json)
 
@@ -902,7 +903,7 @@ def parse_interval_formats(data, tree):
                 if item_sub.tag == "greatestDifference":
                     skel_data[item_sub.attrib["id"]] = split_interval_pattern(item_sub.text)
                 else:
-                    raise NotImplementedError("Not implemented: %s(%r)" % (item_sub.tag, item_sub.attrib))
+                    raise NotImplementedError(f"Not implemented: {item_sub.tag}({item_sub.attrib!r})")
 
 
 def parse_currency_formats(data, tree):
diff --git a/setup.py b/setup.py
index 06caa6a64..157f7c160 100755
--- a/setup.py
+++ b/setup.py
@@ -6,7 +6,7 @@
 try:
     from babel import __version__
 except SyntaxError as exc:
-    sys.stderr.write("Unable to import Babel (%s). Are you running a supported version of Python?\n" % exc)
+    sys.stderr.write(f"Unable to import Babel ({exc}). Are you running a supported version of Python?\n")
     sys.exit(1)
 
 
diff --git a/tests/messages/test_catalog.py b/tests/messages/test_catalog.py
index cc5fb49fc..e9b15a88a 100644
--- a/tests/messages/test_catalog.py
+++ b/tests/messages/test_catalog.py
@@ -357,7 +357,7 @@ def test_catalog_mime_headers():
         ('MIME-Version', '1.0'),
         ('Content-Type', 'text/plain; charset=utf-8'),
         ('Content-Transfer-Encoding', '8bit'),
-        ('Generated-By', 'Babel %s\n' % catalog.VERSION),
+        ('Generated-By', f'Babel {catalog.VERSION}\n'),
     ]
 
 
@@ -380,7 +380,7 @@ def test_catalog_mime_headers_set_locale():
         ('MIME-Version', '1.0'),
         ('Content-Type', 'text/plain; charset=utf-8'),
         ('Content-Transfer-Encoding', '8bit'),
-        ('Generated-By', 'Babel %s\n' % catalog.VERSION),
+        ('Generated-By', f'Babel {catalog.VERSION}\n'),
     ]
 
 
diff --git a/tests/messages/test_frontend.py b/tests/messages/test_frontend.py
index 0eb7e8f3a..9e3ac9f40 100644
--- a/tests/messages/test_frontend.py
+++ b/tests/messages/test_frontend.py
@@ -130,7 +130,7 @@ def test_input_paths_is_treated_as_list(self):
         assert ('file1.py' in msg.locations[0][0])
 
     def test_input_paths_handle_spaces_after_comma(self):
-        self.cmd.input_paths = '%s,  %s' % (this_dir, data_dir)
+        self.cmd.input_paths = f"{this_dir},  {data_dir}"
         self.cmd.output_file = pot_file
         self.cmd.finalize_options()
         assert self.cmd.input_paths == [this_dir, data_dir]
@@ -1118,7 +1118,7 @@ def test_compile_catalog(self):
         self.cli.run(sys.argv + ['compile',
                                  '--locale', 'de_DE',
                                  '-d', i18n_dir])
-        assert not os.path.isfile(mo_file), 'Expected no file at %r' % mo_file
+        assert not os.path.isfile(mo_file), f'Expected no file at {mo_file!r}'
         assert sys.stderr.getvalue() == f'catalog {po_file} is marked as fuzzy, skipping\n'
 
     def test_compile_fuzzy_catalog(self):
@@ -1397,14 +1397,15 @@ def test_extract_keyword_args_384(split, arg_name):
     ]
 
     if split:  # Generate a command line with multiple -ks
-        kwarg_text = " ".join("%s %s" % (arg_name, kwarg_spec) for kwarg_spec in kwarg_specs)
+        kwarg_text = " ".join(f"{arg_name} {kwarg_spec}" for kwarg_spec in kwarg_specs)
     else:  # Generate a single space-separated -k
-        kwarg_text = "%s \"%s\"" % (arg_name, " ".join(kwarg_specs))
+        specs = ' '.join(kwarg_specs)
+        kwarg_text = f'{arg_name} "{specs}"'
 
     # (Both of those invocation styles should be equivalent, so there is no parametrization from here on out)
 
     cmdinst = configure_cli_command(
-        "extract -F babel-django.cfg --add-comments Translators: -o django232.pot %s ." % kwarg_text
+        f"extract -F babel-django.cfg --add-comments Translators: -o django232.pot {kwarg_text} ."
     )
     assert isinstance(cmdinst, extract_messages)
     assert set(cmdinst.keywords.keys()) == {'_', 'dgettext', 'dngettext',
@@ -1489,7 +1490,7 @@ def test_extract_error_code(monkeypatch, capsys):
 def test_extract_ignore_dirs(monkeypatch, capsys, tmp_path, with_underscore_ignore):
     pot_file = tmp_path / 'temp.pot'
     monkeypatch.chdir(project_dir)
-    cmd = "extract . -o '{}' --ignore-dirs '*ignored*' ".format(pot_file)
+    cmd = f"extract . -o '{pot_file}' --ignore-dirs '*ignored*' "
     if with_underscore_ignore:
         # This also tests that multiple arguments are supported.
         cmd += "--ignore-dirs '_*'"
diff --git a/tests/messages/test_pofile.py b/tests/messages/test_pofile.py
index 99e59babc..a72368bcc 100644
--- a/tests/messages/test_pofile.py
+++ b/tests/messages/test_pofile.py
@@ -859,7 +859,7 @@ def test_denormalize_on_msgstr_without_empty_first_line(self):
         expected_denormalized = u'multi-line\n translation'
 
         assert expected_denormalized == pofile.denormalize(msgstr)
-        assert expected_denormalized == pofile.denormalize('""\n' + msgstr)
+        assert expected_denormalized == pofile.denormalize(f'""\n{msgstr}')
 
 
 def test_unknown_language_roundtrip():
diff --git a/tests/test_core.py b/tests/test_core.py
index 2de79e2df..605bf5c02 100644
--- a/tests/test_core.py
+++ b/tests/test_core.py
@@ -309,8 +309,7 @@ def find_class(self, module, name):
             # *.dat files must have compatible classes between Python 2 and 3
             if module.split('.')[0] == 'babel':
                 return pickle.Unpickler.find_class(self, module, name)
-            raise pickle.UnpicklingError("global '%s.%s' is forbidden" %
-                                         (module, name))
+            raise pickle.UnpicklingError(f"global '{module}.{name}' is forbidden")
 
     with open(filename, 'rb') as f:
         assert Unpickler(f).load()
diff --git a/tests/test_plural.py b/tests/test_plural.py
index 421003324..16601cfec 100644
--- a/tests/test_plural.py
+++ b/tests/test_plural.py
@@ -273,7 +273,7 @@ def test_gettext_compilation(locale):
     chars = 'ivwft'
     # Test that these rules are valid for this test; i.e. that they contain at least one
     # of the gettext-unsupported characters.
-    assert any((" " + ch + " ") in rule for ch in chars for rule in ru_rules.values())
+    assert any(f" {ch} " in rule for ch in chars for rule in ru_rules.values())
     # Then test that the generated value indeed does not contain these.
     ru_rules_gettext = plural.to_gettext(ru_rules)
     assert not any(ch in ru_rules_gettext for ch in chars)
diff --git a/tests/test_support.py b/tests/test_support.py
index 944710751..c73e53ba7 100644
--- a/tests/test_support.py
+++ b/tests/test_support.py
@@ -63,8 +63,7 @@ def setUp(self):
 
     def assertEqualTypeToo(self, expected, result):
         assert expected == result
-        assert type(expected) == type(result), "instance type's do not " + \
-            "match: %r!=%r" % (type(expected), type(result))
+        assert type(expected) == type(result), f"instance types do not match: {type(expected)!r}!={type(result)!r}"
 
     def test_pgettext(self):
         self.assertEqualTypeToo('Voh', self.translations.gettext('foo'))
@@ -210,7 +209,7 @@ def method_names(self):
     def test_same_methods(self):
         for name in self.method_names():
             if not hasattr(self.null_translations, name):
-                self.fail('NullTranslations does not provide method %r' % name)
+                self.fail(f"NullTranslations does not provide method {name!r}")
 
     def test_method_signature_compatibility(self):
         for name in self.method_names():
@@ -346,11 +345,13 @@ def test_format_percent():
 
 def test_lazy_proxy():
     def greeting(name='world'):
-        return u'Hello, %s!' % name
+        return f"Hello, {name}!"
+
     lazy_greeting = support.LazyProxy(greeting, name='Joe')
     assert str(lazy_greeting) == u"Hello, Joe!"
     assert u'  ' + lazy_greeting == u'  Hello, Joe!'
     assert u'(%s)' % lazy_greeting == u'(Hello, Joe!)'
+    assert f"[{lazy_greeting}]" == "[Hello, Joe!]"
 
     greetings = [
         support.LazyProxy(greeting, 'world'),

From 82c41ccda68da8322c96c1176936b07ad8af8f1b Mon Sep 17 00:00:00 2001
From: Jonah Lawrence <jonah@freshidea.com>
Date: Mon, 26 Dec 2022 15:22:08 -0700
Subject: [PATCH 09/53] ci: Fix testing dependencies (#936)

---
 .github/workflows/test.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 491581677..f9a7bee0b 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -33,7 +33,7 @@ jobs:
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip setuptools wheel
-        python -m pip install tox tox-gh-actions==2.1.0
+        python -m pip install 'tox<4.0.0' 'tox-gh-actions==2.12.0'
     - name: Run test via Tox
       run: tox --skip-missing-interpreters
       env:

From d425f86a08d5f459d7380d7c196ecb33af564f5c Mon Sep 17 00:00:00 2001
From: Johannes Wilm <johanneswilm@gmail.com>
Date: Fri, 6 Jan 2023 21:18:35 +0100
Subject: [PATCH 10/53] Improved javascript template string expression
 extracting (#939)

Co-authored-by: Rik <gitaarik@posteo.net>
Co-authored-by: Aarni Koskela <akx@iki.fi>
---
 babel/messages/extract.py         | 59 +++++++++++++++++++++++++++----
 babel/messages/jslexer.py         |  4 +--
 tests/messages/test_js_extract.py | 39 ++++++++++++++++++++
 3 files changed, 94 insertions(+), 8 deletions(-)

diff --git a/babel/messages/extract.py b/babel/messages/extract.py
index 4f0f649b3..c19dd5af2 100644
--- a/babel/messages/extract.py
+++ b/babel/messages/extract.py
@@ -16,9 +16,10 @@
     :license: BSD, see LICENSE for more details.
 """
 import ast
+import io
 import os
-from os.path import relpath
 import sys
+from os.path import relpath
 from tokenize import generate_tokens, COMMENT, NAME, OP, STRING
 
 from babel.util import parse_encoding, parse_future_flags, pathmatch
@@ -532,7 +533,7 @@ def _parse_python_string(value, encoding, future_flags):
     return None
 
 
-def extract_javascript(fileobj, keywords, comment_tags, options):
+def extract_javascript(fileobj, keywords, comment_tags, options, lineno=1):
     """Extract messages from JavaScript source code.
 
     :param fileobj: the seekable, file-like object the messages should be
@@ -544,7 +545,11 @@ def extract_javascript(fileobj, keywords, comment_tags, options):
     :param options: a dictionary of additional options (optional)
                     Supported options are:
                     * `jsx` -- set to false to disable JSX/E4X support.
-                    * `template_string` -- set to false to disable ES6 template string support.
+                    * `template_string` -- if `True`, supports gettext(`key`)
+                    * `parse_template_string` -- if `True` will parse the
+                                                 contents of javascript
+                                                 template strings.
+    :param lineno: line number offset (for parsing embedded fragments)
     """
     from babel.messages.jslexer import Token, tokenize, unquote_string
     funcname = message_lineno = None
@@ -556,12 +561,12 @@ def extract_javascript(fileobj, keywords, comment_tags, options):
     last_token = None
     call_stack = -1
     dotted = any('.' in kw for kw in keywords)
-
     for token in tokenize(
         fileobj.read().decode(encoding),
         jsx=options.get("jsx", True),
         template_string=options.get("template_string", True),
-        dotted=dotted
+        dotted=dotted,
+        lineno=lineno
     ):
         if (  # Turn keyword`foo` expressions into keyword("foo") calls:
             funcname and  # have a keyword...
@@ -573,7 +578,11 @@ def extract_javascript(fileobj, keywords, comment_tags, options):
             call_stack = 0
             token = Token('operator', ')', token.lineno)
 
-        if token.type == 'operator' and token.value == '(':
+        if options.get('parse_template_string') and not funcname and token.type == 'template_string':
+            for item in parse_template_string(token.value, keywords, comment_tags, options, token.lineno):
+                yield item
+
+        elif token.type == 'operator' and token.value == '(':
             if funcname:
                 message_lineno = token.lineno
                 call_stack += 1
@@ -665,3 +674,41 @@ def extract_javascript(fileobj, keywords, comment_tags, options):
             funcname = token.value
 
         last_token = token
+
+
+def parse_template_string(template_string, keywords, comment_tags, options, lineno=1):
+    """Parse JavaScript template string.
+
+    :param template_string: the template string to be parsed
+    :param keywords: a list of keywords (i.e. function names) that should be
+                     recognized as translation functions
+    :param comment_tags: a list of translator tags to search for and include
+                         in the results
+    :param options: a dictionary of additional options (optional)
+    :param lineno: starting line number (optional)
+    """
+    from babel.messages.jslexer import line_re
+    prev_character = None
+    level = 0
+    inside_str = False
+    expression_contents = ''
+    for character in template_string[1:-1]:
+        if not inside_str and character in ('"', "'", '`'):
+            inside_str = character
+        elif inside_str == character and prev_character != r'\\':
+            inside_str = False
+        if level:
+            expression_contents += character
+        if not inside_str:
+            if character == '{' and prev_character == '$':
+                level += 1
+            elif level and character == '}':
+                level -= 1
+                if level == 0 and expression_contents:
+                    expression_contents = expression_contents[0:-1]
+                    fake_file_obj = io.BytesIO(expression_contents.encode())
+                    for item in extract_javascript(fake_file_obj, keywords, comment_tags, options, lineno):
+                        yield item
+                    lineno += len(line_re.findall(expression_contents))
+                    expression_contents = ''
+        prev_character = character
diff --git a/babel/messages/jslexer.py b/babel/messages/jslexer.py
index 1264b2dbc..886f69d20 100644
--- a/babel/messages/jslexer.py
+++ b/babel/messages/jslexer.py
@@ -151,17 +151,17 @@ def unquote_string(string):
     return u''.join(result)
 
 
-def tokenize(source, jsx=True, dotted=True, template_string=True):
+def tokenize(source, jsx=True, dotted=True, template_string=True, lineno=1):
     """
     Tokenize JavaScript/JSX source.  Returns a generator of tokens.
 
     :param jsx: Enable (limited) JSX parsing.
     :param dotted: Read dotted names as single name token.
     :param template_string: Support ES6 template strings
+    :param lineno: starting line number (optional)
     """
     may_divide = False
     pos = 0
-    lineno = 1
     end = len(source)
     rules = get_rules(jsx=jsx, dotted=dotted, template_string=template_string)
 
diff --git a/tests/messages/test_js_extract.py b/tests/messages/test_js_extract.py
index 72c521144..95985c0f7 100644
--- a/tests/messages/test_js_extract.py
+++ b/tests/messages/test_js_extract.py
@@ -150,3 +150,42 @@ def test_template_string_tag_usage():
     )
 
     assert messages == [(1, 'Tag template, wow', [], None)]
+
+
+def test_inside_template_string():
+    buf = BytesIO(b"const msg = `${gettext('Hello')} ${user.name}`")
+    messages = list(
+        extract.extract('javascript', buf, {"gettext": None}, [], {'parse_template_string': True})
+    )
+
+    assert messages == [(1, 'Hello', [], None)]
+
+
+def test_inside_template_string_with_linebreaks():
+    buf = BytesIO(b"""\
+const userName = gettext('Username')
+const msg = `${
+gettext('Hello')
+} ${userName} ${
+gettext('Are you having a nice day?')
+}`
+const msg2 = `${
+gettext('Howdy')
+} ${userName} ${
+gettext('Are you doing ok?')
+}`
+""")
+    messages = list(
+        extract.extract('javascript', buf, {"gettext": None}, [], {'parse_template_string': True})
+    )
+
+    assert messages == [(1, 'Username', [], None), (3, 'Hello', [], None), (5, 'Are you having a nice day?', [], None), (8, 'Howdy', [], None), (10, 'Are you doing ok?', [], None)]
+
+
+def test_inside_nested_template_string():
+    buf = BytesIO(b"const msg = `${gettext('Greetings!')} ${ evening ? `${user.name}: ${gettext('This is a lovely evening.')}` : `${gettext('The day is really nice!')} ${user.name}`}`")
+    messages = list(
+        extract.extract('javascript', buf, {"gettext": None}, [], {'parse_template_string': True})
+    )
+
+    assert messages == [(1, 'Greetings!', [], None), (1, 'This is a lovely evening.', [], None), (1, 'The day is really nice!', [], None)]

From 3594836cd9e64b6c98f008ee7e25614de7d9db68 Mon Sep 17 00:00:00 2001
From: Jonah Lawrence <jonah@freshidea.com>
Date: Fri, 6 Jan 2023 13:21:58 -0700
Subject: [PATCH 11/53] Fix compact singular formats and patterns with no
 numbers (#932)

---
 babel/numbers.py      | 19 +++++++++++++------
 tests/test_numbers.py |  7 ++++++-
 2 files changed, 19 insertions(+), 7 deletions(-)

diff --git a/babel/numbers.py b/babel/numbers.py
index 2221e95a1..da5936dbf 100644
--- a/babel/numbers.py
+++ b/babel/numbers.py
@@ -17,6 +17,7 @@
 # TODO:
 #  Padding and rounding increments in pattern:
 #  - https://www.unicode.org/reports/tr35/ (Appendix G.6)
+from __future__ import annotations
 import decimal
 import re
 from datetime import date as date_, datetime as datetime_
@@ -431,7 +432,7 @@ def format_compact_decimal(number, *, format_type="short", locale=LC_NUMERIC, fr
     u'123万'
     >>> format_compact_decimal(2345678, format_type="long", locale="mk")
     u'2 милиони'
-    >>> format_compact_decimal(21098765, format_type="long", locale="mk")
+    >>> format_compact_decimal(21000000, format_type="long", locale="mk")
     u'21 милион'
 
     :param number: the number to format
@@ -469,11 +470,15 @@ def _get_compact_format(number, compact_format, locale, fraction_digits=0):
             # equal to the number of 0's in the pattern minus 1
             number = number / (magnitude // (10 ** (pattern.count("0") - 1)))
             # round to the number of fraction digits requested
-            number = round(number, fraction_digits)
+            rounded = round(number, fraction_digits)
             # if the remaining number is singular, use the singular format
             plural_form = locale.plural_form(abs(number))
-            plural_form = plural_form if plural_form in compact_format else "other"
+            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
 
@@ -960,17 +965,19 @@ def parse_precision(p):
     return NumberPattern(pattern, (pos_prefix, neg_prefix),
                          (pos_suffix, neg_suffix), grouping,
                          int_prec, frac_prec,
-                         exp_prec, exp_plus)
+                         exp_prec, exp_plus, number)
 
 
 class NumberPattern:
 
     def __init__(self, pattern, prefix, suffix, grouping,
-                 int_prec, frac_prec, exp_prec, exp_plus):
+                 int_prec, frac_prec, exp_prec, exp_plus,
+                 number_pattern: str | 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
@@ -1115,7 +1122,7 @@ def apply(
 
         retval = ''.join([
             self.prefix[is_negative],
-            number,
+            number if self.number_pattern != '' else '',
             self.suffix[is_negative]])
 
         if u'¤' in retval:
diff --git a/tests/test_numbers.py b/tests/test_numbers.py
index bb6c4e84e..37d2f9ec6 100644
--- a/tests/test_numbers.py
+++ b/tests/test_numbers.py
@@ -153,7 +153,12 @@ def test_compact(self):
         assert numbers.format_compact_decimal(-123456789, format_type='short', locale='en_US') == u'-123M'
         assert numbers.format_compact_decimal(-123456789, format_type='long', locale='en_US') == u'-123 million'
         assert numbers.format_compact_decimal(2345678, locale='mk', format_type='long') == u'2 милиони'
-        assert numbers.format_compact_decimal(21098765, locale='mk', format_type='long') == u'21 милион'
+        assert numbers.format_compact_decimal(21000000, locale='mk', format_type='long') == u'21 милион'
+        assert numbers.format_compact_decimal(21345, locale="gv", format_type="short") == u'21K'
+        assert numbers.format_compact_decimal(1000, locale='it', format_type='long') == u'mille'
+        assert numbers.format_compact_decimal(1234, locale='it', format_type='long') == u'1 mila'
+        assert numbers.format_compact_decimal(1000, locale='fr', format_type='long') == u'mille'
+        assert numbers.format_compact_decimal(1234, locale='fr', format_type='long') == u'1 millier'
 
 class NumberParsingTestCase(unittest.TestCase):
 

From 338bfa13c39df0837dd45cf492eb24d8d214ba96 Mon Sep 17 00:00:00 2001
From: lilinjie <102012657+uniontech-lilinjie@users.noreply.github.com>
Date: Mon, 9 Jan 2023 17:54:42 +0000
Subject: [PATCH 12/53] fix typo (#941)

Signed-off-by: lilinjie <lilinjie@uniontech.com>
---
 babel/numbers.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/babel/numbers.py b/babel/numbers.py
index da5936dbf..94259f841 100644
--- a/babel/numbers.py
+++ b/babel/numbers.py
@@ -517,7 +517,7 @@ def format_currency(
     >>> format_currency(1099.98, 'COP', u'#,##0.00', locale='es_ES')
     u'1.099,98'
 
-    However, the number of decimal digits can be overriden from the currency
+    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)

From 61097845764f5a6afc2251172168e1b1732b290f Mon Sep 17 00:00:00 2001
From: Aarni Koskela <akx@iki.fi>
Date: Wed, 11 Jan 2023 10:42:08 +0200
Subject: [PATCH 13/53] Enable pre-commit (#943)

* Update pre-commit config syntax

* CI: run pre-commit

* CI: set up pip caching
---
 .coveragerc                |  2 +-
 .github/workflows/test.yml |  9 ++++++++-
 .pre-commit-config.yaml    | 31 +++++++++++++++----------------
 babel/messages/pofile.py   |  2 +-
 docs/installation.rst      |  2 +-
 5 files changed, 26 insertions(+), 20 deletions(-)

diff --git a/.coveragerc b/.coveragerc
index a3d8ae65e..f98d8023f 100644
--- a/.coveragerc
+++ b/.coveragerc
@@ -2,4 +2,4 @@
 exclude_lines =
     NotImplemented
     pragma: no cover
-    warnings.warn
\ No newline at end of file
+    warnings.warn
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index f9a7bee0b..1e8986179 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -11,6 +11,11 @@ on:
       - '*-maint'
 
 jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: pre-commit/action@v3.0.0
   test:
     runs-on: ${{ matrix.os }}
     strategy:
@@ -27,9 +32,11 @@ jobs:
         path: cldr
         key: cldr-${{ hashFiles('scripts/*cldr*') }}
     - name: Set up Python ${{ matrix.python-version }}
-      uses: actions/setup-python@v3
+      uses: actions/setup-python@v4
       with:
         python-version: ${{ matrix.python-version }}
+        cache: "pip"
+        cache-dependency-path: "**/setup.py"
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip setuptools wheel
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 0a345cee9..b61dac46b 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -1,19 +1,18 @@
--   repo: https://github.com/pre-commit/pre-commit-hooks
-    sha: 97b88d9610bcc03982ddac33caba98bb2b751f5f
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.4.0
     hooks:
-    -   id: autopep8-wrapper
-        exclude: (docs/conf.py|tests/messages/data/)
-    -   id: check-added-large-files
-    -   id: check-docstring-first
+      - id: check-added-large-files
+      - id: check-docstring-first
         exclude: (docs/conf.py)
-    -   id: check-json
-    -   id: check-yaml
-    -   id: debug-statements
-    -   id: end-of-file-fixer
-    -   id: flake8
-        exclude: (docs/conf.py|babel/messages/__init__.py|babel/__init__.py|tests/messages/data|scripts/import_cldr.py)
-    -   id: name-tests-test
-        args: ['--django']
+      - id: check-json
+      - id: check-yaml
+      - id: debug-statements
         exclude: (tests/messages/data/)
-    -   id: requirements-txt-fixer
-    -   id: trailing-whitespace
+      - id: end-of-file-fixer
+        exclude: (tests/messages/data/)
+      - id: name-tests-test
+        args: [ '--django' ]
+        exclude: (tests/messages/data/)
+      - id: requirements-txt-fixer
+      - id: trailing-whitespace
diff --git a/babel/messages/pofile.py b/babel/messages/pofile.py
index a213b2237..b366ccb44 100644
--- a/babel/messages/pofile.py
+++ b/babel/messages/pofile.py
@@ -575,7 +575,7 @@ def _write_message(message, prefix=''):
             # if no sorting possible, leave unsorted.
             # (see issue #606)
             try:
-                locations = sorted(message.locations, 
+                locations = sorted(message.locations,
                                    key=lambda x: (x[0], isinstance(x[1], int) and x[1] or -1))
             except TypeError:  # e.g. "TypeError: unorderable types: NoneType() < int()"
                 locations = message.locations
diff --git a/docs/installation.rst b/docs/installation.rst
index c1b7ab9fe..26fe23a47 100644
--- a/docs/installation.rst
+++ b/docs/installation.rst
@@ -86,7 +86,7 @@ Get the git checkout in a new virtualenv and run in development mode::
     Finished processing dependencies for Babel
 
 Make sure to not forget about the ``pip install pytz`` and ``import_cldr`` steps
-because otherwise you will be missing the locale data.  
+because otherwise you will be missing the locale data.
 The custom setup command will download the most appropriate CLDR release from the
 official website and convert it for Babel but will not work without ``pytz``.
 

From 53637ddbacaef2474429b22176091a362ce6567f Mon Sep 17 00:00:00 2001
From: Jonah Lawrence <jonah@freshidea.com>
Date: Wed, 11 Jan 2023 01:54:11 -0700
Subject: [PATCH 14/53] Add type annotations (#934)

Refs e.g. https://github.com/python/typeshed/pull/9455

Co-authored-by: Spencer Brown <spencerb21@live.com>
Co-authored-by: Aarni Koskela <akx@iki.fi>
---
 .coveragerc                 |   1 +
 babel/core.py               | 186 ++++++++++++++++++++------------
 babel/dates.py              | 169 ++++++++++++++++-------------
 babel/languages.py          |   6 +-
 babel/lists.py              |  11 +-
 babel/localedata.py         |  43 ++++----
 babel/localtime/__init__.py |  16 +--
 babel/localtime/_unix.py    |   4 +-
 babel/localtime/_win32.py   |  14 ++-
 babel/messages/catalog.py   | 157 +++++++++++++++++----------
 babel/messages/checkers.py  |  25 +++--
 babel/messages/extract.py   | 133 ++++++++++++++++++-----
 babel/messages/jslexer.py   |  23 ++--
 babel/messages/mofile.py    |  12 ++-
 babel/messages/plurals.py   |  11 +-
 babel/messages/pofile.py    |  92 ++++++++++------
 babel/numbers.py            | 205 ++++++++++++++++++++++++++----------
 babel/plural.py             |  74 +++++++------
 babel/py.typed              |   1 +
 babel/support.py            | 201 +++++++++++++++++++++--------------
 babel/units.py              |  45 ++++++--
 babel/util.py               |  33 +++---
 22 files changed, 958 insertions(+), 504 deletions(-)
 create mode 100644 babel/py.typed

diff --git a/.coveragerc b/.coveragerc
index f98d8023f..32128ff86 100644
--- a/.coveragerc
+++ b/.coveragerc
@@ -3,3 +3,4 @@ exclude_lines =
     NotImplemented
     pragma: no cover
     warnings.warn
+    if TYPE_CHECKING:
diff --git a/babel/core.py b/babel/core.py
index 825af8132..704957b7e 100644
--- a/babel/core.py
+++ b/babel/core.py
@@ -8,8 +8,12 @@
     :license: BSD, see LICENSE for more details.
 """
 
-import pickle
+from __future__ import annotations
+
 import os
+import pickle
+from collections.abc import Iterable, Mapping
+from typing import TYPE_CHECKING, Any, overload
 
 from babel import localedata
 from babel.plural import PluralRule
@@ -17,11 +21,31 @@
 __all__ = ['UnknownLocaleError', 'Locale', 'default_locale', 'negotiate_locale',
            'parse_locale']
 
+if TYPE_CHECKING:
+    from typing_extensions import Literal, TypeAlias
+
+    _GLOBAL_KEY: TypeAlias = Literal[
+        "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",
+    ]
+
+    _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 '
@@ -31,7 +55,7 @@ def _raise_no_data_error():
                        'installing the library.')
 
 
-def get_global(key):
+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
@@ -73,6 +97,7 @@ def get_global(key):
             _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, {})
 
 
@@ -93,7 +118,7 @@ class UnknownLocaleError(Exception):
     is available.
     """
 
-    def __init__(self, identifier):
+    def __init__(self, identifier: str) -> None:
         """Create the exception.
 
         :param identifier: the identifier string of the unsupported locale
@@ -136,7 +161,13 @@ class Locale:
     For more information see :rfc:`3066`.
     """
 
-    def __init__(self, language, territory=None, script=None, variant=None):
+    def __init__(
+        self,
+        language: str,
+        territory: str | None = None,
+        script: str | None = None,
+        variant: str | None = None,
+    ) -> None:
         """Initialize the locale object from the given identifier components.
 
         >>> locale = Locale('en', 'US')
@@ -167,7 +198,7 @@ def __init__(self, language, territory=None, script=None, variant=None):
             raise UnknownLocaleError(identifier)
 
     @classmethod
-    def default(cls, category=None, aliases=LOCALE_ALIASES):
+    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']:
@@ -192,7 +223,13 @@ def default(cls, category=None, aliases=LOCALE_ALIASES):
         return cls.parse(locale_string)
 
     @classmethod
-    def negotiate(cls, preferred, available, sep='_', aliases=LOCALE_ALIASES):
+    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'])
@@ -217,8 +254,21 @@ def negotiate(cls, preferred, available, sep='_', aliases=LOCALE_ALIASES):
         if identifier:
             return Locale.parse(identifier, sep=sep)
 
+    @overload
+    @classmethod
+    def parse(cls, identifier: None, sep: str = ..., resolve_likely_subtags: bool = ...) -> None: ...
+
+    @overload
+    @classmethod
+    def parse(cls, identifier: str | Locale, sep: str = ..., resolve_likely_subtags: bool = ...) -> Locale: ...
+
     @classmethod
-    def parse(cls, identifier, sep='_', resolve_likely_subtags=True):
+    def parse(
+        cls,
+        identifier: str | Locale | None,
+        sep: str = '_',
+        resolve_likely_subtags: bool = True,
+    ) -> Locale | None:
         """Create a `Locale` instance for the given locale identifier.
 
         >>> l = Locale.parse('de-DE', sep='-')
@@ -329,22 +379,22 @@ def _try_load_reducing(parts):
 
         raise UnknownLocaleError(input_id)
 
-    def __eq__(self, other):
+    def __eq__(self, other: object) -> bool:
         for key in ('language', 'territory', 'script', 'variant'):
             if not hasattr(other, key):
                 return False
-        return (self.language == other.language) and \
-            (self.territory == other.territory) and \
-            (self.script == other.script) and \
-            (self.variant == other.variant)
+        return (self.language == getattr(other, 'language')) and \
+            (self.territory == getattr(other, 'territory')) and \
+            (self.script == getattr(other, 'script')) and \
+            (self.variant == getattr(other, 'variant'))
 
-    def __ne__(self, other):
+    def __ne__(self, other: object) -> bool:
         return not self.__eq__(other)
 
-    def __hash__(self):
+    def __hash__(self) -> int:
         return hash((self.language, self.territory, self.script, self.variant))
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         parameters = ['']
         for key in ('territory', 'script', 'variant'):
             value = getattr(self, key)
@@ -352,17 +402,17 @@ def __repr__(self):
                 parameters.append(f"{key}={value!r}")
         return f"Locale({self.language!r}{', '.join(parameters)})"
 
-    def __str__(self):
+    def __str__(self) -> str:
         return get_locale_identifier((self.language, self.territory,
                                       self.script, self.variant))
 
     @property
-    def _data(self):
+    def _data(self) -> localedata.LocaleDataDict:
         if self.__data is None:
             self.__data = localedata.LocaleDataDict(localedata.load(str(self)))
         return self.__data
 
-    def get_display_name(self, locale=None):
+    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
@@ -403,7 +453,7 @@ def get_display_name(self, locale=None):
         :type: `unicode`
         """)
 
-    def get_language_name(self, locale=None):
+    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')
@@ -425,7 +475,7 @@ def get_language_name(self, locale=None):
         u'English'
     """)
 
-    def get_territory_name(self, locale=None):
+    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
@@ -439,7 +489,7 @@ def get_territory_name(self, locale=None):
         u'Deutschland'
     """)
 
-    def get_script_name(self, locale=None):
+    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
@@ -454,7 +504,7 @@ def get_script_name(self, locale=None):
     """)
 
     @property
-    def english_name(self):
+    def english_name(self) -> str | None:
         """The english display name of the locale.
 
         >>> Locale('de').english_name
@@ -468,7 +518,7 @@ def english_name(self):
     # { General Locale Display Names
 
     @property
-    def languages(self):
+    def languages(self) -> localedata.LocaleDataDict:
         """Mapping of language codes to translated language names.
 
         >>> Locale('de', 'DE').languages['ja']
@@ -480,7 +530,7 @@ def languages(self):
         return self._data['languages']
 
     @property
-    def scripts(self):
+    def scripts(self) -> localedata.LocaleDataDict:
         """Mapping of script codes to translated script names.
 
         >>> Locale('en', 'US').scripts['Hira']
@@ -492,7 +542,7 @@ def scripts(self):
         return self._data['scripts']
 
     @property
-    def territories(self):
+    def territories(self) -> localedata.LocaleDataDict:
         """Mapping of script codes to translated script names.
 
         >>> Locale('es', 'CO').territories['DE']
@@ -504,7 +554,7 @@ def territories(self):
         return self._data['territories']
 
     @property
-    def variants(self):
+    def variants(self) -> localedata.LocaleDataDict:
         """Mapping of script codes to translated script names.
 
         >>> Locale('de', 'DE').variants['1901']
@@ -515,7 +565,7 @@ def variants(self):
     # { Number Formatting
 
     @property
-    def currencies(self):
+    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
@@ -529,7 +579,7 @@ def currencies(self):
         return self._data['currency_names']
 
     @property
-    def currency_symbols(self):
+    def currency_symbols(self) -> localedata.LocaleDataDict:
         """Mapping of currency codes to symbols.
 
         >>> Locale('en', 'US').currency_symbols['USD']
@@ -540,7 +590,7 @@ def currency_symbols(self):
         return self._data['currency_symbols']
 
     @property
-    def number_symbols(self):
+    def number_symbols(self) -> localedata.LocaleDataDict:
         """Symbols used in number formatting.
 
         .. note:: The format of the value returned may change between
@@ -552,7 +602,7 @@ def number_symbols(self):
         return self._data['number_symbols']
 
     @property
-    def decimal_formats(self):
+    def decimal_formats(self) -> localedata.LocaleDataDict:
         """Locale patterns for decimal number formatting.
 
         .. note:: The format of the value returned may change between
@@ -564,7 +614,7 @@ def decimal_formats(self):
         return self._data['decimal_formats']
 
     @property
-    def compact_decimal_formats(self):
+    def compact_decimal_formats(self) -> localedata.LocaleDataDict:
         """Locale patterns for compact decimal number formatting.
 
         .. note:: The format of the value returned may change between
@@ -576,7 +626,7 @@ def compact_decimal_formats(self):
         return self._data['compact_decimal_formats']
 
     @property
-    def currency_formats(self):
+    def currency_formats(self) -> localedata.LocaleDataDict:
         """Locale patterns for currency number formatting.
 
         .. note:: The format of the value returned may change between
@@ -590,7 +640,7 @@ def currency_formats(self):
         return self._data['currency_formats']
 
     @property
-    def compact_currency_formats(self):
+    def compact_currency_formats(self) -> localedata.LocaleDataDict:
         """Locale patterns for compact currency number formatting.
 
         .. note:: The format of the value returned may change between
@@ -602,7 +652,7 @@ def compact_currency_formats(self):
         return self._data['compact_currency_formats']
 
     @property
-    def percent_formats(self):
+    def percent_formats(self) -> localedata.LocaleDataDict:
         """Locale patterns for percent number formatting.
 
         .. note:: The format of the value returned may change between
@@ -614,7 +664,7 @@ def percent_formats(self):
         return self._data['percent_formats']
 
     @property
-    def scientific_formats(self):
+    def scientific_formats(self) -> localedata.LocaleDataDict:
         """Locale patterns for scientific number formatting.
 
         .. note:: The format of the value returned may change between
@@ -628,7 +678,7 @@ def scientific_formats(self):
     # { Calendar Information and Date Formatting
 
     @property
-    def periods(self):
+    def periods(self) -> localedata.LocaleDataDict:
         """Locale display names for day periods (AM/PM).
 
         >>> Locale('en', 'US').periods['am']
@@ -637,10 +687,10 @@ def periods(self):
         try:
             return self._data['day_periods']['stand-alone']['wide']
         except KeyError:
-            return {}
+            return localedata.LocaleDataDict({})  # pragma: no cover
 
     @property
-    def day_periods(self):
+    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`.
@@ -648,13 +698,13 @@ def day_periods(self):
         return self._data['day_periods']
 
     @property
-    def day_period_rules(self):
+    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', {})
+        return self._data.get('day_period_rules', localedata.LocaleDataDict({}))
 
     @property
-    def days(self):
+    def days(self) -> localedata.LocaleDataDict:
         """Locale display names for weekdays.
 
         >>> Locale('de', 'DE').days['format']['wide'][3]
@@ -663,7 +713,7 @@ def days(self):
         return self._data['days']
 
     @property
-    def months(self):
+    def months(self) -> localedata.LocaleDataDict:
         """Locale display names for months.
 
         >>> Locale('de', 'DE').months['format']['wide'][10]
@@ -672,7 +722,7 @@ def months(self):
         return self._data['months']
 
     @property
-    def quarters(self):
+    def quarters(self) -> localedata.LocaleDataDict:
         """Locale display names for quarters.
 
         >>> Locale('de', 'DE').quarters['format']['wide'][1]
@@ -681,7 +731,7 @@ def quarters(self):
         return self._data['quarters']
 
     @property
-    def eras(self):
+    def eras(self) -> localedata.LocaleDataDict:
         """Locale display names for eras.
 
         .. note:: The format of the value returned may change between
@@ -695,7 +745,7 @@ def eras(self):
         return self._data['eras']
 
     @property
-    def time_zones(self):
+    def time_zones(self) -> localedata.LocaleDataDict:
         """Locale display names for time zones.
 
         .. note:: The format of the value returned may change between
@@ -709,7 +759,7 @@ def time_zones(self):
         return self._data['time_zones']
 
     @property
-    def meta_zones(self):
+    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
@@ -726,7 +776,7 @@ def meta_zones(self):
         return self._data['meta_zones']
 
     @property
-    def zone_formats(self):
+    def zone_formats(self) -> localedata.LocaleDataDict:
         """Patterns related to the formatting of time zones.
 
         .. note:: The format of the value returned may change between
@@ -742,7 +792,7 @@ def zone_formats(self):
         return self._data['zone_formats']
 
     @property
-    def first_week_day(self):
+    def first_week_day(self) -> int:
         """The first day of a week, with 0 being Monday.
 
         >>> Locale('de', 'DE').first_week_day
@@ -753,7 +803,7 @@ def first_week_day(self):
         return self._data['week_data']['first_day']
 
     @property
-    def weekend_start(self):
+    def weekend_start(self) -> int:
         """The day the weekend starts, with 0 being Monday.
 
         >>> Locale('de', 'DE').weekend_start
@@ -762,7 +812,7 @@ def weekend_start(self):
         return self._data['week_data']['weekend_start']
 
     @property
-    def weekend_end(self):
+    def weekend_end(self) -> int:
         """The day the weekend ends, with 0 being Monday.
 
         >>> Locale('de', 'DE').weekend_end
@@ -771,7 +821,7 @@ def weekend_end(self):
         return self._data['week_data']['weekend_end']
 
     @property
-    def min_week_days(self):
+    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.
 
@@ -781,7 +831,7 @@ def min_week_days(self):
         return self._data['week_data']['min_days']
 
     @property
-    def date_formats(self):
+    def date_formats(self) -> localedata.LocaleDataDict:
         """Locale patterns for date formatting.
 
         .. note:: The format of the value returned may change between
@@ -795,7 +845,7 @@ def date_formats(self):
         return self._data['date_formats']
 
     @property
-    def time_formats(self):
+    def time_formats(self) -> localedata.LocaleDataDict:
         """Locale patterns for time formatting.
 
         .. note:: The format of the value returned may change between
@@ -809,7 +859,7 @@ def time_formats(self):
         return self._data['time_formats']
 
     @property
-    def datetime_formats(self):
+    def datetime_formats(self) -> localedata.LocaleDataDict:
         """Locale patterns for datetime formatting.
 
         .. note:: The format of the value returned may change between
@@ -823,7 +873,7 @@ def datetime_formats(self):
         return self._data['datetime_formats']
 
     @property
-    def datetime_skeletons(self):
+    def datetime_skeletons(self) -> localedata.LocaleDataDict:
         """Locale patterns for formatting parts of a datetime.
 
         >>> Locale('en').datetime_skeletons['MEd']
@@ -836,7 +886,7 @@ def datetime_skeletons(self):
         return self._data['datetime_skeletons']
 
     @property
-    def interval_formats(self):
+    def interval_formats(self) -> localedata.LocaleDataDict:
         """Locale patterns for interval formatting.
 
         .. note:: The format of the value returned may change between
@@ -858,7 +908,7 @@ def interval_formats(self):
         return self._data['interval_formats']
 
     @property
-    def plural_form(self):
+    def plural_form(self) -> PluralRule:
         """Plural rules for the locale.
 
         >>> Locale('en').plural_form(1)
@@ -873,7 +923,7 @@ def plural_form(self):
         return self._data.get('plural_form', _default_plural_rule)
 
     @property
-    def list_patterns(self):
+    def list_patterns(self) -> localedata.LocaleDataDict:
         """Patterns for generating lists
 
         .. note:: The format of the value returned may change between
@@ -889,7 +939,7 @@ def list_patterns(self):
         return self._data['list_patterns']
 
     @property
-    def ordinal_form(self):
+    def ordinal_form(self) -> PluralRule:
         """Plural rules for the locale.
 
         >>> Locale('en').ordinal_form(1)
@@ -906,7 +956,7 @@ def ordinal_form(self):
         return self._data.get('ordinal_form', _default_plural_rule)
 
     @property
-    def measurement_systems(self):
+    def measurement_systems(self) -> localedata.LocaleDataDict:
         """Localized names for various measurement systems.
 
         >>> Locale('fr', 'FR').measurement_systems['US']
@@ -918,7 +968,7 @@ def measurement_systems(self):
         return self._data['measurement_systems']
 
     @property
-    def character_order(self):
+    def character_order(self) -> str:
         """The text direction for the language.
 
         >>> Locale('de', 'DE').character_order
@@ -929,7 +979,7 @@ def character_order(self):
         return self._data['character_order']
 
     @property
-    def text_direction(self):
+    def text_direction(self) -> str:
         """The text direction for the language in CSS short-hand form.
 
         >>> Locale('de', 'DE').text_direction
@@ -940,7 +990,7 @@ def text_direction(self):
         return ''.join(word[0] for word in self.character_order.split('-'))
 
     @property
-    def unit_display_names(self):
+    def unit_display_names(self) -> localedata.LocaleDataDict:
         """Display names for units of measurement.
 
         .. seealso::
@@ -954,7 +1004,7 @@ def unit_display_names(self):
         return self._data['unit_display_names']
 
 
-def default_locale(category=None, aliases=LOCALE_ALIASES):
+def default_locale(category: str | None = None, aliases: Mapping[str, str] = LOCALE_ALIASES) -> str | None:
     """Returns the system default locale for a given category, based on
     environment variables.
 
@@ -999,7 +1049,7 @@ def default_locale(category=None, aliases=LOCALE_ALIASES):
                 pass
 
 
-def negotiate_locale(preferred, available, sep='_', aliases=LOCALE_ALIASES):
+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'])
@@ -1062,7 +1112,7 @@ def negotiate_locale(preferred, available, sep='_', aliases=LOCALE_ALIASES):
     return None
 
 
-def parse_locale(identifier, sep='_'):
+def parse_locale(identifier: str, sep: str = '_') -> tuple[str, str | None, str | None, str | None]:
     """Parse a locale identifier into a tuple of the form ``(language,
     territory, script, variant)``.
 
@@ -1143,7 +1193,7 @@ def parse_locale(identifier, sep='_'):
     return lang, territory, script, variant
 
 
-def get_locale_identifier(tup, sep='_'):
+def get_locale_identifier(tup: tuple[str, 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)`` tuple.  Items can be set to
     ``None`` and trailing ``None``\\s can also be left out of the tuple.
diff --git a/babel/dates.py b/babel/dates.py
index e9f6f6dd2..27f3fe648 100644
--- a/babel/dates.py
+++ b/babel/dates.py
@@ -15,16 +15,28 @@
     :license: BSD, see LICENSE for more details.
 """
 
+from __future__ import annotations
 
 import re
 import warnings
+from bisect import bisect_right
+from collections.abc import Iterable
+from datetime import date, datetime, time, timedelta, tzinfo
+from typing import TYPE_CHECKING, SupportsInt
+
 import pytz as _pytz
 
-from datetime import date, datetime, time, timedelta
-from bisect import bisect_right
+from babel.core import Locale, default_locale, get_global
+from babel.localedata import LocaleDataDict
+from babel.util import LOCALTZ, UTC
+
+if TYPE_CHECKING:
+    from typing_extensions import Literal, TypeAlias
 
-from babel.core import default_locale, get_global, Locale
-from babel.util import UTC, LOCALTZ
+    _Instant: TypeAlias = date | time | float | None
+    _PredefinedTimeFormat: TypeAlias = Literal['full', 'long', 'medium', 'short']
+    _Context: TypeAlias = Literal['format', 'stand-alone']
+    _DtOrTzinfo: TypeAlias = datetime | tzinfo | str | int | 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
@@ -44,7 +56,7 @@
 time_ = time
 
 
-def _get_dt_and_tzinfo(dt_or_tzinfo):
+def _get_dt_and_tzinfo(dt_or_tzinfo: _DtOrTzinfo) -> tuple[datetime_ | None, tzinfo]:
     """
     Parse a `dt_or_tzinfo` value into a datetime and a tzinfo.
 
@@ -73,7 +85,7 @@ def _get_dt_and_tzinfo(dt_or_tzinfo):
     return dt, tzinfo
 
 
-def _get_tz_name(dt_or_tzinfo):
+def _get_tz_name(dt_or_tzinfo: _DtOrTzinfo) -> str:
     """
     Get the timezone name out of a time, datetime, or tzinfo object.
 
@@ -88,7 +100,7 @@ def _get_tz_name(dt_or_tzinfo):
         return tzinfo.tzname(dt or datetime.utcnow())
 
 
-def _get_datetime(instant):
+def _get_datetime(instant: _Instant) -> datetime_:
     """
     Get a datetime out of an "instant" (date, time, datetime, number).
 
@@ -130,7 +142,7 @@ def _get_datetime(instant):
     return instant
 
 
-def _ensure_datetime_tzinfo(datetime, tzinfo=None):
+def _ensure_datetime_tzinfo(datetime: datetime_, tzinfo: tzinfo | None = None) -> datetime_:
     """
     Ensure the datetime passed has an attached tzinfo.
 
@@ -159,7 +171,7 @@ def _ensure_datetime_tzinfo(datetime, tzinfo=None):
     return datetime
 
 
-def _get_time(time, tzinfo=None):
+def _get_time(time: time | datetime | None, tzinfo: tzinfo | None = None) -> time:
     """
     Get a timezoned time from a given instant.
 
@@ -185,7 +197,7 @@ def _get_time(time, tzinfo=None):
     return time
 
 
-def get_timezone(zone=None):
+def get_timezone(zone: str | _pytz.BaseTzInfo | None = None) -> _pytz.BaseTzInfo:
     """Looks up a timezone by name and returns it.  The timezone object
     returned comes from ``pytz`` and corresponds to the `tzinfo` interface and
     can be used with all of the functions of Babel that operate with dates.
@@ -206,7 +218,7 @@ def get_timezone(zone=None):
         raise LookupError(f"Unknown timezone {zone}")
 
 
-def get_next_timezone_transition(zone=None, dt=None):
+def get_next_timezone_transition(zone: _pytz.BaseTzInfo | None = None, dt: _Instant = None) -> TimezoneTransition:
     """Given a timezone it will return a :class:`TimezoneTransition` object
     that holds the information about the next timezone transition that's going
     to happen.  For instance this can be used to detect when the next DST
@@ -278,7 +290,7 @@ class TimezoneTransition:
         to the :func:`get_next_timezone_transition`.
     """
 
-    def __init__(self, activates, from_tzinfo, to_tzinfo, reference_date=None):
+    def __init__(self, activates: datetime_, from_tzinfo: tzinfo, to_tzinfo: tzinfo, reference_date: datetime_ | None = None):
         warnings.warn(
             "TimezoneTransition is deprecated and will be "
             "removed in the next version of Babel. "
@@ -292,30 +304,31 @@ def __init__(self, activates, from_tzinfo, to_tzinfo, reference_date=None):
         self.reference_date = reference_date
 
     @property
-    def from_tz(self):
+    def from_tz(self) -> str:
         """The name of the timezone before the transition."""
         return self.from_tzinfo._tzname
 
     @property
-    def to_tz(self):
+    def to_tz(self) -> str:
         """The name of the timezone after the transition."""
         return self.to_tzinfo._tzname
 
     @property
-    def from_offset(self):
+    def from_offset(self) -> int:
         """The UTC offset in seconds before the transition."""
         return int(self.from_tzinfo._utcoffset.total_seconds())
 
     @property
-    def to_offset(self):
+    def to_offset(self) -> int:
         """The UTC offset in seconds after the transition."""
         return int(self.to_tzinfo._utcoffset.total_seconds())
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f"<TimezoneTransition {self.from_tz} -> {self.to_tz} ({self.activates})>"
 
 
-def get_period_names(width='wide', context='stand-alone', locale=LC_TIME):
+def get_period_names(width: Literal['abbreviated', 'narrow', 'wide'] = 'wide',
+                     context: _Context = 'stand-alone', locale: Locale | str | None = LC_TIME) -> LocaleDataDict:
     """Return the names for day periods (AM/PM) used by the locale.
 
     >>> get_period_names(locale='en_US')['am']
@@ -328,7 +341,8 @@ def get_period_names(width='wide', context='stand-alone', locale=LC_TIME):
     return Locale.parse(locale).day_periods[context][width]
 
 
-def get_day_names(width='wide', context='format', locale=LC_TIME):
+def get_day_names(width: Literal['abbreviated', 'narrow', 'short', 'wide'] = 'wide',
+                  context: _Context = 'format', locale: Locale | str | None = LC_TIME) -> LocaleDataDict:
     """Return the day names used by the locale for the specified format.
 
     >>> get_day_names('wide', locale='en_US')[1]
@@ -347,7 +361,8 @@ def get_day_names(width='wide', context='format', locale=LC_TIME):
     return Locale.parse(locale).days[context][width]
 
 
-def get_month_names(width='wide', context='format', locale=LC_TIME):
+def get_month_names(width: Literal['abbreviated', 'narrow', 'wide'] = 'wide',
+                    context: _Context = 'format', locale: Locale | str | None = LC_TIME) -> LocaleDataDict:
     """Return the month names used by the locale for the specified format.
 
     >>> get_month_names('wide', locale='en_US')[1]
@@ -364,7 +379,8 @@ def get_month_names(width='wide', context='format', locale=LC_TIME):
     return Locale.parse(locale).months[context][width]
 
 
-def get_quarter_names(width='wide', context='format', locale=LC_TIME):
+def get_quarter_names(width: Literal['abbreviated', 'narrow', 'wide'] = 'wide',
+                      context: _Context = 'format', locale: Locale | str | None = LC_TIME) -> LocaleDataDict:
     """Return the quarter names used by the locale for the specified format.
 
     >>> get_quarter_names('wide', locale='en_US')[1]
@@ -381,7 +397,8 @@ def get_quarter_names(width='wide', context='format', locale=LC_TIME):
     return Locale.parse(locale).quarters[context][width]
 
 
-def get_era_names(width='wide', locale=LC_TIME):
+def get_era_names(width: Literal['abbreviated', 'narrow', 'wide'] = 'wide',
+                  locale: Locale | str | None = LC_TIME) -> LocaleDataDict:
     """Return the era names used by the locale for the specified format.
 
     >>> get_era_names('wide', locale='en_US')[1]
@@ -395,7 +412,7 @@ def get_era_names(width='wide', locale=LC_TIME):
     return Locale.parse(locale).eras[width]
 
 
-def get_date_format(format='medium', locale=LC_TIME):
+def get_date_format(format: _PredefinedTimeFormat = 'medium', locale: Locale | str | None = LC_TIME) -> DateTimePattern:
     """Return the date formatting patterns used by the locale for the specified
     format.
 
@@ -411,7 +428,7 @@ def get_date_format(format='medium', locale=LC_TIME):
     return Locale.parse(locale).date_formats[format]
 
 
-def get_datetime_format(format='medium', locale=LC_TIME):
+def get_datetime_format(format: _PredefinedTimeFormat = 'medium', locale: Locale | str | None = LC_TIME) -> DateTimePattern:
     """Return the datetime formatting patterns used by the locale for the
     specified format.
 
@@ -428,7 +445,7 @@ def get_datetime_format(format='medium', locale=LC_TIME):
     return patterns[format]
 
 
-def get_time_format(format='medium', locale=LC_TIME):
+def get_time_format(format: _PredefinedTimeFormat = 'medium', locale: Locale | str | None = LC_TIME) -> DateTimePattern:
     """Return the time formatting patterns used by the locale for the specified
     format.
 
@@ -444,7 +461,8 @@ def get_time_format(format='medium', locale=LC_TIME):
     return Locale.parse(locale).time_formats[format]
 
 
-def get_timezone_gmt(datetime=None, width='long', locale=LC_TIME, return_z=False):
+def get_timezone_gmt(datetime: _Instant = None, width: Literal['long', 'short', 'iso8601', 'iso8601_short'] = 'long',
+                     locale: Locale | str | None = LC_TIME, return_z: bool = False) -> str:
     """Return the timezone associated with the given `datetime` object formatted
     as string indicating the offset from GMT.
 
@@ -498,7 +516,8 @@ def get_timezone_gmt(datetime=None, width='long', locale=LC_TIME, return_z=False
     return pattern % (hours, seconds // 60)
 
 
-def get_timezone_location(dt_or_tzinfo=None, locale=LC_TIME, return_city=False):
+def get_timezone_location(dt_or_tzinfo: _DtOrTzinfo = None, locale: Locale | str | None = LC_TIME,
+                          return_city: bool = False) -> str:
     u"""Return a representation of the given timezone using "location format".
 
     The result depends on both the local display name of the country and the
@@ -574,8 +593,9 @@ def get_timezone_location(dt_or_tzinfo=None, locale=LC_TIME, return_city=False):
     })
 
 
-def get_timezone_name(dt_or_tzinfo=None, width='long', uncommon=False,
-                      locale=LC_TIME, zone_variant=None, return_zone=False):
+def get_timezone_name(dt_or_tzinfo: _DtOrTzinfo = None, width: Literal['long', 'short'] = 'long', uncommon: bool = False,
+                      locale: Locale | str | None = LC_TIME, 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.
 
@@ -693,7 +713,8 @@ def get_timezone_name(dt_or_tzinfo=None, width='long', uncommon=False,
     return get_timezone_location(dt_or_tzinfo, locale=locale)
 
 
-def format_date(date=None, format='medium', locale=LC_TIME):
+def format_date(date: date | None = None, format: _PredefinedTimeFormat | str = 'medium',
+                locale: Locale | str | None = LC_TIME) -> str:
     """Return a date formatted according to the given pattern.
 
     >>> d = date(2007, 4, 1)
@@ -726,8 +747,8 @@ def format_date(date=None, format='medium', locale=LC_TIME):
     return pattern.apply(date, locale)
 
 
-def format_datetime(datetime=None, format='medium', tzinfo=None,
-                    locale=LC_TIME):
+def format_datetime(datetime: _Instant = None, format: _PredefinedTimeFormat | str = 'medium', tzinfo: tzinfo | None = None,
+                    locale: Locale | str | None = LC_TIME) -> str:
     r"""Return a date formatted according to the given pattern.
 
     >>> dt = datetime(2007, 4, 1, 15, 30)
@@ -764,7 +785,8 @@ def format_datetime(datetime=None, format='medium', tzinfo=None,
         return parse_pattern(format).apply(datetime, locale)
 
 
-def format_time(time=None, format='medium', tzinfo=None, locale=LC_TIME):
+def format_time(time: time | datetime | float | None = None, format: _PredefinedTimeFormat | str = 'medium',
+                tzinfo: tzinfo | None = None, locale: Locale | str | None = LC_TIME) -> str:
     r"""Return a time formatted according to the given pattern.
 
     >>> t = time(15, 30)
@@ -827,7 +849,8 @@ def format_time(time=None, format='medium', tzinfo=None, locale=LC_TIME):
     return parse_pattern(format).apply(time, locale)
 
 
-def format_skeleton(skeleton, datetime=None, tzinfo=None, fuzzy=True, locale=LC_TIME):
+def format_skeleton(skeleton: str, datetime: _Instant = None, tzinfo: tzinfo | None = None,
+                    fuzzy: bool = True, locale: Locale | str | None = LC_TIME) -> 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
@@ -865,7 +888,7 @@ def format_skeleton(skeleton, datetime=None, tzinfo=None, fuzzy=True, locale=LC_
     return format_datetime(datetime, format, tzinfo, locale)
 
 
-TIMEDELTA_UNITS = (
+TIMEDELTA_UNITS: tuple[tuple[str, int], ...] = (
     ('year', 3600 * 24 * 365),
     ('month', 3600 * 24 * 30),
     ('week', 3600 * 24 * 7),
@@ -876,9 +899,10 @@ def format_skeleton(skeleton, datetime=None, tzinfo=None, fuzzy=True, locale=LC_
 )
 
 
-def format_timedelta(delta, granularity='second', threshold=.85,
-                     add_direction=False, format='long',
-                     locale=LC_TIME):
+def format_timedelta(delta: 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 = LC_TIME) -> str:
     """Return a time delta according to the rules of the given locale.
 
     >>> format_timedelta(timedelta(weeks=12), locale='en_US')
@@ -977,7 +1001,8 @@ def _iter_patterns(a_unit):
     return u''
 
 
-def _format_fallback_interval(start, end, skeleton, tzinfo, locale):
+def _format_fallback_interval(start: _Instant, end: _Instant, skeleton: str | None, tzinfo: tzinfo | None,
+                              locale: Locale | str | None = LC_TIME) -> 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, date) and not isinstance(d, datetime)) for d in (start, end)):  # Both are just dates
@@ -1000,7 +1025,8 @@ def _format_fallback_interval(start, end, skeleton, tzinfo, locale):
     )
 
 
-def format_interval(start, end, skeleton=None, tzinfo=None, fuzzy=True, locale=LC_TIME):
+def format_interval(start: _Instant, end: _Instant, skeleton: str | None = None, tzinfo: tzinfo | None = None,
+                    fuzzy: bool = True, locale: Locale | str | None = LC_TIME) -> str:
     """
     Format an interval between two instants according to the locale's rules.
 
@@ -1098,7 +1124,8 @@ def format_interval(start, end, skeleton=None, tzinfo=None, fuzzy=True, locale=L
     return _format_fallback_interval(start, end, skeleton, tzinfo, locale)
 
 
-def get_period_id(time, tzinfo=None, type=None, locale=LC_TIME):
+def get_period_id(time: _Instant, tzinfo: _pytz.BaseTzInfo | None = None, type: Literal['selection'] | None = None,
+                  locale: Locale | str | None = LC_TIME) -> str:
     """
     Get the day period ID for a given time.
 
@@ -1172,7 +1199,7 @@ class ParseError(ValueError):
     pass
 
 
-def parse_date(string, locale=LC_TIME, format='medium'):
+def parse_date(string: str, locale: Locale | str | None = LC_TIME, format: _PredefinedTimeFormat = 'medium') -> date:
     """Parse a date from a string.
 
     This function first tries to interpret the string as ISO-8601
@@ -1232,7 +1259,7 @@ def parse_date(string, locale=LC_TIME, format='medium'):
     return date(year, month, day)
 
 
-def parse_time(string, locale=LC_TIME, format='medium'):
+def parse_time(string: str, locale: Locale | str | None = LC_TIME, format: _PredefinedTimeFormat = 'medium') -> time:
     """Parse a time from a string.
 
     This function uses the time format for the locale as a hint to determine
@@ -1284,36 +1311,36 @@ def parse_time(string, locale=LC_TIME, format='medium'):
 
 class DateTimePattern:
 
-    def __init__(self, pattern, format):
+    def __init__(self, pattern: str, format: DateTimeFormat):
         self.pattern = pattern
         self.format = format
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f"<{type(self).__name__} {self.pattern!r}>"
 
-    def __str__(self):
+    def __str__(self) -> str:
         pat = self.pattern
         return pat
 
-    def __mod__(self, other):
+    def __mod__(self, other: DateTimeFormat) -> str:
         if type(other) is not DateTimeFormat:
             return NotImplemented
         return self.format % other
 
-    def apply(self, datetime, locale):
+    def apply(self, datetime: date | time, locale: Locale | str | None) -> str:
         return self % DateTimeFormat(datetime, locale)
 
 
 class DateTimeFormat:
 
-    def __init__(self, value, locale):
+    def __init__(self, value: date | time, locale: Locale | str):
         assert isinstance(value, (date, datetime, time))
         if isinstance(value, (datetime, time)) and value.tzinfo is None:
             value = value.replace(tzinfo=UTC)
         self.value = value
         self.locale = Locale.parse(locale)
 
-    def __getitem__(self, name):
+    def __getitem__(self, name: str) -> str:
         char = name[0]
         num = len(name)
         if char == 'G':
@@ -1363,7 +1390,7 @@ def __getitem__(self, name):
         else:
             raise KeyError(f"Unsupported date/time field {char!r}")
 
-    def extract(self, char):
+    def extract(self, char: str) -> int:
         char = str(char)[0]
         if char == 'y':
             return self.value.year
@@ -1382,12 +1409,12 @@ def extract(self, char):
         else:
             raise NotImplementedError(f"Not implemented: extracting {char!r} from {self.value!r}")
 
-    def format_era(self, char, num):
+    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, num):
+    def format_year(self, char: str, num: int) -> str:
         value = self.value.year
         if char.isupper():
             value = self.value.isocalendar()[0]
@@ -1396,7 +1423,7 @@ def format_year(self, char, num):
             year = year[-2:]
         return year
 
-    def format_quarter(self, char, num):
+    def format_quarter(self, char: str, num: int) -> str:
         quarter = (self.value.month - 1) // 3 + 1
         if num <= 2:
             return '%0*d' % (num, quarter)
@@ -1404,14 +1431,14 @@ def format_quarter(self, char, num):
         context = {'Q': 'format', 'q': 'stand-alone'}[char]
         return get_quarter_names(width, context, self.locale)[quarter]
 
-    def format_month(self, char, num):
+    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, num):
+    def format_week(self, char: str, num: int) -> str:
         if char.islower():  # week of year
             day_of_year = self.get_day_of_year()
             week = self.get_week_number(day_of_year)
@@ -1427,7 +1454,7 @@ def format_week(self, char, num):
                 week = self.get_week_number(date.day, date.weekday())
             return str(week)
 
-    def format_weekday(self, char='E', num=4):
+    def format_weekday(self, char: str = 'E', num: int = 4) -> str:
         """
         Return weekday from parsed datetime according to format pattern.
 
@@ -1467,13 +1494,13 @@ def format_weekday(self, char='E', num=4):
             context = 'format'
         return get_day_names(width, context, self.locale)[weekday]
 
-    def format_day_of_year(self, num):
+    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):
+    def format_day_of_week_in_month(self) -> str:
         return str((self.value.day - 1) // 7 + 1)
 
-    def format_period(self, char, num):
+    def format_period(self, char: str, num: int) -> str:
         """
         Return period from parsed datetime according to format pattern.
 
@@ -1515,7 +1542,7 @@ def format_period(self, char, num):
                 return period_names[period]
         raise ValueError(f"Could not format period {period} in {self.locale}")
 
-    def format_frac_seconds(self, num):
+    def format_frac_seconds(self, num: int) -> str:
         """ Return fractional seconds.
 
         Rounds the time's microseconds to the precision given by the number \
@@ -1529,7 +1556,7 @@ def format_milliseconds_in_day(self, num):
             self.value.minute * 60000 + self.value.hour * 3600000
         return self.format(msecs, num)
 
-    def format_timezone(self, char, num):
+    def format_timezone(self, char: str, num: int) -> str:
         width = {3: 'short', 4: 'long', 5: 'iso8601'}[max(3, num)]
         if char == 'z':
             return get_timezone_name(self.value, width, locale=self.locale)
@@ -1572,15 +1599,15 @@ def format_timezone(self, char, num):
             elif num in (3, 5):
                 return get_timezone_gmt(self.value, width='iso8601', locale=self.locale)
 
-    def format(self, value, length):
+    def format(self, value: SupportsInt, length: int) -> str:
         return '%0*d' % (length, value)
 
-    def get_day_of_year(self, date=None):
+    def get_day_of_year(self, date: date | None = None) -> int:
         if date is None:
             date = self.value
         return (date - date.replace(month=1, day=1)).days + 1
 
-    def get_week_number(self, day_of_period, day_of_week=None):
+    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.
 
@@ -1625,7 +1652,7 @@ def get_week_number(self, day_of_period, day_of_week=None):
         return week_number
 
 
-PATTERN_CHARS = {
+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
@@ -1649,7 +1676,7 @@ def get_week_number(self, day_of_period, day_of_week=None):
 _pattern_cache = {}
 
 
-def parse_pattern(pattern):
+def parse_pattern(pattern: str) -> DateTimePattern:
     """Parse date, time, and datetime format patterns.
 
     >>> parse_pattern("MMMMd").format
@@ -1694,7 +1721,7 @@ def parse_pattern(pattern):
     return pat
 
 
-def tokenize_pattern(pattern):
+def tokenize_pattern(pattern: str) -> list[tuple[str, str | tuple[str, int]]]:
     """
     Tokenize date format patterns.
 
@@ -1763,7 +1790,7 @@ def append_field():
     return result
 
 
-def untokenize_pattern(tokens):
+def untokenize_pattern(tokens: Iterable[tuple[str, str | tuple[str, int]]]) -> str:
     """
     Turn a date format pattern token stream back into a string.
 
@@ -1784,7 +1811,7 @@ def untokenize_pattern(tokens):
     return "".join(output)
 
 
-def split_interval_pattern(pattern):
+def split_interval_pattern(pattern: str) -> list[str]:
     """
     Split an interval-describing datetime pattern into multiple pieces.
 
@@ -1822,7 +1849,7 @@ def split_interval_pattern(pattern):
     return [untokenize_pattern(tokens) for tokens in parts]
 
 
-def match_skeleton(skeleton, options, allow_different_fields=False):
+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.
 
diff --git a/babel/languages.py b/babel/languages.py
index cac59c162..564f555d2 100644
--- a/babel/languages.py
+++ b/babel/languages.py
@@ -1,7 +1,9 @@
+from __future__ import annotations
+
 from babel.core import get_global
 
 
-def get_official_languages(territory, regional=False, de_facto=False):
+def get_official_languages(territory: str, regional: bool = False, de_facto: bool = False) -> tuple[str, ...]:
     """
     Get the official language(s) for the given territory.
 
@@ -41,7 +43,7 @@ def get_official_languages(territory, regional=False, de_facto=False):
     return tuple(lang for _, lang in pairs)
 
 
-def get_territory_language_info(territory):
+def get_territory_language_info(territory: str) -> dict[str, dict[str, float | str | None]]:
     """
     Get a dictionary of language information for a territory.
 
diff --git a/babel/lists.py b/babel/lists.py
index ea983efe0..97fc49a71 100644
--- a/babel/lists.py
+++ b/babel/lists.py
@@ -13,13 +13,22 @@
     :copyright: (c) 2015-2022 by the Babel Team.
     :license: BSD, see LICENSE for more details.
 """
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import TYPE_CHECKING
 
 from babel.core import Locale, default_locale
 
+if TYPE_CHECKING:
+    from typing_extensions import Literal
+
 DEFAULT_LOCALE = default_locale()
 
 
-def format_list(lst, style='standard', locale=DEFAULT_LOCALE):
+def format_list(lst: Sequence[str],
+                style: Literal['standard', 'standard-short', 'or', 'or-short', 'unit', 'unit-short', 'unit-narrow'] = 'standard',
+                locale: Locale | str | None = DEFAULT_LOCALE) -> str:
     """
     Format the items in `lst` as a list.
 
diff --git a/babel/localedata.py b/babel/localedata.py
index 8ec8f4aaa..0d3508d1e 100644
--- a/babel/localedata.py
+++ b/babel/localedata.py
@@ -11,22 +11,25 @@
     :license: BSD, see LICENSE for more details.
 """
 
-import pickle
+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 itertools import chain
+from typing import Any
 
-
-_cache = {}
+_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):
+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
@@ -40,7 +43,7 @@ def normalize_locale(name):
             return locale_id
 
 
-def resolve_locale_filename(name):
+def resolve_locale_filename(name: os.PathLike[str] | str) -> str:
     """
     Resolve a locale identifier to a `.dat` path on disk.
     """
@@ -56,7 +59,7 @@ def resolve_locale_filename(name):
     return os.path.join(_dirname, f"{name}.dat")
 
 
-def exists(name):
+def exists(name: str) -> bool:
     """Check whether locale data is available for the given locale.
 
     Returns `True` if it exists, `False` otherwise.
@@ -71,7 +74,7 @@ def exists(name):
     return True if file_found else bool(normalize_locale(name))
 
 
-def locale_identifiers():
+def locale_identifiers() -> list[str]:
     """Return a list of all locale identifiers for which locale data is
     available.
 
@@ -95,7 +98,7 @@ def locale_identifiers():
     return data
 
 
-def load(name, merge_inherited=True):
+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
@@ -150,7 +153,7 @@ def load(name, merge_inherited=True):
         _cache_lock.release()
 
 
-def merge(dict1, dict2):
+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.
 
@@ -190,13 +193,13 @@ class Alias:
     as specified by the `keys`.
     """
 
-    def __init__(self, keys):
+    def __init__(self, keys: tuple[str, ...]) -> None:
         self.keys = tuple(keys)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f"<{type(self).__name__} {self.keys!r}>"
 
-    def resolve(self, data):
+    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,
@@ -221,19 +224,19 @@ class LocaleDataDict(abc.MutableMapping):
     values.
     """
 
-    def __init__(self, data, base=None):
+    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):
+    def __len__(self) -> int:
         return len(self._data)
 
-    def __iter__(self):
+    def __iter__(self) -> Iterator[str | int | None]:
         return iter(self._data)
 
-    def __getitem__(self, key):
+    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)
@@ -241,17 +244,17 @@ def __getitem__(self, key):
             alias, others = val
             val = alias.resolve(self.base).copy()
             merge(val, others)
-        if type(val) is dict:  # Return a nested alias-resolving dict
+        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, value):
+    def __setitem__(self, key: str | int | None, value: Any) -> None:
         self._data[key] = value
 
-    def __delitem__(self, key):
+    def __delitem__(self, key: str | int | None) -> None:
         del self._data[key]
 
-    def copy(self):
+    def copy(self) -> LocaleDataDict:
         return LocaleDataDict(self._data.copy(), base=self.base)
diff --git a/babel/localtime/__init__.py b/babel/localtime/__init__.py
index 7e626a0f1..ffe2d49f1 100644
--- a/babel/localtime/__init__.py
+++ b/babel/localtime/__init__.py
@@ -10,12 +10,12 @@
 """
 
 import sys
-import pytz
 import time
-from datetime import timedelta
-from datetime import tzinfo
+from datetime import datetime, timedelta, tzinfo
 from threading import RLock
 
+import pytz
+
 if sys.platform == 'win32':
     from babel.localtime._win32 import _get_localzone
 else:
@@ -37,22 +37,22 @@
 
 class _FallbackLocalTimezone(tzinfo):
 
-    def utcoffset(self, dt):
+    def utcoffset(self, dt: datetime) -> timedelta:
         if self._isdst(dt):
             return DSTOFFSET
         else:
             return STDOFFSET
 
-    def dst(self, dt):
+    def dst(self, dt: datetime) -> timedelta:
         if self._isdst(dt):
             return DSTDIFF
         else:
             return ZERO
 
-    def tzname(self, dt):
+    def tzname(self, dt: datetime) -> str:
         return time.tzname[self._isdst(dt)]
 
-    def _isdst(self, dt):
+    def _isdst(self, dt: datetime) -> bool:
         tt = (dt.year, dt.month, dt.day,
               dt.hour, dt.minute, dt.second,
               dt.weekday(), 0, -1)
@@ -61,7 +61,7 @@ def _isdst(self, dt):
         return tt.tm_isdst > 0
 
 
-def get_localzone():
+def get_localzone() -> pytz.BaseTzInfo:
     """Returns the current underlying local timezone object.
     Generally this function does not need to be used, it's a
     better idea to use the :data:`LOCALTZ` singleton instead.
diff --git a/babel/localtime/_unix.py b/babel/localtime/_unix.py
index 3d1480ed8..beb7f6021 100644
--- a/babel/localtime/_unix.py
+++ b/babel/localtime/_unix.py
@@ -3,7 +3,7 @@
 import pytz
 
 
-def _tz_from_env(tzenv):
+def _tz_from_env(tzenv: str) -> pytz.BaseTzInfo:
     if tzenv[0] == ':':
         tzenv = tzenv[1:]
 
@@ -23,7 +23,7 @@ def _tz_from_env(tzenv):
             "Please use a timezone in the form of Continent/City")
 
 
-def _get_localzone(_root='/'):
+def _get_localzone(_root: str = '/') -> pytz.BaseTzInfo:
     """Tries to find the local timezone configuration.
     This method prefers finding the timezone name and passing that to pytz,
     over passing in the localtime file, as in the later case the zoneinfo
diff --git a/babel/localtime/_win32.py b/babel/localtime/_win32.py
index a4f6d557a..98d51708d 100644
--- a/babel/localtime/_win32.py
+++ b/babel/localtime/_win32.py
@@ -1,23 +1,27 @@
+from __future__ import annotations
+
 try:
     import winreg
 except ImportError:
     winreg = None
 
-from babel.core import get_global
+from typing import Any, Dict, cast
+
 import pytz
 
+from babel.core import get_global
 
 # When building the cldr data on windows this module gets imported.
 # Because at that point there is no global.dat yet this call will
 # fail.  We want to catch it down in that case then and just assume
 # the mapping was empty.
 try:
-    tz_names = get_global('windows_zone_mapping')
+    tz_names: dict[str, str] = cast(Dict[str, str], get_global('windows_zone_mapping'))
 except RuntimeError:
     tz_names = {}
 
 
-def valuestodict(key):
+def valuestodict(key) -> dict[str, Any]:
     """Convert a registry key's values to a dictionary."""
     dict = {}
     size = winreg.QueryInfoKey(key)[1]
@@ -27,7 +31,7 @@ def valuestodict(key):
     return dict
 
 
-def get_localzone_name():
+def get_localzone_name() -> str:
     # Windows is special. It has unique time zone names (in several
     # meanings of the word) available, but unfortunately, they can be
     # translated to the language of the operating system, so we need to
@@ -86,7 +90,7 @@ def get_localzone_name():
     return timezone
 
 
-def _get_localzone():
+def _get_localzone() -> pytz.BaseTzInfo:
     if winreg is None:
         raise pytz.UnknownTimeZoneError(
             'Runtime support not available')
diff --git a/babel/messages/catalog.py b/babel/messages/catalog.py
index 22ce66067..0801de371 100644
--- a/babel/messages/catalog.py
+++ b/babel/messages/catalog.py
@@ -7,14 +7,17 @@
     :copyright: (c) 2013-2022 by the Babel Team.
     :license: BSD, see LICENSE for more details.
 """
+from __future__ import annotations
 
 import re
 
 from collections import OrderedDict
+from collections.abc import Generator, Iterable, Iterator
 from datetime import datetime, time as time_
 from difflib import get_close_matches
 from email import message_from_string
 from copy import copy
+from typing import TYPE_CHECKING
 
 from babel import __version__ as VERSION
 from babel.core import Locale, UnknownLocaleError
@@ -22,6 +25,11 @@
 from babel.messages.plurals import get_plural
 from babel.util import distinct, LOCALTZ, FixedOffsetTimezone, _cmp
 
+if TYPE_CHECKING:
+    from typing_extensions import TypeAlias
+
+    _MessageID: TypeAlias = str | tuple[str, ...] | list[str]
+
 __all__ = ['Message', 'Catalog', 'TranslationError']
 
 
@@ -37,7 +45,7 @@
 ''', re.VERBOSE)
 
 
-def _parse_datetime_header(value):
+def _parse_datetime_header(value: str) -> datetime:
     match = re.match(r'^(?P<datetime>.*?)(?P<tzoffset>[+-]\d{4})?$', value)
 
     dt = datetime.strptime(match.group('datetime'), '%Y-%m-%d %H:%M')
@@ -70,8 +78,18 @@ def _parse_datetime_header(value):
 class Message:
     """Representation of a single message in a catalog."""
 
-    def __init__(self, id, string=u'', locations=(), flags=(), auto_comments=(),
-                 user_comments=(), previous_id=(), lineno=None, context=None):
+    def __init__(
+        self,
+        id: _MessageID,
+        string: _MessageID | None = u'',
+        locations: Iterable[tuple[str, int]] = (),
+        flags: Iterable[str] = (),
+        auto_comments: Iterable[str] = (),
+        user_comments: Iterable[str] = (),
+        previous_id: _MessageID = (),
+        lineno: int | None = None,
+        context: str | None = None,
+    ) -> None:
         """Create the message object.
 
         :param id: the message ID, or a ``(singular, plural)`` tuple for
@@ -107,10 +125,10 @@ def __init__(self, id, string=u'', locations=(), flags=(), auto_comments=(),
         self.lineno = lineno
         self.context = context
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f"<{type(self).__name__} {self.id!r} (flags: {list(self.flags)!r})>"
 
-    def __cmp__(self, other):
+    def __cmp__(self, other: object) -> int:
         """Compare Messages, taking into account plural ids"""
         def values_to_compare(obj):
             if isinstance(obj, Message) and obj.pluralizable:
@@ -118,38 +136,38 @@ def values_to_compare(obj):
             return obj.id, obj.context or ''
         return _cmp(values_to_compare(self), values_to_compare(other))
 
-    def __gt__(self, other):
+    def __gt__(self, other: object) -> bool:
         return self.__cmp__(other) > 0
 
-    def __lt__(self, other):
+    def __lt__(self, other: object) -> bool:
         return self.__cmp__(other) < 0
 
-    def __ge__(self, other):
+    def __ge__(self, other: object) -> bool:
         return self.__cmp__(other) >= 0
 
-    def __le__(self, other):
+    def __le__(self, other: object) -> bool:
         return self.__cmp__(other) <= 0
 
-    def __eq__(self, other):
+    def __eq__(self, other: object) -> bool:
         return self.__cmp__(other) == 0
 
-    def __ne__(self, other):
+    def __ne__(self, other: object) -> bool:
         return self.__cmp__(other) != 0
 
-    def is_identical(self, other):
+    def is_identical(self, other: Message) -> bool:
         """Checks whether messages are identical, taking into account all
         properties.
         """
         assert isinstance(other, Message)
         return self.__dict__ == other.__dict__
 
-    def clone(self):
+    def clone(self) -> Message:
         return Message(*map(copy, (self.id, self.string, self.locations,
                                    self.flags, self.auto_comments,
                                    self.user_comments, self.previous_id,
                                    self.lineno, self.context)))
 
-    def check(self, catalog=None):
+    def check(self, catalog: Catalog | None = None) -> list[TranslationError]:
         """Run various validation checks on the message.  Some validations
         are only performed if the catalog is provided.  This method returns
         a sequence of `TranslationError` objects.
@@ -160,7 +178,7 @@ def check(self, catalog=None):
               in a catalog.
         """
         from babel.messages.checkers import checkers
-        errors = []
+        errors: list[TranslationError] = []
         for checker in checkers:
             try:
                 checker(catalog, self)
@@ -169,7 +187,7 @@ def check(self, catalog=None):
         return errors
 
     @property
-    def fuzzy(self):
+    def fuzzy(self) -> bool:
         """Whether the translation is fuzzy.
 
         >>> Message('foo').fuzzy
@@ -184,7 +202,7 @@ def fuzzy(self):
         return 'fuzzy' in self.flags
 
     @property
-    def pluralizable(self):
+    def pluralizable(self) -> bool:
         """Whether the message is plurizable.
 
         >>> Message('foo').pluralizable
@@ -196,7 +214,7 @@ def pluralizable(self):
         return isinstance(self.id, (list, tuple))
 
     @property
-    def python_format(self):
+    def python_format(self) -> bool:
         """Whether the message contains Python-style parameters.
 
         >>> Message('foo %(name)s bar').python_format
@@ -223,7 +241,7 @@ class TranslationError(Exception):
 # FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
 #"""
 
-def parse_separated_header(value: str):
+def parse_separated_header(value: str) -> dict[str, str]:
     # Adapted from https://peps.python.org/pep-0594/#cgi
     from email.message import Message
     m = Message()
@@ -234,11 +252,22 @@ def parse_separated_header(value: str):
 class Catalog:
     """Representation of a message catalog."""
 
-    def __init__(self, locale=None, domain=None, header_comment=DEFAULT_HEADER,
-                 project=None, version=None, copyright_holder=None,
-                 msgid_bugs_address=None, creation_date=None,
-                 revision_date=None, last_translator=None, language_team=None,
-                 charset=None, fuzzy=True):
+    def __init__(
+        self,
+        locale: str | Locale | None = None,
+        domain: str | None = None,
+        header_comment: str | None = DEFAULT_HEADER,
+        project: str | None = None,
+        version: str | None = None,
+        copyright_holder: str | None = None,
+        msgid_bugs_address: str | None = None,
+        creation_date: datetime | str | None = None,
+        revision_date: datetime | time_ | float | str | None = None,
+        last_translator: str | None = None,
+        language_team: str | None = None,
+        charset: str | None = None,
+        fuzzy: bool = True,
+    ) -> None:
         """Initialize the catalog object.
 
         :param locale: the locale identifier or `Locale` object, or `None`
@@ -262,7 +291,7 @@ def __init__(self, locale=None, domain=None, header_comment=DEFAULT_HEADER,
         self.domain = domain
         self.locale = locale
         self._header_comment = header_comment
-        self._messages = OrderedDict()
+        self._messages: OrderedDict[str | tuple[str, str], Message] = OrderedDict()
 
         self.project = project or 'PROJECT'
         self.version = version or 'VERSION'
@@ -288,11 +317,12 @@ def __init__(self, locale=None, domain=None, header_comment=DEFAULT_HEADER,
         self.revision_date = revision_date
         self.fuzzy = fuzzy
 
-        self.obsolete = OrderedDict()  # Dictionary of obsolete messages
+        # Dictionary of obsolete messages
+        self.obsolete: OrderedDict[str | tuple[str, str], Message] = OrderedDict()
         self._num_plurals = None
         self._plural_expr = None
 
-    def _set_locale(self, locale):
+    def _set_locale(self, locale: Locale | str | None) -> None:
         if locale is None:
             self._locale_identifier = None
             self._locale = None
@@ -313,16 +343,16 @@ def _set_locale(self, locale):
 
         raise TypeError(f"`locale` must be a Locale, a locale identifier string, or None; got {locale!r}")
 
-    def _get_locale(self):
+    def _get_locale(self) -> Locale | None:
         return self._locale
 
-    def _get_locale_identifier(self):
+    def _get_locale_identifier(self) -> str | None:
         return self._locale_identifier
 
     locale = property(_get_locale, _set_locale)
     locale_identifier = property(_get_locale_identifier)
 
-    def _get_header_comment(self):
+    def _get_header_comment(self) -> str:
         comment = self._header_comment
         year = datetime.now(LOCALTZ).strftime('%Y')
         if hasattr(self.revision_date, 'strftime'):
@@ -336,7 +366,7 @@ def _get_header_comment(self):
             comment = comment.replace("Translations template", f"{locale_name} translations")
         return comment
 
-    def _set_header_comment(self, string):
+    def _set_header_comment(self, string: str | None) -> None:
         self._header_comment = string
 
     header_comment = property(_get_header_comment, _set_header_comment, doc="""\
@@ -372,8 +402,8 @@ def _set_header_comment(self, string):
     :type: `unicode`
     """)
 
-    def _get_mime_headers(self):
-        headers = []
+    def _get_mime_headers(self) -> list[tuple[str, str]]:
+        headers: list[tuple[str, str]] = []
         headers.append(("Project-Id-Version", f"{self.project} {self.version}"))
         headers.append(('Report-Msgid-Bugs-To', self.msgid_bugs_address))
         headers.append(('POT-Creation-Date',
@@ -402,14 +432,14 @@ def _get_mime_headers(self):
         headers.append(("Generated-By", f"Babel {VERSION}\n"))
         return headers
 
-    def _force_text(self, s, encoding='utf-8', errors='strict'):
+    def _force_text(self, s: str | bytes, encoding: str = 'utf-8', errors: str = 'strict') -> str:
         if isinstance(s, str):
             return s
         if isinstance(s, bytes):
             return s.decode(encoding, errors)
         return str(s)
 
-    def _set_mime_headers(self, headers):
+    def _set_mime_headers(self, headers: Iterable[tuple[str, str]]) -> None:
         for name, value in headers:
             name = self._force_text(name.lower(), encoding=self.charset)
             value = self._force_text(value, encoding=self.charset)
@@ -493,7 +523,7 @@ def _set_mime_headers(self, headers):
     """)
 
     @property
-    def num_plurals(self):
+    def num_plurals(self) -> int:
         """The number of plurals used by the catalog or locale.
 
         >>> Catalog(locale='en').num_plurals
@@ -510,7 +540,7 @@ def num_plurals(self):
         return self._num_plurals
 
     @property
-    def plural_expr(self):
+    def plural_expr(self) -> str:
         """The plural expression used by the catalog or locale.
 
         >>> Catalog(locale='en').plural_expr
@@ -529,7 +559,7 @@ def plural_expr(self):
         return self._plural_expr
 
     @property
-    def plural_forms(self):
+    def plural_forms(self) -> str:
         """Return the plural forms declaration for the locale.
 
         >>> Catalog(locale='en').plural_forms
@@ -540,17 +570,17 @@ def plural_forms(self):
         :type: `str`"""
         return f"nplurals={self.num_plurals}; plural={self.plural_expr};"
 
-    def __contains__(self, id):
+    def __contains__(self, id: _MessageID) -> bool:
         """Return whether the catalog has a message with the specified ID."""
         return self._key_for(id) in self._messages
 
-    def __len__(self):
+    def __len__(self) -> int:
         """The number of messages in the catalog.
 
         This does not include the special ``msgid ""`` entry."""
         return len(self._messages)
 
-    def __iter__(self):
+    def __iter__(self) -> Iterator[Message]:
         """Iterates through all the entries in the catalog, in the order they
         were added, yielding a `Message` object for every entry.
 
@@ -565,24 +595,24 @@ def __iter__(self):
         for key in self._messages:
             yield self._messages[key]
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         locale = ''
         if self.locale:
             locale = f" {self.locale}"
         return f"<{type(self).__name__} {self.domain!r}{locale}>"
 
-    def __delitem__(self, id):
+    def __delitem__(self, id: _MessageID) -> None:
         """Delete the message with the specified ID."""
         self.delete(id)
 
-    def __getitem__(self, id):
+    def __getitem__(self, id: _MessageID) -> Message:
         """Return the message with the specified ID.
 
         :param id: the message ID
         """
         return self.get(id)
 
-    def __setitem__(self, id, message):
+    def __setitem__(self, id: _MessageID, message: Message) -> None:
         """Add or update the message with the specified ID.
 
         >>> catalog = Catalog()
@@ -631,8 +661,18 @@ def __setitem__(self, id, message):
                     f"Expected sequence but got {type(message.string)}"
             self._messages[key] = message
 
-    def add(self, id, string=None, locations=(), flags=(), auto_comments=(),
-            user_comments=(), previous_id=(), lineno=None, context=None):
+    def add(
+        self,
+        id: _MessageID,
+        string: _MessageID | None = None,
+        locations: Iterable[tuple[str, int]] = (),
+        flags: Iterable[str] = (),
+        auto_comments: Iterable[str] = (),
+        user_comments: Iterable[str] = (),
+        previous_id: _MessageID = (),
+        lineno: int | None = None,
+        context: str | None = None,
+    ) -> Message:
         """Add or update the message with the specified ID.
 
         >>> catalog = Catalog()
@@ -664,21 +704,21 @@ def add(self, id, string=None, locations=(), flags=(), auto_comments=(),
         self[id] = message
         return message
 
-    def check(self):
+    def check(self) -> Iterable[tuple[Message, list[TranslationError]]]:
         """Run various validation checks on the translations in the catalog.
 
         For every message which fails validation, this method yield a
         ``(message, errors)`` tuple, where ``message`` is the `Message` object
         and ``errors`` is a sequence of `TranslationError` objects.
 
-        :rtype: ``iterator``
+        :rtype: ``generator`` of ``(message, errors)``
         """
         for message in self._messages.values():
             errors = message.check(catalog=self)
             if errors:
                 yield message, errors
 
-    def get(self, id, context=None):
+    def get(self, id: _MessageID, context: str | None = None) -> Message | None:
         """Return the message with the specified ID and context.
 
         :param id: the message ID
@@ -686,7 +726,7 @@ def get(self, id, context=None):
         """
         return self._messages.get(self._key_for(id, context))
 
-    def delete(self, id, context=None):
+    def delete(self, id: _MessageID, context: str | None = None) -> None:
         """Delete the message with the specified ID and context.
 
         :param id: the message ID
@@ -696,7 +736,12 @@ def delete(self, id, context=None):
         if key in self._messages:
             del self._messages[key]
 
-    def update(self, template, no_fuzzy_matching=False, update_header_comment=False, keep_user_comments=True):
+    def update(self,
+        template: Catalog,
+        no_fuzzy_matching: bool = False,
+        update_header_comment: bool = False,
+        keep_user_comments: bool = True,
+    ) -> None:
         """Update the catalog based on the given template catalog.
 
         >>> from babel.messages import Catalog
@@ -762,19 +807,21 @@ def update(self, template, no_fuzzy_matching=False, update_header_comment=False,
             }
         fuzzy_matches = set()
 
-        def _merge(message, oldkey, newkey):
+        def _merge(message: Message, oldkey: tuple[str, str] | str, newkey: tuple[str, str] | str) -> None:
             message = message.clone()
             fuzzy = False
             if oldkey != newkey:
                 fuzzy = True
                 fuzzy_matches.add(oldkey)
                 oldmsg = messages.get(oldkey)
+                assert oldmsg is not None
                 if isinstance(oldmsg.id, str):
                     message.previous_id = [oldmsg.id]
                 else:
                     message.previous_id = list(oldmsg.id)
             else:
                 oldmsg = remaining.pop(oldkey, None)
+                assert oldmsg is not None
             message.string = oldmsg.string
 
             if keep_user_comments:
@@ -834,7 +881,7 @@ def _merge(message, oldkey, newkey):
         # used to update the catalog
         self.creation_date = template.creation_date
 
-    def _key_for(self, id, context=None):
+    def _key_for(self, id: _MessageID, context: str | None = None) -> tuple[str, str] | str:
         """The key for a message is just the singular ID even for pluralizable
         messages, but is a ``(msgid, msgctxt)`` tuple for context-specific
         messages.
@@ -846,7 +893,7 @@ def _key_for(self, id, context=None):
             key = (key, context)
         return key
 
-    def is_identical(self, other):
+    def is_identical(self, other: Catalog) -> bool:
         """Checks if catalogs are identical, taking into account messages and
         headers.
         """
diff --git a/babel/messages/checkers.py b/babel/messages/checkers.py
index 2706c5bfe..9231c678e 100644
--- a/babel/messages/checkers.py
+++ b/babel/messages/checkers.py
@@ -9,8 +9,11 @@
     :copyright: (c) 2013-2022 by the Babel Team.
     :license: BSD, see LICENSE for more details.
 """
+from __future__ import annotations
 
-from babel.messages.catalog import TranslationError, PYTHON_FORMAT
+from collections.abc import Callable
+
+from babel.messages.catalog import Catalog, Message, TranslationError, PYTHON_FORMAT
 
 
 #: list of format chars that are compatible to each other
@@ -21,7 +24,7 @@
 ]
 
 
-def num_plurals(catalog, message):
+def num_plurals(catalog: Catalog | None, message: Message) -> None:
     """Verify the number of plurals in the translation."""
     if not message.pluralizable:
         if not isinstance(message.string, str):
@@ -41,7 +44,7 @@ def num_plurals(catalog, message):
                                catalog.num_plurals)
 
 
-def python_format(catalog, message):
+def python_format(catalog: Catalog | None, message: Message) -> None:
     """Verify the format string placeholders in the translation."""
     if 'python-format' not in message.flags:
         return
@@ -57,7 +60,7 @@ def python_format(catalog, message):
             _validate_format(msgid, msgstr)
 
 
-def _validate_format(format, alternative):
+def _validate_format(format: str, alternative: str) -> None:
     """Test format string `alternative` against `format`.  `format` can be the
     msgid of a message and `alternative` one of the `msgstr`\\s.  The two
     arguments are not interchangeable as `alternative` may contain less
@@ -89,8 +92,8 @@ def _validate_format(format, alternative):
     :raises TranslationError: on formatting errors
     """
 
-    def _parse(string):
-        result = []
+    def _parse(string: str) -> list[tuple[str, str]]:
+        result: list[tuple[str, str]] = []
         for match in PYTHON_FORMAT.finditer(string):
             name, format, typechar = match.groups()
             if typechar == '%' and name is None:
@@ -98,7 +101,7 @@ def _parse(string):
             result.append((name, str(typechar)))
         return result
 
-    def _compatible(a, b):
+    def _compatible(a: str, b: str) -> bool:
         if a == b:
             return True
         for set in _string_format_compatibilities:
@@ -106,7 +109,7 @@ def _compatible(a, b):
                 return True
         return False
 
-    def _check_positional(results):
+    def _check_positional(results: list[tuple[str, str]]) -> bool:
         positional = None
         for name, char in results:
             if positional is None:
@@ -152,8 +155,8 @@ def _check_positional(results):
                                        (name, typechar, type_map[name]))
 
 
-def _find_checkers():
-    checkers = []
+def _find_checkers() -> list[Callable[[Catalog | None, Message], object]]:
+    checkers: list[Callable[[Catalog | None, Message], object]] = []
     try:
         from pkg_resources import working_set
     except ImportError:
@@ -168,4 +171,4 @@ def _find_checkers():
     return checkers
 
 
-checkers = _find_checkers()
+checkers: list[Callable[[Catalog | None, Message], object]] = _find_checkers()
diff --git a/babel/messages/extract.py b/babel/messages/extract.py
index c19dd5af2..5c331c0a5 100644
--- a/babel/messages/extract.py
+++ b/babel/messages/extract.py
@@ -15,20 +15,58 @@
     :copyright: (c) 2013-2022 by the Babel Team.
     :license: BSD, see LICENSE for more details.
 """
+from __future__ import annotations
+
 import ast
+from collections.abc import Callable, Collection, Generator, Iterable, Mapping, MutableSequence
 import io
 import os
 import sys
 from os.path import relpath
 from tokenize import generate_tokens, COMMENT, NAME, OP, STRING
+from typing import Any, TYPE_CHECKING
 
 from babel.util import parse_encoding, parse_future_flags, pathmatch
 from textwrap import dedent
 
+if TYPE_CHECKING:
+    from typing import IO, Protocol
+    from typing_extensions import Final, TypeAlias, TypedDict
+    from _typeshed import SupportsItems, SupportsRead, SupportsReadline
+
+    class _PyOptions(TypedDict, total=False):
+        encoding: str
+
+    class _JSOptions(TypedDict, total=False):
+        encoding: str
+        jsx: bool
+        template_string: bool
+        parse_template_string: bool
+
+    class _FileObj(SupportsRead[bytes], SupportsReadline[bytes], Protocol):
+        def seek(self, __offset: int, __whence: int = ...) -> int: ...
+        def tell(self) -> int: ...
+
+    _Keyword: TypeAlias = tuple[int | tuple[int, int] | tuple[int, str], ...] | None
+
+    # 5-tuple of (filename, lineno, messages, comments, context)
+    _FileExtractionResult: TypeAlias = tuple[str, int, str | tuple[str, ...], list[str], str | None]
+
+    # 4-tuple of (lineno, message, comments, context)
+    _ExtractionResult: TypeAlias = tuple[int, str | tuple[str, ...], list[str], str | None]
+
+    # Required arguments: fileobj, keywords, comment_tags, options
+    # Return value: Iterable of (lineno, message, comments, context)
+    _CallableExtractionMethod: TypeAlias = Callable[
+        [_FileObj | IO[bytes], Mapping[str, _Keyword], Collection[str], Mapping[str, Any]],
+        Iterable[_ExtractionResult],
+    ]
+
+    _ExtractionMethod: TypeAlias = _CallableExtractionMethod | str
 
-GROUP_NAME = 'babel.extractors'
+GROUP_NAME: Final[str] = 'babel.extractors'
 
-DEFAULT_KEYWORDS = {
+DEFAULT_KEYWORDS: dict[str, _Keyword] = {
     '_': None,
     'gettext': None,
     'ngettext': (1, 2),
@@ -41,15 +79,15 @@
     'npgettext': ((1, 'c'), 2, 3)
 }
 
-DEFAULT_MAPPING = [('**.py', 'python')]
+DEFAULT_MAPPING: list[tuple[str, str]] = [('**.py', 'python')]
 
 
 
-def _strip_comment_tags(comments, tags):
+def _strip_comment_tags(comments: MutableSequence[str], tags: Iterable[str]):
     """Helper function for `extract` that strips comment tags from strings
     in a list of comment lines.  This functions operates in-place.
     """
-    def _strip(line):
+    def _strip(line: str):
         for tag in tags:
             if line.startswith(tag):
                 return line[len(tag):].strip()
@@ -57,22 +95,22 @@ def _strip(line):
     comments[:] = map(_strip, comments)
 
 
-def default_directory_filter(dirpath):
+def default_directory_filter(dirpath: str | os.PathLike[str]) -> bool:
     subdir = os.path.basename(dirpath)
     # Legacy default behavior: ignore dot and underscore directories
     return not (subdir.startswith('.') or subdir.startswith('_'))
 
 
 def extract_from_dir(
-    dirname=None,
-    method_map=DEFAULT_MAPPING,
-    options_map=None,
-    keywords=DEFAULT_KEYWORDS,
-    comment_tags=(),
-    callback=None,
-    strip_comment_tags=False,
-    directory_filter=None,
-):
+    dirname: str | os.PathLike[str] | None = None,
+    method_map: Iterable[tuple[str, str]] = DEFAULT_MAPPING,
+    options_map: SupportsItems[str, dict[str, Any]] | None = None,
+    keywords: Mapping[str, _Keyword] = DEFAULT_KEYWORDS,
+    comment_tags: Collection[str] = (),
+    callback: Callable[[str, str, dict[str, Any]], object] | None = None,
+    strip_comment_tags: bool = False,
+    directory_filter: Callable[[str], bool] | None = None,
+) -> Generator[_FileExtractionResult, None, None]:
     """Extract messages from any source files found in the given directory.
 
     This function generates tuples of the form ``(filename, lineno, message,
@@ -172,9 +210,16 @@ def extract_from_dir(
             )
 
 
-def check_and_call_extract_file(filepath, method_map, options_map,
-                                callback, keywords, comment_tags,
-                                strip_comment_tags, dirpath=None):
+def check_and_call_extract_file(
+    filepath: str | os.PathLike[str],
+    method_map: Iterable[tuple[str, str]],
+    options_map: SupportsItems[str, dict[str, Any]],
+    callback: Callable[[str, str, dict[str, Any]], object] | None,
+    keywords: Mapping[str, _Keyword],
+    comment_tags: Collection[str],
+    strip_comment_tags: bool,
+    dirpath: str | os.PathLike[str] | None = None,
+) -> Generator[_FileExtractionResult, None, None]:
     """Checks if the given file matches an extraction method mapping, and if so, calls extract_from_file.
 
     Note that the extraction method mappings are based relative to dirpath.
@@ -229,8 +274,14 @@ def check_and_call_extract_file(filepath, method_map, options_map,
         break
 
 
-def extract_from_file(method, filename, keywords=DEFAULT_KEYWORDS,
-                      comment_tags=(), options=None, strip_comment_tags=False):
+def extract_from_file(
+    method: _ExtractionMethod,
+    filename: str | os.PathLike[str],
+    keywords: Mapping[str, _Keyword] = DEFAULT_KEYWORDS,
+    comment_tags: Collection[str] = (),
+    options: Mapping[str, Any] | None = None,
+    strip_comment_tags: bool = False,
+) -> list[_ExtractionResult]:
     """Extract messages from a specific file.
 
     This function returns a list of tuples of the form ``(lineno, message, comments, context)``.
@@ -257,8 +308,14 @@ def extract_from_file(method, filename, keywords=DEFAULT_KEYWORDS,
                             options, strip_comment_tags))
 
 
-def extract(method, fileobj, keywords=DEFAULT_KEYWORDS, comment_tags=(),
-            options=None, strip_comment_tags=False):
+def extract(
+    method: _ExtractionMethod,
+    fileobj: _FileObj,
+    keywords: Mapping[str, _Keyword] = DEFAULT_KEYWORDS,
+    comment_tags: Collection[str] = (),
+    options: Mapping[str, Any] | None = None,
+    strip_comment_tags: bool = False,
+) -> Generator[_ExtractionResult, None, None]:
     """Extract messages from the given file-like object using the specified
     extraction method.
 
@@ -391,14 +448,24 @@ def extract(method, fileobj, keywords=DEFAULT_KEYWORDS, comment_tags=(),
         yield lineno, messages, comments, context
 
 
-def extract_nothing(fileobj, keywords, comment_tags, options):
+def extract_nothing(
+    fileobj: _FileObj,
+    keywords: Mapping[str, _Keyword],
+    comment_tags: Collection[str],
+    options: Mapping[str, Any],
+) -> list[_ExtractionResult]:
     """Pseudo extractor that does not actually extract anything, but simply
     returns an empty list.
     """
     return []
 
 
-def extract_python(fileobj, keywords, comment_tags, options):
+def extract_python(
+    fileobj: IO[bytes],
+    keywords: Mapping[str, _Keyword],
+    comment_tags: Collection[str],
+    options: _PyOptions,
+) -> Generator[_ExtractionResult, None, None]:
     """Extract messages from Python source code.
 
     It returns an iterator yielding tuples in the following form ``(lineno,
@@ -511,7 +578,7 @@ def extract_python(fileobj, keywords, comment_tags, options):
             funcname = value
 
 
-def _parse_python_string(value, encoding, future_flags):
+def _parse_python_string(value: str, encoding: str, future_flags: int) -> str | None:
     # Unwrap quotes in a safe manner, maintaining the string's encoding
     # https://sourceforge.net/tracker/?func=detail&atid=355470&aid=617979&group_id=5470
     code = compile(
@@ -533,7 +600,13 @@ def _parse_python_string(value, encoding, future_flags):
     return None
 
 
-def extract_javascript(fileobj, keywords, comment_tags, options, lineno=1):
+def extract_javascript(
+    fileobj: _FileObj,
+    keywords: Mapping[str, _Keyword],
+    comment_tags: Collection[str],
+    options: _JSOptions,
+    lineno: int = 1,
+) -> Generator[_ExtractionResult, None, None]:
     """Extract messages from JavaScript source code.
 
     :param fileobj: the seekable, file-like object the messages should be
@@ -676,7 +749,13 @@ def extract_javascript(fileobj, keywords, comment_tags, options, lineno=1):
         last_token = token
 
 
-def parse_template_string(template_string, keywords, comment_tags, options, lineno=1):
+def parse_template_string(
+    template_string: str,
+    keywords: Mapping[str, _Keyword],
+    comment_tags: Collection[str],
+    options: _JSOptions,
+    lineno: int = 1,
+) -> Generator[_ExtractionResult, None, None]:
     """Parse JavaScript template string.
 
     :param template_string: the template string to be parsed
diff --git a/babel/messages/jslexer.py b/babel/messages/jslexer.py
index 886f69d20..07fffdec7 100644
--- a/babel/messages/jslexer.py
+++ b/babel/messages/jslexer.py
@@ -9,17 +9,21 @@
     :copyright: (c) 2013-2022 by the Babel Team.
     :license: BSD, see LICENSE for more details.
 """
+from __future__ import annotations
+
 from collections import namedtuple
+from collections.abc import Generator, Iterator, Sequence
 import re
+from typing import NamedTuple
 
-operators = sorted([
+operators: list[str] = sorted([
     '+', '-', '*', '%', '!=', '==', '<', '>', '<=', '>=', '=',
     '+=', '-=', '*=', '%=', '<<', '>>', '>>>', '<<=', '>>=',
     '>>>=', '&', '&=', '|', '|=', '&&', '||', '^', '^=', '(', ')',
     '[', ']', '{', '}', '!', '--', '++', '~', ',', ';', '.', ':'
 ], key=len, reverse=True)
 
-escapes = {'b': '\b', 'f': '\f', 'n': '\n', 'r': '\r', 't': '\t'}
+escapes: dict[str, str] = {'b': '\b', 'f': '\f', 'n': '\n', 'r': '\r', 't': '\t'}
 
 name_re = re.compile(r'[\w$_][\w\d$_]*', re.UNICODE)
 dotted_name_re = re.compile(r'[\w$_][\w\d$_.]*[\w\d$_.]', re.UNICODE)
@@ -30,9 +34,12 @@
 uni_escape_re = re.compile(r'[a-fA-F0-9]{1,4}')
 hex_escape_re = re.compile(r'[a-fA-F0-9]{1,2}')
 
-Token = namedtuple('Token', 'type value lineno')
+class Token(NamedTuple):
+    type: str
+    value: str
+    lineno: int
 
-_rules = [
+_rules: list[tuple[str | None, re.Pattern[str]]] = [
     (None, re.compile(r'\s+', re.UNICODE)),
     (None, re.compile(r'<!--.*')),
     ('linecomment', re.compile(r'//.*')),
@@ -55,7 +62,7 @@
 ]
 
 
-def get_rules(jsx, dotted, template_string):
+def get_rules(jsx: bool, dotted: bool, template_string: bool) -> list[tuple[str | None, re.Pattern[str]]]:
     """
     Get a tokenization rule list given the passed syntax options.
 
@@ -75,7 +82,7 @@ def get_rules(jsx, dotted, template_string):
     return rules
 
 
-def indicates_division(token):
+def indicates_division(token: Token) -> bool:
     """A helper function that helps the tokenizer to decide if the current
     token may be followed by a division operator.
     """
@@ -84,7 +91,7 @@ def indicates_division(token):
     return token.type in ('name', 'number', 'string', 'regexp')
 
 
-def unquote_string(string):
+def unquote_string(string: str) -> str:
     """Unquote a string with JavaScript rules.  The string has to start with
     string delimiters (``'``, ``"`` or the back-tick/grave accent (for template strings).)
     """
@@ -151,7 +158,7 @@ def unquote_string(string):
     return u''.join(result)
 
 
-def tokenize(source, jsx=True, dotted=True, template_string=True, lineno=1):
+def tokenize(source: str, jsx: bool = True, dotted: bool = True, template_string: bool = True, lineno: int = 1) -> Generator[Token, None, None]:
     """
     Tokenize JavaScript/JSX source.  Returns a generator of tokens.
 
diff --git a/babel/messages/mofile.py b/babel/messages/mofile.py
index 828457408..a96f0592b 100644
--- a/babel/messages/mofile.py
+++ b/babel/messages/mofile.py
@@ -7,18 +7,22 @@
     :copyright: (c) 2013-2022 by the Babel Team.
     :license: BSD, see LICENSE for more details.
 """
+from __future__ import annotations
 
 import array
 import struct
+from typing import TYPE_CHECKING
 
 from babel.messages.catalog import Catalog, Message
 
+if TYPE_CHECKING:
+    from _typeshed import SupportsRead, SupportsWrite
 
-LE_MAGIC = 0x950412de
-BE_MAGIC = 0xde120495
+LE_MAGIC: int = 0x950412de
+BE_MAGIC: int = 0xde120495
 
 
-def read_mo(fileobj):
+def read_mo(fileobj: SupportsRead[bytes]) -> Catalog:
     """Read a binary MO file from the given file-like object and return a
     corresponding `Catalog` object.
 
@@ -102,7 +106,7 @@ def read_mo(fileobj):
     return catalog
 
 
-def write_mo(fileobj, catalog, use_fuzzy=False):
+def write_mo(fileobj: SupportsWrite[bytes], catalog: Catalog, use_fuzzy: bool = False) -> None:
     """Write a catalog to the specified file-like object using the GNU MO file
     format.
 
diff --git a/babel/messages/plurals.py b/babel/messages/plurals.py
index 8722566dc..0fdf53bb0 100644
--- a/babel/messages/plurals.py
+++ b/babel/messages/plurals.py
@@ -7,6 +7,7 @@
     :copyright: (c) 2013-2022 by the Babel Team.
     :license: BSD, see LICENSE for more details.
 """
+from __future__ import annotations
 
 from babel.core import default_locale, Locale
 from operator import itemgetter
@@ -15,10 +16,10 @@
 # XXX: remove this file, duplication with babel.plural
 
 
-LC_CTYPE = default_locale('LC_CTYPE')
+LC_CTYPE: str | None = default_locale('LC_CTYPE')
 
 
-PLURALS = {
+PLURALS: dict[str, tuple[int, str]] = {
     # Afar
     # 'aa': (),
     # Abkhazian
@@ -201,7 +202,7 @@
 }
 
 
-DEFAULT_PLURAL = (2, '(n != 1)')
+DEFAULT_PLURAL: tuple[int, str] = (2, '(n != 1)')
 
 
 class _PluralTuple(tuple):
@@ -215,11 +216,11 @@ class _PluralTuple(tuple):
     plural_forms = property(lambda x: 'nplurals=%s; plural=%s;' % x, doc="""
     The plural expression used by the catalog or locale.""")
 
-    def __str__(self):
+    def __str__(self) -> str:
         return self.plural_forms
 
 
-def get_plural(locale=LC_CTYPE):
+def get_plural(locale: str | None = LC_CTYPE) -> _PluralTuple:
     """A tuple with the information catalogs need to perform proper
     pluralization.  The first item of the tuple is the number of plural
     forms, the second the plural expression.
diff --git a/babel/messages/pofile.py b/babel/messages/pofile.py
index b366ccb44..b6d0d6ed8 100644
--- a/babel/messages/pofile.py
+++ b/babel/messages/pofile.py
@@ -8,15 +8,24 @@
     :copyright: (c) 2013-2022 by the Babel Team.
     :license: BSD, see LICENSE for more details.
 """
+from __future__ import annotations
 
 import os
 import re
+from collections.abc import Iterable
+from typing import TYPE_CHECKING
+from babel.core import Locale
 
 from babel.messages.catalog import Catalog, Message
 from babel.util import wraptext, _cmp
 
+if TYPE_CHECKING:
+    from _typeshed import SupportsWrite
+    from typing import IO, AnyStr
+    from typing_extensions import Literal
 
-def unescape(string):
+
+def unescape(string: str) -> str:
     r"""Reverse `escape` the given string.
 
     >>> print(unescape('"Say:\\n  \\"hello, world!\\"\\n"'))
@@ -39,7 +48,7 @@ def replace_escapes(match):
     return re.compile(r'\\([\\trn"])').sub(replace_escapes, string[1:-1])
 
 
-def denormalize(string):
+def denormalize(string: str) -> str:
     r"""Reverse the normalization done by the `normalize` function.
 
     >>> print(denormalize(r'''""
@@ -72,7 +81,8 @@ def denormalize(string):
 
 class PoFileError(Exception):
     """Exception thrown by PoParser when an invalid po file is encountered."""
-    def __init__(self, message, catalog, line, lineno):
+
+    def __init__(self, message: str, catalog: Catalog, line: str, lineno: int) -> None:
         super().__init__(f'{message} on {lineno}')
         self.catalog = catalog
         self.line = line
@@ -81,45 +91,45 @@ def __init__(self, message, catalog, line, lineno):
 
 class _NormalizedString:
 
-    def __init__(self, *args):
-        self._strs = []
+    def __init__(self, *args: str) -> None:
+        self._strs: list[str] = []
         for arg in args:
             self.append(arg)
 
-    def append(self, s):
+    def append(self, s: str) -> None:
         self._strs.append(s.strip())
 
-    def denormalize(self):
+    def denormalize(self) -> str:
         return ''.join(map(unescape, self._strs))
 
-    def __bool__(self):
+    def __bool__(self) -> bool:
         return bool(self._strs)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return os.linesep.join(self._strs)
 
-    def __cmp__(self, other):
+    def __cmp__(self, other: object) -> int:
         if not other:
             return 1
 
         return _cmp(str(self), str(other))
 
-    def __gt__(self, other):
+    def __gt__(self, other: object) -> bool:
         return self.__cmp__(other) > 0
 
-    def __lt__(self, other):
+    def __lt__(self, other: object) -> bool:
         return self.__cmp__(other) < 0
 
-    def __ge__(self, other):
+    def __ge__(self, other: object) -> bool:
         return self.__cmp__(other) >= 0
 
-    def __le__(self, other):
+    def __le__(self, other: object) -> bool:
         return self.__cmp__(other) <= 0
 
-    def __eq__(self, other):
+    def __eq__(self, other: object) -> bool:
         return self.__cmp__(other) == 0
 
-    def __ne__(self, other):
+    def __ne__(self, other: object) -> bool:
         return self.__cmp__(other) != 0
 
 
@@ -138,7 +148,7 @@ class PoFileParser:
         'msgid_plural',
     ]
 
-    def __init__(self, catalog, ignore_obsolete=False, abort_invalid=False):
+    def __init__(self, catalog: Catalog, ignore_obsolete: bool = False, abort_invalid: bool = False) -> None:
         self.catalog = catalog
         self.ignore_obsolete = ignore_obsolete
         self.counter = 0
@@ -146,7 +156,7 @@ def __init__(self, catalog, ignore_obsolete=False, abort_invalid=False):
         self.abort_invalid = abort_invalid
         self._reset_message_state()
 
-    def _reset_message_state(self):
+    def _reset_message_state(self) -> None:
         self.messages = []
         self.translations = []
         self.locations = []
@@ -159,7 +169,7 @@ def _reset_message_state(self):
         self.in_msgstr = False
         self.in_msgctxt = False
 
-    def _add_message(self):
+    def _add_message(self) -> None:
         """
         Add a message to the catalog based on the current parser state and
         clear the state ready to process the next message.
@@ -194,17 +204,17 @@ def _add_message(self):
         self.counter += 1
         self._reset_message_state()
 
-    def _finish_current_message(self):
+    def _finish_current_message(self) -> None:
         if self.messages:
             self._add_message()
 
-    def _process_message_line(self, lineno, line, obsolete=False):
+    def _process_message_line(self, lineno, line, obsolete=False) -> None:
         if line.startswith('"'):
             self._process_string_continuation_line(line, lineno)
         else:
             self._process_keyword_line(lineno, line, obsolete)
 
-    def _process_keyword_line(self, lineno, line, obsolete=False):
+    def _process_keyword_line(self, lineno, line, obsolete=False) -> None:
 
         for keyword in self._keywords:
             try:
@@ -245,7 +255,7 @@ def _process_keyword_line(self, lineno, line, obsolete=False):
             self.in_msgctxt = True
             self.context = _NormalizedString(arg)
 
-    def _process_string_continuation_line(self, line, lineno):
+    def _process_string_continuation_line(self, line, lineno) -> None:
         if self.in_msgid:
             s = self.messages[-1]
         elif self.in_msgstr:
@@ -257,7 +267,7 @@ def _process_string_continuation_line(self, line, lineno):
             return
         s.append(line)
 
-    def _process_comment(self, line):
+    def _process_comment(self, line) -> None:
 
         self._finish_current_message()
 
@@ -284,7 +294,7 @@ def _process_comment(self, line):
             # These are called user comments
             self.user_comments.append(line[1:].strip())
 
-    def parse(self, fileobj):
+    def parse(self, fileobj: IO[AnyStr]) -> None:
         """
         Reads from the file-like object `fileobj` and adds any po file
         units found in it to the `Catalog` supplied to the constructor.
@@ -313,7 +323,7 @@ def parse(self, fileobj):
             self.translations.append([0, _NormalizedString(u'""')])
             self._add_message()
 
-    def _invalid_pofile(self, line, lineno, msg):
+    def _invalid_pofile(self, line, lineno, msg) -> None:
         assert isinstance(line, str)
         if self.abort_invalid:
             raise PoFileError(msg, self.catalog, line, lineno)
@@ -321,7 +331,14 @@ def _invalid_pofile(self, line, lineno, msg):
         print(f"WARNING: Problem on line {lineno + 1}: {line!r}")
 
 
-def read_po(fileobj, locale=None, domain=None, ignore_obsolete=False, charset=None, abort_invalid=False):
+def read_po(
+    fileobj: IO[AnyStr],
+    locale: str | Locale | None = None,
+    domain: str | None = None,
+    ignore_obsolete: bool = False,
+    charset: str | None = None,
+    abort_invalid: bool = False,
+) -> Catalog:
     """Read messages from a ``gettext`` PO (portable object) file from the given
     file-like object and return a `Catalog`.
 
@@ -381,7 +398,7 @@ def read_po(fileobj, locale=None, domain=None, ignore_obsolete=False, charset=No
                       ')')
 
 
-def escape(string):
+def escape(string: str) -> str:
     r"""Escape the given string so that it can be included in double-quoted
     strings in ``PO`` files.
 
@@ -399,7 +416,7 @@ def escape(string):
                           .replace('\"', '\\"')
 
 
-def normalize(string, prefix='', width=76):
+def normalize(string: str, prefix: str = '', width: int = 76) -> str:
     r"""Convert a string into a format that is appropriate for .po files.
 
     >>> print(normalize('''Say:
@@ -460,9 +477,18 @@ def normalize(string, prefix='', width=76):
     return u'""\n' + u'\n'.join([(prefix + escape(line)) for line in lines])
 
 
-def write_po(fileobj, catalog, width=76, no_location=False, omit_header=False,
-             sort_output=False, sort_by_file=False, ignore_obsolete=False,
-             include_previous=False, include_lineno=True):
+def write_po(
+    fileobj: SupportsWrite[bytes],
+    catalog: Catalog,
+    width: int = 76,
+    no_location: bool = False,
+    omit_header: bool = False,
+    sort_output: bool = False,
+    sort_by_file: bool = False,
+    ignore_obsolete: bool = False,
+    include_previous: bool = False,
+    include_lineno: bool = True,
+) -> None:
     r"""Write a ``gettext`` PO (portable object) template file for a given
     message catalog to the provided file-like object.
 
@@ -612,7 +638,7 @@ def _write_message(message, prefix=''):
             _write('\n')
 
 
-def _sort_messages(messages, sort_by):
+def _sort_messages(messages: Iterable[Message], sort_by: Literal["message", "location"]) -> list[Message]:
     """
     Sort the given message iterable by the given criteria.
 
diff --git a/babel/numbers.py b/babel/numbers.py
index 94259f841..73155c4cf 100644
--- a/babel/numbers.py
+++ b/babel/numbers.py
@@ -18,13 +18,18 @@
 #  Padding and rounding increments in pattern:
 #  - https://www.unicode.org/reports/tr35/ (Appendix G.6)
 from __future__ import annotations
+
 import decimal
 import re
-from datetime import date as date_, datetime as datetime_
+from typing import TYPE_CHECKING, Any, overload
 import warnings
+from datetime import date as date_, datetime as datetime_
 
-from babel.core import default_locale, Locale, get_global
+from babel.core import Locale, default_locale, get_global
+from babel.localedata import LocaleDataDict
 
+if TYPE_CHECKING:
+    from typing_extensions import Literal
 
 LC_NUMERIC = default_locale('LC_NUMERIC')
 
@@ -33,7 +38,7 @@ class UnknownCurrencyError(Exception):
     """Exception thrown when a currency is requested for which no data is available.
     """
 
-    def __init__(self, identifier):
+    def __init__(self, identifier: str) -> None:
         """Create the exception.
         :param identifier: the identifier string of the unsupported currency
         """
@@ -43,7 +48,7 @@ def __init__(self, identifier):
         self.identifier = identifier
 
 
-def list_currencies(locale=None):
+def list_currencies(locale: Locale | str | None = None) -> set[str]:
     """ Return a `set` of normalized currency codes.
 
     .. versionadded:: 2.5.0
@@ -61,7 +66,7 @@ def list_currencies(locale=None):
     return set(currencies)
 
 
-def validate_currency(currency, locale=None):
+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
@@ -73,7 +78,7 @@ def validate_currency(currency, locale=None):
         raise UnknownCurrencyError(currency)
 
 
-def is_currency(currency, locale=None):
+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.
@@ -87,7 +92,7 @@ def is_currency(currency, locale=None):
     return True
 
 
-def normalize_currency(currency, locale=None):
+def normalize_currency(currency: str, locale: Locale | str | None = None) -> str | None:
     """Returns the normalized sting of any currency code.
 
     Accepts a ``locale`` parameter for fined-grained validation, working as
@@ -102,7 +107,11 @@ def normalize_currency(currency, locale=None):
     return currency
 
 
-def get_currency_name(currency, count=None, locale=LC_NUMERIC):
+def get_currency_name(
+    currency: str,
+    count: float | decimal.Decimal | None = None,
+    locale: Locale | str | None = LC_NUMERIC,
+) -> str:
     """Return the name used by the locale for the specified currency.
 
     >>> get_currency_name('USD', locale='en_US')
@@ -128,7 +137,7 @@ def get_currency_name(currency, count=None, locale=LC_NUMERIC):
     return loc.currencies.get(currency, currency)
 
 
-def get_currency_symbol(currency, locale=LC_NUMERIC):
+def get_currency_symbol(currency: str, locale: Locale | str | None = LC_NUMERIC) -> str:
     """Return the symbol used by the locale for the specified currency.
 
     >>> get_currency_symbol('USD', locale='en_US')
@@ -140,7 +149,7 @@ def get_currency_symbol(currency, locale=LC_NUMERIC):
     return Locale.parse(locale).currency_symbols.get(currency, currency)
 
 
-def get_currency_precision(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
@@ -154,7 +163,11 @@ def get_currency_precision(currency):
     return precisions.get(currency, precisions['DEFAULT'])[0]
 
 
-def get_currency_unit_pattern(currency, count=None, locale=LC_NUMERIC):
+def get_currency_unit_pattern(
+    currency: str,
+    count: float | decimal.Decimal | None = None,
+    locale: Locale | str | None = LC_NUMERIC,
+) -> str:
     """
     Return the unit pattern used for long display of a currency value
     for a given locale.
@@ -184,9 +197,38 @@ def get_currency_unit_pattern(currency, count=None, locale=LC_NUMERIC):
     return loc._data['currency_unit_patterns']['other']
 
 
-def get_territory_currencies(territory, start_date=None, end_date=None,
-                             tender=True, non_tender=False,
-                             include_details=False):
+@overload
+def get_territory_currencies(
+    territory: str,
+    start_date: date_ | None = ...,
+    end_date: 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: date_ | None = ...,
+    end_date: 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: date_ | None = None,
+    end_date: 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
@@ -274,7 +316,7 @@ def _is_active(start, end):
     return result
 
 
-def get_decimal_symbol(locale=LC_NUMERIC):
+def get_decimal_symbol(locale: Locale | str | None = LC_NUMERIC) -> str:
     """Return the symbol used by the locale to separate decimal fractions.
 
     >>> get_decimal_symbol('en_US')
@@ -285,7 +327,7 @@ def get_decimal_symbol(locale=LC_NUMERIC):
     return Locale.parse(locale).number_symbols.get('decimal', u'.')
 
 
-def get_plus_sign_symbol(locale=LC_NUMERIC):
+def get_plus_sign_symbol(locale: Locale | str | None = LC_NUMERIC) -> str:
     """Return the plus sign symbol used by the current locale.
 
     >>> get_plus_sign_symbol('en_US')
@@ -296,7 +338,7 @@ def get_plus_sign_symbol(locale=LC_NUMERIC):
     return Locale.parse(locale).number_symbols.get('plusSign', u'+')
 
 
-def get_minus_sign_symbol(locale=LC_NUMERIC):
+def get_minus_sign_symbol(locale: Locale | str | None = LC_NUMERIC) -> str:
     """Return the plus sign symbol used by the current locale.
 
     >>> get_minus_sign_symbol('en_US')
@@ -307,7 +349,7 @@ def get_minus_sign_symbol(locale=LC_NUMERIC):
     return Locale.parse(locale).number_symbols.get('minusSign', u'-')
 
 
-def get_exponential_symbol(locale=LC_NUMERIC):
+def get_exponential_symbol(locale: Locale | str | None = LC_NUMERIC) -> str:
     """Return the symbol used by the locale to separate mantissa and exponent.
 
     >>> get_exponential_symbol('en_US')
@@ -318,7 +360,7 @@ def get_exponential_symbol(locale=LC_NUMERIC):
     return Locale.parse(locale).number_symbols.get('exponential', u'E')
 
 
-def get_group_symbol(locale=LC_NUMERIC):
+def get_group_symbol(locale: Locale | str | None = LC_NUMERIC) -> str:
     """Return the symbol used by the locale to separate groups of thousands.
 
     >>> get_group_symbol('en_US')
@@ -329,7 +371,7 @@ def get_group_symbol(locale=LC_NUMERIC):
     return Locale.parse(locale).number_symbols.get('group', u',')
 
 
-def format_number(number, locale=LC_NUMERIC):
+def format_number(number: float | decimal.Decimal | str, locale: Locale | str | None = LC_NUMERIC) -> str:
     u"""Return the given number formatted for a specific locale.
 
     >>> format_number(1099, locale='en_US')  # doctest: +SKIP
@@ -350,7 +392,7 @@ def format_number(number, locale=LC_NUMERIC):
     return format_decimal(number, locale=locale)
 
 
-def get_decimal_precision(number):
+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.
@@ -363,14 +405,19 @@ def get_decimal_precision(number):
     return abs(decimal_tuple.exponent)
 
 
-def get_decimal_quantum(precision):
+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, format=None, locale=LC_NUMERIC, decimal_quantization=True, group_separator=True):
+    number: float | decimal.Decimal | str,
+    format: str | None = None,
+    locale: Locale | str | None = LC_NUMERIC,
+    decimal_quantization: bool = True,
+    group_separator: bool = True,
+) -> str:
     u"""Return the given decimal number formatted for a specific locale.
 
     >>> format_decimal(1.2345, locale='en_US')
@@ -419,7 +466,13 @@ def format_decimal(
         number, locale, decimal_quantization=decimal_quantization, group_separator=group_separator)
 
 
-def format_compact_decimal(number, *, format_type="short", locale=LC_NUMERIC, fraction_digits=0):
+def format_compact_decimal(
+    number: float | decimal.Decimal | str,
+    *,
+    format_type: Literal["short", "long"] = "short",
+    locale: Locale | str | None = LC_NUMERIC,
+    fraction_digits: int = 0,
+) -> str:
     u"""Return the given decimal number formatted for a specific locale in compact form.
 
     >>> format_compact_decimal(12345, format_type="short", locale='en_US')
@@ -450,7 +503,12 @@ def format_compact_decimal(number, *, format_type="short", locale=LC_NUMERIC, fr
     return pattern.apply(number, locale, decimal_quantization=False)
 
 
-def _get_compact_format(number, compact_format, locale, fraction_digits=0):
+def _get_compact_format(
+    number: float | decimal.Decimal | str,
+    compact_format: LocaleDataDict,
+    locale: Locale | str | None,
+    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.
@@ -488,8 +546,15 @@ class UnknownCurrencyFormatError(KeyError):
 
 
 def format_currency(
-        number, currency, format=None, locale=LC_NUMERIC, currency_digits=True,
-        format_type='standard', decimal_quantization=True, group_separator=True):
+    number: float | decimal.Decimal | str,
+    currency: str,
+    format: str | None = None,
+    locale: Locale | str | None = LC_NUMERIC,
+    currency_digits: bool = True,
+    format_type: Literal["name", "standard", "accounting"] = "standard",
+    decimal_quantization: bool = True,
+    group_separator: bool = True,
+) -> str:
     u"""Return formatted currency value.
 
     >>> format_currency(1099.98, 'USD', locale='en_US')
@@ -596,8 +661,15 @@ def format_currency(
 
 
 def _format_currency_long_name(
-        number, currency, format=None, locale=LC_NUMERIC, currency_digits=True,
-        format_type='standard', decimal_quantization=True, group_separator=True):
+    number: float | decimal.Decimal | str,
+    currency: str,
+    format: str | None = None,
+    locale: Locale | str | None = LC_NUMERIC,
+    currency_digits: bool = True,
+    format_type: Literal["name", "standard", "accounting"] = "standard",
+    decimal_quantization: bool = True,
+    group_separator: bool = True,
+) -> str:
     # Algorithm described here:
     # https://www.unicode.org/reports/tr35/tr35-numbers.html#Currencies
     locale = Locale.parse(locale)
@@ -631,7 +703,14 @@ def _format_currency_long_name(
     return unit_pattern.format(number_part, display_name)
 
 
-def format_compact_currency(number, currency, *, format_type="short", locale=LC_NUMERIC, fraction_digits=0):
+def format_compact_currency(
+    number: float | decimal.Decimal | str,
+    currency: str,
+    *,
+    format_type: Literal["short"] = "short",
+    locale: Locale | str | None = LC_NUMERIC,
+    fraction_digits: int = 0
+) -> str:
     u"""Format a number as a currency value in compact form.
 
     >>> format_compact_currency(12345, 'USD', locale='en_US')
@@ -670,7 +749,12 @@ def format_compact_currency(number, currency, *, format_type="short", locale=LC_
 
 
 def format_percent(
-        number, format=None, locale=LC_NUMERIC, decimal_quantization=True, group_separator=True):
+    number: float | decimal.Decimal | str,
+    format: str | None = None,
+    locale: Locale | str | None = LC_NUMERIC,
+    decimal_quantization: bool = True,
+    group_separator: bool = True,
+) -> str:
     """Return formatted percent value for a specific locale.
 
     >>> format_percent(0.34, locale='en_US')
@@ -717,7 +801,11 @@ def format_percent(
 
 
 def format_scientific(
-        number, format=None, locale=LC_NUMERIC, decimal_quantization=True):
+        number: float | decimal.Decimal | str,
+        format: str | None = None,
+        locale: Locale | str | None = LC_NUMERIC,
+        decimal_quantization: bool = True,
+) -> str:
     """Return value formatted in scientific notation for a specific locale.
 
     >>> format_scientific(10000, locale='en_US')
@@ -754,13 +842,13 @@ def format_scientific(
 class NumberFormatError(ValueError):
     """Exception raised when a string cannot be parsed into a number."""
 
-    def __init__(self, message, suggestions=None):
+    def __init__(self, message: str, suggestions: str | None = None) -> None:
         super().__init__(message)
         #: a list of properly formatted numbers derived from the invalid input
         self.suggestions = suggestions
 
 
-def parse_number(string, locale=LC_NUMERIC):
+def parse_number(string: str, locale: Locale | str | None = LC_NUMERIC) -> int:
     """Parse localized number string into an integer.
 
     >>> parse_number('1,099', locale='en_US')
@@ -786,7 +874,7 @@ def parse_number(string, locale=LC_NUMERIC):
         raise NumberFormatError(f"{string!r} is not a valid number")
 
 
-def parse_decimal(string, locale=LC_NUMERIC, strict=False):
+def parse_decimal(string: str, locale: Locale | str | None = LC_NUMERIC, strict: bool = False) -> decimal.Decimal:
     """Parse localized decimal string into a decimal.
 
     >>> parse_decimal('1,099.98', locale='en_US')
@@ -879,7 +967,7 @@ def parse_decimal(string, locale=LC_NUMERIC, strict=False):
 number_re = re.compile(f"{PREFIX_PATTERN}{NUMBER_PATTERN}{SUFFIX_PATTERN}")
 
 
-def parse_grouping(p):
+def parse_grouping(p: str) -> tuple[int, int]:
     """Parse primary and secondary digit grouping
 
     >>> parse_grouping('##')
@@ -901,7 +989,7 @@ def parse_grouping(p):
     return g1, g2
 
 
-def parse_pattern(pattern):
+def parse_pattern(pattern: NumberPattern | str) -> NumberPattern:
     """Parse number format patterns"""
     if isinstance(pattern, NumberPattern):
         return pattern
@@ -970,9 +1058,18 @@ def parse_precision(p):
 
 class NumberPattern:
 
-    def __init__(self, pattern, prefix, suffix, grouping,
-                 int_prec, frac_prec, exp_prec, exp_plus,
-                 number_pattern: str | None = None):
+    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
@@ -985,10 +1082,10 @@ def __init__(self, pattern, prefix, suffix, grouping,
         self.exp_plus = exp_plus
         self.scale = self.compute_scale()
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f"<{type(self).__name__} {self.pattern!r}>"
 
-    def compute_scale(self):
+    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
@@ -1002,7 +1099,7 @@ def compute_scale(self):
             scale = 3
         return scale
 
-    def scientific_notation_elements(self, value, locale):
+    def scientific_notation_elements(self, value: decimal.Decimal, locale: Locale | str | None) -> tuple[decimal.Decimal, int, str]:
         """ Returns normalized scientific notation components of a value.
         """
         # Normalize value to only have one lead digit.
@@ -1031,13 +1128,13 @@ def scientific_notation_elements(self, value, locale):
 
     def apply(
         self,
-        value,
-        locale,
-        currency=None,
-        currency_digits=True,
-        decimal_quantization=True,
-        force_frac=None,
-        group_separator=True,
+        value: float | decimal.Decimal,
+        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,
     ):
         """Renders into a string a number following the defined pattern.
 
@@ -1157,7 +1254,7 @@ def apply(
     #   - Restore the original position of the decimal point, potentially
     #     padding with zeroes on either side
     #
-    def _format_significant(self, value, minimum, maximum):
+    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)))
@@ -1176,7 +1273,7 @@ def _format_significant(self, value, minimum, maximum):
             ).rstrip('.')
         return result
 
-    def _format_int(self, value, min, max, locale):
+    def _format_int(self, value: str, min: int, max: int, locale: Locale | str | None) -> str:
         width = len(value)
         if width < min:
             value = '0' * (min - width) + value
@@ -1189,7 +1286,7 @@ def _format_int(self, value, min, max, locale):
             gsize = self.grouping[1]
         return value + ret
 
-    def _quantize_value(self, value, locale, frac_prec, group_separator):
+    def _quantize_value(self, value: decimal.Decimal, locale: Locale | str | None, frac_prec: tuple[int, int], group_separator: bool) -> str:
         quantum = get_decimal_quantum(frac_prec[1])
         rounded = value.quantize(quantum)
         a, sep, b = f"{rounded:f}".partition(".")
@@ -1199,7 +1296,7 @@ def _quantize_value(self, value, locale, frac_prec, group_separator):
         number = integer_part + self._format_frac(b or '0', locale, frac_prec)
         return number
 
-    def _format_frac(self, value, locale, force_frac=None):
+    def _format_frac(self, value: str, locale: Locale | str | None, force_frac: tuple[int, int] | None = None) -> str:
         min, max = force_frac or self.frac_prec
         if len(value) < min:
             value += ('0' * (min - len(value)))
diff --git a/babel/plural.py b/babel/plural.py
index 712acec6b..efd0f1f6a 100644
--- a/babel/plural.py
+++ b/babel/plural.py
@@ -7,15 +7,21 @@
     :copyright: (c) 2013-2022 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 TYPE_CHECKING, Any, Callable
 
+if TYPE_CHECKING:
+    from typing_extensions import Literal
 
 _plural_tags = ('zero', 'one', 'two', 'few', 'many', 'other')
 _fallback_tag = 'other'
 
 
-def extract_operands(source):
+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 a 8-tuple (n, i, v, w, f, t, c, e), where those symbols are as follows:
@@ -97,7 +103,7 @@ class PluralRule:
 
     __slots__ = ('abstract', '_func')
 
-    def __init__(self, rules):
+    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
@@ -105,10 +111,10 @@ def __init__(self, rules):
                       and expressions as values.
         :raise RuleError: if the expression is malformed
         """
-        if isinstance(rules, dict):
+        if isinstance(rules, Mapping):
             rules = rules.items()
         found = set()
-        self.abstract = []
+        self.abstract: list[tuple[str, Any]] = []
         for key, expr in sorted(list(rules)):
             if key not in _plural_tags:
                 raise ValueError(f"unknown tag {key!r}")
@@ -119,25 +125,25 @@ def __init__(self, rules):
             if ast:
                 self.abstract.append((key, ast))
 
-    def __repr__(self):
+    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):
+    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, cls):
+        if isinstance(rules, PluralRule):
             return rules
         return cls(rules)
 
     @property
-    def rules(self):
+    def rules(self) -> Mapping[str, str]:
         """The `PluralRule` as a dict of unicode plural rules.
 
         >>> rule = PluralRule({'one': 'n is 1'})
@@ -147,24 +153,27 @@ def rules(self):
         _compile = _UnicodeCompiler().compile
         return {tag: _compile(ast) for tag, ast in self.abstract}
 
-    tags = property(lambda x: frozenset(i[0] for i in x.abstract), doc="""
-        A set of explicitly defined tags in this rule.  The implicit default
+    @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.""")
+        rule for it.
+        """
+        return frozenset(i[0] for i in self.abstract)
 
-    def __getstate__(self):
+    def __getstate__(self) -> list[tuple[str, Any]]:
         return self.abstract
 
-    def __setstate__(self, abstract):
+    def __setstate__(self, abstract: list[tuple[str, Any]]) -> None:
         self.abstract = abstract
 
-    def __call__(self, n):
+    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):
+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:
 
@@ -187,7 +196,7 @@ def to_javascript(rule):
     return ''.join(result)
 
 
-def to_python(rule):
+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:
@@ -227,7 +236,7 @@ def to_python(rule):
     return namespace['evaluate']
 
 
-def to_gettext(rule):
+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.
 
@@ -250,7 +259,7 @@ def to_gettext(rule):
     return ''.join(result)
 
 
-def in_range_list(num, range_list):
+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:
 
@@ -270,7 +279,7 @@ def in_range_list(num, range_list):
     return num == int(num) and within_range_list(num, range_list)
 
 
-def 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:
 
@@ -290,7 +299,7 @@ def within_range_list(num, range_list):
     return any(num >= min_ and num <= max_ for min_, max_ in range_list)
 
 
-def cldr_modulo(a, b):
+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:
 
@@ -327,7 +336,7 @@ class RuleError(Exception):
     'e',  # currently, synonym for ‘c’. however, may be redefined in the future.
 }
 
-_RULES = [
+_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+')),
@@ -336,9 +345,9 @@ class RuleError(Exception):
 ]
 
 
-def tokenize_rule(s):
+def tokenize_rule(s: str) -> list[tuple[str, str]]:
     s = s.split('@')[0]
-    result = []
+    result: list[tuple[str, str]] = []
     pos = 0
     end = len(s)
     while pos < end:
@@ -354,30 +363,35 @@ def tokenize_rule(s):
                             'Got unexpected %r' % s[pos])
     return result[::-1]
 
-
-def test_next_token(tokens, type_, value=None):
+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, type_, value=None):
+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):
+def value_node(value: int) -> tuple[Literal['value'], tuple[int]]:
     return 'value', (value, )
 
 
-def ident_node(name):
+def ident_node(name: str) -> tuple[str, tuple[()]]:
     return name, ()
 
 
-def range_list_node(range_list):
+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):
+def negate(rv: tuple[Any, ...]) -> tuple[Literal['not'], tuple[tuple[Any, ...]]]:
     return 'not', (rv,)
 
 
diff --git a/babel/py.typed b/babel/py.typed
new file mode 100644
index 000000000..d3245e747
--- /dev/null
+++ b/babel/py.typed
@@ -0,0 +1 @@
+# Marker file for PEP 561. This package uses inline types.
diff --git a/babel/support.py b/babel/support.py
index 8cebd7d97..7a6eaa23a 100644
--- a/babel/support.py
+++ b/babel/support.py
@@ -10,16 +10,29 @@
     :copyright: (c) 2013-2022 by the Babel Team.
     :license: BSD, see LICENSE for more details.
 """
+from __future__ import annotations
 
+import decimal
 import gettext
 import locale
+import os
+from collections.abc import Iterator
+from datetime import date as _date, datetime as _datetime, time as _time, timedelta as _timedelta
+from typing import TYPE_CHECKING, Any, Callable
+
+from pytz import BaseTzInfo
 
 from babel.core import Locale
-from babel.dates import format_date, format_datetime, format_time, \
-    format_timedelta
-from babel.numbers import format_decimal, format_currency, format_compact_currency, \
-    format_percent, format_scientific, format_compact_decimal
+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:
+    from typing_extensions import Literal
 
+    from babel.dates import _PredefinedTimeFormat
 
 class Format:
     """Wrapper class providing the various date and number formatting functions
@@ -34,7 +47,7 @@ class Format:
     u'1.234'
     """
 
-    def __init__(self, locale, tzinfo=None):
+    def __init__(self, locale: Locale | str, tzinfo: BaseTzInfo | None = None) -> None:
         """Initialize the formatter.
 
         :param locale: the locale identifier or `Locale` instance
@@ -43,7 +56,7 @@ def __init__(self, locale, tzinfo=None):
         self.locale = Locale.parse(locale)
         self.tzinfo = tzinfo
 
-    def date(self, date=None, format='medium'):
+    def date(self, date: _date | None = None, format: _PredefinedTimeFormat | str = 'medium') -> str:
         """Return a date formatted according to the given pattern.
 
         >>> from datetime import date
@@ -53,7 +66,7 @@ def date(self, date=None, format='medium'):
         """
         return format_date(date, format, locale=self.locale)
 
-    def datetime(self, datetime=None, format='medium'):
+    def datetime(self, datetime: _date | None = None, format: _PredefinedTimeFormat | str = 'medium') -> str:
         """Return a date and time formatted according to the given pattern.
 
         >>> from datetime import datetime
@@ -65,7 +78,7 @@ def datetime(self, datetime=None, format='medium'):
         return format_datetime(datetime, format, tzinfo=self.tzinfo,
                                locale=self.locale)
 
-    def time(self, time=None, format='medium'):
+    def time(self, time: _time | _datetime | None = None, format: _PredefinedTimeFormat | str = 'medium') -> str:
         """Return a time formatted according to the given pattern.
 
         >>> from datetime import datetime
@@ -76,8 +89,14 @@ def time(self, time=None, format='medium'):
         """
         return format_time(time, format, tzinfo=self.tzinfo, locale=self.locale)
 
-    def timedelta(self, delta, granularity='second', threshold=.85,
-                  format='long', add_direction=False):
+    def timedelta(
+        self,
+        delta: _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
@@ -90,7 +109,7 @@ def timedelta(self, delta, granularity='second', threshold=.85,
                                 format=format, add_direction=add_direction,
                                 locale=self.locale)
 
-    def number(self, number):
+    def number(self, number: float | decimal.Decimal | str) -> str:
         """Return an integer number formatted for the locale.
 
         >>> fmt = Format('en_US')
@@ -99,7 +118,7 @@ def number(self, number):
         """
         return format_decimal(number, locale=self.locale)
 
-    def decimal(self, number, format=None):
+    def decimal(self, number: float | decimal.Decimal | str, format: str | None = None) -> str:
         """Return a decimal number formatted for the locale.
 
         >>> fmt = Format('en_US')
@@ -108,7 +127,12 @@ def decimal(self, number, format=None):
         """
         return format_decimal(number, format, locale=self.locale)
 
-    def compact_decimal(self, number, format_type='short', fraction_digits=0):
+    def compact_decimal(
+        self,
+        number: float | decimal.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')
@@ -119,19 +143,25 @@ def compact_decimal(self, number, format_type='short', fraction_digits=0):
                                       fraction_digits=fraction_digits,
                                       locale=self.locale)
 
-    def currency(self, number, currency):
+    def currency(self, number: float | decimal.Decimal | str, currency: str) -> str:
         """Return a number in the given currency formatted for the locale.
         """
         return format_currency(number, currency, locale=self.locale)
 
-    def compact_currency(self, number, currency, format_type='short', fraction_digits=0):
+    def compact_currency(
+        self,
+        number: float | decimal.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.
         """
         return format_compact_currency(number, currency, format_type=format_type,
                                         fraction_digits=fraction_digits, locale=self.locale)
 
-    def percent(self, number, format=None):
+    def percent(self, number: float | decimal.Decimal | str, format: str | None = None) -> str:
         """Return a number formatted as percentage for the locale.
 
         >>> fmt = Format('en_US')
@@ -140,7 +170,7 @@ def percent(self, number, format=None):
         """
         return format_percent(number, format, locale=self.locale)
 
-    def scientific(self, number):
+    def scientific(self, number: float | decimal.Decimal | str) -> str:
         """Return a number formatted using scientific notation for the locale.
         """
         return format_scientific(number, locale=self.locale)
@@ -183,18 +213,25 @@ class LazyProxy:
     """
     __slots__ = ['_func', '_args', '_kwargs', '_value', '_is_cache_enabled', '_attribute_error']
 
-    def __init__(self, func, *args, **kwargs):
-        is_cache_enabled = kwargs.pop('enable_cache', True)
+    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', is_cache_enabled)
+        object.__setattr__(self, '_is_cache_enabled', enable_cache)
         object.__setattr__(self, '_value', None)
         object.__setattr__(self, '_attribute_error', None)
 
     @property
-    def value(self):
+    def value(self) -> Any:
         if self._value is None:
             try:
                 value = self._func(*self._args, **self._kwargs)
@@ -207,84 +244,84 @@ def value(self):
             object.__setattr__(self, '_value', value)
         return self._value
 
-    def __contains__(self, key):
+    def __contains__(self, key: object) -> bool:
         return key in self.value
 
-    def __bool__(self):
+    def __bool__(self) -> bool:
         return bool(self.value)
 
-    def __dir__(self):
+    def __dir__(self) -> list[str]:
         return dir(self.value)
 
-    def __iter__(self):
+    def __iter__(self) -> Iterator[Any]:
         return iter(self.value)
 
-    def __len__(self):
+    def __len__(self) -> int:
         return len(self.value)
 
-    def __str__(self):
+    def __str__(self) -> str:
         return str(self.value)
 
-    def __add__(self, other):
+    def __add__(self, other: object) -> Any:
         return self.value + other
 
-    def __radd__(self, other):
+    def __radd__(self, other: object) -> Any:
         return other + self.value
 
-    def __mod__(self, other):
+    def __mod__(self, other: object) -> Any:
         return self.value % other
 
-    def __rmod__(self, other):
+    def __rmod__(self, other: object) -> Any:
         return other % self.value
 
-    def __mul__(self, other):
+    def __mul__(self, other: object) -> Any:
         return self.value * other
 
-    def __rmul__(self, other):
+    def __rmul__(self, other: object) -> Any:
         return other * self.value
 
-    def __call__(self, *args, **kwargs):
+    def __call__(self, *args: Any, **kwargs: Any) -> Any:
         return self.value(*args, **kwargs)
 
-    def __lt__(self, other):
+    def __lt__(self, other: object) -> bool:
         return self.value < other
 
-    def __le__(self, other):
+    def __le__(self, other: object) -> bool:
         return self.value <= other
 
-    def __eq__(self, other):
+    def __eq__(self, other: object) -> bool:
         return self.value == other
 
-    def __ne__(self, other):
+    def __ne__(self, other: object) -> bool:
         return self.value != other
 
-    def __gt__(self, other):
+    def __gt__(self, other: object) -> bool:
         return self.value > other
 
-    def __ge__(self, other):
+    def __ge__(self, other: object) -> bool:
         return self.value >= other
 
-    def __delattr__(self, name):
+    def __delattr__(self, name: str) -> None:
         delattr(self.value, name)
 
-    def __getattr__(self, 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, value):
+    def __setattr__(self, name: str, value: Any) -> None:
         setattr(self.value, name, value)
 
-    def __delitem__(self, key):
+    def __delitem__(self, key: Any) -> None:
         del self.value[key]
 
-    def __getitem__(self, key):
+    def __getitem__(self, key: Any) -> Any:
         return self.value[key]
 
-    def __setitem__(self, key, value):
+    def __setitem__(self, key: Any, value: Any) -> None:
         self.value[key] = value
 
-    def __copy__(self):
+    def __copy__(self) -> LazyProxy:
         return LazyProxy(
             self._func,
             enable_cache=self._is_cache_enabled,
@@ -292,7 +329,7 @@ def __copy__(self):
             **self._kwargs
         )
 
-    def __deepcopy__(self, memo):
+    def __deepcopy__(self, memo: Any) -> LazyProxy:
         from copy import deepcopy
         return LazyProxy(
             deepcopy(self._func, memo),
@@ -304,9 +341,13 @@ def __deepcopy__(self, memo):
 
 class NullTranslations(gettext.NullTranslations):
 
+    if TYPE_CHECKING:
+        _info: dict[str, str]
+        _fallback: NullTranslations | None
+
     DEFAULT_DOMAIN = None
 
-    def __init__(self, fp=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()').
@@ -316,20 +357,20 @@ def __init__(self, fp=None):
         # 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 = {}
-        self.plural = lambda n: int(n != 1)
+        self._catalog: dict[tuple[str, Any] | str, str] = {}
+        self.plural: Callable[[float | decimal.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 = {}
+        self._domains: dict[str, NullTranslations] = {}
 
-    def dgettext(self, domain, message):
+    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, message):
+    def ldgettext(self, domain: str, message: str) -> str:
         """Like ``lgettext()``, but look the message up in the specified
         domain.
         """
@@ -338,7 +379,7 @@ def ldgettext(self, domain, message):
                       DeprecationWarning, 2)
         return self._domains.get(domain, self).lgettext(message)
 
-    def udgettext(self, domain, message):
+    def udgettext(self, domain: str, message: str) -> str:
         """Like ``ugettext()``, but look the message up in the specified
         domain.
         """
@@ -346,13 +387,13 @@ def udgettext(self, domain, message):
     # backward compatibility with 0.9
     dugettext = udgettext
 
-    def dngettext(self, domain, singular, plural, num):
+    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, 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.
         """
@@ -361,7 +402,7 @@ def ldngettext(self, domain, singular, plural, num):
                       DeprecationWarning, 2)
         return self._domains.get(domain, self).lngettext(singular, plural, num)
 
-    def udngettext(self, domain, 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.
         """
@@ -376,7 +417,7 @@ def udngettext(self, domain, singular, plural, num):
     # msgctxt + "\x04" + msgid (gettext version >= 0.15)
     CONTEXT_ENCODING = '%s\x04%s'
 
-    def pgettext(self, context, message):
+    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
@@ -393,7 +434,7 @@ def pgettext(self, context, message):
             return message
         return tmsg
 
-    def lpgettext(self, context, 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()``.
@@ -403,9 +444,9 @@ def lpgettext(self, context, message):
                       DeprecationWarning, 2)
         tmsg = self.pgettext(context, message)
         encoding = getattr(self, "_output_charset", None) or locale.getpreferredencoding()
-        return tmsg.encode(encoding)
+        return tmsg.encode(encoding) if isinstance(tmsg, str) else tmsg
 
-    def npgettext(self, context, singular, plural, num):
+    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
@@ -428,7 +469,7 @@ def npgettext(self, context, singular, plural, num):
             else:
                 return plural
 
-    def lnpgettext(self, context, singular, plural, num):
+    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()``.
@@ -449,7 +490,7 @@ def lnpgettext(self, context, singular, plural, num):
             else:
                 return plural
 
-    def upgettext(self, context, message):
+    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
@@ -463,9 +504,10 @@ def upgettext(self, context, message):
             if self._fallback:
                 return self._fallback.upgettext(context, message)
             return str(message)
+        assert isinstance(tmsg, str)
         return tmsg
 
-    def unpgettext(self, context, singular, plural, num):
+    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
@@ -488,13 +530,13 @@ def unpgettext(self, context, singular, plural, num):
                 tmsg = str(plural)
         return tmsg
 
-    def dpgettext(self, domain, context, message):
+    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, context, message):
+    def udpgettext(self, domain: str, context: str, message: str) -> str:
         """Like `upgettext()`, but look the message up in the specified
         `domain`.
         """
@@ -502,21 +544,21 @@ def udpgettext(self, domain, context, message):
     # backward compatibility with 0.9
     dupgettext = udpgettext
 
-    def ldpgettext(self, domain, context, message):
+    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, context, singular, plural, num):
+    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, 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`.
         """
@@ -525,7 +567,7 @@ def udnpgettext(self, domain, context, singular, plural, num):
     # backward compatibility with 0.9
     dunpgettext = udnpgettext
 
-    def ldnpgettext(self, domain, context, singular, plural, num):
+    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()``.
@@ -542,7 +584,7 @@ class Translations(NullTranslations, gettext.GNUTranslations):
 
     DEFAULT_DOMAIN = 'messages'
 
-    def __init__(self, fp=None, domain=None):
+    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
@@ -555,7 +597,12 @@ def __init__(self, fp=None, domain=None):
     ungettext = gettext.GNUTranslations.ngettext
 
     @classmethod
-    def load(cls, dirname=None, locales=None, domain=None):
+    def load(
+        cls,
+        dirname: str | os.PathLike[str] | None = None,
+        locales: list[str] | tuple[str, ...] | str | None = None,
+        domain: str | None = None,
+    ) -> NullTranslations:
         """Load translations from the given directory.
 
         :param dirname: the directory containing the ``MO`` files
@@ -576,11 +623,11 @@ def load(cls, dirname=None, locales=None, domain=None):
         with open(filename, 'rb') as fp:
             return cls(fp=fp, domain=domain)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         version = self._info.get('project-id-version')
         return f'<{type(self).__name__}: "{version}">'
 
-    def add(self, translations, merge=True):
+    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
@@ -598,7 +645,7 @@ def add(self, translations, merge=True):
             return self.merge(translations)
 
         existing = self._domains.get(domain)
-        if merge and existing is not None:
+        if merge and isinstance(existing, Translations):
             existing.merge(translations)
         else:
             translations.add_fallback(self)
@@ -606,7 +653,7 @@ def add(self, translations, merge=True):
 
         return self
 
-    def merge(self, translations):
+    def merge(self, translations: Translations):
         """Merge the given translations into the catalog.
 
         Message translations in the specified catalog override any messages
diff --git a/babel/units.py b/babel/units.py
index f8f267579..1180bd125 100644
--- a/babel/units.py
+++ b/babel/units.py
@@ -1,13 +1,24 @@
+from __future__ import annotations
+
+import decimal
+from typing import TYPE_CHECKING
+
 from babel.core import Locale
-from babel.numbers import format_decimal, LC_NUMERIC
+from babel.numbers import LC_NUMERIC, format_decimal
 
+if TYPE_CHECKING:
+    from typing_extensions import Literal
 
 class UnknownUnitError(ValueError):
-    def __init__(self, unit, locale):
+    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, length='long', locale=LC_NUMERIC):
+def get_unit_name(
+    measurement_unit: str,
+    length: Literal['short', 'long', 'narrow'] = 'long',
+    locale: Locale | str | None = LC_NUMERIC,
+) -> str | None:
     """
     Get the display name for a measurement unit in the given locale.
 
@@ -36,7 +47,7 @@ def get_unit_name(measurement_unit, length='long', locale=LC_NUMERIC):
     return locale.unit_display_names.get(unit, {}).get(length)
 
 
-def _find_unit_pattern(unit_id, locale=LC_NUMERIC):
+def _find_unit_pattern(unit_id: str, locale: Locale | str | None = LC_NUMERIC) -> str | None:
     """
     Expand an unit into a qualified form.
 
@@ -62,7 +73,13 @@ def _find_unit_pattern(unit_id, locale=LC_NUMERIC):
             return unit_pattern
 
 
-def format_unit(value, measurement_unit, length='long', format=None, locale=LC_NUMERIC):
+def format_unit(
+    value: float | decimal.Decimal,
+    measurement_unit: str,
+    length: Literal['short', 'long', 'narrow'] = 'long',
+    format: str | None = None,
+    locale: Locale | str | None = LC_NUMERIC,
+) -> str:
     """Format a value of a given unit.
 
     Values are formatted according to the locale's usual pluralization rules
@@ -132,7 +149,11 @@ def format_unit(value, measurement_unit, length='long', format=None, locale=LC_N
     return f"{formatted_value} {fallback_name or measurement_unit}"  # pragma: no cover
 
 
-def _find_compound_unit(numerator_unit, denominator_unit, locale=LC_NUMERIC):
+def _find_compound_unit(
+    numerator_unit: str,
+    denominator_unit: str,
+    locale: Locale | str | None = LC_NUMERIC,
+) -> str | None:
     """
     Find a predefined compound unit pattern.
 
@@ -181,10 +202,14 @@ def _find_compound_unit(numerator_unit, denominator_unit, locale=LC_NUMERIC):
 
 
 def format_compound_unit(
-    numerator_value, numerator_unit=None,
-    denominator_value=1, denominator_unit=None,
-    length='long', format=None, locale=LC_NUMERIC
-):
+    numerator_value: float | decimal.Decimal,
+    numerator_unit: str | None = None,
+    denominator_value: float | decimal.Decimal = 1,
+    denominator_unit: str | None = None,
+    length: Literal["short", "long", "narrow"] = "long",
+    format: str | None = None,
+    locale: Locale | str | None = LC_NUMERIC,
+) -> str | None:
     """
     Format a compound number value, i.e. "kilometers per hour" or similar.
 
diff --git a/babel/util.py b/babel/util.py
index 0436b9ee4..f159c33c1 100644
--- a/babel/util.py
+++ b/babel/util.py
@@ -7,20 +7,26 @@
     :copyright: (c) 2013-2022 by the Babel Team.
     :license: BSD, see LICENSE for more details.
 """
+from __future__ import annotations
 
 import codecs
 import collections
-from datetime import timedelta, tzinfo
 import os
 import re
 import textwrap
+from collections.abc import Generator, Iterable
+from datetime import datetime as datetime_, timedelta, tzinfo
+from typing import IO, Any, TypeVar
+
 import pytz as _pytz
+
 from babel import localtime
 
 missing = object()
 
+_T = TypeVar("_T")
 
-def distinct(iterable):
+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
@@ -44,7 +50,7 @@ def distinct(iterable):
     br'[ \t\f]* \# .* coding[=:][ \t]*([-\w.]+)', re.VERBOSE)
 
 
-def parse_encoding(fp):
+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`__
@@ -96,7 +102,7 @@ def parse_encoding(fp):
     r'from\s+__future__\s+import\s+\(*(.+)\)*')
 
 
-def parse_future_flags(fp, encoding='latin-1'):
+def parse_future_flags(fp: IO[bytes], encoding: str = 'latin-1') -> int:
     """Parse the compiler flags by :mod:`__future__` from the given Python
     code.
     """
@@ -128,7 +134,7 @@ def parse_future_flags(fp, encoding='latin-1'):
     return flags
 
 
-def pathmatch(pattern, filename):
+def pathmatch(pattern: str, filename: str) -> bool:
     """Extended pathname pattern matching.
 
     This function is similar to what is provided by the ``fnmatch`` module in
@@ -200,7 +206,7 @@ class TextWrapper(textwrap.TextWrapper):
     )
 
 
-def wraptext(text, width=70, initial_indent='', subsequent_indent=''):
+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.
 
@@ -224,25 +230,26 @@ def wraptext(text, width=70, initial_indent='', subsequent_indent=''):
 class FixedOffsetTimezone(tzinfo):
     """Fixed offset in minutes east from UTC."""
 
-    def __init__(self, offset, name=None):
+    def __init__(self, offset: float, name: str | None = None) -> None:
+
         self._offset = timedelta(minutes=offset)
         if name is None:
             name = 'Etc/GMT%+d' % offset
         self.zone = name
 
-    def __str__(self):
+    def __str__(self) -> str:
         return self.zone
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f'<FixedOffset "{self.zone}" {self._offset}>'
 
-    def utcoffset(self, dt):
+    def utcoffset(self, dt: datetime_) -> timedelta:
         return self._offset
 
-    def tzname(self, dt):
+    def tzname(self, dt: datetime_) -> str:
         return self.zone
 
-    def dst(self, dt):
+    def dst(self, dt: datetime_) -> timedelta:
         return ZERO
 
 
@@ -258,5 +265,5 @@ def dst(self, dt):
 ZERO = localtime.ZERO
 
 
-def _cmp(a, b):
+def _cmp(a: Any, b: Any):
     return (a > b) - (a < b)

From 14216ed8f90832eed9c8ea24442d5b63da4389eb Mon Sep 17 00:00:00 2001
From: DS/Charlie <82801887+ds-cbo@users.noreply.github.com>
Date: Wed, 11 Jan 2023 11:34:43 +0100
Subject: [PATCH 15/53] Implement zoneinfo support and make pytz optional
 (#940)

---
 CHANGES.rst                  |   7 ++
 babel/dates.py               | 151 +++++++++++++++++++++--------
 babel/localtime/__init__.py  |   6 +-
 babel/localtime/_helpers.py  |  42 ++++++++
 babel/localtime/_unix.py     |  48 +++++----
 babel/localtime/_win32.py    |  16 +--
 babel/support.py             |  21 ++--
 babel/util.py                |  10 +-
 docs/dates.rst               |  22 +++--
 docs/dev.rst                 |   7 +-
 docs/installation.rst        |  17 ++--
 setup.py                     |   3 +-
 tests/test_date_intervals.py |   6 +-
 tests/test_dates.py          | 183 +++++++++++++++++++----------------
 tests/test_support.py        |  12 +--
 15 files changed, 340 insertions(+), 211 deletions(-)
 create mode 100644 babel/localtime/_helpers.py

diff --git a/CHANGES.rst b/CHANGES.rst
index 949d16dd7..bee5c3f40 100644
--- a/CHANGES.rst
+++ b/CHANGES.rst
@@ -1,6 +1,13 @@
 Babel Changelog
 ===============
 
+Unreleased
+----------
+
+* Use `zoneinfo` timezone resolving on python 3.9+, while keeping pytz support
+  for lower versions
+
+
 Version 2.11.0
 --------------
 
diff --git a/babel/dates.py b/babel/dates.py
index 27f3fe648..f7289619f 100644
--- a/babel/dates.py
+++ b/babel/dates.py
@@ -19,20 +19,24 @@
 
 import re
 import warnings
+from typing import TYPE_CHECKING, SupportsInt
+
+try:
+    import pytz
+except ModuleNotFoundError:
+    pytz = None
+    import zoneinfo
+
 from bisect import bisect_right
 from collections.abc import Iterable
 from datetime import date, datetime, time, timedelta, tzinfo
-from typing import TYPE_CHECKING, SupportsInt
-
-import pytz as _pytz
 
+from babel import localtime
 from babel.core import Locale, default_locale, get_global
 from babel.localedata import LocaleDataDict
-from babel.util import LOCALTZ, UTC
 
 if TYPE_CHECKING:
     from typing_extensions import Literal, TypeAlias
-
     _Instant: TypeAlias = date | time | float | None
     _PredefinedTimeFormat: TypeAlias = Literal['full', 'long', 'medium', 'short']
     _Context: TypeAlias = Literal['format', 'stand-alone']
@@ -48,6 +52,12 @@
 NO_INHERITANCE_MARKER = u'\u2205\u2205\u2205'
 
 
+if pytz:
+    UTC = pytz.utc
+else:
+    UTC = zoneinfo.ZoneInfo('UTC')
+LOCALTZ = localtime.LOCALTZ
+
 LC_TIME = default_locale('LC_TIME')
 
 # Aliases for use in scopes where the modules are shadowed by local variables
@@ -56,6 +66,24 @@
 time_ = time
 
 
+def _localize(tz: tzinfo, dt: 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_ | None, tzinfo]:
     """
     Parse a `dt_or_tzinfo` value into a datetime and a tzinfo.
@@ -150,7 +178,7 @@ def _ensure_datetime_tzinfo(datetime: datetime_, tzinfo: tzinfo | None = None) -
 
     If a tzinfo is passed in, the datetime is normalized to that timezone.
 
-    >>> _ensure_datetime_tzinfo(datetime(2015, 1, 1)).tzinfo.zone
+    >>> _get_tz_name(_ensure_datetime_tzinfo(datetime(2015, 1, 1)))
     'UTC'
 
     >>> tz = get_timezone("Europe/Stockholm")
@@ -158,7 +186,7 @@ def _ensure_datetime_tzinfo(datetime: datetime_, tzinfo: tzinfo | None = None) -
     14
 
     :param datetime: Datetime to augment.
-    :param tzinfo: Optional tznfo.
+    :param tzinfo: optional tzinfo
     :return: datetime with tzinfo
     :rtype: datetime
     """
@@ -184,8 +212,10 @@ def _get_time(time: time | datetime | None, tzinfo: tzinfo | None = None) -> tim
         time = datetime.utcnow()
     elif isinstance(time, (int, float)):
         time = datetime.utcfromtimestamp(time)
+
     if time.tzinfo is None:
         time = time.replace(tzinfo=UTC)
+
     if isinstance(time, datetime):
         if tzinfo is not None:
             time = time.astimezone(tzinfo)
@@ -197,28 +227,40 @@ def _get_time(time: time | datetime | None, tzinfo: tzinfo | None = None) -> tim
     return time
 
 
-def get_timezone(zone: str | _pytz.BaseTzInfo | None = None) -> _pytz.BaseTzInfo:
+def get_timezone(zone: str | tzinfo | None = None) -> tzinfo:
     """Looks up a timezone by name and returns it.  The timezone object
-    returned comes from ``pytz`` and corresponds to the `tzinfo` interface and
-    can be used with all of the functions of Babel that operate with dates.
+    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, mit's returned unchanged.
+                 itself is passed in, it's returned unchanged.
     """
     if zone is None:
         return LOCALTZ
     if not isinstance(zone, str):
         return zone
-    try:
-        return _pytz.timezone(zone)
-    except _pytz.UnknownTimeZoneError:
-        raise LookupError(f"Unknown timezone {zone}")
 
+    exc = None
+    if pytz:
+        try:
+            return pytz.timezone(zone)
+        except pytz.UnknownTimeZoneError as exc:
+            pass
+    else:
+        assert zoneinfo
+        try:
+            return zoneinfo.ZoneInfo(zone)
+        except zoneinfo.ZoneInfoNotFoundError as exc:
+            pass
+
+    raise LookupError(f"Unknown timezone {zone}") from exc
 
-def get_next_timezone_transition(zone: _pytz.BaseTzInfo | None = None, dt: _Instant = None) -> TimezoneTransition:
+
+def get_next_timezone_transition(zone: tzinfo | None = None, dt: _Instant = None) -> TimezoneTransition:
     """Given a timezone it will return a :class:`TimezoneTransition` object
     that holds the information about the next timezone transition that's going
     to happen.  For instance this can be used to detect when the next DST
@@ -474,7 +516,7 @@ def get_timezone_gmt(datetime: _Instant = None, width: Literal['long', 'short',
     >>> get_timezone_gmt(dt, locale='en', width='iso8601_short')
     u'+00'
     >>> tz = get_timezone('America/Los_Angeles')
-    >>> dt = tz.localize(datetime(2007, 4, 1, 15, 30))
+    >>> 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')
@@ -608,7 +650,7 @@ def get_timezone_name(dt_or_tzinfo: _DtOrTzinfo = None, width: Literal['long', '
     u'PST'
 
     If this function gets passed only a `tzinfo` object and no concrete
-    `datetime`,  the returned display name is indenpendent of daylight savings
+    `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:
 
@@ -755,12 +797,11 @@ def format_datetime(datetime: _Instant = None, format: _PredefinedTimeFormat | s
     >>> format_datetime(dt, locale='en_US')
     u'Apr 1, 2007, 3:30:00 PM'
 
-    For any pattern requiring the display of the time-zone, the third-party
-    ``pytz`` package is needed to explicitly specify the time-zone:
+    For any pattern requiring the display of the timezone:
 
     >>> format_datetime(dt, 'full', tzinfo=get_timezone('Europe/Paris'),
     ...                 locale='fr_FR')
-    u'dimanche 1 avril 2007 \xe0 17:30:00 heure d\u2019\xe9t\xe9 d\u2019Europe centrale'
+    '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'
@@ -806,9 +847,9 @@ def format_time(time: time | datetime | float | None = None, format: _Predefined
 
     >>> t = datetime(2007, 4, 1, 15, 30)
     >>> tzinfo = get_timezone('Europe/Paris')
-    >>> t = tzinfo.localize(t)
+    >>> t = _localize(tzinfo, t)
     >>> format_time(t, format='full', tzinfo=tzinfo, locale='fr_FR')
-    u'15:30:00 heure d\u2019\xe9t\xe9 d\u2019Europe centrale'
+    '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"
@@ -841,12 +882,17 @@ def format_time(time: time | datetime | float | None = None, format: _Predefined
     :param tzinfo: the time-zone to apply to the time for display
     :param locale: a `Locale` object or a locale identifier
     """
+
+    # get reference date for if we need to find the right timezone variant
+    # in the pattern
+    ref_date = time.date() if isinstance(time, datetime) else None
+
     time = _get_time(time, tzinfo)
 
     locale = Locale.parse(locale)
     if format in ('full', 'long', 'medium', 'short'):
         format = get_time_format(format, locale=locale)
-    return parse_pattern(format).apply(time, locale)
+    return parse_pattern(format).apply(time, locale, reference_date=ref_date)
 
 
 def format_skeleton(skeleton: str, datetime: _Instant = None, tzinfo: tzinfo | None = None,
@@ -1124,7 +1170,7 @@ def format_interval(start: _Instant, end: _Instant, skeleton: str | None = None,
     return _format_fallback_interval(start, end, skeleton, tzinfo, locale)
 
 
-def get_period_id(time: _Instant, tzinfo: _pytz.BaseTzInfo | None = None, type: Literal['selection'] | None = None,
+def get_period_id(time: _Instant, tzinfo: tzinfo | None = None, type: Literal['selection'] | None = None,
                   locale: Locale | str | None = LC_TIME) -> str:
     """
     Get the day period ID for a given time.
@@ -1327,18 +1373,29 @@ def __mod__(self, other: DateTimeFormat) -> str:
             return NotImplemented
         return self.format % other
 
-    def apply(self, datetime: date | time, locale: Locale | str | None) -> str:
-        return self % DateTimeFormat(datetime, locale)
+    def apply(
+        self,
+        datetime: date | time,
+        locale: Locale | str | None,
+        reference_date: date | None = None
+    ) -> str:
+        return self % DateTimeFormat(datetime, locale, reference_date)
 
 
 class DateTimeFormat:
 
-    def __init__(self, value: date | time, locale: Locale | str):
+    def __init__(
+        self,
+        value: date | time,
+        locale: Locale | str,
+        reference_date: date | None = None
+    ):
         assert isinstance(value, (date, datetime, time))
         if isinstance(value, (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]
@@ -1558,46 +1615,54 @@ def format_milliseconds_in_day(self, 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.combine(self.reference_date, self.value)
+
         if char == 'z':
-            return get_timezone_name(self.value, width, locale=self.locale)
+            return get_timezone_name(value, width, locale=self.locale)
         elif char == 'Z':
             if num == 5:
-                return get_timezone_gmt(self.value, width, locale=self.locale, return_z=True)
-            return get_timezone_gmt(self.value, width, locale=self.locale)
+                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(self.value, width, locale=self.locale)
+                return get_timezone_gmt(value, width, locale=self.locale)
         # TODO: To add support for O:1
         elif char == 'v':
-            return get_timezone_name(self.value.tzinfo, width,
+            return get_timezone_name(value.tzinfo, width,
                                      locale=self.locale)
         elif char == 'V':
             if num == 1:
-                return get_timezone_name(self.value.tzinfo, width,
+                return get_timezone_name(value.tzinfo, width,
                                          uncommon=True, locale=self.locale)
             elif num == 2:
-                return get_timezone_name(self.value.tzinfo, locale=self.locale, return_zone=True)
+                return get_timezone_name(value.tzinfo, locale=self.locale, return_zone=True)
             elif num == 3:
-                return get_timezone_location(self.value.tzinfo, locale=self.locale, return_city=True)
-            return get_timezone_location(self.value.tzinfo, locale=self.locale)
+                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(self.value, width='iso8601_short', locale=self.locale,
+                return get_timezone_gmt(value, width='iso8601_short', locale=self.locale,
                                         return_z=True)
             elif num in (2, 4):
-                return get_timezone_gmt(self.value, width='short', locale=self.locale,
+                return get_timezone_gmt(value, width='short', locale=self.locale,
                                         return_z=True)
             elif num in (3, 5):
-                return get_timezone_gmt(self.value, width='iso8601', locale=self.locale,
+                return get_timezone_gmt(value, width='iso8601', locale=self.locale,
                                         return_z=True)
         elif char == 'x':
             if num == 1:
-                return get_timezone_gmt(self.value, width='iso8601_short', locale=self.locale)
+                return get_timezone_gmt(value, width='iso8601_short', locale=self.locale)
             elif num in (2, 4):
-                return get_timezone_gmt(self.value, width='short', locale=self.locale)
+                return get_timezone_gmt(value, width='short', locale=self.locale)
             elif num in (3, 5):
-                return get_timezone_gmt(self.value, width='iso8601', locale=self.locale)
+                return get_timezone_gmt(value, width='iso8601', locale=self.locale)
 
     def format(self, value: SupportsInt, length: int) -> str:
         return '%0*d' % (length, value)
diff --git a/babel/localtime/__init__.py b/babel/localtime/__init__.py
index ffe2d49f1..c7f214aa8 100644
--- a/babel/localtime/__init__.py
+++ b/babel/localtime/__init__.py
@@ -14,8 +14,6 @@
 from datetime import datetime, timedelta, tzinfo
 from threading import RLock
 
-import pytz
-
 if sys.platform == 'win32':
     from babel.localtime._win32 import _get_localzone
 else:
@@ -61,7 +59,7 @@ def _isdst(self, dt: datetime) -> bool:
         return tt.tm_isdst > 0
 
 
-def get_localzone() -> pytz.BaseTzInfo:
+def get_localzone() -> tzinfo:
     """Returns the current underlying local timezone object.
     Generally this function does not need to be used, it's a
     better idea to use the :data:`LOCALTZ` singleton instead.
@@ -71,5 +69,5 @@ def get_localzone() -> pytz.BaseTzInfo:
 
 try:
     LOCALTZ = get_localzone()
-except pytz.UnknownTimeZoneError:
+except LookupError:
     LOCALTZ = _FallbackLocalTimezone()
diff --git a/babel/localtime/_helpers.py b/babel/localtime/_helpers.py
new file mode 100644
index 000000000..b7238f6a6
--- /dev/null
+++ b/babel/localtime/_helpers.py
@@ -0,0 +1,42 @@
+try:
+    import pytz
+except ModuleNotFoundError:
+    pytz = None
+    import zoneinfo
+
+
+def _get_tzinfo(tzenv: str):
+    """Get the tzinfo from `zoneinfo` or `pytz`
+
+    :param tzenv: timezone in the form of Continent/City
+    :return: tzinfo object or None if not found
+    """
+    if pytz:
+        try:
+            return pytz.timezone(tzenv)
+        except pytz.UnknownTimeZoneError:
+            pass
+    else:
+        try:
+            return zoneinfo.ZoneInfo(tzenv)
+        except zoneinfo.ZoneInfoNotFoundError:
+            pass
+
+    return None
+
+def _get_tzinfo_or_raise(tzenv: str):
+    tzinfo = _get_tzinfo(tzenv)
+    if tzinfo is None:
+        raise LookupError(
+            f"Can not find timezone {tzenv}. \n"
+            "Timezone names are generally in the form `Continent/City`."
+        )
+    return tzinfo
+
+
+def _get_tzinfo_from_file(tzfilename: str):
+    with open(tzfilename, 'rb') as tzfile:
+        if pytz:
+            return pytz.tzfile.build_tzinfo('local', tzfile)
+        else:
+            return zoneinfo.ZoneInfo.from_file(tzfile)
diff --git a/babel/localtime/_unix.py b/babel/localtime/_unix.py
index beb7f6021..319c8cfbc 100644
--- a/babel/localtime/_unix.py
+++ b/babel/localtime/_unix.py
@@ -1,33 +1,31 @@
 import os
 import re
-import pytz
 
+from datetime import tzinfo
 
-def _tz_from_env(tzenv: str) -> pytz.BaseTzInfo:
+from babel.localtime._helpers import (
+    _get_tzinfo_from_file,
+    _get_tzinfo_or_raise,
+    _get_tzinfo,
+)
+
+def _tz_from_env(tzenv: str) -> tzinfo:
     if tzenv[0] == ':':
         tzenv = tzenv[1:]
 
     # TZ specifies a file
     if os.path.exists(tzenv):
-        with open(tzenv, 'rb') as tzfile:
-            return pytz.tzfile.build_tzinfo('local', tzfile)
+        return _get_tzinfo_from_file(tzenv)
 
     # TZ specifies a zoneinfo zone.
-    try:
-        tz = pytz.timezone(tzenv)
-        # That worked, so we return this:
-        return tz
-    except pytz.UnknownTimeZoneError:
-        raise pytz.UnknownTimeZoneError(
-            "tzlocal() does not support non-zoneinfo timezones like %s. \n"
-            "Please use a timezone in the form of Continent/City")
+    return _get_tzinfo_or_raise(tzenv)
 
 
-def _get_localzone(_root: str = '/') -> pytz.BaseTzInfo:
+def _get_localzone(_root: str = '/') -> tzinfo:
     """Tries to find the local timezone configuration.
-    This method prefers finding the timezone name and passing that to pytz,
-    over passing in the localtime file, as in the later case the zoneinfo
-    name is unknown.
+    This method prefers finding the timezone name and passing that to
+    zoneinfo or pytz, over passing in the localtime file, as in the later
+    case the zoneinfo name is unknown.
     The parameter _root makes the function look for files like /etc/localtime
     beneath the _root directory. This is primarily used by the tests.
     In normal usage you call the function without parameters.
@@ -48,10 +46,9 @@ def _get_localzone(_root: str = '/') -> pytz.BaseTzInfo:
         pos = link_dst.find('/zoneinfo/')
         if pos >= 0:
             zone_name = link_dst[pos + 10:]
-            try:
-                return pytz.timezone(zone_name)
-            except pytz.UnknownTimeZoneError:
-                pass
+            tzinfo = _get_tzinfo(zone_name)
+            if tzinfo is not None:
+                return tzinfo
 
     # Now look for distribution specific configuration files
     # that contain the timezone name.
@@ -69,7 +66,8 @@ def _get_localzone(_root: str = '/') -> pytz.BaseTzInfo:
                     etctz, dummy = etctz.split(' ', 1)
                 if '#' in etctz:
                     etctz, dummy = etctz.split('#', 1)
-                return pytz.timezone(etctz.replace(' ', '_'))
+
+                return _get_tzinfo_or_raise(etctz.replace(' ', '_'))
 
     # CentOS has a ZONE setting in /etc/sysconfig/clock,
     # OpenSUSE has a TIMEZONE setting in /etc/sysconfig/clock and
@@ -87,7 +85,7 @@ def _get_localzone(_root: str = '/') -> pytz.BaseTzInfo:
                 if match is not None:
                     # We found a timezone
                     etctz = match.group("etctz")
-                    return pytz.timezone(etctz.replace(' ', '_'))
+                    return _get_tzinfo_or_raise(etctz.replace(' ', '_'))
 
     # No explicit setting existed. Use localtime
     for filename in ('etc/localtime', 'usr/local/etc/localtime'):
@@ -95,8 +93,6 @@ def _get_localzone(_root: str = '/') -> pytz.BaseTzInfo:
 
         if not os.path.exists(tzpath):
             continue
+        return _get_tzinfo_from_file(tzpath)
 
-        with open(tzpath, 'rb') as tzfile:
-            return pytz.tzfile.build_tzinfo('local', tzfile)
-
-    raise pytz.UnknownTimeZoneError('Can not find any timezone configuration')
+    raise LookupError('Can not find any timezone configuration')
diff --git a/babel/localtime/_win32.py b/babel/localtime/_win32.py
index 98d51708d..3d7e0d512 100644
--- a/babel/localtime/_win32.py
+++ b/babel/localtime/_win32.py
@@ -5,11 +5,10 @@
 except ImportError:
     winreg = None
 
-from typing import Any, Dict, cast
-
-import pytz
-
+from datetime import tzinfo
 from babel.core import get_global
+from babel.localtime._helpers import _get_tzinfo_or_raise
+from typing import Any, Dict, cast
 
 # When building the cldr data on windows this module gets imported.
 # Because at that point there is no global.dat yet this call will
@@ -85,13 +84,14 @@ def get_localzone_name() -> str:
 
     # Return what we have.
     if timezone is None:
-        raise pytz.UnknownTimeZoneError(f"Can not find timezone {tzkeyname}")
+        raise LookupError(f"Can not find timezone {tzkeyname}")
 
     return timezone
 
 
-def _get_localzone() -> pytz.BaseTzInfo:
+def _get_localzone() -> tzinfo:
     if winreg is None:
-        raise pytz.UnknownTimeZoneError(
+        raise LookupError(
             'Runtime support not available')
-    return pytz.timezone(get_localzone_name())
+
+    return _get_tzinfo_or_raise(get_localzone_name())
diff --git a/babel/support.py b/babel/support.py
index 7a6eaa23a..7477ee10c 100644
--- a/babel/support.py
+++ b/babel/support.py
@@ -17,14 +17,19 @@
 import locale
 import os
 from collections.abc import Iterator
-from datetime import date as _date, datetime as _datetime, time as _time, timedelta as _timedelta
+from datetime import (
+    date as _date,
+    datetime as _datetime,
+    time as _time,
+    timedelta as _timedelta,
+    tzinfo
+)
 from typing import TYPE_CHECKING, Any, Callable
 
-from pytz import BaseTzInfo
-
 from babel.core import Locale
+
 from babel.dates import (format_date, format_datetime, format_time,
-                         format_timedelta)
+                         format_timedelta, get_timezone)
 from babel.numbers import (format_compact_currency, format_compact_decimal,
                            format_currency, format_decimal, format_percent,
                            format_scientific)
@@ -47,7 +52,7 @@ class Format:
     u'1.234'
     """
 
-    def __init__(self, locale: Locale | str, tzinfo: BaseTzInfo | None = None) -> None:
+    def __init__(self, locale: Locale | str, tzinfo: tzinfo | None = None) -> None:
         """Initialize the formatter.
 
         :param locale: the locale identifier or `Locale` instance
@@ -70,8 +75,7 @@ def datetime(self, datetime: _date | None = None, format: _PredefinedTimeFormat
         """Return a date and time formatted according to the given pattern.
 
         >>> from datetime import datetime
-        >>> from pytz import timezone
-        >>> fmt = Format('en_US', tzinfo=timezone('US/Eastern'))
+        >>> fmt = Format('en_US', tzinfo=get_timezone('US/Eastern'))
         >>> fmt.datetime(datetime(2007, 4, 1, 15, 30))
         u'Apr 1, 2007, 11:30:00 AM'
         """
@@ -82,8 +86,7 @@ def time(self, time: _time | _datetime | None = None, format: _PredefinedTimeFor
         """Return a time formatted according to the given pattern.
 
         >>> from datetime import datetime
-        >>> from pytz import timezone
-        >>> fmt = Format('en_US', tzinfo=timezone('US/Eastern'))
+        >>> fmt = Format('en_US', tzinfo=get_timezone('US/Eastern'))
         >>> fmt.time(datetime(2007, 4, 1, 15, 30))
         u'11:30:00 AM'
         """
diff --git a/babel/util.py b/babel/util.py
index f159c33c1..fb4870d66 100644
--- a/babel/util.py
+++ b/babel/util.py
@@ -14,14 +14,12 @@
 import os
 import re
 import textwrap
+from babel import localtime, dates
+
 from collections.abc import Generator, Iterable
 from datetime import datetime as datetime_, timedelta, tzinfo
 from typing import IO, Any, TypeVar
 
-import pytz as _pytz
-
-from babel import localtime
-
 missing = object()
 
 _T = TypeVar("_T")
@@ -255,8 +253,8 @@ def dst(self, dt: datetime_) -> timedelta:
 
 # Export the localtime functionality here because that's
 # where it was in the past.
-UTC = _pytz.utc
-LOCALTZ = localtime.LOCALTZ
+UTC = dates.UTC
+LOCALTZ = dates.LOCALTZ
 get_localzone = localtime.get_localzone
 
 STDOFFSET = localtime.STDOFFSET
diff --git a/docs/dates.rst b/docs/dates.rst
index 44201877e..8b3509115 100644
--- a/docs/dates.rst
+++ b/docs/dates.rst
@@ -276,11 +276,9 @@ class, which you need appropriate implementations for to actually use in your
 application. Babel includes a ``tzinfo`` implementation for UTC (Universal
 Time).
 
-Babel uses `pytz`_ for real timezone support which includes the
-definitions of practically all of the time-zones used on the world, as
-well as important functions for reliably converting from UTC to local
-time, and vice versa.  The module is generally wrapped for you so you can
-directly interface with it from within Babel:
+Babel uses either `zoneinfo`_ or `pytz`_ for timezone support.
+If pytz is installed, it is preferred over the standard library's zoneinfo.
+You can directly interface with either of these modules from within Babel:
 
 .. code-block:: pycon
 
@@ -294,9 +292,9 @@ directly interface with it from within Babel:
 The recommended approach to deal with different time-zones in a Python
 application is to always use UTC internally, and only convert from/to the users
 time-zone when accepting user input and displaying date/time data, respectively.
-You can use Babel together with ``pytz`` to apply a time-zone to any
-``datetime`` or ``time`` object for display, leaving the original information
-unchanged:
+You can use Babel together with ``zoneinfo`` or ``pytz`` to apply a time-zone
+to any ``datetime`` or ``time`` object for display, leaving the original
+information unchanged:
 
 .. code-block:: pycon
 
@@ -314,6 +312,9 @@ For many timezones it's also possible to ask for the next timezone
 transition.  This for instance is useful to answer the question “when do I
 have to move the clock forward next”:
 
+.. warning:: ``get_next_timezone_transition`` is deprecated and will be removed
+             in the next version of Babel
+
 .. code-block:: pycon
 
     >>> t = get_next_timezone_transition('Europe/Vienna', datetime(2011, 3, 2))
@@ -339,7 +340,7 @@ your operating system.  It's provided through the ``LOCALTZ`` constant:
     >>> get_timezone_name(LOCALTZ)
     u'Central European Time'
 
-.. _pytz: http://pytz.sourceforge.net/
+.. _pytz: https://pythonhosted.org/pytz/
 
 
 Localized Time-zone Names
@@ -370,8 +371,9 @@ display a list of time-zones to the user.
 .. code-block:: pycon
 
     >>> from datetime import datetime
+    >>> from babel.dates import _localize
 
-    >>> dt = tz.localize(datetime(2007, 8, 15))
+    >>> dt = _localize(tz, datetime(2007, 8, 15))
     >>> get_timezone_name(dt, locale=Locale.parse('de_DE'))
     u'Mitteleurop\xe4ische Sommerzeit'
     >>> get_timezone_name(tz, locale=Locale.parse('de_DE'))
diff --git a/docs/dev.rst b/docs/dev.rst
index 1c4453d8e..97a105b98 100644
--- a/docs/dev.rst
+++ b/docs/dev.rst
@@ -46,10 +46,9 @@ Unicode is a big deal in Babel.  Here is how the rules are set up:
 Dates and Timezones
 -------------------
 
-Generally all timezone support in Babel is based on pytz which it just
-depends on.  Babel should assume that timezone objects are pytz based
-because those are the only ones with an API that actually work correctly
-(due to the API problems with non UTC based timezones).
+Babel's timezone support relies on either ``pytz`` or ``zoneinfo``; if ``pytz``
+is installed, it is preferred over ``zoneinfo``.  Babel should assume that any
+timezone objects can be from either of these modules.
 
 Assumptions to make:
 
diff --git a/docs/installation.rst b/docs/installation.rst
index 26fe23a47..8bf614cb6 100644
--- a/docs/installation.rst
+++ b/docs/installation.rst
@@ -4,10 +4,14 @@ Installation
 ============
 
 Babel is distributed as a standard Python package fully set up with all
-the dependencies it needs.  It primarily depends on the excellent `pytz`_
-library for timezone handling.  To install it you can use ``pip``.
+the dependencies it needs.  On Python versions where the standard library
+`zoneinfo`_ module is not available, `pytz`_  needs to be installed for
+timezone support. If `pytz`_  is installed, it is preferred over the
+standard library `zoneinfo`_  module where possible.
 
-.. _pytz: http://pytz.sourceforge.net/
+.. _pytz: https://pythonhosted.org/pytz/
+
+.. _zoneinfo: https://docs.python.org/3/library/zoneinfo.html
 
 .. _virtualenv:
 
@@ -79,16 +83,15 @@ Get the git checkout in a new virtualenv and run in development mode::
     New python executable in venv/bin/python
     Installing distribute............done.
     $ . venv/bin/activate
-    $ pip install pytz
     $ python setup.py import_cldr
     $ pip install --editable .
     ...
     Finished processing dependencies for Babel
 
-Make sure to not forget about the ``pip install pytz`` and ``import_cldr`` steps
-because otherwise you will be missing the locale data.
+Make sure to not forget about the ``import_cldr`` step because otherwise
+you will be missing the locale data.
 The custom setup command will download the most appropriate CLDR release from the
-official website and convert it for Babel but will not work without ``pytz``.
+official website and convert it for Babel.
 
 This will pull also in the dependencies and activate the git head as the
 current version inside the virtualenv.  Then all you have to do is run
diff --git a/setup.py b/setup.py
index 157f7c160..db63216e9 100755
--- a/setup.py
+++ b/setup.py
@@ -63,7 +63,8 @@ def run(self):
         # This version identifier is currently necessary as
         # pytz otherwise does not install on pip 1.4 or
         # higher.
-        'pytz>=2015.7',
+        # Python 3.9 and later include zoneinfo which replaces pytz
+        'pytz>=2015.7; python_version<"3.9"',
     ],
     cmdclass={'import_cldr': import_cldr},
     zip_safe=False,
diff --git a/tests/test_date_intervals.py b/tests/test_date_intervals.py
index dc3ae346f..eb3aa8977 100644
--- a/tests/test_date_intervals.py
+++ b/tests/test_date_intervals.py
@@ -1,8 +1,8 @@
 import datetime
 
 from babel import dates
-from babel.dates import get_timezone
 from babel.util import UTC
+from .test_dates import timezone_getter
 
 TEST_DT = datetime.datetime(2016, 1, 8, 11, 46, 15)
 TEST_TIME = TEST_DT.time()
@@ -31,10 +31,10 @@ def test_format_interval_no_difference():
     assert dates.format_interval(t1, t2, "yMd", fuzzy=False, locale="fi") == "8.1.2016"
 
 
-def test_format_interval_in_tz():
+def test_format_interval_in_tz(timezone_getter):
     t1 = TEST_DT.replace(tzinfo=UTC)
     t2 = t1 + datetime.timedelta(minutes=18)
-    hki_tz = get_timezone("Europe/Helsinki")
+    hki_tz = timezone_getter("Europe/Helsinki")
     assert dates.format_interval(t1, t2, "Hmv", tzinfo=hki_tz, locale="fi") == "13.46\u201314.04 aikavyöhyke: Suomi"
 
 
diff --git a/tests/test_dates.py b/tests/test_dates.py
index b62f542cd..9fd73148b 100644
--- a/tests/test_dates.py
+++ b/tests/test_dates.py
@@ -12,36 +12,46 @@
 
 import calendar
 from datetime import date, datetime, time, timedelta
-import unittest
 
 import freezegun
 import pytest
-import pytz
-from pytz import timezone
+
+# for tests it can be useful to have both zoneinfo and pytz available
+try:
+    import zoneinfo
+except ModuleNotFoundError:
+    try:
+        from backports import zoneinfo
+    except ImportError:
+        zoneinfo = None
+
+try:
+    import pytz
+except ModuleNotFoundError:
+    pytz = None
 
 from babel import dates, Locale
-from babel.dates import NO_INHERITANCE_MARKER
+from babel.dates import NO_INHERITANCE_MARKER, _localize, _get_tz_name, LOCALTZ
 from babel.util import FixedOffsetTimezone
 
 
-@pytest.fixture(params=["pytz.timezone", "zoneinfo.ZoneInfo"])
+@pytest.fixture(params=["pytz.timezone", "zoneinfo.ZoneInfo"], scope="package")
 def timezone_getter(request):
     if request.param == "pytz.timezone":
-        return timezone
+        if pytz:
+            return pytz.timezone
+        else:
+            pytest.skip("pytz not available")
     elif request.param == "zoneinfo.ZoneInfo":
-        try:
-            import zoneinfo
-        except ImportError:
-            try:
-                from backports import zoneinfo
-            except ImportError:
-                pytest.skip("zoneinfo not available")
-        return zoneinfo.ZoneInfo
+        if zoneinfo:
+            return zoneinfo.ZoneInfo
+        else:
+            pytest.skip("zoneinfo not available")
     else:
         raise NotImplementedError
 
 
-class DateTimeFormatTestCase(unittest.TestCase):
+class DateTimeFormatTestCase:
 
     def test_quarter_format(self):
         d = date(2006, 6, 8)
@@ -205,33 +215,33 @@ def test_milliseconds_in_day_zero(self):
         d = time(0, 0, 0)
         assert dates.DateTimeFormat(d, locale='en_US')['AAAA'] == '0000'
 
-    def test_timezone_rfc822(self):
-        tz = timezone('Europe/Berlin')
-        t = tz.localize(datetime(2015, 1, 1, 15, 30))
+    def test_timezone_rfc822(self, timezone_getter):
+        tz = timezone_getter('Europe/Berlin')
+        t = _localize(tz, datetime(2015, 1, 1, 15, 30))
         assert dates.DateTimeFormat(t, locale='de_DE')['Z'] == '+0100'
 
-    def test_timezone_gmt(self):
-        tz = timezone('Europe/Berlin')
-        t = tz.localize(datetime(2015, 1, 1, 15, 30))
+    def test_timezone_gmt(self, timezone_getter):
+        tz = timezone_getter('Europe/Berlin')
+        t = _localize(tz, datetime(2015, 1, 1, 15, 30))
         assert dates.DateTimeFormat(t, locale='de_DE')['ZZZZ'] == 'GMT+01:00'
 
-    def test_timezone_name(self):
-        tz = timezone('Europe/Paris')
-        dt = tz.localize(datetime(2007, 4, 1, 15, 30))
+    def test_timezone_name(self, timezone_getter):
+        tz = timezone_getter('Europe/Paris')
+        dt = _localize(tz, datetime(2007, 4, 1, 15, 30))
         assert dates.DateTimeFormat(dt, locale='fr_FR')['v'] == 'heure : France'
 
-    def test_timezone_location_format(self):
-        tz = timezone('Europe/Paris')
-        dt = datetime(2007, 4, 1, 15, 30, tzinfo=tz)
+    def test_timezone_location_format(self, timezone_getter):
+        tz = timezone_getter('Europe/Paris')
+        dt = _localize(tz, datetime(2007, 4, 1, 15, 30))
         assert dates.DateTimeFormat(dt, locale='fr_FR')['VVVV'] == 'heure : France'
 
-    def test_timezone_walltime_short(self):
-        tz = timezone('Europe/Paris')
+    def test_timezone_walltime_short(self, timezone_getter):
+        tz = timezone_getter('Europe/Paris')
         t = time(15, 30, tzinfo=tz)
         assert dates.DateTimeFormat(t, locale='fr_FR')['v'] == 'heure : France'
 
-    def test_timezone_walltime_long(self):
-        tz = timezone('Europe/Paris')
+    def test_timezone_walltime_long(self, timezone_getter):
+        tz = timezone_getter('Europe/Paris')
         t = time(15, 30, tzinfo=tz)
         assert dates.DateTimeFormat(t, locale='fr_FR')['vvvv'] == u'heure d’Europe centrale'
 
@@ -249,7 +259,7 @@ def test_hour_formatting(self):
         assert dates.format_time(t, 'K a', locale=l) == '0 PM'
 
 
-class FormatDateTestCase(unittest.TestCase):
+class FormatDateTestCase:
 
     def test_with_time_fields_in_pattern(self):
         with pytest.raises(AttributeError):
@@ -265,18 +275,18 @@ def test_with_day_of_year_in_pattern_and_datetime_param(self):
         assert dates.format_date(d, 'w', locale='en_US') == '14'
 
 
-class FormatDatetimeTestCase(unittest.TestCase):
+class FormatDatetimeTestCase:
 
-    def test_with_float(self):
-        d = datetime(2012, 4, 1, 15, 30, 29, tzinfo=timezone('UTC'))
+    def test_with_float(self, timezone_getter):
+        UTC = timezone_getter('UTC')
+        d = datetime(2012, 4, 1, 15, 30, 29, tzinfo=UTC)
         epoch = float(calendar.timegm(d.timetuple()))
         formatted_string = dates.format_datetime(epoch, format='long', locale='en_US')
         assert formatted_string == u'April 1, 2012 at 3:30:29 PM UTC'
 
-    def test_timezone_formats_los_angeles(self):
-        dt = datetime(2016, 1, 13, 7, 8, 35)
-        tz = dates.get_timezone('America/Los_Angeles')
-        dt = tz.localize(dt)
+    def test_timezone_formats_los_angeles(self, timezone_getter):
+        tz = timezone_getter('America/Los_Angeles')
+        dt = _localize(tz, datetime(2016, 1, 13, 7, 8, 35))
         assert dates.format_datetime(dt, 'z', locale='en') == u'PST'
         assert dates.format_datetime(dt, 'zz', locale='en') == u'PST'
         assert dates.format_datetime(dt, 'zzz', locale='en') == u'PST'
@@ -300,10 +310,9 @@ def test_timezone_formats_los_angeles(self):
         assert dates.format_datetime(dt, 'xxxx', locale='en') == u'-0800'
         assert dates.format_datetime(dt, 'xxxxx', locale='en') == u'-08:00'
 
-    def test_timezone_formats_utc(self):
-        dt = datetime(2016, 1, 13, 7, 8, 35)
-        tz = dates.get_timezone('UTC')
-        dt = tz.localize(dt)
+    def test_timezone_formats_utc(self, timezone_getter):
+        tz = timezone_getter('UTC')
+        dt = _localize(tz, datetime(2016, 1, 13, 7, 8, 35))
         assert dates.format_datetime(dt, 'Z', locale='en') == u'+0000'
         assert dates.format_datetime(dt, 'ZZ', locale='en') == u'+0000'
         assert dates.format_datetime(dt, 'ZZZ', locale='en') == u'+0000'
@@ -323,10 +332,9 @@ def test_timezone_formats_utc(self):
         assert dates.format_datetime(dt, 'xxxx', locale='en') == u'+0000'
         assert dates.format_datetime(dt, 'xxxxx', locale='en') == u'+00:00'
 
-    def test_timezone_formats_kolkata(self):
-        dt = datetime(2016, 1, 13, 7, 8, 35)
-        tz = dates.get_timezone('Asia/Kolkata')
-        dt = tz.localize(dt)
+    def test_timezone_formats_kolkata(self, timezone_getter):
+        tz = timezone_getter('Asia/Kolkata')
+        dt = _localize(tz, datetime(2016, 1, 13, 7, 8, 35))
         assert dates.format_datetime(dt, 'zzzz', locale='en') == u'India Standard Time'
         assert dates.format_datetime(dt, 'ZZZZ', locale='en') == u'GMT+05:30'
         assert dates.format_datetime(dt, 'ZZZZZ', locale='en') == u'+05:30'
@@ -345,18 +353,19 @@ def test_timezone_formats_kolkata(self):
         assert dates.format_datetime(dt, 'xxxxx', locale='en') == u'+05:30'
 
 
-class FormatTimeTestCase(unittest.TestCase):
+class FormatTimeTestCase:
 
-    def test_with_naive_datetime_and_tzinfo(self):
+    def test_with_naive_datetime_and_tzinfo(self, timezone_getter):
         assert dates.format_time(
             datetime(2007, 4, 1, 15, 30),
             'long',
-            tzinfo=timezone('US/Eastern'),
+            tzinfo=timezone_getter('US/Eastern'),
             locale='en',
         ) == '11:30:00 AM EDT'
 
-    def test_with_float(self):
-        d = datetime(2012, 4, 1, 15, 30, 29, tzinfo=timezone('UTC'))
+    def test_with_float(self, timezone_getter):
+        tz = timezone_getter('UTC')
+        d = _localize(tz, datetime(2012, 4, 1, 15, 30, 29))
         epoch = float(calendar.timegm(d.timetuple()))
         assert dates.format_time(epoch, format='long', locale='en_US') == u'3:30:29 PM UTC'
 
@@ -369,7 +378,7 @@ def test_with_date_fields_in_pattern_and_datetime_param(self):
             dates.format_time(datetime(2007, 4, 1, 15, 30), "yyyy-MM-dd HH:mm", locale='en_US')
 
 
-class FormatTimedeltaTestCase(unittest.TestCase):
+class FormatTimedeltaTestCase:
 
     def test_zero_seconds(self):
         td = timedelta(seconds=0)
@@ -398,7 +407,7 @@ def test_format_invalid(self):
                 dates.format_timedelta(timedelta(hours=1), format=format)
 
 
-class TimeZoneAdjustTestCase(unittest.TestCase):
+class TimeZoneAdjustTestCase:
 
     def _utc(self):
         class EvilFixedOffsetTimezone(FixedOffsetTimezone):
@@ -410,7 +419,7 @@ def localize(self, dt, is_dst=False):
         assert hasattr(UTC, 'normalize') is False
         return UTC
 
-    def test_can_format_time_with_non_pytz_timezone(self):
+    def test_can_format_time_with_custom_timezone(self):
         # regression test for #257
         utc = self._utc()
         t = datetime(2007, 4, 1, 15, 30, tzinfo=utc)
@@ -465,13 +474,13 @@ def test_get_time_format():
             u'HH:mm:ss zzzz')
 
 
-def test_get_timezone_gmt():
+def test_get_timezone_gmt(timezone_getter):
     dt = datetime(2007, 4, 1, 15, 30)
     assert dates.get_timezone_gmt(dt, locale='en') == u'GMT+00:00'
     assert dates.get_timezone_gmt(dt, locale='en', return_z=True) == 'Z'
     assert dates.get_timezone_gmt(dt, locale='en', width='iso8601_short') == u'+00'
-    tz = timezone('America/Los_Angeles')
-    dt = tz.localize(datetime(2007, 4, 1, 15, 30))
+    tz = timezone_getter('America/Los_Angeles')
+    dt = _localize(tz, datetime(2007, 4, 1, 15, 30))
     assert dates.get_timezone_gmt(dt, locale='en') == u'GMT-07:00'
     assert dates.get_timezone_gmt(dt, 'short', locale='en') == u'-0700'
     assert dates.get_timezone_gmt(dt, locale='en', width='iso8601_short') == u'-07'
@@ -582,21 +591,27 @@ def test_format_date():
             u"Sun, Apr 1, '07")
 
 
-def test_format_datetime():
+def test_format_datetime(timezone_getter):
     dt = datetime(2007, 4, 1, 15, 30)
     assert (dates.format_datetime(dt, locale='en_US') ==
             u'Apr 1, 2007, 3:30:00 PM')
 
-    full = dates.format_datetime(dt, 'full', tzinfo=timezone('Europe/Paris'),
-                                 locale='fr_FR')
+    full = dates.format_datetime(
+        dt, 'full',
+        tzinfo=timezone_getter('Europe/Paris'),
+        locale='fr_FR'
+    )
     assert full == (u'dimanche 1 avril 2007 à 17:30:00 heure '
                     u'd\u2019\xe9t\xe9 d\u2019Europe centrale')
-    custom = dates.format_datetime(dt, "yyyy.MM.dd G 'at' HH:mm:ss zzz",
-                                   tzinfo=timezone('US/Eastern'), locale='en')
+    custom = dates.format_datetime(
+        dt, "yyyy.MM.dd G 'at' HH:mm:ss zzz",
+        tzinfo=timezone_getter('US/Eastern'),
+        locale='en'
+    )
     assert custom == u'2007.04.01 AD at 11:30:00 EDT'
 
 
-def test_format_time():
+def test_format_time(timezone_getter):
     t = time(15, 30)
     assert dates.format_time(t, locale='en_US') == u'3:30:00 PM'
     assert dates.format_time(t, format='short', locale='de_DE') == u'15:30'
@@ -604,31 +619,31 @@ def test_format_time():
     assert (dates.format_time(t, "hh 'o''clock' a", locale='en') ==
             u"03 o'clock PM")
 
-    t = datetime(2007, 4, 1, 15, 30)
-    tzinfo = timezone('Europe/Paris')
-    t = tzinfo.localize(t)
-    fr = dates.format_time(t, format='full', tzinfo=tzinfo, locale='fr_FR')
-    assert fr == u'15:30:00 heure d\u2019\xe9t\xe9 d\u2019Europe centrale'
-    custom = dates.format_time(t, "hh 'o''clock' a, zzzz",
-                               tzinfo=timezone('US/Eastern'), locale='en')
+    paris = timezone_getter('Europe/Paris')
+    eastern = timezone_getter('US/Eastern')
+
+    t = _localize(paris, datetime(2007, 4, 1, 15, 30))
+    fr = dates.format_time(t, format='full', tzinfo=paris, locale='fr_FR')
+    assert fr == '15:30:00 heure d’été d’Europe centrale'
+
+    custom = dates.format_time(t, "hh 'o''clock' a, zzzz", tzinfo=eastern, locale='en')
     assert custom == u"09 o'clock AM, Eastern Daylight Time"
 
     t = time(15, 30)
-    paris = dates.format_time(t, format='full',
-                              tzinfo=timezone('Europe/Paris'), locale='fr_FR')
-    assert paris == u'15:30:00 heure normale d\u2019Europe centrale'
-    us_east = dates.format_time(t, format='full',
-                                tzinfo=timezone('US/Eastern'), locale='en_US')
+    paris = dates.format_time(t, format='full', tzinfo=paris, locale='fr_FR')
+    assert paris == '15:30:00 heure normale d’Europe centrale'
+
+    us_east = dates.format_time(t, format='full', tzinfo=eastern, locale='en_US')
     assert us_east == u'3:30:00 PM Eastern Standard Time'
 
 
-def test_format_skeleton():
+def test_format_skeleton(timezone_getter):
     dt = datetime(2007, 4, 1, 15, 30)
     assert (dates.format_skeleton('yMEd', dt, locale='en_US') == u'Sun, 4/1/2007')
     assert (dates.format_skeleton('yMEd', dt, locale='th') == u'อา. 1/4/2007')
 
     assert (dates.format_skeleton('EHm', dt, locale='en') == u'Sun 15:30')
-    assert (dates.format_skeleton('EHm', dt, tzinfo=timezone('Asia/Bangkok'), locale='th') == u'อา. 22:30 น.')
+    assert (dates.format_skeleton('EHm', dt, tzinfo=timezone_getter('Asia/Bangkok'), locale='th') == u'อา. 22:30 น.')
 
 
 def test_format_timedelta():
@@ -721,18 +736,18 @@ def test_format_current_moment():
 
 
 @pytest.mark.all_locales
-def test_no_inherit_metazone_marker_never_in_output(locale):
+def test_no_inherit_metazone_marker_never_in_output(locale, timezone_getter):
     # See: https://github.com/python-babel/babel/issues/428
-    tz = pytz.timezone('America/Los_Angeles')
-    t = tz.localize(datetime(2016, 1, 6, 7))
+    tz = timezone_getter('America/Los_Angeles')
+    t = _localize(tz, datetime(2016, 1, 6, 7))
     assert NO_INHERITANCE_MARKER not in dates.format_time(t, format='long', locale=locale)
     assert NO_INHERITANCE_MARKER not in dates.get_timezone_name(t, width='short', locale=locale)
 
 
-def test_no_inherit_metazone_formatting():
+def test_no_inherit_metazone_formatting(timezone_getter):
     # See: https://github.com/python-babel/babel/issues/428
-    tz = pytz.timezone('America/Los_Angeles')
-    t = tz.localize(datetime(2016, 1, 6, 7))
+    tz = timezone_getter('America/Los_Angeles')
+    t = _localize(tz, datetime(2016, 1, 6, 7))
     assert dates.format_time(t, format='long', locale='en_US') == "7:00:00 AM PST"
     assert dates.format_time(t, format='long', locale='en_GB') == "07:00:00 Pacific Standard Time"
     assert dates.get_timezone_name(t, width='short', locale='en_US') == "PST"
diff --git a/tests/test_support.py b/tests/test_support.py
index c73e53ba7..d39d8ef6d 100644
--- a/tests/test_support.py
+++ b/tests/test_support.py
@@ -23,6 +23,8 @@
 from babel import support
 from babel.messages import Catalog
 from babel.messages.mofile import write_mo
+from babel.dates import get_timezone
+from .test_dates import timezone_getter
 
 
 SKIP_LGETTEXT = sys.version_info >= (3, 8)
@@ -300,16 +302,14 @@ def test_format_date():
     assert fmt.date(date(2007, 4, 1)) == 'Apr 1, 2007'
 
 
-def test_format_datetime():
-    from pytz import timezone
-    fmt = support.Format('en_US', tzinfo=timezone('US/Eastern'))
+def test_format_datetime(timezone_getter):
+    fmt = support.Format('en_US', tzinfo=timezone_getter('US/Eastern'))
     when = datetime(2007, 4, 1, 15, 30)
     assert fmt.datetime(when) == 'Apr 1, 2007, 11:30:00 AM'
 
 
-def test_format_time():
-    from pytz import timezone
-    fmt = support.Format('en_US', tzinfo=timezone('US/Eastern'))
+def test_format_time(timezone_getter):
+    fmt = support.Format('en_US', tzinfo=timezone_getter('US/Eastern'))
     assert fmt.time(datetime(2007, 4, 1, 15, 30)) == '11:30:00 AM'
 
 

From 27380daecb325d39ab62deffde7fba8e494cfefd Mon Sep 17 00:00:00 2001
From: Aarni Koskela <akx@iki.fi>
Date: Wed, 18 Jan 2023 11:01:11 +0200
Subject: [PATCH 16/53] Unify datetime imports (#945)

Co-authored-by: Jonah Lawrence <jonah@freshidea.com>
---
 babel/dates.py              | 247 +++++++++++++++++++++++-------------
 babel/localtime/__init__.py |  20 +--
 babel/localtime/_unix.py    |   6 +-
 babel/localtime/_win32.py   |   4 +-
 babel/messages/catalog.py   |  21 +--
 babel/messages/frontend.py  |   6 +-
 babel/numbers.py            |  24 ++--
 babel/support.py            |  33 +++--
 babel/util.py               |  12 +-
 9 files changed, 223 insertions(+), 150 deletions(-)

diff --git a/babel/dates.py b/babel/dates.py
index f7289619f..05cfa251c 100644
--- a/babel/dates.py
+++ b/babel/dates.py
@@ -29,7 +29,7 @@
 
 from bisect import bisect_right
 from collections.abc import Iterable
-from datetime import date, datetime, time, timedelta, tzinfo
+import datetime
 
 from babel import localtime
 from babel.core import Locale, default_locale, get_global
@@ -37,10 +37,10 @@
 
 if TYPE_CHECKING:
     from typing_extensions import Literal, TypeAlias
-    _Instant: TypeAlias = date | time | float | None
+    _Instant: TypeAlias = datetime.date | datetime.time | float | None
     _PredefinedTimeFormat: TypeAlias = Literal['full', 'long', 'medium', 'short']
     _Context: TypeAlias = Literal['format', 'stand-alone']
-    _DtOrTzinfo: TypeAlias = datetime | tzinfo | str | int | time | None
+    _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
@@ -60,13 +60,8 @@
 
 LC_TIME = default_locale('LC_TIME')
 
-# Aliases for use in scopes where the modules are shadowed by local variables
-date_ = date
-datetime_ = datetime
-time_ = time
 
-
-def _localize(tz: tzinfo, dt: datetime) -> datetime:
+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:
@@ -83,8 +78,7 @@ def _localize(tz: tzinfo, dt: datetime) -> datetime:
     return dt.astimezone(tz)
 
 
-
-def _get_dt_and_tzinfo(dt_or_tzinfo: _DtOrTzinfo) -> tuple[datetime_ | None, tzinfo]:
+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.
 
@@ -93,7 +87,7 @@ def _get_dt_and_tzinfo(dt_or_tzinfo: _DtOrTzinfo) -> tuple[datetime_ | None, tzi
     :rtype: tuple[datetime, tzinfo]
     """
     if dt_or_tzinfo is None:
-        dt = datetime.now()
+        dt = datetime.datetime.now()
         tzinfo = LOCALTZ
     elif isinstance(dt_or_tzinfo, str):
         dt = None
@@ -101,7 +95,7 @@ def _get_dt_and_tzinfo(dt_or_tzinfo: _DtOrTzinfo) -> tuple[datetime_ | None, tzi
     elif isinstance(dt_or_tzinfo, int):
         dt = None
         tzinfo = UTC
-    elif isinstance(dt_or_tzinfo, (datetime, time)):
+    elif isinstance(dt_or_tzinfo, (datetime.datetime, datetime.time)):
         dt = _get_datetime(dt_or_tzinfo)
         if dt.tzinfo is not None:
             tzinfo = dt.tzinfo
@@ -125,10 +119,10 @@ def _get_tz_name(dt_or_tzinfo: _DtOrTzinfo) -> str:
     elif hasattr(tzinfo, 'key') and tzinfo.key is not None:  # ZoneInfo object
         return tzinfo.key
     else:
-        return tzinfo.tzname(dt or datetime.utcnow())
+        return tzinfo.tzname(dt or datetime.datetime.utcnow())
 
 
-def _get_datetime(instant: _Instant) -> datetime_:
+def _get_datetime(instant: _Instant) -> datetime.datetime:
     """
     Get a datetime out of an "instant" (date, time, datetime, number).
 
@@ -139,6 +133,7 @@ def _get_datetime(instant: _Instant) -> datetime_:
 
     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)
 
@@ -159,18 +154,18 @@ def _get_datetime(instant: _Instant) -> datetime_:
     :rtype: datetime
     """
     if instant is None:
-        return datetime_.utcnow()
+        return datetime.datetime.utcnow()
     elif isinstance(instant, int) or isinstance(instant, float):
-        return datetime_.utcfromtimestamp(instant)
-    elif isinstance(instant, time):
-        return datetime_.combine(date.today(), instant)
-    elif isinstance(instant, date) and not isinstance(instant, datetime):
-        return datetime_.combine(instant, time())
+        return datetime.datetime.utcfromtimestamp(instant)
+    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(datetime: datetime_, tzinfo: tzinfo | None = None) -> datetime_:
+def _ensure_datetime_tzinfo(dt: datetime.datetime, tzinfo: datetime.tzinfo | None = None) -> datetime.datetime:
     """
     Ensure the datetime passed has an attached tzinfo.
 
@@ -178,6 +173,7 @@ def _ensure_datetime_tzinfo(datetime: datetime_, tzinfo: tzinfo | None = None) -
 
     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'
 
@@ -190,16 +186,19 @@ def _ensure_datetime_tzinfo(datetime: datetime_, tzinfo: tzinfo | None = None) -
     :return: datetime with tzinfo
     :rtype: datetime
     """
-    if datetime.tzinfo is None:
-        datetime = datetime.replace(tzinfo=UTC)
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=UTC)
     if tzinfo is not None:
-        datetime = datetime.astimezone(get_timezone(tzinfo))
+        dt = dt.astimezone(get_timezone(tzinfo))
         if hasattr(tzinfo, 'normalize'):  # pytz
-            datetime = tzinfo.normalize(datetime)
-    return datetime
+            dt = tzinfo.normalize(dt)
+    return dt
 
 
-def _get_time(time: time | datetime | None, tzinfo: tzinfo | None = None) -> time:
+def _get_time(
+    time: datetime.time | datetime.datetime | None,
+    tzinfo: datetime.tzinfo | None = None,
+) -> datetime.time:
     """
     Get a timezoned time from a given instant.
 
@@ -209,14 +208,14 @@ def _get_time(time: time | datetime | None, tzinfo: tzinfo | None = None) -> tim
     :rtype: time
     """
     if time is None:
-        time = datetime.utcnow()
+        time = datetime.datetime.utcnow()
     elif isinstance(time, (int, float)):
-        time = datetime.utcfromtimestamp(time)
+        time = datetime.datetime.utcfromtimestamp(time)
 
     if time.tzinfo is None:
         time = time.replace(tzinfo=UTC)
 
-    if isinstance(time, datetime):
+    if isinstance(time, datetime.datetime):
         if tzinfo is not None:
             time = time.astimezone(tzinfo)
             if hasattr(tzinfo, 'normalize'):  # pytz
@@ -227,7 +226,7 @@ def _get_time(time: time | datetime | None, tzinfo: tzinfo | None = None) -> tim
     return time
 
 
-def get_timezone(zone: str | tzinfo | None = None) -> tzinfo:
+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
@@ -260,7 +259,7 @@ def get_timezone(zone: str | tzinfo | None = None) -> tzinfo:
     raise LookupError(f"Unknown timezone {zone}") from exc
 
 
-def get_next_timezone_transition(zone: tzinfo | None = None, dt: _Instant = None) -> TimezoneTransition:
+def get_next_timezone_transition(zone: datetime.tzinfo | None = None, dt: _Instant = None) -> TimezoneTransition:
     """Given a timezone it will return a :class:`TimezoneTransition` object
     that holds the information about the next timezone transition that's going
     to happen.  For instance this can be used to detect when the next DST
@@ -332,7 +331,13 @@ class TimezoneTransition:
         to the :func:`get_next_timezone_transition`.
     """
 
-    def __init__(self, activates: datetime_, from_tzinfo: tzinfo, to_tzinfo: tzinfo, reference_date: datetime_ | None = None):
+    def __init__(
+        self,
+        activates: datetime.datetime,
+        from_tzinfo: datetime.tzinfo,
+        to_tzinfo: datetime.tzinfo,
+        reference_date: datetime.datetime | None = None,
+    ) -> None:
         warnings.warn(
             "TimezoneTransition is deprecated and will be "
             "removed in the next version of Babel. "
@@ -503,11 +508,16 @@ def get_time_format(format: _PredefinedTimeFormat = 'medium', locale: Locale | s
     return Locale.parse(locale).time_formats[format]
 
 
-def get_timezone_gmt(datetime: _Instant = None, width: Literal['long', 'short', 'iso8601', 'iso8601_short'] = 'long',
-                     locale: Locale | str | None = LC_TIME, return_z: bool = False) -> str:
+def get_timezone_gmt(
+    datetime: _Instant = None,
+    width: Literal['long', 'short', 'iso8601', 'iso8601_short'] = 'long',
+    locale: Locale | str | None = LC_TIME,
+    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'
@@ -558,9 +568,12 @@ def get_timezone_gmt(datetime: _Instant = None, width: Literal['long', 'short',
     return pattern % (hours, seconds // 60)
 
 
-def get_timezone_location(dt_or_tzinfo: _DtOrTzinfo = None, locale: Locale | str | None = LC_TIME,
-                          return_city: bool = False) -> str:
-    u"""Return a representation of the given timezone using "location format".
+def get_timezone_location(
+    dt_or_tzinfo: _DtOrTzinfo = None,
+    locale: Locale | str | None = LC_TIME,
+    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:
@@ -635,12 +648,18 @@ def get_timezone_location(dt_or_tzinfo: _DtOrTzinfo = None, locale: Locale | str
     })
 
 
-def get_timezone_name(dt_or_tzinfo: _DtOrTzinfo = None, width: Literal['long', 'short'] = 'long', uncommon: bool = False,
-                      locale: Locale | str | None = LC_TIME, zone_variant: Literal['generic', 'daylight', 'standard'] | None = None,
-                      return_zone: bool = False) -> str:
+def get_timezone_name(
+    dt_or_tzinfo: _DtOrTzinfo = None,
+    width: Literal['long', 'short'] = 'long',
+    uncommon: bool = False,
+    locale: Locale | str | None = LC_TIME,
+    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')
     u'Pacific Standard Time'
@@ -755,10 +774,14 @@ def get_timezone_name(dt_or_tzinfo: _DtOrTzinfo = None, width: Literal['long', '
     return get_timezone_location(dt_or_tzinfo, locale=locale)
 
 
-def format_date(date: date | None = None, format: _PredefinedTimeFormat | str = 'medium',
-                locale: Locale | str | None = LC_TIME) -> str:
+def format_date(
+    date: datetime.date | None = None,
+    format: _PredefinedTimeFormat | str = 'medium',
+    locale: Locale | str | None = LC_TIME,
+) -> 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'
@@ -778,8 +801,8 @@ def format_date(date: date | None = None, format: _PredefinedTimeFormat | str =
     :param locale: a `Locale` object or a locale identifier
     """
     if date is None:
-        date = date_.today()
-    elif isinstance(date, datetime):
+        date = datetime.date.today()
+    elif isinstance(date, datetime.datetime):
         date = date.date()
 
     locale = Locale.parse(locale)
@@ -789,10 +812,15 @@ def format_date(date: date | None = None, format: _PredefinedTimeFormat | str =
     return pattern.apply(date, locale)
 
 
-def format_datetime(datetime: _Instant = None, format: _PredefinedTimeFormat | str = 'medium', tzinfo: tzinfo | None = None,
-                    locale: Locale | str | None = LC_TIME) -> str:
+def format_datetime(
+    datetime: _Instant = None,
+    format: _PredefinedTimeFormat | str = 'medium',
+    tzinfo: datetime.tzinfo | None = None,
+    locale: Locale | str | None = LC_TIME,
+) -> 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 PM'
@@ -826,10 +854,14 @@ def format_datetime(datetime: _Instant = None, format: _PredefinedTimeFormat | s
         return parse_pattern(format).apply(datetime, locale)
 
 
-def format_time(time: time | datetime | float | None = None, format: _PredefinedTimeFormat | str = 'medium',
-                tzinfo: tzinfo | None = None, locale: Locale | str | None = LC_TIME) -> str:
+def format_time(
+    time: datetime.time | datetime.datetime | float | None = None,
+    format: _PredefinedTimeFormat | str = 'medium',
+    tzinfo: datetime.tzinfo | None = None, locale: Locale | str | None = LC_TIME,
+) -> 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 PM'
@@ -885,7 +917,7 @@ def format_time(time: time | datetime | float | None = None, format: _Predefined
 
     # get reference date for if we need to find the right timezone variant
     # in the pattern
-    ref_date = time.date() if isinstance(time, datetime) else None
+    ref_date = time.date() if isinstance(time, datetime.datetime) else None
 
     time = _get_time(time, tzinfo)
 
@@ -895,8 +927,13 @@ def format_time(time: time | datetime | float | None = None, format: _Predefined
     return parse_pattern(format).apply(time, locale, reference_date=ref_date)
 
 
-def format_skeleton(skeleton: str, datetime: _Instant = None, tzinfo: tzinfo | None = None,
-                    fuzzy: bool = True, locale: Locale | str | None = LC_TIME) -> str:
+def format_skeleton(
+    skeleton: str,
+    datetime: _Instant = None,
+    tzinfo: datetime.tzinfo | None = None,
+    fuzzy: bool = True,
+    locale: Locale | str | None = LC_TIME,
+) -> 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
@@ -904,6 +941,7 @@ def format_skeleton(skeleton: str, datetime: _Instant = None, tzinfo: tzinfo | N
     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.'
@@ -945,12 +983,17 @@ def format_skeleton(skeleton: str, datetime: _Instant = None, tzinfo: tzinfo | N
 )
 
 
-def format_timedelta(delta: 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 = LC_TIME) -> str:
+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 = LC_TIME,
+) -> 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')
@@ -959,8 +1002,7 @@ def format_timedelta(delta: timedelta | int,
     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')
+    >>> 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
@@ -1011,7 +1053,7 @@ def format_timedelta(delta: timedelta | int,
                       ' is deprecated. Use "long" instead',
                       category=DeprecationWarning)
         format = 'long'
-    if isinstance(delta, timedelta):
+    if isinstance(delta, datetime.timedelta):
         seconds = int((delta.days * 86400) + delta.seconds)
     else:
         seconds = delta
@@ -1047,13 +1089,18 @@ def _iter_patterns(a_unit):
     return u''
 
 
-def _format_fallback_interval(start: _Instant, end: _Instant, skeleton: str | None, tzinfo: tzinfo | None,
-                              locale: Locale | str | None = LC_TIME) -> str:
+def _format_fallback_interval(
+    start: _Instant,
+    end: _Instant,
+    skeleton: str | None,
+    tzinfo: datetime.tzinfo | None,
+    locale: Locale | str | None = LC_TIME,
+) -> 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, date) and not isinstance(d, datetime)) for d in (start, end)):  # Both are just dates
+    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, time) and not isinstance(d, date)) for d in (start, end)):  # Both are times
+    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)
@@ -1071,11 +1118,18 @@ def _format_fallback_interval(start: _Instant, end: _Instant, skeleton: str | No
     )
 
 
-def format_interval(start: _Instant, end: _Instant, skeleton: str | None = None, tzinfo: tzinfo | None = None,
-                    fuzzy: bool = True, locale: Locale | str | None = LC_TIME) -> str:
+def format_interval(
+    start: _Instant,
+    end: _Instant,
+    skeleton: str | None = None,
+    tzinfo: datetime.tzinfo | None = None,
+    fuzzy: bool = True,
+    locale: Locale | str | None = LC_TIME,
+) -> 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'
 
@@ -1170,13 +1224,18 @@ def format_interval(start: _Instant, end: _Instant, skeleton: str | None = None,
     return _format_fallback_interval(start, end, skeleton, tzinfo, locale)
 
 
-def get_period_id(time: _Instant, tzinfo: tzinfo | None = None, type: Literal['selection'] | None = None,
-                  locale: Locale | str | None = LC_TIME) -> str:
+def get_period_id(
+    time: _Instant,
+    tzinfo: datetime.tzinfo | None = None,
+    type: Literal['selection'] | None = None,
+    locale: Locale | str | None = LC_TIME,
+) -> 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'
 
@@ -1245,7 +1304,11 @@ class ParseError(ValueError):
     pass
 
 
-def parse_date(string: str, locale: Locale | str | None = LC_TIME, format: _PredefinedTimeFormat = 'medium') -> date:
+def parse_date(
+    string: str,
+    locale: Locale | str | None = LC_TIME,
+    format: _PredefinedTimeFormat = 'medium',
+) -> datetime.date:
     """Parse a date from a string.
 
     This function first tries to interpret the string as ISO-8601
@@ -1275,7 +1338,7 @@ def parse_date(string: str, locale: Locale | str | None = LC_TIME, format: _Pred
                          string, flags=re.ASCII)  # allow only ASCII digits
     if iso_alike:
         try:
-            return date(*map(int, iso_alike.groups()))
+            return datetime.date(*map(int, iso_alike.groups()))
         except ValueError:
             pass  # a locale format might fit better, so let's continue
 
@@ -1302,10 +1365,14 @@ def parse_date(string: str, locale: Locale | str | None = LC_TIME, format: _Pred
     day = int(numbers[indexes['D']])
     if month > 12:
         month, day = day, month
-    return date(year, month, day)
+    return datetime.date(year, month, day)
 
 
-def parse_time(string: str, locale: Locale | str | None = LC_TIME, format: _PredefinedTimeFormat = 'medium') -> time:
+def parse_time(
+    string: str,
+    locale: Locale | str | None = LC_TIME,
+    format: _PredefinedTimeFormat = 'medium',
+) -> datetime.time:
     """Parse a time from a string.
 
     This function uses the time format for the locale as a hint to determine
@@ -1352,7 +1419,7 @@ def parse_time(string: str, locale: Locale | str | None = LC_TIME, format: _Pred
         minute = int(numbers[indexes['M']])
         if len(numbers) > 2:
             second = int(numbers[indexes['S']])
-    return time(hour, minute, second)
+    return datetime.time(hour, minute, second)
 
 
 class DateTimePattern:
@@ -1375,9 +1442,9 @@ def __mod__(self, other: DateTimeFormat) -> str:
 
     def apply(
         self,
-        datetime: date | time,
+        datetime: datetime.date | datetime.time,
         locale: Locale | str | None,
-        reference_date: date | None = None
+        reference_date: datetime.date | None = None,
     ) -> str:
         return self % DateTimeFormat(datetime, locale, reference_date)
 
@@ -1386,12 +1453,12 @@ class DateTimeFormat:
 
     def __init__(
         self,
-        value: date | time,
+        value: datetime.date | datetime.time,
         locale: Locale | str,
-        reference_date: date | None = None
-    ):
-        assert isinstance(value, (date, datetime, time))
-        if isinstance(value, (datetime, time)) and value.tzinfo is None:
+        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)
@@ -1500,14 +1567,14 @@ def format_week(self, char: str, num: int) -> str:
             day_of_year = self.get_day_of_year()
             week = self.get_week_number(day_of_year)
             if week == 0:
-                date = self.value - timedelta(days=day_of_year)
+                date = self.value - datetime.timedelta(days=day_of_year)
                 week = self.get_week_number(self.get_day_of_year(date),
                                             date.weekday())
             return self.format(week, num)
         else:  # week of month
             week = self.get_week_number(self.value.day)
             if week == 0:
-                date = self.value - timedelta(days=self.value.day)
+                date = self.value - datetime.timedelta(days=self.value.day)
                 week = self.get_week_number(date.day, date.weekday())
             return str(week)
 
@@ -1515,6 +1582,7 @@ 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'
@@ -1561,6 +1629,7 @@ 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.'
@@ -1621,7 +1690,7 @@ def format_timezone(self, char: str, num: int) -> str:
         # variants (summer/standard time)
         value = self.value
         if self.reference_date:
-            value = datetime.combine(self.reference_date, self.value)
+            value = datetime.datetime.combine(self.reference_date, self.value)
 
         if char == 'z':
             return get_timezone_name(value, width, locale=self.locale)
@@ -1667,7 +1736,7 @@ def format_timezone(self, char: str, num: int) -> str:
     def format(self, value: SupportsInt, length: int) -> str:
         return '%0*d' % (length, value)
 
-    def get_day_of_year(self, date: date | None = None) -> int:
+    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
@@ -1680,12 +1749,10 @@ def get_week_number(self, day_of_period: int, day_of_week: int | None = None) ->
         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.
 
-        >>> format = DateTimeFormat(date(2006, 1, 8), Locale.parse('de_DE'))
-        >>> format.get_week_number(6)
+        >>> date = datetime.date(2006, 1, 8)
+        >>> DateTimeFormat(date, 'de_DE').get_week_number(6)
         1
-
-        >>> format = DateTimeFormat(date(2006, 1, 8), Locale.parse('en_US'))
-        >>> format.get_week_number(6)
+        >>> DateTimeFormat(date, 'en_US').get_week_number(6)
         2
 
         :param day_of_period: the number of the day in the period (usually
@@ -1710,7 +1777,7 @@ def get_week_number(self, day_of_period: int, day_of_week: int | None = None) ->
             # we must count from zero.For example the above calculation gives week 53
             # for 2018-12-31. By iso-calender definition 2018 has a max of 52
             # weeks, thus the weeknumber must be 53-52=1.
-            max_weeks = date(year=self.value.year, day=28, month=12).isocalendar()[1]
+            max_weeks = datetime.date(year=self.value.year, day=28, month=12).isocalendar()[1]
             if week_number > max_weeks:
                 week_number -= max_weeks
 
diff --git a/babel/localtime/__init__.py b/babel/localtime/__init__.py
index c7f214aa8..9d227c7b1 100644
--- a/babel/localtime/__init__.py
+++ b/babel/localtime/__init__.py
@@ -11,7 +11,7 @@
 
 import sys
 import time
-from datetime import datetime, timedelta, tzinfo
+import datetime
 from threading import RLock
 
 if sys.platform == 'win32':
@@ -23,34 +23,34 @@
 _cached_tz = None
 _cache_lock = RLock()
 
-STDOFFSET = timedelta(seconds=-time.timezone)
+STDOFFSET = datetime.timedelta(seconds=-time.timezone)
 if time.daylight:
-    DSTOFFSET = timedelta(seconds=-time.altzone)
+    DSTOFFSET = datetime.timedelta(seconds=-time.altzone)
 else:
     DSTOFFSET = STDOFFSET
 
 DSTDIFF = DSTOFFSET - STDOFFSET
-ZERO = timedelta(0)
+ZERO = datetime.timedelta(0)
 
 
-class _FallbackLocalTimezone(tzinfo):
+class _FallbackLocalTimezone(datetime.tzinfo):
 
-    def utcoffset(self, dt: datetime) -> timedelta:
+    def utcoffset(self, dt: datetime.datetime) -> datetime.timedelta:
         if self._isdst(dt):
             return DSTOFFSET
         else:
             return STDOFFSET
 
-    def dst(self, dt: datetime) -> timedelta:
+    def dst(self, dt: datetime.datetime) -> datetime.timedelta:
         if self._isdst(dt):
             return DSTDIFF
         else:
             return ZERO
 
-    def tzname(self, dt: datetime) -> str:
+    def tzname(self, dt: datetime.datetime) -> str:
         return time.tzname[self._isdst(dt)]
 
-    def _isdst(self, dt: datetime) -> bool:
+    def _isdst(self, dt: datetime.datetime) -> bool:
         tt = (dt.year, dt.month, dt.day,
               dt.hour, dt.minute, dt.second,
               dt.weekday(), 0, -1)
@@ -59,7 +59,7 @@ def _isdst(self, dt: datetime) -> bool:
         return tt.tm_isdst > 0
 
 
-def get_localzone() -> tzinfo:
+def get_localzone() -> datetime.tzinfo:
     """Returns the current underlying local timezone object.
     Generally this function does not need to be used, it's a
     better idea to use the :data:`LOCALTZ` singleton instead.
diff --git a/babel/localtime/_unix.py b/babel/localtime/_unix.py
index 319c8cfbc..89b461a01 100644
--- a/babel/localtime/_unix.py
+++ b/babel/localtime/_unix.py
@@ -1,7 +1,7 @@
 import os
 import re
 
-from datetime import tzinfo
+import datetime
 
 from babel.localtime._helpers import (
     _get_tzinfo_from_file,
@@ -9,7 +9,7 @@
     _get_tzinfo,
 )
 
-def _tz_from_env(tzenv: str) -> tzinfo:
+def _tz_from_env(tzenv: str) -> datetime.tzinfo:
     if tzenv[0] == ':':
         tzenv = tzenv[1:]
 
@@ -21,7 +21,7 @@ def _tz_from_env(tzenv: str) -> tzinfo:
     return _get_tzinfo_or_raise(tzenv)
 
 
-def _get_localzone(_root: str = '/') -> tzinfo:
+def _get_localzone(_root: str = '/') -> datetime.tzinfo:
     """Tries to find the local timezone configuration.
     This method prefers finding the timezone name and passing that to
     zoneinfo or pytz, over passing in the localtime file, as in the later
diff --git a/babel/localtime/_win32.py b/babel/localtime/_win32.py
index 3d7e0d512..42f819a21 100644
--- a/babel/localtime/_win32.py
+++ b/babel/localtime/_win32.py
@@ -5,7 +5,7 @@
 except ImportError:
     winreg = None
 
-from datetime import tzinfo
+import datetime
 from babel.core import get_global
 from babel.localtime._helpers import _get_tzinfo_or_raise
 from typing import Any, Dict, cast
@@ -89,7 +89,7 @@ def get_localzone_name() -> str:
     return timezone
 
 
-def _get_localzone() -> tzinfo:
+def _get_localzone() -> datetime.tzinfo:
     if winreg is None:
         raise LookupError(
             'Runtime support not available')
diff --git a/babel/messages/catalog.py b/babel/messages/catalog.py
index 0801de371..4486bec4e 100644
--- a/babel/messages/catalog.py
+++ b/babel/messages/catalog.py
@@ -13,7 +13,7 @@
 
 from collections import OrderedDict
 from collections.abc import Generator, Iterable, Iterator
-from datetime import datetime, time as time_
+import datetime
 from difflib import get_close_matches
 from email import message_from_string
 from copy import copy
@@ -45,10 +45,10 @@
 ''', re.VERBOSE)
 
 
-def _parse_datetime_header(value: str) -> datetime:
+def _parse_datetime_header(value: str) -> datetime.datetime:
     match = re.match(r'^(?P<datetime>.*?)(?P<tzoffset>[+-]\d{4})?$', value)
 
-    dt = datetime.strptime(match.group('datetime'), '%Y-%m-%d %H:%M')
+    dt = datetime.datetime.strptime(match.group('datetime'), '%Y-%m-%d %H:%M')
 
     # Separate the offset into a sign component, hours, and # minutes
     tzoffset = match.group('tzoffset')
@@ -261,8 +261,8 @@ def __init__(
         version: str | None = None,
         copyright_holder: str | None = None,
         msgid_bugs_address: str | None = None,
-        creation_date: datetime | str | None = None,
-        revision_date: datetime | time_ | float | str | None = None,
+        creation_date: datetime.datetime | str | None = None,
+        revision_date: datetime.datetime | datetime.time | float | str | None = None,
         last_translator: str | None = None,
         language_team: str | None = None,
         charset: str | None = None,
@@ -306,13 +306,13 @@ def __init__(
         self.charset = charset or 'utf-8'
 
         if creation_date is None:
-            creation_date = datetime.now(LOCALTZ)
-        elif isinstance(creation_date, datetime) and not creation_date.tzinfo:
+            creation_date = datetime.datetime.now(LOCALTZ)
+        elif isinstance(creation_date, datetime.datetime) and not creation_date.tzinfo:
             creation_date = creation_date.replace(tzinfo=LOCALTZ)
         self.creation_date = creation_date
         if revision_date is None:
             revision_date = 'YEAR-MO-DA HO:MI+ZONE'
-        elif isinstance(revision_date, datetime) and not revision_date.tzinfo:
+        elif isinstance(revision_date, datetime.datetime) and not revision_date.tzinfo:
             revision_date = revision_date.replace(tzinfo=LOCALTZ)
         self.revision_date = revision_date
         self.fuzzy = fuzzy
@@ -354,7 +354,7 @@ def _get_locale_identifier(self) -> str | None:
 
     def _get_header_comment(self) -> str:
         comment = self._header_comment
-        year = datetime.now(LOCALTZ).strftime('%Y')
+        year = datetime.datetime.now(LOCALTZ).strftime('%Y')
         if hasattr(self.revision_date, 'strftime'):
             year = self.revision_date.strftime('%Y')
         comment = comment.replace('PROJECT', self.project) \
@@ -409,7 +409,7 @@ def _get_mime_headers(self) -> list[tuple[str, str]]:
         headers.append(('POT-Creation-Date',
                         format_datetime(self.creation_date, 'yyyy-MM-dd HH:mmZ',
                                         locale='en')))
-        if isinstance(self.revision_date, (datetime, time_, int, float)):
+        if isinstance(self.revision_date, (datetime.datetime, datetime.time, int, float)):
             headers.append(('PO-Revision-Date',
                             format_datetime(self.revision_date,
                                             'yyyy-MM-dd HH:mmZ', locale='en')))
@@ -481,6 +481,7 @@ def _set_mime_headers(self, headers: Iterable[tuple[str, str]]) -> None:
     Here's an example of the output for such a catalog template:
 
     >>> from babel.dates import UTC
+    >>> from datetime import datetime
     >>> created = datetime(1990, 4, 1, 15, 30, tzinfo=UTC)
     >>> catalog = Catalog(project='Foobar', version='1.0',
     ...                   creation_date=created)
diff --git a/babel/messages/frontend.py b/babel/messages/frontend.py
index c42cdc2e2..c7e921d09 100644
--- a/babel/messages/frontend.py
+++ b/babel/messages/frontend.py
@@ -18,7 +18,7 @@
 import tempfile
 from collections import OrderedDict
 from configparser import RawConfigParser
-from datetime import datetime
+import datetime
 from io import StringIO
 
 from babel import __version__ as VERSION
@@ -662,7 +662,7 @@ def run(self):
             catalog = read_po(infile, locale=self.locale)
 
         catalog.locale = self._locale
-        catalog.revision_date = datetime.now(LOCALTZ)
+        catalog.revision_date = datetime.datetime.now(LOCALTZ)
         catalog.fuzzy = False
 
         with open(self.output_file, 'wb') as outfile:
@@ -818,7 +818,7 @@ def run(self):
                     catalog = read_po(infile, locale=self.locale)
 
                 catalog.locale = self._locale
-                catalog.revision_date = datetime.now(LOCALTZ)
+                catalog.revision_date = datetime.datetime.now(LOCALTZ)
                 catalog.fuzzy = False
 
                 with open(filename, 'wb') as outfile:
diff --git a/babel/numbers.py b/babel/numbers.py
index 73155c4cf..95e9d2af0 100644
--- a/babel/numbers.py
+++ b/babel/numbers.py
@@ -23,7 +23,7 @@
 import re
 from typing import TYPE_CHECKING, Any, overload
 import warnings
-from datetime import date as date_, datetime as datetime_
+import datetime
 
 from babel.core import Locale, default_locale, get_global
 from babel.localedata import LocaleDataDict
@@ -200,8 +200,8 @@ def get_currency_unit_pattern(
 @overload
 def get_territory_currencies(
     territory: str,
-    start_date: date_ | None = ...,
-    end_date: date_ | None = ...,
+    start_date: datetime.date | None = ...,
+    end_date: datetime.date | None = ...,
     tender: bool = ...,
     non_tender: bool = ...,
     include_details: Literal[False] = ...,
@@ -212,8 +212,8 @@ def get_territory_currencies(
 @overload
 def get_territory_currencies(
     territory: str,
-    start_date: date_ | None = ...,
-    end_date: date_ | None = ...,
+    start_date: datetime.date | None = ...,
+    end_date: datetime.date | None = ...,
     tender: bool = ...,
     non_tender: bool = ...,
     include_details: Literal[True] = ...,
@@ -223,8 +223,8 @@ def get_territory_currencies(
 
 def get_territory_currencies(
     territory: str,
-    start_date: date_ | None = None,
-    end_date: date_ | None = None,
+    start_date: datetime.date | None = None,
+    end_date: datetime.date | None = None,
     tender: bool = True,
     non_tender: bool = False,
     include_details: bool = False,
@@ -280,12 +280,12 @@ def get_territory_currencies(
     """
     currencies = get_global('territory_currencies')
     if start_date is None:
-        start_date = date_.today()
-    elif isinstance(start_date, datetime_):
+        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_):
+    elif isinstance(end_date, datetime.datetime):
         end_date = end_date.date()
 
     curs = currencies.get(territory.upper(), ())
@@ -298,9 +298,9 @@ def _is_active(start, end):
     result = []
     for currency_code, start, end, is_tender in curs:
         if start:
-            start = date_(*start)
+            start = datetime.date(*start)
         if end:
-            end = date_(*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:
diff --git a/babel/support.py b/babel/support.py
index 7477ee10c..da111fc26 100644
--- a/babel/support.py
+++ b/babel/support.py
@@ -16,14 +16,8 @@
 import gettext
 import locale
 import os
+import datetime
 from collections.abc import Iterator
-from datetime import (
-    date as _date,
-    datetime as _datetime,
-    time as _time,
-    timedelta as _timedelta,
-    tzinfo
-)
 from typing import TYPE_CHECKING, Any, Callable
 
 from babel.core import Locale
@@ -52,7 +46,7 @@ class Format:
     u'1.234'
     """
 
-    def __init__(self, locale: Locale | str, tzinfo: tzinfo | None = None) -> None:
+    def __init__(self, locale: Locale | str, tzinfo: datetime.tzinfo | None = None) -> None:
         """Initialize the formatter.
 
         :param locale: the locale identifier or `Locale` instance
@@ -61,7 +55,11 @@ def __init__(self, locale: Locale | str, tzinfo: tzinfo | None = None) -> None:
         self.locale = Locale.parse(locale)
         self.tzinfo = tzinfo
 
-    def date(self, date: _date | None = None, format: _PredefinedTimeFormat | str = 'medium') -> str:
+    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
@@ -71,7 +69,11 @@ def date(self, date: _date | None = None, format: _PredefinedTimeFormat | str =
         """
         return format_date(date, format, locale=self.locale)
 
-    def datetime(self, datetime: _date | None = None, format: _PredefinedTimeFormat | str = 'medium') -> str:
+    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
@@ -79,10 +81,13 @@ def datetime(self, datetime: _date | None = None, format: _PredefinedTimeFormat
         >>> fmt.datetime(datetime(2007, 4, 1, 15, 30))
         u'Apr 1, 2007, 11:30:00 AM'
         """
-        return format_datetime(datetime, format, tzinfo=self.tzinfo,
-                               locale=self.locale)
+        return format_datetime(datetime, format, tzinfo=self.tzinfo, locale=self.locale)
 
-    def time(self, time: _time | _datetime | None = None, format: _PredefinedTimeFormat | str = 'medium') -> str:
+    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
@@ -94,7 +99,7 @@ def time(self, time: _time | _datetime | None = None, format: _PredefinedTimeFor
 
     def timedelta(
         self,
-        delta: _timedelta | int,
+        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",
diff --git a/babel/util.py b/babel/util.py
index fb4870d66..d25ec533d 100644
--- a/babel/util.py
+++ b/babel/util.py
@@ -17,7 +17,7 @@
 from babel import localtime, dates
 
 from collections.abc import Generator, Iterable
-from datetime import datetime as datetime_, timedelta, tzinfo
+import datetime
 from typing import IO, Any, TypeVar
 
 missing = object()
@@ -225,12 +225,12 @@ def wraptext(text: str, width: int = 70, initial_indent: str = '', subsequent_in
 odict = collections.OrderedDict
 
 
-class FixedOffsetTimezone(tzinfo):
+class FixedOffsetTimezone(datetime.tzinfo):
     """Fixed offset in minutes east from UTC."""
 
     def __init__(self, offset: float, name: str | None = None) -> None:
 
-        self._offset = timedelta(minutes=offset)
+        self._offset = datetime.timedelta(minutes=offset)
         if name is None:
             name = 'Etc/GMT%+d' % offset
         self.zone = name
@@ -241,13 +241,13 @@ def __str__(self) -> str:
     def __repr__(self) -> str:
         return f'<FixedOffset "{self.zone}" {self._offset}>'
 
-    def utcoffset(self, dt: datetime_) -> timedelta:
+    def utcoffset(self, dt: datetime.datetime) -> datetime.timedelta:
         return self._offset
 
-    def tzname(self, dt: datetime_) -> str:
+    def tzname(self, dt: datetime.datetime) -> str:
         return self.zone
 
-    def dst(self, dt: datetime_) -> timedelta:
+    def dst(self, dt: datetime.datetime) -> datetime.timedelta:
         return ZERO
 
 

From 03641361830ce036b89b4f9660ebadfe96e10445 Mon Sep 17 00:00:00 2001
From: Aarni Koskela <akx@iki.fi>
Date: Wed, 18 Jan 2023 19:47:43 +0200
Subject: [PATCH 17/53] Minor cleanups (#948)

* Add __all__s to be cleaner about re-exports
* Move timezone_getter to conftest
* Apply spelling corrections suggested by codespell
---
 CHANGES.rst                  |  4 ++--
 babel/__init__.py            | 20 +++++++++++++++++---
 babel/core.py                |  4 ++--
 babel/dates.py               |  2 +-
 babel/localedata.py          |  2 +-
 babel/messages/__init__.py   | 12 +++++++++++-
 babel/messages/checkers.py   |  2 +-
 babel/messages/extract.py    |  6 +++---
 babel/numbers.py             |  4 ++--
 babel/plural.py              |  2 +-
 babel/support.py             |  2 +-
 tests/conftest.py            | 29 +++++++++++++++++++++++++++++
 tests/test_date_intervals.py |  1 -
 tests/test_dates.py          | 32 +-------------------------------
 tests/test_numbers.py        |  2 +-
 tests/test_support.py        |  2 --
 16 files changed, 73 insertions(+), 53 deletions(-)

diff --git a/CHANGES.rst b/CHANGES.rst
index bee5c3f40..a146e8fba 100644
--- a/CHANGES.rst
+++ b/CHANGES.rst
@@ -613,7 +613,7 @@ Version 1.0
 - Explicitly sort instead of using sorted() and don't assume ordering
   (Jython compatibility).
 - Removed ValueError raising for string formatting message checkers if the
-  string does not contain any string formattings (:trac:`150`).
+  string does not contain any string formatting (:trac:`150`).
 - Fix Serbian plural forms (:trac:`213`).
 - Small speed improvement in format_date() (:trac:`216`).
 - Fix so frontend.CommandLineInterface.run does not accumulate logging
@@ -690,7 +690,7 @@ Version 0.9.6
 - Explicitly sort instead of using sorted() and don't assume ordering
   (Python 2.3 and Jython compatibility).
 - Removed ValueError raising for string formatting message checkers if the
-  string does not contain any string formattings (:trac:`150`).
+  string does not contain any string formatting (:trac:`150`).
 - Fix Serbian plural forms (:trac:`213`).
 - Small speed improvement in format_date() (:trac:`216`).
 - Fix number formatting for locales where CLDR specifies alt or draft
diff --git a/babel/__init__.py b/babel/__init__.py
index df190033c..be35c0361 100644
--- a/babel/__init__.py
+++ b/babel/__init__.py
@@ -16,8 +16,22 @@
     :license: BSD, see LICENSE for more details.
 """
 
-from babel.core import UnknownLocaleError, Locale, default_locale, \
-    negotiate_locale, parse_locale, get_locale_identifier
-
+from babel.core import (
+    Locale,
+    UnknownLocaleError,
+    default_locale,
+    get_locale_identifier,
+    negotiate_locale,
+    parse_locale,
+)
 
 __version__ = '2.11.0'
+
+__all__ = [
+    'Locale',
+    'UnknownLocaleError',
+    'default_locale',
+    'get_locale_identifier',
+    'negotiate_locale',
+    'parse_locale',
+]
diff --git a/babel/core.py b/babel/core.py
index 704957b7e..5041c1bb9 100644
--- a/babel/core.py
+++ b/babel/core.py
@@ -239,13 +239,13 @@ def negotiate(
         >>> Locale.negotiate(['de_DE', 'de'], ['en_US'])
 
         You can specify the character used in the locale identifiers to separate
-        the differnet components. This separator is applied to both lists. Also,
+        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 identifers preferred by the user
+        :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
         """
diff --git a/babel/dates.py b/babel/dates.py
index 05cfa251c..51bc7ffcf 100644
--- a/babel/dates.py
+++ b/babel/dates.py
@@ -1757,7 +1757,7 @@ def get_week_number(self, day_of_period: int, day_of_week: int | None = None) ->
 
         :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 ommitted, the week day of the
+        :param day_of_week: the week day; if omitted, the week day of the
                             current date is assumed
         """
         if day_of_week is None:
diff --git a/babel/localedata.py b/babel/localedata.py
index 0d3508d1e..c14391aa7 100644
--- a/babel/localedata.py
+++ b/babel/localedata.py
@@ -121,7 +121,7 @@ def load(name: os.PathLike[str] | str, merge_inherited: bool = True) -> dict[str
     :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
-                      identifer, or one of the locales it inherits from
+                      identifier, or one of the locales it inherits from
     """
     name = os.path.basename(name)
     _cache_lock.acquire()
diff --git a/babel/messages/__init__.py b/babel/messages/__init__.py
index ad4fd346d..60aeba0ed 100644
--- a/babel/messages/__init__.py
+++ b/babel/messages/__init__.py
@@ -8,4 +8,14 @@
     :license: BSD, see LICENSE for more details.
 """
 
-from babel.messages.catalog import *
+from babel.messages.catalog import (
+    Catalog,
+    Message,
+    TranslationError,
+)
+
+__all__ = [
+    "Catalog",
+    "Message",
+    "TranslationError",
+]
diff --git a/babel/messages/checkers.py b/babel/messages/checkers.py
index 9231c678e..00b84e5e3 100644
--- a/babel/messages/checkers.py
+++ b/babel/messages/checkers.py
@@ -67,7 +67,7 @@ def _validate_format(format: str, alternative: str) -> None:
     placeholders if `format` uses named placeholders.
 
     The behavior of this function is undefined if the string does not use
-    string formattings.
+    string formatting.
 
     If the string formatting of `alternative` is compatible to `format` the
     function returns `None`, otherwise a `TranslationError` is raised.
diff --git a/babel/messages/extract.py b/babel/messages/extract.py
index 5c331c0a5..a4265101a 100644
--- a/babel/messages/extract.py
+++ b/babel/messages/extract.py
@@ -537,8 +537,8 @@ def extract_python(
                     messages = tuple(messages)
                 else:
                     messages = messages[0]
-                # Comments don't apply unless they immediately preceed the
-                # message
+                # Comments don't apply unless they immediately
+                # precede the message
                 if translator_comments and \
                         translator_comments[-1][0] < message_lineno - 1:
                     translator_comments = []
@@ -673,7 +673,7 @@ def extract_javascript(
                     break
 
         elif token.type == 'multilinecomment':
-            # only one multi-line comment may preceed a translation
+            # only one multi-line comment may precede a translation
             translator_comments = []
             value = token.value[2:-2].strip()
             for comment_tag in comment_tags:
diff --git a/babel/numbers.py b/babel/numbers.py
index 95e9d2af0..5a05f910e 100644
--- a/babel/numbers.py
+++ b/babel/numbers.py
@@ -93,7 +93,7 @@ def is_currency(currency: str, locale: Locale | str | None = None) -> bool:
 
 
 def normalize_currency(currency: str, locale: Locale | str | None = None) -> str | None:
-    """Returns the normalized sting of any currency code.
+    """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.
@@ -1203,7 +1203,7 @@ def apply(
                 self._format_int(
                     str(exp), self.exp_prec[0], self.exp_prec[1], locale)])
 
-        # Is it a siginificant digits pattern?
+        # Is it a significant digits pattern?
         elif '@' in self.pattern:
             text = self._format_significant(value,
                                             self.int_prec[0],
diff --git a/babel/plural.py b/babel/plural.py
index efd0f1f6a..b4f54c018 100644
--- a/babel/plural.py
+++ b/babel/plural.py
@@ -425,7 +425,7 @@ class _Parser:
       'n in 3,5,7..15'.
     - Samples are ignored.
 
-    The translator parses the expression on instanciation into an attribute
+    The translator parses the expression on instantiation into an attribute
     called `ast`.
     """
 
diff --git a/babel/support.py b/babel/support.py
index da111fc26..a8dd2305d 100644
--- a/babel/support.py
+++ b/babel/support.py
@@ -418,7 +418,7 @@ def udngettext(self, domain: str, singular: str, plural: str, num: int) -> str:
     # backward compatibility with 0.9
     dungettext = udngettext
 
-    # Most of the downwards code, until it get's included in stdlib, from:
+    # 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
diff --git a/tests/conftest.py b/tests/conftest.py
index 5b14b1ca7..0506a8330 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -1,6 +1,19 @@
 import os
 import pytest
 
+try:
+    import zoneinfo
+except ModuleNotFoundError:
+    try:
+        from backports import zoneinfo
+    except ImportError:
+        zoneinfo = None
+
+try:
+    import pytz
+except ModuleNotFoundError:
+    pytz = None
+
 
 @pytest.fixture
 def os_environ(monkeypatch):
@@ -16,3 +29,19 @@ def pytest_generate_tests(metafunc):
                 from babel.localedata import locale_identifiers
                 metafunc.parametrize("locale", list(locale_identifiers()))
                 break
+
+
+@pytest.fixture(params=["pytz.timezone", "zoneinfo.ZoneInfo"], scope="package")
+def timezone_getter(request):
+    if request.param == "pytz.timezone":
+        if pytz:
+            return pytz.timezone
+        else:
+            pytest.skip("pytz not available")
+    elif request.param == "zoneinfo.ZoneInfo":
+        if zoneinfo:
+            return zoneinfo.ZoneInfo
+        else:
+            pytest.skip("zoneinfo not available")
+    else:
+        raise NotImplementedError
diff --git a/tests/test_date_intervals.py b/tests/test_date_intervals.py
index eb3aa8977..8e84a9eb6 100644
--- a/tests/test_date_intervals.py
+++ b/tests/test_date_intervals.py
@@ -2,7 +2,6 @@
 
 from babel import dates
 from babel.util import UTC
-from .test_dates import timezone_getter
 
 TEST_DT = datetime.datetime(2016, 1, 8, 11, 46, 15)
 TEST_TIME = TEST_DT.time()
diff --git a/tests/test_dates.py b/tests/test_dates.py
index 9fd73148b..a4fb9c5bf 100644
--- a/tests/test_dates.py
+++ b/tests/test_dates.py
@@ -16,41 +16,11 @@
 import freezegun
 import pytest
 
-# for tests it can be useful to have both zoneinfo and pytz available
-try:
-    import zoneinfo
-except ModuleNotFoundError:
-    try:
-        from backports import zoneinfo
-    except ImportError:
-        zoneinfo = None
-
-try:
-    import pytz
-except ModuleNotFoundError:
-    pytz = None
-
 from babel import dates, Locale
-from babel.dates import NO_INHERITANCE_MARKER, _localize, _get_tz_name, LOCALTZ
+from babel.dates import NO_INHERITANCE_MARKER, _localize
 from babel.util import FixedOffsetTimezone
 
 
-@pytest.fixture(params=["pytz.timezone", "zoneinfo.ZoneInfo"], scope="package")
-def timezone_getter(request):
-    if request.param == "pytz.timezone":
-        if pytz:
-            return pytz.timezone
-        else:
-            pytest.skip("pytz not available")
-    elif request.param == "zoneinfo.ZoneInfo":
-        if zoneinfo:
-            return zoneinfo.ZoneInfo
-        else:
-            pytest.skip("zoneinfo not available")
-    else:
-        raise NotImplementedError
-
-
 class DateTimeFormatTestCase:
 
     def test_quarter_format(self):
diff --git a/tests/test_numbers.py b/tests/test_numbers.py
index 37d2f9ec6..0939562bf 100644
--- a/tests/test_numbers.py
+++ b/tests/test_numbers.py
@@ -28,7 +28,7 @@ def test_patterns(self):
         assert numbers.format_decimal(12345, '##0', locale='en_US') == '12345'
         assert numbers.format_decimal(6.5, '0.00', locale='sv') == '6,50'
         assert numbers.format_decimal((10.0 ** 20), '#.00', locale='en_US') == '100000000000000000000.00'
-        # regression test for #183, fraction digits were not correctly cutted
+        # regression test for #183, fraction digits were not correctly cut
         # if the input was a float value and the value had more than 7
         # significant digits
         assert numbers.format_decimal(12345678.051, '#,##0.00', locale='en_US') == u'12,345,678.05'
diff --git a/tests/test_support.py b/tests/test_support.py
index d39d8ef6d..3ca0be3d6 100644
--- a/tests/test_support.py
+++ b/tests/test_support.py
@@ -23,8 +23,6 @@
 from babel import support
 from babel.messages import Catalog
 from babel.messages.mofile import write_mo
-from babel.dates import get_timezone
-from .test_dates import timezone_getter
 
 
 SKIP_LGETTEXT = sys.version_info >= (3, 8)

From 6e02940868a73cbcf3cc86077fc83c7cb21a4780 Mon Sep 17 00:00:00 2001
From: Aarni Koskela <akx@iki.fi>
Date: Wed, 18 Jan 2023 21:07:37 +0200
Subject: [PATCH 18/53] Renovate formatting in test_checkers and test_frontend
 (#950)

---
 tests/messages/test_checkers.py | 146 +++++++++--------------
 tests/messages/test_frontend.py | 205 ++++++++++++++------------------
 2 files changed, 147 insertions(+), 204 deletions(-)

diff --git a/tests/messages/test_checkers.py b/tests/messages/test_checkers.py
index 2ae594679..3ed9a1923 100644
--- a/tests/messages/test_checkers.py
+++ b/tests/messages/test_checkers.py
@@ -10,9 +10,8 @@
 # individuals. For the exact contribution history, see the revision
 # history and logs, available at http://babel.edgewall.org/log/.
 
-from datetime import datetime
-import time
 import unittest
+from datetime import datetime
 from io import BytesIO
 
 from babel import __version__ as VERSION
@@ -34,8 +33,10 @@ def test_1_num_plurals_checkers(self):
             except UnknownLocaleError:
                 # Just an alias? Not what we're testing here, let's continue
                 continue
-            po_file = (u"""\
-# %(english_name)s translations for TestProject.
+            date = format_datetime(datetime.now(LOCALTZ), 'yyyy-MM-dd HH:mmZ', tzinfo=LOCALTZ, locale=_locale)
+            plural = PLURALS[_locale][0]
+            po_file = (f"""\
+# {locale.english_name} translations for TestProject.
 # Copyright (C) 2007 FooBar, Inc.
 # This file is distributed under the same license as the TestProject
 # project.
@@ -46,14 +47,14 @@ def test_1_num_plurals_checkers(self):
 "Project-Id-Version: TestProject 0.1\\n"
 "Report-Msgid-Bugs-To: bugs.address@email.tld\\n"
 "POT-Creation-Date: 2007-04-01 15:30+0200\\n"
-"PO-Revision-Date: %(date)s\\n"
+"PO-Revision-Date: {date}\\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\\n"
-"Language-Team: %(locale)s <LL@li.org>\n"
-"Plural-Forms: nplurals=%(num_plurals)s; plural=%(plural_expr)s;\\n"
+"Language-Team: {_locale} <LL@li.org>\n"
+"Plural-Forms: nplurals={plural}; plural={plural};\\n"
 "MIME-Version: 1.0\\n"
 "Content-Type: text/plain; charset=utf-8\\n"
 "Content-Transfer-Encoding: 8bit\\n"
-"Generated-By: Babel %(version)s\\n"
+"Generated-By: Babel {VERSION}\\n"
 
 #. This will be a translator comment,
 #. that will include several lines
@@ -66,15 +67,7 @@ def test_1_num_plurals_checkers(self):
 msgid_plural "foobars"
 msgstr[0] ""
 
-""" % dict(locale=_locale,
-                english_name=locale.english_name,
-                version=VERSION,
-                year=time.strftime('%Y'),
-                date=format_datetime(datetime.now(LOCALTZ),
-                                     'yyyy-MM-dd HH:mmZ',
-                                     tzinfo=LOCALTZ, locale=_locale),
-                num_plurals=PLURALS[_locale][0],
-                plural_expr=PLURALS[_locale][0])).encode('utf-8')
+""").encode('utf-8')
 
             # This test will fail for revisions <= 406 because so far
             # catalog.num_plurals was neglected
@@ -101,8 +94,8 @@ def test_2_num_plurals_checkers(self):
             except UnknownLocaleError:
                 # Just an alias? Not what we're testing here, let's continue
                 continue
-            po_file = (u"""\
-# %(english_name)s translations for TestProject.
+            po_file = f"""\
+# {locale.english_name} translations for TestProject.
 # Copyright (C) 2007 FooBar, Inc.
 # This file is distributed under the same license as the TestProject
 # project.
@@ -113,14 +106,14 @@ def test_2_num_plurals_checkers(self):
 "Project-Id-Version: TestProject 0.1\\n"
 "Report-Msgid-Bugs-To: bugs.address@email.tld\\n"
 "POT-Creation-Date: 2007-04-01 15:30+0200\\n"
-"PO-Revision-Date: %(date)s\\n"
+"PO-Revision-Date: {date}\\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\\n"
-"Language-Team: %(locale)s <LL@li.org>\\n"
-"Plural-Forms: nplurals=%(num_plurals)s; plural=%(plural_expr)s;\\n"
+"Language-Team: {_locale} <LL@li.org>\\n"
+"Plural-Forms: nplurals={num_plurals}; plural={plural_expr};\\n"
 "MIME-Version: 1.0\\n"
 "Content-Type: text/plain; charset=utf-8\\n"
 "Content-Transfer-Encoding: 8bit\\n"
-"Generated-By: Babel %(version)s\\n"
+"Generated-By: Babel {VERSION}\\n"
 
 #. This will be a translator comment,
 #. that will include several lines
@@ -135,13 +128,7 @@ def test_2_num_plurals_checkers(self):
 msgstr[1] ""
 msgstr[2] ""
 
-""" % dict(locale=_locale,
-                english_name=locale.english_name,
-                version=VERSION,
-                year=time.strftime('%Y'),
-                date=date,
-                num_plurals=num_plurals,
-                plural_expr=plural_expr)).encode('utf-8')
+""".encode('utf-8')
             # we should be adding the missing msgstr[0]
 
             # This test will fail for revisions <= 406 because so far
@@ -152,8 +139,10 @@ def test_2_num_plurals_checkers(self):
 
     def test_3_num_plurals_checkers(self):
         for _locale in [p for p in PLURALS if PLURALS[p][0] == 3]:
-            po_file = (r"""\
-# %(english_name)s translations for TestProject.
+            plural = format_datetime(datetime.now(LOCALTZ), 'yyyy-MM-dd HH:mmZ', tzinfo=LOCALTZ, locale=_locale)
+            english_name = Locale.parse(_locale).english_name
+            po_file = fr"""\
+# {english_name} translations for TestProject.
 # Copyright (C) 2007 FooBar, Inc.
 # This file is distributed under the same license as the TestProject
 # project.
@@ -164,14 +153,14 @@ def test_3_num_plurals_checkers(self):
 "Project-Id-Version: TestProject 0.1\n"
 "Report-Msgid-Bugs-To: bugs.address@email.tld\n"
 "POT-Creation-Date: 2007-04-01 15:30+0200\n"
-"PO-Revision-Date: %(date)s\n"
+"PO-Revision-Date: {plural}\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
-"Language-Team: %(locale)s <LL@li.org>\n"
-"Plural-Forms: nplurals=%(num_plurals)s; plural=%(plural_expr)s;\n"
+"Language-Team: {_locale} <LL@li.org>\n"
+"Plural-Forms: nplurals={PLURALS[_locale][0]}; plural={PLURALS[_locale][0]};\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=utf-8\n"
 "Content-Transfer-Encoding: 8bit\n"
-"Generated-By: Babel %(version)s\n"
+"Generated-By: Babel {VERSION}\n"
 
 #. This will be a translator comment,
 #. that will include several lines
@@ -185,15 +174,7 @@ def test_3_num_plurals_checkers(self):
 msgstr[0] ""
 msgstr[1] ""
 
-""" % dict(locale=_locale,
-                english_name=Locale.parse(_locale).english_name,
-                version=VERSION,
-                year=time.strftime('%Y'),
-                date=format_datetime(datetime.now(LOCALTZ),
-                                     'yyyy-MM-dd HH:mmZ',
-                                     tzinfo=LOCALTZ, locale=_locale),
-                num_plurals=PLURALS[_locale][0],
-                plural_expr=PLURALS[_locale][0])).encode('utf-8')
+""".encode('utf-8')
 
             # This test will fail for revisions <= 406 because so far
             # catalog.num_plurals was neglected
@@ -203,8 +184,11 @@ def test_3_num_plurals_checkers(self):
 
     def test_4_num_plurals_checkers(self):
         for _locale in [p for p in PLURALS if PLURALS[p][0] == 4]:
-            po_file = (r"""\
-# %(english_name)s translations for TestProject.
+            date = format_datetime(datetime.now(LOCALTZ), 'yyyy-MM-dd HH:mmZ', tzinfo=LOCALTZ, locale=_locale)
+            english_name = Locale.parse(_locale).english_name
+            plural = PLURALS[_locale][0]
+            po_file = fr"""\
+# {english_name} translations for TestProject.
 # Copyright (C) 2007 FooBar, Inc.
 # This file is distributed under the same license as the TestProject
 # project.
@@ -215,14 +199,14 @@ def test_4_num_plurals_checkers(self):
 "Project-Id-Version: TestProject 0.1\n"
 "Report-Msgid-Bugs-To: bugs.address@email.tld\n"
 "POT-Creation-Date: 2007-04-01 15:30+0200\n"
-"PO-Revision-Date: %(date)s\n"
+"PO-Revision-Date: {date}\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
-"Language-Team: %(locale)s <LL@li.org>\n"
-"Plural-Forms: nplurals=%(num_plurals)s; plural=%(plural_expr)s;\n"
+"Language-Team: {_locale} <LL@li.org>\n"
+"Plural-Forms: nplurals={plural}; plural={plural};\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=utf-8\n"
 "Content-Transfer-Encoding: 8bit\n"
-"Generated-By: Babel %(version)s\n"
+"Generated-By: Babel {VERSION}\n"
 
 #. This will be a translator comment,
 #. that will include several lines
@@ -237,15 +221,7 @@ def test_4_num_plurals_checkers(self):
 msgstr[1] ""
 msgstr[2] ""
 
-""" % dict(locale=_locale,
-                english_name=Locale.parse(_locale).english_name,
-                version=VERSION,
-                year=time.strftime('%Y'),
-                date=format_datetime(datetime.now(LOCALTZ),
-                                     'yyyy-MM-dd HH:mmZ',
-                                     tzinfo=LOCALTZ, locale=_locale),
-                num_plurals=PLURALS[_locale][0],
-                plural_expr=PLURALS[_locale][0])).encode('utf-8')
+""".encode('utf-8')
 
             # This test will fail for revisions <= 406 because so far
             # catalog.num_plurals was neglected
@@ -255,8 +231,11 @@ def test_4_num_plurals_checkers(self):
 
     def test_5_num_plurals_checkers(self):
         for _locale in [p for p in PLURALS if PLURALS[p][0] == 5]:
-            po_file = (r"""\
-# %(english_name)s translations for TestProject.
+            date = format_datetime(datetime.now(LOCALTZ), 'yyyy-MM-dd HH:mmZ', tzinfo=LOCALTZ, locale=_locale)
+            english_name = Locale.parse(_locale).english_name
+            plural = PLURALS[_locale][0]
+            po_file = fr"""\
+# {english_name} translations for TestProject.
 # Copyright (C) 2007 FooBar, Inc.
 # This file is distributed under the same license as the TestProject
 # project.
@@ -267,14 +246,14 @@ def test_5_num_plurals_checkers(self):
 "Project-Id-Version: TestProject 0.1\n"
 "Report-Msgid-Bugs-To: bugs.address@email.tld\n"
 "POT-Creation-Date: 2007-04-01 15:30+0200\n"
-"PO-Revision-Date: %(date)s\n"
+"PO-Revision-Date: {date}\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
-"Language-Team: %(locale)s <LL@li.org>\n"
-"Plural-Forms: nplurals=%(num_plurals)s; plural=%(plural_expr)s;\n"
+"Language-Team: {_locale} <LL@li.org>\n"
+"Plural-Forms: nplurals={plural}; plural={plural};\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=utf-8\n"
 "Content-Transfer-Encoding: 8bit\n"
-"Generated-By: Babel %(version)s\n"
+"Generated-By: Babel {VERSION}\n"
 
 #. This will be a translator comment,
 #. that will include several lines
@@ -290,15 +269,7 @@ def test_5_num_plurals_checkers(self):
 msgstr[2] ""
 msgstr[3] ""
 
-""" % dict(locale=_locale,
-                english_name=Locale.parse(_locale).english_name,
-                version=VERSION,
-                year=time.strftime('%Y'),
-                date=format_datetime(datetime.now(LOCALTZ),
-                                     'yyyy-MM-dd HH:mmZ',
-                                     tzinfo=LOCALTZ, locale=_locale),
-                num_plurals=PLURALS[_locale][0],
-                plural_expr=PLURALS[_locale][0])).encode('utf-8')
+""".encode('utf-8')
 
             # This test will fail for revisions <= 406 because so far
             # catalog.num_plurals was neglected
@@ -308,8 +279,11 @@ def test_5_num_plurals_checkers(self):
 
     def test_6_num_plurals_checkers(self):
         for _locale in [p for p in PLURALS if PLURALS[p][0] == 6]:
-            po_file = (r"""\
-# %(english_name)s translations for TestProject.
+            english_name = Locale.parse(_locale).english_name
+            date = format_datetime(datetime.now(LOCALTZ), 'yyyy-MM-dd HH:mmZ', tzinfo=LOCALTZ, locale=_locale)
+            plural = PLURALS[_locale][0]
+            po_file = fr"""\
+# {english_name} translations for TestProject.
 # Copyright (C) 2007 FooBar, Inc.
 # This file is distributed under the same license as the TestProject
 # project.
@@ -320,14 +294,14 @@ def test_6_num_plurals_checkers(self):
 "Project-Id-Version: TestProject 0.1\n"
 "Report-Msgid-Bugs-To: bugs.address@email.tld\n"
 "POT-Creation-Date: 2007-04-01 15:30+0200\n"
-"PO-Revision-Date: %(date)s\n"
+"PO-Revision-Date: {date}\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
-"Language-Team: %(locale)s <LL@li.org>\n"
-"Plural-Forms: nplurals=%(num_plurals)s; plural=%(plural_expr)s;\n"
+"Language-Team: {_locale} <LL@li.org>\n"
+"Plural-Forms: nplurals={plural}; plural={plural};\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=utf-8\n"
 "Content-Transfer-Encoding: 8bit\n"
-"Generated-By: Babel %(version)s\n"
+"Generated-By: Babel {VERSION}\n"
 
 #. This will be a translator comment,
 #. that will include several lines
@@ -344,15 +318,7 @@ def test_6_num_plurals_checkers(self):
 msgstr[3] ""
 msgstr[4] ""
 
-""" % dict(locale=_locale,
-                english_name=Locale.parse(_locale).english_name,
-                version=VERSION,
-                year=time.strftime('%Y'),
-                date=format_datetime(datetime.now(LOCALTZ),
-                                     'yyyy-MM-dd HH:mmZ',
-                                     tzinfo=LOCALTZ, locale=_locale),
-                num_plurals=PLURALS[_locale][0],
-                plural_expr=PLURALS[_locale][0])).encode('utf-8')
+""".encode('utf-8')
 
             # This test will fail for revisions <= 406 because so far
             # catalog.num_plurals was neglected
diff --git a/tests/messages/test_frontend.py b/tests/messages/test_frontend.py
index 9e3ac9f40..e91d02bf7 100644
--- a/tests/messages/test_frontend.py
+++ b/tests/messages/test_frontend.py
@@ -161,25 +161,26 @@ def test_extraction_with_default_mapping(self):
 
         self.assert_pot_file_exists()
 
-        expected_content = r"""# Translations template for TestProject.
-# Copyright (C) %(year)s FooBar, Inc.
+        date = format_datetime(datetime(1994, 11, 11, 00, 00), 'yyyy-MM-dd HH:mmZ', tzinfo=LOCALTZ, locale='en')
+        expected_content = fr"""# Translations template for TestProject.
+# Copyright (C) {time.strftime('%Y')} FooBar, Inc.
 # This file is distributed under the same license as the TestProject
 # project.
-# FIRST AUTHOR <EMAIL@ADDRESS>, %(year)s.
+# FIRST AUTHOR <EMAIL@ADDRESS>, {time.strftime('%Y')}.
 #
 #, fuzzy
 msgid ""
 msgstr ""
 "Project-Id-Version: TestProject 0.1\n"
 "Report-Msgid-Bugs-To: bugs.address@email.tld\n"
-"POT-Creation-Date: %(date)s\n"
+"POT-Creation-Date: {date}\n"
 "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language-Team: LANGUAGE <LL@li.org>\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=utf-8\n"
 "Content-Transfer-Encoding: 8bit\n"
-"Generated-By: Babel %(version)s\n"
+"Generated-By: Babel {VERSION}\n"
 
 #. TRANSLATOR: This will be a translator coment,
 #. that will include several lines
@@ -199,10 +200,7 @@ def test_extraction_with_default_mapping(self):
 msgstr[0] ""
 msgstr[1] ""
 
-""" % {'version': VERSION,
-            'year': time.strftime('%Y'),
-            'date': format_datetime(datetime(1994, 11, 11, 00, 00), 'yyyy-MM-dd HH:mmZ',
-                                    tzinfo=LOCALTZ, locale='en')}
+"""
         with open(pot_file) as f:
             actual_content = f.read()
         assert expected_content == actual_content
@@ -220,25 +218,26 @@ def test_extraction_with_mapping_file(self):
 
         self.assert_pot_file_exists()
 
-        expected_content = r"""# Translations template for TestProject.
-# Copyright (C) %(year)s FooBar, Inc.
+        date = format_datetime(datetime(1994, 11, 11, 00, 00), 'yyyy-MM-dd HH:mmZ', tzinfo=LOCALTZ, locale='en')
+        expected_content = fr"""# Translations template for TestProject.
+# Copyright (C) {time.strftime('%Y')} FooBar, Inc.
 # This file is distributed under the same license as the TestProject
 # project.
-# FIRST AUTHOR <EMAIL@ADDRESS>, %(year)s.
+# FIRST AUTHOR <EMAIL@ADDRESS>, {time.strftime('%Y')}.
 #
 #, fuzzy
 msgid ""
 msgstr ""
 "Project-Id-Version: TestProject 0.1\n"
 "Report-Msgid-Bugs-To: bugs.address@email.tld\n"
-"POT-Creation-Date: %(date)s\n"
+"POT-Creation-Date: {date}\n"
 "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language-Team: LANGUAGE <LL@li.org>\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=utf-8\n"
 "Content-Transfer-Encoding: 8bit\n"
-"Generated-By: Babel %(version)s\n"
+"Generated-By: Babel {VERSION}\n"
 
 #. TRANSLATOR: This will be a translator coment,
 #. that will include several lines
@@ -252,10 +251,7 @@ def test_extraction_with_mapping_file(self):
 msgstr[0] ""
 msgstr[1] ""
 
-""" % {'version': VERSION,
-            'year': time.strftime('%Y'),
-            'date': format_datetime(datetime(1994, 11, 11, 00, 00), 'yyyy-MM-dd HH:mmZ',
-                                    tzinfo=LOCALTZ, locale='en')}
+"""
         with open(pot_file) as f:
             actual_content = f.read()
         assert expected_content == actual_content
@@ -278,25 +274,26 @@ def test_extraction_with_mapping_dict(self):
 
         self.assert_pot_file_exists()
 
-        expected_content = r"""# Translations template for TestProject.
-# Copyright (C) %(year)s FooBar, Inc.
+        date = format_datetime(datetime(1994, 11, 11, 00, 00), 'yyyy-MM-dd HH:mmZ', tzinfo=LOCALTZ, locale='en')
+        expected_content = fr"""# Translations template for TestProject.
+# Copyright (C) {time.strftime('%Y')} FooBar, Inc.
 # This file is distributed under the same license as the TestProject
 # project.
-# FIRST AUTHOR <EMAIL@ADDRESS>, %(year)s.
+# FIRST AUTHOR <EMAIL@ADDRESS>, {time.strftime('%Y')}.
 #
 #, fuzzy
 msgid ""
 msgstr ""
 "Project-Id-Version: TestProject 0.1\n"
 "Report-Msgid-Bugs-To: bugs.address@email.tld\n"
-"POT-Creation-Date: %(date)s\n"
+"POT-Creation-Date: {date}\n"
 "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language-Team: LANGUAGE <LL@li.org>\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=utf-8\n"
 "Content-Transfer-Encoding: 8bit\n"
-"Generated-By: Babel %(version)s\n"
+"Generated-By: Babel {VERSION}\n"
 
 #. TRANSLATOR: This will be a translator coment,
 #. that will include several lines
@@ -310,10 +307,7 @@ def test_extraction_with_mapping_dict(self):
 msgstr[0] ""
 msgstr[1] ""
 
-""" % {'version': VERSION,
-            'year': time.strftime('%Y'),
-            'date': format_datetime(datetime(1994, 11, 11, 00, 00), 'yyyy-MM-dd HH:mmZ',
-                                    tzinfo=LOCALTZ, locale='en')}
+"""
         with open(pot_file) as f:
             actual_content = f.read()
         assert expected_content == actual_content
@@ -396,7 +390,8 @@ def test_with_output_dir(self):
         po_file = _po_file('en_US')
         assert os.path.isfile(po_file)
 
-        expected_content = r"""# English (United States) translations for TestProject.
+        date = format_datetime(datetime(1994, 11, 11, 00, 00), 'yyyy-MM-dd HH:mmZ', tzinfo=LOCALTZ, locale='en')
+        expected_content = fr"""# English (United States) translations for TestProject.
 # Copyright (C) 2007 FooBar, Inc.
 # This file is distributed under the same license as the TestProject
 # project.
@@ -407,7 +402,7 @@ def test_with_output_dir(self):
 "Project-Id-Version: TestProject 0.1\n"
 "Report-Msgid-Bugs-To: bugs.address@email.tld\n"
 "POT-Creation-Date: 2007-04-01 15:30+0200\n"
-"PO-Revision-Date: %(date)s\n"
+"PO-Revision-Date: {date}\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language: en_US\n"
 "Language-Team: en_US <LL@li.org>\n"
@@ -415,7 +410,7 @@ def test_with_output_dir(self):
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=utf-8\n"
 "Content-Transfer-Encoding: 8bit\n"
-"Generated-By: Babel %(version)s\n"
+"Generated-By: Babel {VERSION}\n"
 
 #. This will be a translator coment,
 #. that will include several lines
@@ -429,9 +424,7 @@ def test_with_output_dir(self):
 msgstr[0] ""
 msgstr[1] ""
 
-""" % {'version': VERSION,
-            'date': format_datetime(datetime(1994, 11, 11, 00, 00), 'yyyy-MM-dd HH:mmZ',
-                                    tzinfo=LOCALTZ, locale='en')}
+"""
         with open(po_file) as f:
             actual_content = f.read()
         assert expected_content == actual_content
@@ -448,7 +441,8 @@ def test_keeps_catalog_non_fuzzy(self):
         po_file = _po_file('en_US')
         assert os.path.isfile(po_file)
 
-        expected_content = r"""# English (United States) translations for TestProject.
+        date = format_datetime(datetime(1994, 11, 11, 00, 00), 'yyyy-MM-dd HH:mmZ', tzinfo=LOCALTZ, locale='en')
+        expected_content = fr"""# English (United States) translations for TestProject.
 # Copyright (C) 2007 FooBar, Inc.
 # This file is distributed under the same license as the TestProject
 # project.
@@ -459,7 +453,7 @@ def test_keeps_catalog_non_fuzzy(self):
 "Project-Id-Version: TestProject 0.1\n"
 "Report-Msgid-Bugs-To: bugs.address@email.tld\n"
 "POT-Creation-Date: 2007-04-01 15:30+0200\n"
-"PO-Revision-Date: %(date)s\n"
+"PO-Revision-Date: {date}\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language: en_US\n"
 "Language-Team: en_US <LL@li.org>\n"
@@ -467,7 +461,7 @@ def test_keeps_catalog_non_fuzzy(self):
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=utf-8\n"
 "Content-Transfer-Encoding: 8bit\n"
-"Generated-By: Babel %(version)s\n"
+"Generated-By: Babel {VERSION}\n"
 
 #. This will be a translator coment,
 #. that will include several lines
@@ -481,9 +475,7 @@ def test_keeps_catalog_non_fuzzy(self):
 msgstr[0] ""
 msgstr[1] ""
 
-""" % {'version': VERSION,
-            'date': format_datetime(datetime(1994, 11, 11, 00, 00), 'yyyy-MM-dd HH:mmZ',
-                                    tzinfo=LOCALTZ, locale='en')}
+"""
         with open(po_file) as f:
             actual_content = f.read()
         assert expected_content == actual_content
@@ -500,7 +492,8 @@ def test_correct_init_more_than_2_plurals(self):
         po_file = _po_file('lv_LV')
         assert os.path.isfile(po_file)
 
-        expected_content = r"""# Latvian (Latvia) translations for TestProject.
+        date = format_datetime(datetime(1994, 11, 11, 00, 00), 'yyyy-MM-dd HH:mmZ', tzinfo=LOCALTZ, locale='en')
+        expected_content = fr"""# Latvian (Latvia) translations for TestProject.
 # Copyright (C) 2007 FooBar, Inc.
 # This file is distributed under the same license as the TestProject
 # project.
@@ -511,16 +504,16 @@ def test_correct_init_more_than_2_plurals(self):
 "Project-Id-Version: TestProject 0.1\n"
 "Report-Msgid-Bugs-To: bugs.address@email.tld\n"
 "POT-Creation-Date: 2007-04-01 15:30+0200\n"
-"PO-Revision-Date: %(date)s\n"
+"PO-Revision-Date: {date}\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language: lv_LV\n"
 "Language-Team: lv_LV <LL@li.org>\n"
-"Plural-Forms: nplurals=3; plural=(n%%10==1 && n%%100!=11 ? 0 : n != 0 ? 1 :"
+"Plural-Forms: nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n != 0 ? 1 :"
 " 2);\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=utf-8\n"
 "Content-Transfer-Encoding: 8bit\n"
-"Generated-By: Babel %(version)s\n"
+"Generated-By: Babel {VERSION}\n"
 
 #. This will be a translator coment,
 #. that will include several lines
@@ -535,9 +528,7 @@ def test_correct_init_more_than_2_plurals(self):
 msgstr[1] ""
 msgstr[2] ""
 
-""" % {'version': VERSION,
-            'date': format_datetime(datetime(1994, 11, 11, 00, 00), 'yyyy-MM-dd HH:mmZ',
-                                    tzinfo=LOCALTZ, locale='en')}
+"""
         with open(po_file) as f:
             actual_content = f.read()
         assert expected_content == actual_content
@@ -554,7 +545,8 @@ def test_correct_init_singular_plural_forms(self):
         po_file = _po_file('ja_JP')
         assert os.path.isfile(po_file)
 
-        expected_content = r"""# Japanese (Japan) translations for TestProject.
+        date = format_datetime(datetime(1994, 11, 11, 00, 00), 'yyyy-MM-dd HH:mmZ', tzinfo=LOCALTZ, locale='ja_JP')
+        expected_content = fr"""# Japanese (Japan) translations for TestProject.
 # Copyright (C) 2007 FooBar, Inc.
 # This file is distributed under the same license as the TestProject
 # project.
@@ -565,7 +557,7 @@ def test_correct_init_singular_plural_forms(self):
 "Project-Id-Version: TestProject 0.1\n"
 "Report-Msgid-Bugs-To: bugs.address@email.tld\n"
 "POT-Creation-Date: 2007-04-01 15:30+0200\n"
-"PO-Revision-Date: %(date)s\n"
+"PO-Revision-Date: {date}\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language: ja_JP\n"
 "Language-Team: ja_JP <LL@li.org>\n"
@@ -573,7 +565,7 @@ def test_correct_init_singular_plural_forms(self):
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=utf-8\n"
 "Content-Transfer-Encoding: 8bit\n"
-"Generated-By: Babel %(version)s\n"
+"Generated-By: Babel {VERSION}\n"
 
 #. This will be a translator coment,
 #. that will include several lines
@@ -586,9 +578,7 @@ def test_correct_init_singular_plural_forms(self):
 msgid_plural "foobars"
 msgstr[0] ""
 
-""" % {'version': VERSION,
-            'date': format_datetime(datetime(1994, 11, 11, 00, 00), 'yyyy-MM-dd HH:mmZ',
-                                    tzinfo=LOCALTZ, locale='ja_JP')}
+"""
         with open(po_file) as f:
             actual_content = f.read()
         assert expected_content == actual_content
@@ -613,7 +603,8 @@ def test_supports_no_wrap(self):
 
         po_file = _po_file('en_US')
         assert os.path.isfile(po_file)
-        expected_content = r"""# English (United States) translations for TestProject.
+        date = format_datetime(datetime(1994, 11, 11, 00, 00), 'yyyy-MM-dd HH:mmZ', tzinfo=LOCALTZ, locale='en_US')
+        expected_content = fr"""# English (United States) translations for TestProject.
 # Copyright (C) 2007 FooBar, Inc.
 # This file is distributed under the same license as the TestProject
 # project.
@@ -624,7 +615,7 @@ def test_supports_no_wrap(self):
 "Project-Id-Version: TestProject 0.1\n"
 "Report-Msgid-Bugs-To: bugs.address@email.tld\n"
 "POT-Creation-Date: 2007-04-01 15:30+0200\n"
-"PO-Revision-Date: %(date)s\n"
+"PO-Revision-Date: {date}\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language: en_US\n"
 "Language-Team: en_US <LL@li.org>\n"
@@ -632,12 +623,12 @@ def test_supports_no_wrap(self):
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=utf-8\n"
 "Content-Transfer-Encoding: 8bit\n"
-"Generated-By: Babel %(version)s\n"
+"Generated-By: Babel {VERSION}\n"
 
 #. This will be a translator coment,
 #. that will include several lines
 #: project/file1.py:8
-msgid %(long_message)s
+msgid {long_message}
 msgstr ""
 
 #: project/file2.py:9
@@ -646,10 +637,7 @@ def test_supports_no_wrap(self):
 msgstr[0] ""
 msgstr[1] ""
 
-""" % {'version': VERSION,
-            'date': format_datetime(datetime(1994, 11, 11, 00, 00), 'yyyy-MM-dd HH:mmZ',
-                                    tzinfo=LOCALTZ, locale='en_US'),
-            'long_message': long_message}
+"""
         with open(po_file) as f:
             actual_content = f.read()
         assert expected_content == actual_content
@@ -673,7 +661,8 @@ def test_supports_width(self):
 
         po_file = _po_file('en_US')
         assert os.path.isfile(po_file)
-        expected_content = r"""# English (United States) translations for TestProject.
+        date = format_datetime(datetime(1994, 11, 11, 00, 00), 'yyyy-MM-dd HH:mmZ', tzinfo=LOCALTZ, locale='en_US')
+        expected_content = fr"""# English (United States) translations for TestProject.
 # Copyright (C) 2007 FooBar, Inc.
 # This file is distributed under the same license as the TestProject
 # project.
@@ -684,7 +673,7 @@ def test_supports_width(self):
 "Project-Id-Version: TestProject 0.1\n"
 "Report-Msgid-Bugs-To: bugs.address@email.tld\n"
 "POT-Creation-Date: 2007-04-01 15:30+0200\n"
-"PO-Revision-Date: %(date)s\n"
+"PO-Revision-Date: {date}\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language: en_US\n"
 "Language-Team: en_US <LL@li.org>\n"
@@ -692,12 +681,12 @@ def test_supports_width(self):
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=utf-8\n"
 "Content-Transfer-Encoding: 8bit\n"
-"Generated-By: Babel %(version)s\n"
+"Generated-By: Babel {VERSION}\n"
 
 #. This will be a translator coment,
 #. that will include several lines
 #: project/file1.py:8
-msgid %(long_message)s
+msgid {long_message}
 msgstr ""
 
 #: project/file2.py:9
@@ -706,10 +695,7 @@ def test_supports_width(self):
 msgstr[0] ""
 msgstr[1] ""
 
-""" % {'version': VERSION,
-            'date': format_datetime(datetime(1994, 11, 11, 00, 00), 'yyyy-MM-dd HH:mmZ',
-                                    tzinfo=LOCALTZ, locale='en_US'),
-            'long_message': long_message}
+"""
         with open(po_file) as f:
             actual_content = f.read()
         assert expected_content == actual_content
@@ -823,25 +809,26 @@ def test_extract_with_default_mapping(self):
                                  '-c', 'TRANSLATOR', '-c', 'TRANSLATORS:',
                                  '-o', pot_file, 'project'])
         self.assert_pot_file_exists()
-        expected_content = r"""# Translations template for TestProject.
-# Copyright (C) %(year)s FooBar, Inc.
+        date = format_datetime(datetime(1994, 11, 11, 00, 00), 'yyyy-MM-dd HH:mmZ', tzinfo=LOCALTZ, locale='en')
+        expected_content = fr"""# Translations template for TestProject.
+# Copyright (C) {time.strftime('%Y')} FooBar, Inc.
 # This file is distributed under the same license as the TestProject
 # project.
-# FIRST AUTHOR <EMAIL@ADDRESS>, %(year)s.
+# FIRST AUTHOR <EMAIL@ADDRESS>, {time.strftime('%Y')}.
 #
 #, fuzzy
 msgid ""
 msgstr ""
 "Project-Id-Version: TestProject 0.1\n"
 "Report-Msgid-Bugs-To: bugs.address@email.tld\n"
-"POT-Creation-Date: %(date)s\n"
+"POT-Creation-Date: {date}\n"
 "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language-Team: LANGUAGE <LL@li.org>\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=utf-8\n"
 "Content-Transfer-Encoding: 8bit\n"
-"Generated-By: Babel %(version)s\n"
+"Generated-By: Babel {VERSION}\n"
 
 #. TRANSLATOR: This will be a translator coment,
 #. that will include several lines
@@ -861,10 +848,7 @@ def test_extract_with_default_mapping(self):
 msgstr[0] ""
 msgstr[1] ""
 
-""" % {'version': VERSION,
-            'year': time.strftime('%Y'),
-            'date': format_datetime(datetime(1994, 11, 11, 00, 00), 'yyyy-MM-dd HH:mmZ',
-                                    tzinfo=LOCALTZ, locale='en')}
+"""
         with open(pot_file) as f:
             actual_content = f.read()
         assert expected_content == actual_content
@@ -879,25 +863,26 @@ def test_extract_with_mapping_file(self):
                                  '-c', 'TRANSLATOR', '-c', 'TRANSLATORS:',
                                  '-o', pot_file, 'project'])
         self.assert_pot_file_exists()
-        expected_content = r"""# Translations template for TestProject.
-# Copyright (C) %(year)s FooBar, Inc.
+        date = format_datetime(datetime(1994, 11, 11, 00, 00), 'yyyy-MM-dd HH:mmZ', tzinfo=LOCALTZ, locale='en')
+        expected_content = fr"""# Translations template for TestProject.
+# Copyright (C) {time.strftime('%Y')} FooBar, Inc.
 # This file is distributed under the same license as the TestProject
 # project.
-# FIRST AUTHOR <EMAIL@ADDRESS>, %(year)s.
+# FIRST AUTHOR <EMAIL@ADDRESS>, {time.strftime('%Y')}.
 #
 #, fuzzy
 msgid ""
 msgstr ""
 "Project-Id-Version: TestProject 0.1\n"
 "Report-Msgid-Bugs-To: bugs.address@email.tld\n"
-"POT-Creation-Date: %(date)s\n"
+"POT-Creation-Date: {date}\n"
 "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language-Team: LANGUAGE <LL@li.org>\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=utf-8\n"
 "Content-Transfer-Encoding: 8bit\n"
-"Generated-By: Babel %(version)s\n"
+"Generated-By: Babel {VERSION}\n"
 
 #. TRANSLATOR: This will be a translator coment,
 #. that will include several lines
@@ -911,10 +896,7 @@ def test_extract_with_mapping_file(self):
 msgstr[0] ""
 msgstr[1] ""
 
-""" % {'version': VERSION,
-            'year': time.strftime('%Y'),
-            'date': format_datetime(datetime(1994, 11, 11, 00, 00), 'yyyy-MM-dd HH:mmZ',
-                                    tzinfo=LOCALTZ, locale='en')}
+"""
         with open(pot_file) as f:
             actual_content = f.read()
         assert expected_content == actual_content
@@ -933,25 +915,26 @@ def test_extract_with_exact_file(self):
                                  '-c', 'TRANSLATOR', '-c', 'TRANSLATORS:',
                                  '-o', pot_file, file_to_extract])
         self.assert_pot_file_exists()
-        expected_content = r"""# Translations template for TestProject.
-# Copyright (C) %(year)s FooBar, Inc.
+        date = format_datetime(datetime(1994, 11, 11, 00, 00), 'yyyy-MM-dd HH:mmZ', tzinfo=LOCALTZ, locale='en')
+        expected_content = fr"""# Translations template for TestProject.
+# Copyright (C) {time.strftime('%Y')} FooBar, Inc.
 # This file is distributed under the same license as the TestProject
 # project.
-# FIRST AUTHOR <EMAIL@ADDRESS>, %(year)s.
+# FIRST AUTHOR <EMAIL@ADDRESS>, {time.strftime('%Y')}.
 #
 #, fuzzy
 msgid ""
 msgstr ""
 "Project-Id-Version: TestProject 0.1\n"
 "Report-Msgid-Bugs-To: bugs.address@email.tld\n"
-"POT-Creation-Date: %(date)s\n"
+"POT-Creation-Date: {date}\n"
 "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language-Team: LANGUAGE <LL@li.org>\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=utf-8\n"
 "Content-Transfer-Encoding: 8bit\n"
-"Generated-By: Babel %(version)s\n"
+"Generated-By: Babel {VERSION}\n"
 
 #: project/file2.py:9
 msgid "foobar"
@@ -959,10 +942,7 @@ def test_extract_with_exact_file(self):
 msgstr[0] ""
 msgstr[1] ""
 
-""" % {'version': VERSION,
-            'year': time.strftime('%Y'),
-            'date': format_datetime(datetime(1994, 11, 11, 00, 00), 'yyyy-MM-dd HH:mmZ',
-                                    tzinfo=LOCALTZ, locale='en')}
+"""
         with open(pot_file) as f:
             actual_content = f.read()
         assert expected_content == actual_content
@@ -975,7 +955,8 @@ def test_init_with_output_dir(self):
                                  '-d', os.path.join(i18n_dir),
                                  '-i', os.path.join(i18n_dir, 'messages.pot')])
         assert os.path.isfile(po_file)
-        expected_content = r"""# English (United States) translations for TestProject.
+        date = format_datetime(datetime(1994, 11, 11, 00, 00), 'yyyy-MM-dd HH:mmZ', tzinfo=LOCALTZ, locale='en')
+        expected_content = fr"""# English (United States) translations for TestProject.
 # Copyright (C) 2007 FooBar, Inc.
 # This file is distributed under the same license as the TestProject
 # project.
@@ -986,7 +967,7 @@ def test_init_with_output_dir(self):
 "Project-Id-Version: TestProject 0.1\n"
 "Report-Msgid-Bugs-To: bugs.address@email.tld\n"
 "POT-Creation-Date: 2007-04-01 15:30+0200\n"
-"PO-Revision-Date: %(date)s\n"
+"PO-Revision-Date: {date}\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language: en_US\n"
 "Language-Team: en_US <LL@li.org>\n"
@@ -994,7 +975,7 @@ def test_init_with_output_dir(self):
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=utf-8\n"
 "Content-Transfer-Encoding: 8bit\n"
-"Generated-By: Babel %(version)s\n"
+"Generated-By: Babel {VERSION}\n"
 
 #. This will be a translator coment,
 #. that will include several lines
@@ -1008,9 +989,7 @@ def test_init_with_output_dir(self):
 msgstr[0] ""
 msgstr[1] ""
 
-""" % {'version': VERSION,
-            'date': format_datetime(datetime(1994, 11, 11, 00, 00), 'yyyy-MM-dd HH:mmZ',
-                                    tzinfo=LOCALTZ, locale='en')}
+"""
         with open(po_file) as f:
             actual_content = f.read()
         assert expected_content == actual_content
@@ -1023,7 +1002,8 @@ def test_init_singular_plural_forms(self):
                                  '-d', os.path.join(i18n_dir),
                                  '-i', os.path.join(i18n_dir, 'messages.pot')])
         assert os.path.isfile(po_file)
-        expected_content = r"""# Japanese (Japan) translations for TestProject.
+        date = format_datetime(datetime(1994, 11, 11, 00, 00), 'yyyy-MM-dd HH:mmZ', tzinfo=LOCALTZ, locale='en')
+        expected_content = fr"""# Japanese (Japan) translations for TestProject.
 # Copyright (C) 2007 FooBar, Inc.
 # This file is distributed under the same license as the TestProject
 # project.
@@ -1034,7 +1014,7 @@ def test_init_singular_plural_forms(self):
 "Project-Id-Version: TestProject 0.1\n"
 "Report-Msgid-Bugs-To: bugs.address@email.tld\n"
 "POT-Creation-Date: 2007-04-01 15:30+0200\n"
-"PO-Revision-Date: %(date)s\n"
+"PO-Revision-Date: {date}\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language: ja_JP\n"
 "Language-Team: ja_JP <LL@li.org>\n"
@@ -1042,7 +1022,7 @@ def test_init_singular_plural_forms(self):
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=utf-8\n"
 "Content-Transfer-Encoding: 8bit\n"
-"Generated-By: Babel %(version)s\n"
+"Generated-By: Babel {VERSION}\n"
 
 #. This will be a translator coment,
 #. that will include several lines
@@ -1055,9 +1035,7 @@ def test_init_singular_plural_forms(self):
 msgid_plural "foobars"
 msgstr[0] ""
 
-""" % {'version': VERSION,
-            'date': format_datetime(datetime(1994, 11, 11, 00, 00), 'yyyy-MM-dd HH:mmZ',
-                                    tzinfo=LOCALTZ, locale='en')}
+"""
         with open(po_file) as f:
             actual_content = f.read()
         assert expected_content == actual_content
@@ -1070,7 +1048,8 @@ def test_init_more_than_2_plural_forms(self):
                                  '-d', i18n_dir,
                                  '-i', os.path.join(i18n_dir, 'messages.pot')])
         assert os.path.isfile(po_file)
-        expected_content = r"""# Latvian (Latvia) translations for TestProject.
+        date = format_datetime(datetime(1994, 11, 11, 00, 00), 'yyyy-MM-dd HH:mmZ', tzinfo=LOCALTZ, locale='en')
+        expected_content = fr"""# Latvian (Latvia) translations for TestProject.
 # Copyright (C) 2007 FooBar, Inc.
 # This file is distributed under the same license as the TestProject
 # project.
@@ -1081,16 +1060,16 @@ def test_init_more_than_2_plural_forms(self):
 "Project-Id-Version: TestProject 0.1\n"
 "Report-Msgid-Bugs-To: bugs.address@email.tld\n"
 "POT-Creation-Date: 2007-04-01 15:30+0200\n"
-"PO-Revision-Date: %(date)s\n"
+"PO-Revision-Date: {date}\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language: lv_LV\n"
 "Language-Team: lv_LV <LL@li.org>\n"
-"Plural-Forms: nplurals=3; plural=(n%%10==1 && n%%100!=11 ? 0 : n != 0 ? 1 :"
+"Plural-Forms: nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n != 0 ? 1 :"
 " 2);\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=utf-8\n"
 "Content-Transfer-Encoding: 8bit\n"
-"Generated-By: Babel %(version)s\n"
+"Generated-By: Babel {VERSION}\n"
 
 #. This will be a translator coment,
 #. that will include several lines
@@ -1105,9 +1084,7 @@ def test_init_more_than_2_plural_forms(self):
 msgstr[1] ""
 msgstr[2] ""
 
-""" % {'version': VERSION,
-            'date': format_datetime(datetime(1994, 11, 11, 00, 00), 'yyyy-MM-dd HH:mmZ',
-                                    tzinfo=LOCALTZ, locale='en')}
+"""
         with open(po_file) as f:
             actual_content = f.read()
         assert expected_content == actual_content

From 3fc318e6faf656c8da567281b3c5d3042e3ca010 Mon Sep 17 00:00:00 2001
From: Aarni Koskela <akx@iki.fi>
Date: Wed, 11 Jan 2023 12:49:43 +0200
Subject: [PATCH 19/53] Ensure `path` is correctly bound for extract callback
 (flake8 B023)

---
 babel/messages/frontend.py | 41 ++++++++++++++++++++------------------
 1 file changed, 22 insertions(+), 19 deletions(-)

diff --git a/babel/messages/frontend.py b/babel/messages/frontend.py
index c7e921d09..a18d00d9f 100644
--- a/babel/messages/frontend.py
+++ b/babel/messages/frontend.py
@@ -472,6 +472,27 @@ def finalize_options(self):
         else:
             self.directory_filter = None
 
+    def _build_callback(self, path: str):
+        def callback(filename: str, method: str, options: dict):
+            if method == 'ignore':
+                return
+
+            # If we explicitly provide a full filepath, just use that.
+            # Otherwise, path will be the directory path and filename
+            # is the relative path from that dir to the file.
+            # So we can join those to get the full filepath.
+            if os.path.isfile(path):
+                filepath = path
+            else:
+                filepath = os.path.normpath(os.path.join(path, filename))
+
+            optstr = ''
+            if options:
+                opt_values = ", ".join(f'{k}="{v}"' for k, v in options.items())
+                optstr = f" ({opt_values})"
+            self.log.info('extracting messages from %s%s', filepath, optstr)
+        return callback
+
     def run(self):
         mappings = self._get_mappings()
         with open(self.output_file, 'wb') as outfile:
@@ -483,25 +504,7 @@ def run(self):
                               header_comment=(self.header_comment or DEFAULT_HEADER))
 
             for path, method_map, options_map in mappings:
-                def callback(filename, method, options):
-                    if method == 'ignore':
-                        return
-
-                    # If we explicitly provide a full filepath, just use that.
-                    # Otherwise, path will be the directory path and filename
-                    # is the relative path from that dir to the file.
-                    # So we can join those to get the full filepath.
-                    if os.path.isfile(path):
-                        filepath = path
-                    else:
-                        filepath = os.path.normpath(os.path.join(path, filename))
-
-                    optstr = ''
-                    if options:
-                        opt_values = ", ".join(f'{k}="{v}"' for k, v in options.items())
-                        optstr = f" ({opt_values})"
-                    self.log.info('extracting messages from %s%s', filepath, optstr)
-
+                callback = self._build_callback(path)
                 if os.path.isfile(path):
                     current_dir = os.getcwd()
                     extracted = check_and_call_extract_file(

From 4cc26402e846733201d3d283d70deec394000dd0 Mon Sep 17 00:00:00 2001
From: Aarni Koskela <akx@iki.fi>
Date: Wed, 18 Jan 2023 19:52:05 +0200
Subject: [PATCH 20/53] Add baseline ruff configuration

---
 .pre-commit-config.yaml |  7 +++++++
 pyproject.toml          | 11 +++++++++++
 2 files changed, 18 insertions(+)
 create mode 100644 pyproject.toml

diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index b61dac46b..4c3eb9c30 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -1,4 +1,11 @@
 repos:
+  - repo: https://github.com/charliermarsh/ruff-pre-commit
+    rev: v0.0.224
+    hooks:
+      - id: ruff
+        args:
+          - --fix
+          - --force-exclude
   - repo: https://github.com/pre-commit/pre-commit-hooks
     rev: v4.4.0
     hooks:
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 000000000..977d84b66
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,11 @@
+[tool.ruff]
+target-version = "py37"
+select = []
+ignore = [
+    "C901",  # Complexity
+    "E501",  # Line length
+    "E741",  # Ambiguous variable name
+]
+extend-exclude = [
+    "tests/messages/data",
+]

From f5ef6d06f961865ff9dbb3ff9d3fc81f0bbe8fd1 Mon Sep 17 00:00:00 2001
From: Aarni Koskela <akx@iki.fi>
Date: Wed, 18 Jan 2023 20:01:03 +0200
Subject: [PATCH 21/53] Apply ruff B category fixes

---
 babel/core.py              | 10 ++++++----
 babel/dates.py             |  2 +-
 babel/messages/checkers.py |  2 +-
 babel/messages/frontend.py |  5 +++--
 babel/messages/jslexer.py  |  2 +-
 babel/messages/mofile.py   |  2 +-
 babel/numbers.py           | 14 +++++++-------
 babel/plural.py            |  2 +-
 babel/support.py           |  4 ++--
 pyproject.toml             |  4 +++-
 10 files changed, 26 insertions(+), 21 deletions(-)

diff --git a/babel/core.py b/babel/core.py
index 5041c1bb9..604e5d9ee 100644
--- a/babel/core.py
+++ b/babel/core.py
@@ -383,10 +383,12 @@ def __eq__(self, other: object) -> bool:
         for key in ('language', 'territory', 'script', 'variant'):
             if not hasattr(other, key):
                 return False
-        return (self.language == getattr(other, 'language')) and \
-            (self.territory == getattr(other, 'territory')) and \
-            (self.script == getattr(other, 'script')) and \
-            (self.variant == getattr(other, 'variant'))
+        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')  # noqa: B009
+        )
 
     def __ne__(self, other: object) -> bool:
         return not self.__eq__(other)
diff --git a/babel/dates.py b/babel/dates.py
index 51bc7ffcf..0f0843766 100644
--- a/babel/dates.py
+++ b/babel/dates.py
@@ -1884,7 +1884,7 @@ def append_field():
         fieldchar[0] = ''
         fieldnum[0] = 0
 
-    for idx, char in enumerate(pattern.replace("''", '\0')):
+    for char in pattern.replace("''", '\0'):
         if quotebuf is None:
             if char == "'":  # quote started
                 if fieldchar[0]:
diff --git a/babel/messages/checkers.py b/babel/messages/checkers.py
index 00b84e5e3..5e36b87f3 100644
--- a/babel/messages/checkers.py
+++ b/babel/messages/checkers.py
@@ -111,7 +111,7 @@ def _compatible(a: str, b: str) -> bool:
 
     def _check_positional(results: list[tuple[str, str]]) -> bool:
         positional = None
-        for name, char in results:
+        for name, _char in results:
             if positional is None:
                 positional = name is None
             else:
diff --git a/babel/messages/frontend.py b/babel/messages/frontend.py
index a18d00d9f..a9a3e4d6a 100644
--- a/babel/messages/frontend.py
+++ b/babel/messages/frontend.py
@@ -20,6 +20,7 @@
 from configparser import RawConfigParser
 import datetime
 from io import StringIO
+from typing import Iterable
 
 from babel import __version__ as VERSION
 from babel import Locale, localedata
@@ -188,7 +189,7 @@ def finalize_options(self):
     def run(self):
         n_errors = 0
         for domain in self.domain:
-            for catalog, errors in self._run_domain(domain).items():
+            for errors in self._run_domain(domain).values():
                 n_errors += len(errors)
         if n_errors:
             self.log.error('%d errors encountered.', n_errors)
@@ -1108,7 +1109,7 @@ def parse_mapping(fileobj, filename=None):
     return method_map, options_map
 
 
-def parse_keywords(strings=[]):
+def parse_keywords(strings: Iterable[str] = ()):
     """Parse keywords specifications from the given list of strings.
 
     >>> kw = sorted(parse_keywords(['_', 'dgettext:2', 'dngettext:2,3', 'pgettext:1c,2']).items())
diff --git a/babel/messages/jslexer.py b/babel/messages/jslexer.py
index 07fffdec7..0c7630cfb 100644
--- a/babel/messages/jslexer.py
+++ b/babel/messages/jslexer.py
@@ -174,7 +174,7 @@ def tokenize(source: str, jsx: bool = True, dotted: bool = True, template_string
 
     while pos < end:
         # handle regular rules first
-        for token_type, rule in rules:
+        for token_type, rule in rules:  # noqa: B007
             match = rule.match(source, pos)
             if match is not None:
                 break
diff --git a/babel/messages/mofile.py b/babel/messages/mofile.py
index a96f0592b..0a432a792 100644
--- a/babel/messages/mofile.py
+++ b/babel/messages/mofile.py
@@ -55,7 +55,7 @@ def read_mo(fileobj: SupportsRead[bytes]) -> Catalog:
 
     # Now put all messages from the .mo file buffer into the catalog
     # dictionary
-    for i in range(0, msgcount):
+    for _i in range(msgcount):
         mlen, moff = unpack(ii, buf[origidx:origidx + 8])
         mend = moff + mlen
         tlen, toff = unpack(ii, buf[transidx:transidx + 8])
diff --git a/babel/numbers.py b/babel/numbers.py
index 5a05f910e..f229072a8 100644
--- a/babel/numbers.py
+++ b/babel/numbers.py
@@ -653,7 +653,7 @@ def format_currency(
         try:
             pattern = locale.currency_formats[format_type]
         except KeyError:
-            raise UnknownCurrencyFormatError(f"{format_type!r} is not a known currency format type")
+            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,
@@ -870,8 +870,8 @@ def parse_number(string: str, locale: Locale | str | None = LC_NUMERIC) -> int:
     """
     try:
         return int(string.replace(get_group_symbol(locale), ''))
-    except ValueError:
-        raise NumberFormatError(f"{string!r} is not a valid number")
+    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 = LC_NUMERIC, strict: bool = False) -> decimal.Decimal:
@@ -926,20 +926,20 @@ def parse_decimal(string: str, locale: Locale | str | None = LC_NUMERIC, strict:
     try:
         parsed = decimal.Decimal(string.replace(group_symbol, '')
                                        .replace(decimal_symbol, '.'))
-    except decimal.InvalidOperation:
-        raise NumberFormatError(f"{string!r} is not a valid decimal number")
+    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)
         if string != proper and string.rstrip('0') != (proper + decimal_symbol):
             try:
                 parsed_alt = decimal.Decimal(string.replace(decimal_symbol, '')
                                                    .replace(group_symbol, '.'))
-            except decimal.InvalidOperation:
+            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)
                 if proper_alt == proper:
diff --git a/babel/plural.py b/babel/plural.py
index b4f54c018..62bb02078 100644
--- a/babel/plural.py
+++ b/babel/plural.py
@@ -627,7 +627,7 @@ class _UnicodeCompiler(_Compiler):
     compile_mod = _binary_compiler('%s mod %s')
 
     def compile_not(self, relation):
-        return self.compile_relation(negated=True, *relation[1])
+        return self.compile_relation(*relation[1], negated=True)
 
     def compile_relation(self, method, expr, range_list, negated=False):
         ranges = []
diff --git a/babel/support.py b/babel/support.py
index a8dd2305d..d457d796c 100644
--- a/babel/support.py
+++ b/babel/support.py
@@ -333,7 +333,7 @@ def __copy__(self) -> LazyProxy:
         return LazyProxy(
             self._func,
             enable_cache=self._is_cache_enabled,
-            *self._args,
+            *self._args,  # noqa: B026
             **self._kwargs
         )
 
@@ -342,7 +342,7 @@ def __deepcopy__(self, memo: Any) -> LazyProxy:
         return LazyProxy(
             deepcopy(self._func, memo),
             enable_cache=deepcopy(self._is_cache_enabled, memo),
-            *deepcopy(self._args, memo),
+            *deepcopy(self._args, memo),  # noqa: B026
             **deepcopy(self._kwargs, memo)
         )
 
diff --git a/pyproject.toml b/pyproject.toml
index 977d84b66..aeee57024 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,6 +1,8 @@
 [tool.ruff]
 target-version = "py37"
-select = []
+select = [
+    "B",
+]
 ignore = [
     "C901",  # Complexity
     "E501",  # Line length

From 47072d2c96390f5e5daae9e96d5dc30ae2d704ec Mon Sep 17 00:00:00 2001
From: Aarni Koskela <akx@iki.fi>
Date: Wed, 18 Jan 2023 20:01:47 +0200
Subject: [PATCH 22/53] Apply ruff C category fixes

---
 babel/plural.py                 |  2 +-
 pyproject.toml                  |  1 +
 tests/messages/test_frontend.py | 24 +++++++++---------------
 3 files changed, 11 insertions(+), 16 deletions(-)

diff --git a/babel/plural.py b/babel/plural.py
index 62bb02078..fd0d0da52 100644
--- a/babel/plural.py
+++ b/babel/plural.py
@@ -115,7 +115,7 @@ def __init__(self, rules: Mapping[str, str] | Iterable[tuple[str, str]]) -> None
             rules = rules.items()
         found = set()
         self.abstract: list[tuple[str, Any]] = []
-        for key, expr in sorted(list(rules)):
+        for key, expr in sorted(rules):
             if key not in _plural_tags:
                 raise ValueError(f"unknown tag {key!r}")
             elif key in found:
diff --git a/pyproject.toml b/pyproject.toml
index aeee57024..0a92130a6 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -2,6 +2,7 @@
 target-version = "py37"
 select = [
     "B",
+    "C",
 ]
 ignore = [
     "C901",  # Complexity
diff --git a/tests/messages/test_frontend.py b/tests/messages/test_frontend.py
index e91d02bf7..8727cb82b 100644
--- a/tests/messages/test_frontend.py
+++ b/tests/messages/test_frontend.py
@@ -30,6 +30,12 @@
 from babel.util import LOCALTZ
 from babel.messages.pofile import read_po, write_po
 
+TEST_PROJECT_DISTRIBUTION_DATA = {
+    "name": "TestProject",
+    "version": "0.1",
+    "packages": ["project"],
+}
+
 this_dir = os.path.abspath(os.path.dirname(__file__))
 data_dir = os.path.join(this_dir, 'data')
 project_dir = os.path.join(data_dir, 'project')
@@ -47,11 +53,7 @@ def setUp(self):
         self.olddir = os.getcwd()
         os.chdir(data_dir)
 
-        self.dist = Distribution(dict(
-            name='TestProject',
-            version='0.1',
-            packages=['project']
-        ))
+        self.dist = Distribution(TEST_PROJECT_DISTRIBUTION_DATA)
         self.cmd = frontend.compile_catalog(self.dist)
         self.cmd.initialize_options()
 
@@ -77,11 +79,7 @@ def setUp(self):
         self.olddir = os.getcwd()
         os.chdir(data_dir)
 
-        self.dist = Distribution(dict(
-            name='TestProject',
-            version='0.1',
-            packages=['project']
-        ))
+        self.dist = Distribution(TEST_PROJECT_DISTRIBUTION_DATA)
         self.cmd = frontend.extract_messages(self.dist)
         self.cmd.initialize_options()
 
@@ -350,11 +348,7 @@ def setUp(self):
         self.olddir = os.getcwd()
         os.chdir(data_dir)
 
-        self.dist = Distribution(dict(
-            name='TestProject',
-            version='0.1',
-            packages=['project']
-        ))
+        self.dist = Distribution(TEST_PROJECT_DISTRIBUTION_DATA)
         self.cmd = frontend.init_catalog(self.dist)
         self.cmd.initialize_options()
 

From 9512281c7e45e9c829b47c50d332e9654809cb64 Mon Sep 17 00:00:00 2001
From: Aarni Koskela <akx@iki.fi>
Date: Wed, 18 Jan 2023 20:04:18 +0200
Subject: [PATCH 23/53] Apply ruff E category fixes

---
 docs/conf.py             |  3 ++-
 pyproject.toml           |  4 ++++
 tests/test_core.py       |  2 +-
 tests/test_localedata.py |  4 ++--
 tests/test_numbers.py    | 18 +++++++++---------
 tests/test_util.py       |  3 ++-
 6 files changed, 20 insertions(+), 14 deletions(-)

diff --git a/docs/conf.py b/docs/conf.py
index c0e23894b..ed4794ea9 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -10,7 +10,8 @@
 # All configuration values have a default; values that are commented out
 # serve to show the default.
 
-import sys, os
+import sys
+import os
 
 # If extensions (or modules to document with autodoc) are in another directory,
 # add these directories to sys.path here. If the directory is relative to the
diff --git a/pyproject.toml b/pyproject.toml
index 0a92130a6..df9eba7e6 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -3,12 +3,16 @@ target-version = "py37"
 select = [
     "B",
     "C",
+    "E",
 ]
 ignore = [
     "C901",  # Complexity
     "E501",  # Line length
+    "E731",  # Do not assign a lambda expression (we use them on purpose)
     "E741",  # Ambiguous variable name
 ]
 extend-exclude = [
     "tests/messages/data",
 ]
+[tool.ruff.per-file-ignores]
+"scripts/import_cldr.py" = ["E402"]
diff --git a/tests/test_core.py b/tests/test_core.py
index 605bf5c02..a20071897 100644
--- a/tests/test_core.py
+++ b/tests/test_core.py
@@ -322,7 +322,7 @@ def test_issue_601_no_language_name_but_has_variant():
     # Instead, it's better to return None altogether, as we can't reliably format
     # part of a language name.
 
-    assert Locale.parse('fi_FI').get_display_name('kw_GB') == None
+    assert Locale.parse('fi_FI').get_display_name('kw_GB') is None
 
 
 def test_issue_814():
diff --git a/tests/test_localedata.py b/tests/test_localedata.py
index 7bfe9c6ba..006a6b047 100644
--- a/tests/test_localedata.py
+++ b/tests/test_localedata.py
@@ -95,13 +95,13 @@ def test_locale_argument_acceptance():
     normalized_locale = localedata.normalize_locale(None)
     assert normalized_locale is None
     locale_exist = localedata.exists(None)
-    assert locale_exist == False
+    assert locale_exist is False
 
     # # Testing list input.
     normalized_locale = localedata.normalize_locale(['en_us', None])
     assert normalized_locale is None
     locale_exist = localedata.exists(['en_us', None])
-    assert locale_exist == False
+    assert locale_exist is False
 
 
 def test_locale_identifiers_cache(monkeypatch):
diff --git a/tests/test_numbers.py b/tests/test_numbers.py
index 0939562bf..3ae914396 100644
--- a/tests/test_numbers.py
+++ b/tests/test_numbers.py
@@ -224,15 +224,15 @@ def test_validate_currency():
 
 
 def test_is_currency():
-    assert is_currency('EUR') == True
-    assert is_currency('eUr') == False
-    assert is_currency('FUU') == False
-    assert is_currency('') == False
-    assert is_currency(None) == False
-    assert is_currency('   EUR    ') == False
-    assert is_currency('   ') == False
-    assert is_currency([]) == False
-    assert is_currency(set()) == False
+    assert is_currency('EUR') is True
+    assert is_currency('eUr') is False
+    assert is_currency('FUU') is False
+    assert is_currency('') is False
+    assert is_currency(None) is False
+    assert is_currency('   EUR    ') is False
+    assert is_currency('   ') is False
+    assert is_currency([]) is False
+    assert is_currency(set()) is False
 
 
 def test_normalize_currency():
diff --git a/tests/test_util.py b/tests/test_util.py
index d78aee7bc..ba62d9bb8 100644
--- a/tests/test_util.py
+++ b/tests/test_util.py
@@ -56,7 +56,8 @@ def test_zone_positive_offset(self):
         assert util.FixedOffsetTimezone(330).zone == 'Etc/GMT+330'
 
 
-parse_encoding = lambda s: util.parse_encoding(BytesIO(s.encode('utf-8')))
+def parse_encoding(s):
+    return util.parse_encoding(BytesIO(s.encode('utf-8')))
 
 
 def test_parse_encoding_defined():

From 67870e3ce54d6b0a61900e2436f3ffdfa4d6a83d Mon Sep 17 00:00:00 2001
From: Aarni Koskela <akx@iki.fi>
Date: Wed, 18 Jan 2023 20:07:05 +0200
Subject: [PATCH 24/53] Apply ruff F category fixes

---
 babel/dates.py            | 4 ++--
 babel/messages/catalog.py | 2 +-
 babel/messages/jslexer.py | 3 +--
 babel/support.py          | 5 +++--
 pyproject.toml            | 1 +
 5 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/babel/dates.py b/babel/dates.py
index 0f0843766..ee8bcfdef 100644
--- a/babel/dates.py
+++ b/babel/dates.py
@@ -247,13 +247,13 @@ def get_timezone(zone: str | datetime.tzinfo | None = None) -> datetime.tzinfo:
     if pytz:
         try:
             return pytz.timezone(zone)
-        except pytz.UnknownTimeZoneError as exc:
+        except pytz.UnknownTimeZoneError as exc:  # noqa: F841
             pass
     else:
         assert zoneinfo
         try:
             return zoneinfo.ZoneInfo(zone)
-        except zoneinfo.ZoneInfoNotFoundError as exc:
+        except zoneinfo.ZoneInfoNotFoundError as exc:  # noqa: F841
             pass
 
     raise LookupError(f"Unknown timezone {zone}") from exc
diff --git a/babel/messages/catalog.py b/babel/messages/catalog.py
index 4486bec4e..7b27f6427 100644
--- a/babel/messages/catalog.py
+++ b/babel/messages/catalog.py
@@ -12,7 +12,7 @@
 import re
 
 from collections import OrderedDict
-from collections.abc import Generator, Iterable, Iterator
+from collections.abc import Iterable, Iterator
 import datetime
 from difflib import get_close_matches
 from email import message_from_string
diff --git a/babel/messages/jslexer.py b/babel/messages/jslexer.py
index 0c7630cfb..11ddf9659 100644
--- a/babel/messages/jslexer.py
+++ b/babel/messages/jslexer.py
@@ -11,8 +11,7 @@
 """
 from __future__ import annotations
 
-from collections import namedtuple
-from collections.abc import Generator, Iterator, Sequence
+from collections.abc import Generator
 import re
 from typing import NamedTuple
 
diff --git a/babel/support.py b/babel/support.py
index d457d796c..216c8f1d6 100644
--- a/babel/support.py
+++ b/babel/support.py
@@ -16,14 +16,13 @@
 import gettext
 import locale
 import os
-import datetime
 from collections.abc import Iterator
 from typing import TYPE_CHECKING, Any, Callable
 
 from babel.core import Locale
 
 from babel.dates import (format_date, format_datetime, format_time,
-                         format_timedelta, get_timezone)
+                         format_timedelta)
 from babel.numbers import (format_compact_currency, format_compact_decimal,
                            format_currency, format_decimal, format_percent,
                            format_scientific)
@@ -77,6 +76,7 @@ def datetime(
         """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 AM'
@@ -91,6 +91,7 @@ def time(
         """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 AM'
diff --git a/pyproject.toml b/pyproject.toml
index df9eba7e6..7dd161ef3 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,6 +4,7 @@ select = [
     "B",
     "C",
     "E",
+    "F",
 ]
 ignore = [
     "C901",  # Complexity

From 3fb72cea613ba05480a9027aa927d2c8b817d693 Mon Sep 17 00:00:00 2001
From: Aarni Koskela <akx@iki.fi>
Date: Wed, 18 Jan 2023 20:07:31 +0200
Subject: [PATCH 25/53] Apply ruff I category fixes

---
 babel/dates.py                    |  2 +-
 babel/localtime/__init__.py       |  2 +-
 babel/localtime/_unix.py          |  6 +++---
 babel/localtime/_win32.py         |  3 ++-
 babel/messages/catalog.py         |  7 +++----
 babel/messages/checkers.py        |  3 +--
 babel/messages/extract.py         | 18 +++++++++++++-----
 babel/messages/frontend.py        | 19 +++++++++++++------
 babel/messages/jslexer.py         |  2 +-
 babel/messages/plurals.py         |  2 +-
 babel/messages/pofile.py          |  7 ++++---
 babel/numbers.py                  |  4 ++--
 babel/support.py                  | 15 +++++++++------
 babel/util.py                     |  6 +++---
 docs/conf.py                      |  2 +-
 pyproject.toml                    |  1 +
 scripts/download_import_cldr.py   |  7 +++----
 scripts/dump_data.py              |  2 +-
 scripts/dump_global.py            |  5 +++--
 scripts/generate_authors.py       |  3 +--
 scripts/import_cldr.py            |  5 ++---
 setup.py                          |  2 +-
 tests/conftest.py                 |  1 +
 tests/messages/test_catalog.py    |  2 +-
 tests/messages/test_frontend.py   | 22 ++++++++++++++--------
 tests/messages/test_js_extract.py |  2 ++
 tests/messages/test_mofile.py     |  2 +-
 tests/messages/test_pofile.py     |  6 ++++--
 tests/test_core.py                |  2 +-
 tests/test_dates.py               |  2 +-
 tests/test_day_periods.py         |  3 ++-
 tests/test_localedata.py          |  4 ++--
 tests/test_numbers.py             | 15 +++++++++++----
 tests/test_plural.py              |  3 ++-
 tests/test_smoke.py               |  5 +++--
 tests/test_support.py             |  6 +++---
 tests/test_util.py                |  1 +
 37 files changed, 119 insertions(+), 80 deletions(-)

diff --git a/babel/dates.py b/babel/dates.py
index ee8bcfdef..7bfea7111 100644
--- a/babel/dates.py
+++ b/babel/dates.py
@@ -27,9 +27,9 @@
     pytz = None
     import zoneinfo
 
+import datetime
 from bisect import bisect_right
 from collections.abc import Iterable
-import datetime
 
 from babel import localtime
 from babel.core import Locale, default_locale, get_global
diff --git a/babel/localtime/__init__.py b/babel/localtime/__init__.py
index 9d227c7b1..1d65fb207 100644
--- a/babel/localtime/__init__.py
+++ b/babel/localtime/__init__.py
@@ -9,9 +9,9 @@
     :license: BSD, see LICENSE for more details.
 """
 
+import datetime
 import sys
 import time
-import datetime
 from threading import RLock
 
 if sys.platform == 'win32':
diff --git a/babel/localtime/_unix.py b/babel/localtime/_unix.py
index 89b461a01..eb81beb61 100644
--- a/babel/localtime/_unix.py
+++ b/babel/localtime/_unix.py
@@ -1,14 +1,14 @@
+import datetime
 import os
 import re
 
-import datetime
-
 from babel.localtime._helpers import (
+    _get_tzinfo,
     _get_tzinfo_from_file,
     _get_tzinfo_or_raise,
-    _get_tzinfo,
 )
 
+
 def _tz_from_env(tzenv: str) -> datetime.tzinfo:
     if tzenv[0] == ':':
         tzenv = tzenv[1:]
diff --git a/babel/localtime/_win32.py b/babel/localtime/_win32.py
index 42f819a21..1a52567bc 100644
--- a/babel/localtime/_win32.py
+++ b/babel/localtime/_win32.py
@@ -6,9 +6,10 @@
     winreg = None
 
 import datetime
+from typing import Any, Dict, cast
+
 from babel.core import get_global
 from babel.localtime._helpers import _get_tzinfo_or_raise
-from typing import Any, Dict, cast
 
 # When building the cldr data on windows this module gets imported.
 # Because at that point there is no global.dat yet this call will
diff --git a/babel/messages/catalog.py b/babel/messages/catalog.py
index 7b27f6427..dbca10f45 100644
--- a/babel/messages/catalog.py
+++ b/babel/messages/catalog.py
@@ -9,21 +9,20 @@
 """
 from __future__ import annotations
 
+import datetime
 import re
-
 from collections import OrderedDict
 from collections.abc import Iterable, Iterator
-import datetime
+from copy import copy
 from difflib import get_close_matches
 from email import message_from_string
-from copy import copy
 from typing import TYPE_CHECKING
 
 from babel import __version__ as VERSION
 from babel.core import Locale, UnknownLocaleError
 from babel.dates import format_datetime
 from babel.messages.plurals import get_plural
-from babel.util import distinct, LOCALTZ, FixedOffsetTimezone, _cmp
+from babel.util import LOCALTZ, FixedOffsetTimezone, _cmp, distinct
 
 if TYPE_CHECKING:
     from typing_extensions import TypeAlias
diff --git a/babel/messages/checkers.py b/babel/messages/checkers.py
index 5e36b87f3..38a26e844 100644
--- a/babel/messages/checkers.py
+++ b/babel/messages/checkers.py
@@ -13,8 +13,7 @@
 
 from collections.abc import Callable
 
-from babel.messages.catalog import Catalog, Message, TranslationError, PYTHON_FORMAT
-
+from babel.messages.catalog import PYTHON_FORMAT, Catalog, Message, TranslationError
 
 #: list of format chars that are compatible to each other
 _string_format_compatibilities = [
diff --git a/babel/messages/extract.py b/babel/messages/extract.py
index a4265101a..0934937c8 100644
--- a/babel/messages/extract.py
+++ b/babel/messages/extract.py
@@ -18,21 +18,29 @@
 from __future__ import annotations
 
 import ast
-from collections.abc import Callable, Collection, Generator, Iterable, Mapping, MutableSequence
 import io
 import os
 import sys
+from collections.abc import (
+    Callable,
+    Collection,
+    Generator,
+    Iterable,
+    Mapping,
+    MutableSequence,
+)
 from os.path import relpath
-from tokenize import generate_tokens, COMMENT, NAME, OP, STRING
-from typing import Any, TYPE_CHECKING
+from textwrap import dedent
+from tokenize import COMMENT, NAME, OP, STRING, generate_tokens
+from typing import TYPE_CHECKING, Any
 
 from babel.util import parse_encoding, parse_future_flags, pathmatch
-from textwrap import dedent
 
 if TYPE_CHECKING:
     from typing import IO, Protocol
-    from typing_extensions import Final, TypeAlias, TypedDict
+
     from _typeshed import SupportsItems, SupportsRead, SupportsReadline
+    from typing_extensions import Final, TypeAlias, TypedDict
 
     class _PyOptions(TypedDict, total=False):
         encoding: str
diff --git a/babel/messages/frontend.py b/babel/messages/frontend.py
index a9a3e4d6a..98a1ca89a 100644
--- a/babel/messages/frontend.py
+++ b/babel/messages/frontend.py
@@ -8,6 +8,7 @@
     :license: BSD, see LICENSE for more details.
 """
 
+import datetime
 import fnmatch
 import logging
 import optparse
@@ -18,15 +19,19 @@
 import tempfile
 from collections import OrderedDict
 from configparser import RawConfigParser
-import datetime
 from io import StringIO
 from typing import Iterable
 
-from babel import __version__ as VERSION
 from babel import Locale, localedata
+from babel import __version__ as VERSION
 from babel.core import UnknownLocaleError
-from babel.messages.catalog import Catalog, DEFAULT_HEADER
-from babel.messages.extract import DEFAULT_KEYWORDS, DEFAULT_MAPPING, check_and_call_extract_file, extract_from_dir
+from babel.messages.catalog import DEFAULT_HEADER, Catalog
+from babel.messages.extract import (
+    DEFAULT_KEYWORDS,
+    DEFAULT_MAPPING,
+    check_and_call_extract_file,
+    extract_from_dir,
+)
 from babel.messages.mofile import write_mo
 from babel.messages.pofile import read_po, write_po
 from babel.util import LOCALTZ
@@ -39,14 +44,16 @@
     distutils_log = log  # "distutils.log → (no replacement yet)"
 
     try:
-        from setuptools.errors import OptionError, SetupError, BaseError
+        from setuptools.errors import BaseError, OptionError, SetupError
     except ImportError:  # Error aliases only added in setuptools 59 (2021-11).
         OptionError = SetupError = BaseError = Exception
 
 except ImportError:
     from distutils import log as distutils_log
     from distutils.cmd import Command as _Command
-    from distutils.errors import DistutilsOptionError as OptionError, DistutilsSetupError as SetupError, DistutilsError as BaseError
+    from distutils.errors import DistutilsError as BaseError
+    from distutils.errors import DistutilsOptionError as OptionError
+    from distutils.errors import DistutilsSetupError as SetupError
 
 
 
diff --git a/babel/messages/jslexer.py b/babel/messages/jslexer.py
index 11ddf9659..e6d20aec5 100644
--- a/babel/messages/jslexer.py
+++ b/babel/messages/jslexer.py
@@ -11,8 +11,8 @@
 """
 from __future__ import annotations
 
-from collections.abc import Generator
 import re
+from collections.abc import Generator
 from typing import NamedTuple
 
 operators: list[str] = sorted([
diff --git a/babel/messages/plurals.py b/babel/messages/plurals.py
index 0fdf53bb0..eb8de47e1 100644
--- a/babel/messages/plurals.py
+++ b/babel/messages/plurals.py
@@ -9,9 +9,9 @@
 """
 from __future__ import annotations
 
-from babel.core import default_locale, Locale
 from operator import itemgetter
 
+from babel.core import Locale, default_locale
 
 # XXX: remove this file, duplication with babel.plural
 
diff --git a/babel/messages/pofile.py b/babel/messages/pofile.py
index b6d0d6ed8..76d3123e7 100644
--- a/babel/messages/pofile.py
+++ b/babel/messages/pofile.py
@@ -14,14 +14,15 @@
 import re
 from collections.abc import Iterable
 from typing import TYPE_CHECKING
-from babel.core import Locale
 
+from babel.core import Locale
 from babel.messages.catalog import Catalog, Message
-from babel.util import wraptext, _cmp
+from babel.util import _cmp, wraptext
 
 if TYPE_CHECKING:
-    from _typeshed import SupportsWrite
     from typing import IO, AnyStr
+
+    from _typeshed import SupportsWrite
     from typing_extensions import Literal
 
 
diff --git a/babel/numbers.py b/babel/numbers.py
index f229072a8..6ecd7dc11 100644
--- a/babel/numbers.py
+++ b/babel/numbers.py
@@ -19,11 +19,11 @@
 #  - https://www.unicode.org/reports/tr35/ (Appendix G.6)
 from __future__ import annotations
 
+import datetime
 import decimal
 import re
-from typing import TYPE_CHECKING, Any, overload
 import warnings
-import datetime
+from typing import TYPE_CHECKING, Any, overload
 
 from babel.core import Locale, default_locale, get_global
 from babel.localedata import LocaleDataDict
diff --git a/babel/support.py b/babel/support.py
index 216c8f1d6..70925997c 100644
--- a/babel/support.py
+++ b/babel/support.py
@@ -20,12 +20,15 @@
 from typing import TYPE_CHECKING, Any, Callable
 
 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)
+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:
     from typing_extensions import Literal
diff --git a/babel/util.py b/babel/util.py
index d25ec533d..cf86f20f5 100644
--- a/babel/util.py
+++ b/babel/util.py
@@ -11,15 +11,15 @@
 
 import codecs
 import collections
+import datetime
 import os
 import re
 import textwrap
-from babel import localtime, dates
-
 from collections.abc import Generator, Iterable
-import datetime
 from typing import IO, Any, TypeVar
 
+from babel import dates, localtime
+
 missing = object()
 
 _T = TypeVar("_T")
diff --git a/docs/conf.py b/docs/conf.py
index ed4794ea9..84bbd7ed2 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -10,8 +10,8 @@
 # All configuration values have a default; values that are commented out
 # serve to show the default.
 
-import sys
 import os
+import sys
 
 # If extensions (or modules to document with autodoc) are in another directory,
 # add these directories to sys.path here. If the directory is relative to the
diff --git a/pyproject.toml b/pyproject.toml
index 7dd161ef3..37f7fe34d 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -5,6 +5,7 @@ select = [
     "C",
     "E",
     "F",
+    "I",
 ]
 ignore = [
     "C901",  # Complexity
diff --git a/scripts/download_import_cldr.py b/scripts/download_import_cldr.py
index 57995b571..926e74760 100755
--- a/scripts/download_import_cldr.py
+++ b/scripts/download_import_cldr.py
@@ -1,15 +1,14 @@
 #!/usr/bin/env python3
 
 import contextlib
+import hashlib
 import os
-import sys
 import shutil
-import hashlib
-import zipfile
 import subprocess
+import sys
+import zipfile
 from urllib.request import urlretrieve
 
-
 URL = 'http://unicode.org/Public/cldr/41/cldr-common-41.0.zip'
 FILENAME = 'cldr-common-41.0.zip'
 # Via https://unicode.org/Public/cldr/41/hashes/SHASUM512
diff --git a/scripts/dump_data.py b/scripts/dump_data.py
index e41905000..041a410e1 100755
--- a/scripts/dump_data.py
+++ b/scripts/dump_data.py
@@ -14,7 +14,7 @@
 from optparse import OptionParser
 from pprint import pprint
 
-from babel.localedata import load, LocaleDataDict
+from babel.localedata import LocaleDataDict, load
 
 
 def main():
diff --git a/scripts/dump_global.py b/scripts/dump_global.py
index 6696415e6..3fc95b6c9 100755
--- a/scripts/dump_global.py
+++ b/scripts/dump_global.py
@@ -11,10 +11,11 @@
 # individuals. For the exact contribution history, see the revision
 # history and logs, available at http://babel.edgewall.org/log/.
 
-import cPickle as pickle
 import os
-from pprint import pprint
 import sys
+from pprint import pprint
+
+import cPickle as pickle
 
 import babel
 
diff --git a/scripts/generate_authors.py b/scripts/generate_authors.py
index e2e3addcd..64c0af82e 100644
--- a/scripts/generate_authors.py
+++ b/scripts/generate_authors.py
@@ -1,8 +1,7 @@
+import os
 from collections import Counter
 from subprocess import check_output
 
-import os
-
 root_path = os.path.realpath(os.path.join(os.path.dirname(__file__), '..'))
 
 
diff --git a/scripts/import_cldr.py b/scripts/import_cldr.py
index 5de707c89..0dc47382f 100755
--- a/scripts/import_cldr.py
+++ b/scripts/import_cldr.py
@@ -12,13 +12,12 @@
 # history and logs, available at http://babel.edgewall.org/log/.
 
 import collections
-from optparse import OptionParser
+import logging
 import os
 import pickle
 import re
 import sys
-import logging
-
+from optparse import OptionParser
 from xml.etree import ElementTree
 
 # Make sure we're using Babel source, and not some previously installed version
diff --git a/setup.py b/setup.py
index db63216e9..df6ad8b9a 100755
--- a/setup.py
+++ b/setup.py
@@ -1,7 +1,7 @@
 import subprocess
 import sys
 
-from setuptools import setup, Command
+from setuptools import Command, setup
 
 try:
     from babel import __version__
diff --git a/tests/conftest.py b/tests/conftest.py
index 0506a8330..67e3ce921 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -1,4 +1,5 @@
 import os
+
 import pytest
 
 try:
diff --git a/tests/messages/test_catalog.py b/tests/messages/test_catalog.py
index e9b15a88a..eb1e308f2 100644
--- a/tests/messages/test_catalog.py
+++ b/tests/messages/test_catalog.py
@@ -15,7 +15,7 @@
 import unittest
 from io import StringIO
 
-from babel.dates import format_datetime, UTC
+from babel.dates import UTC, format_datetime
 from babel.messages import catalog, pofile
 from babel.util import FixedOffsetTimezone
 
diff --git a/tests/messages/test_frontend.py b/tests/messages/test_frontend.py
index 8727cb82b..e540e7137 100644
--- a/tests/messages/test_frontend.py
+++ b/tests/messages/test_frontend.py
@@ -9,26 +9,32 @@
 # This software consists of voluntary contributions made by many
 # individuals. For the exact contribution history, see the revision
 # history and logs, available at http://babel.edgewall.org/log/.
-import shlex
-from datetime import datetime
-from freezegun import freeze_time
-from io import StringIO
-from setuptools import Distribution
 import logging
 import os
+import shlex
 import shutil
 import sys
 import time
 import unittest
+from datetime import datetime
+from io import StringIO
 
 import pytest
+from freezegun import freeze_time
+from setuptools import Distribution
 
 from babel import __version__ as VERSION
 from babel.dates import format_datetime
-from babel.messages import frontend, Catalog
-from babel.messages.frontend import CommandLineInterface, extract_messages, update_catalog, OptionError, BaseError
-from babel.util import LOCALTZ
+from babel.messages import Catalog, frontend
+from babel.messages.frontend import (
+    BaseError,
+    CommandLineInterface,
+    OptionError,
+    extract_messages,
+    update_catalog,
+)
 from babel.messages.pofile import read_po, write_po
+from babel.util import LOCALTZ
 
 TEST_PROJECT_DISTRIBUTION_DATA = {
     "name": "TestProject",
diff --git a/tests/messages/test_js_extract.py b/tests/messages/test_js_extract.py
index 95985c0f7..7d4392150 100644
--- a/tests/messages/test_js_extract.py
+++ b/tests/messages/test_js_extract.py
@@ -1,5 +1,7 @@
 from io import BytesIO
+
 import pytest
+
 from babel.messages import extract
 
 
diff --git a/tests/messages/test_mofile.py b/tests/messages/test_mofile.py
index 6e026a846..ff7c2ed0b 100644
--- a/tests/messages/test_mofile.py
+++ b/tests/messages/test_mofile.py
@@ -14,7 +14,7 @@
 import unittest
 from io import BytesIO
 
-from babel.messages import mofile, Catalog
+from babel.messages import Catalog, mofile
 from babel.support import Translations
 
 
diff --git a/tests/messages/test_pofile.py b/tests/messages/test_pofile.py
index a72368bcc..fb5799b16 100644
--- a/tests/messages/test_pofile.py
+++ b/tests/messages/test_pofile.py
@@ -10,16 +10,18 @@
 # individuals. For the exact contribution history, see the revision
 # history and logs, available at http://babel.edgewall.org/log/.
 
-from datetime import datetime
 import unittest
+from datetime import datetime
 from io import BytesIO, StringIO
+
 import pytest
 
 from babel.core import Locale
-from babel.messages.catalog import Catalog, Message
 from babel.messages import pofile
+from babel.messages.catalog import Catalog, Message
 from babel.util import FixedOffsetTimezone
 
+
 class ReadPoTestCase(unittest.TestCase):
 
     def test_preserve_locale(self):
diff --git a/tests/test_core.py b/tests/test_core.py
index a20071897..f4d253c10 100644
--- a/tests/test_core.py
+++ b/tests/test_core.py
@@ -13,7 +13,7 @@
 import pytest
 
 from babel import core
-from babel.core import default_locale, Locale
+from babel.core import Locale, default_locale
 
 
 def test_locale_provides_access_to_cldr_locale_data():
diff --git a/tests/test_dates.py b/tests/test_dates.py
index a4fb9c5bf..b4abaf934 100644
--- a/tests/test_dates.py
+++ b/tests/test_dates.py
@@ -16,7 +16,7 @@
 import freezegun
 import pytest
 
-from babel import dates, Locale
+from babel import Locale, dates
 from babel.dates import NO_INHERITANCE_MARKER, _localize
 from babel.util import FixedOffsetTimezone
 
diff --git a/tests/test_day_periods.py b/tests/test_day_periods.py
index 414c0f6e5..9b51e1dd9 100644
--- a/tests/test_day_periods.py
+++ b/tests/test_day_periods.py
@@ -1,8 +1,9 @@
 from datetime import time
 
-import babel.dates as dates
 import pytest
 
+import babel.dates as dates
+
 
 @pytest.mark.parametrize("locale, time, expected_period_id", [
     ("de", time(7, 42), "morning1"),  # (from, before)
diff --git a/tests/test_localedata.py b/tests/test_localedata.py
index 006a6b047..7672ddc15 100644
--- a/tests/test_localedata.py
+++ b/tests/test_localedata.py
@@ -12,15 +12,15 @@
 
 import os
 import pickle
+import random
 import sys
 import tempfile
 import unittest
-import random
 from operator import methodcaller
 
 import pytest
 
-from babel import localedata, Locale, UnknownLocaleError
+from babel import Locale, UnknownLocaleError, localedata
 
 
 class MergeResolveTestCase(unittest.TestCase):
diff --git a/tests/test_numbers.py b/tests/test_numbers.py
index 3ae914396..ca33c1e2b 100644
--- a/tests/test_numbers.py
+++ b/tests/test_numbers.py
@@ -12,14 +12,21 @@
 
 import decimal
 import unittest
-import pytest
-
 from datetime import date
 
+import pytest
+
 from babel import localedata, numbers
 from babel.numbers import (
-    list_currencies, validate_currency, UnknownCurrencyError, is_currency, normalize_currency,
-    get_currency_precision, get_decimal_precision, get_currency_unit_pattern)
+    UnknownCurrencyError,
+    get_currency_precision,
+    get_currency_unit_pattern,
+    get_decimal_precision,
+    is_currency,
+    list_currencies,
+    normalize_currency,
+    validate_currency,
+)
 
 
 class FormatDecimalTestCase(unittest.TestCase):
diff --git a/tests/test_plural.py b/tests/test_plural.py
index 16601cfec..e1e5ead60 100644
--- a/tests/test_plural.py
+++ b/tests/test_plural.py
@@ -11,9 +11,10 @@
 # history and logs, available at http://babel.edgewall.org/log/.
 import decimal
 import unittest
+
 import pytest
 
-from babel import plural, localedata
+from babel import localedata, plural
 
 EPSILON = decimal.Decimal("0.0001")
 
diff --git a/tests/test_smoke.py b/tests/test_smoke.py
index aed676a16..c91684534 100644
--- a/tests/test_smoke.py
+++ b/tests/test_smoke.py
@@ -4,11 +4,12 @@
 operations don't fail due to odd corner cases on any locale that
 we ship.
 """
-import decimal
 import datetime
+import decimal
+
 import pytest
 
-from babel import Locale, units, dates, numbers
+from babel import Locale, dates, numbers, units
 
 NUMBERS = (
     decimal.Decimal("-33.76"),  # Negative Decimal
diff --git a/tests/test_support.py b/tests/test_support.py
index 3ca0be3d6..fe1040264 100644
--- a/tests/test_support.py
+++ b/tests/test_support.py
@@ -13,18 +13,18 @@
 import inspect
 import os
 import shutil
+import sys
 import tempfile
 import unittest
-import pytest
-import sys
 from datetime import date, datetime, timedelta
 from io import BytesIO
 
+import pytest
+
 from babel import support
 from babel.messages import Catalog
 from babel.messages.mofile import write_mo
 
-
 SKIP_LGETTEXT = sys.version_info >= (3, 8)
 
 @pytest.mark.usefixtures("os_environ")
diff --git a/tests/test_util.py b/tests/test_util.py
index ba62d9bb8..f58fc2443 100644
--- a/tests/test_util.py
+++ b/tests/test_util.py
@@ -11,6 +11,7 @@
 # history and logs, available at http://babel.edgewall.org/log/.
 
 import __future__
+
 import unittest
 from io import BytesIO
 

From 65d9ae36ecb9d4a4691ffb9f21f3ff11e6ff5739 Mon Sep 17 00:00:00 2001
From: Aarni Koskela <akx@iki.fi>
Date: Wed, 18 Jan 2023 20:08:59 +0200
Subject: [PATCH 26/53] Apply ruff SIM300 (de-yoda) fixes

---
 pyproject.toml     | 1 +
 tests/test_core.py | 9 ++++-----
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/pyproject.toml b/pyproject.toml
index 37f7fe34d..a7915af10 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -6,6 +6,7 @@ select = [
     "E",
     "F",
     "I",
+    "SIM300",
 ]
 ignore = [
     "C901",  # Complexity
diff --git a/tests/test_core.py b/tests/test_core.py
index f4d253c10..cc234550e 100644
--- a/tests/test_core.py
+++ b/tests/test_core.py
@@ -18,15 +18,14 @@
 
 def test_locale_provides_access_to_cldr_locale_data():
     locale = Locale('en', 'US')
-    assert u'English (United States)' == locale.display_name
-    assert u'.' == locale.number_symbols['decimal']
+    assert locale.display_name == u'English (United States)'
+    assert locale.number_symbols['decimal'] == u'.'
 
 
 def test_locale_repr():
     assert repr(Locale('en', 'US')) == "Locale('en', territory='US')"
-    assert ("Locale('de', territory='DE')" == repr(Locale('de', 'DE')))
-    assert ("Locale('zh', territory='CN', script='Hans')" ==
-            repr(Locale('zh', 'CN', script='Hans')))
+    assert (repr(Locale('de', 'DE')) == "Locale('de', territory='DE')")
+    assert (repr(Locale('zh', 'CN', script='Hans')) == "Locale('zh', territory='CN', script='Hans')")
 
 
 def test_locale_comparison():

From 5f7580d40523ce8aa67f51a3eb941dc81faa47f2 Mon Sep 17 00:00:00 2001
From: Aarni Koskela <akx@iki.fi>
Date: Wed, 18 Jan 2023 20:59:35 +0200
Subject: [PATCH 27/53] Apply ruff UP025 (unicode literal prefix) fix

---
 babel/dates.py                    |  14 +-
 babel/messages/catalog.py         |  14 +-
 babel/messages/frontend.py        |   2 +-
 babel/messages/jslexer.py         |   2 +-
 babel/messages/pofile.py          |  12 +-
 babel/numbers.py                  |  32 ++--
 docs/conf.py                      |  14 +-
 pyproject.toml                    |   2 +
 scripts/import_cldr.py            |   2 +-
 tests/messages/test_catalog.py    |  40 ++---
 tests/messages/test_extract.py    |  38 ++--
 tests/messages/test_js_extract.py |  28 +--
 tests/messages/test_jslexer.py    |   6 +-
 tests/messages/test_mofile.py     |  16 +-
 tests/messages/test_pofile.py     |  82 ++++-----
 tests/test_core.py                |  20 +--
 tests/test_date_intervals.py      |   4 +-
 tests/test_dates.py               | 258 +++++++++++++-------------
 tests/test_lists.py               |  10 +-
 tests/test_numbers.py             | 290 +++++++++++++++---------------
 tests/test_support.py             |  42 ++---
 tests/test_util.py                |   6 +-
 22 files changed, 468 insertions(+), 466 deletions(-)

diff --git a/babel/dates.py b/babel/dates.py
index 7bfea7111..26766a695 100644
--- a/babel/dates.py
+++ b/babel/dates.py
@@ -49,7 +49,7 @@
 #  empty set characters ( U+2205 )."
 #  - https://www.unicode.org/reports/tr35/tr35-dates.html#Metazone_Names
 
-NO_INHERITANCE_MARKER = u'\u2205\u2205\u2205'
+NO_INHERITANCE_MARKER = '\u2205\u2205\u2205'
 
 
 if pytz:
@@ -558,11 +558,11 @@ def get_timezone_gmt(
     if return_z and hours == 0 and seconds == 0:
         return 'Z'
     elif seconds == 0 and width == 'iso8601_short':
-        return u'%+03d' % hours
+        return '%+03d' % hours
     elif width == 'short' or width == 'iso8601_short':
-        pattern = u'%+03d%02d'
+        pattern = '%+03d%02d'
     elif width == 'iso8601':
-        pattern = u'%+03d:%02d'
+        pattern = '%+03d:%02d'
     else:
         pattern = locale.zone_formats['gmt'] % '%+03d:%02d'
     return pattern % (hours, seconds // 60)
@@ -1083,10 +1083,10 @@ def _iter_patterns(a_unit):
                     break
             # This really should not happen
             if pattern is None:
-                return u''
+                return ''
             return pattern.replace('{0}', str(value))
 
-    return u''
+    return ''
 
 
 def _format_fallback_interval(
@@ -1849,7 +1849,7 @@ def parse_pattern(pattern: str) -> DateTimePattern:
         else:
             raise NotImplementedError(f"Unknown token type: {tok_type}")
 
-    _pattern_cache[pattern] = pat = DateTimePattern(pattern, u''.join(result))
+    _pattern_cache[pattern] = pat = DateTimePattern(pattern, ''.join(result))
     return pat
 
 
diff --git a/babel/messages/catalog.py b/babel/messages/catalog.py
index dbca10f45..85f16b259 100644
--- a/babel/messages/catalog.py
+++ b/babel/messages/catalog.py
@@ -80,7 +80,7 @@ class Message:
     def __init__(
         self,
         id: _MessageID,
-        string: _MessageID | None = u'',
+        string: _MessageID | None = '',
         locations: Iterable[tuple[str, int]] = (),
         flags: Iterable[str] = (),
         auto_comments: Iterable[str] = (),
@@ -107,7 +107,7 @@ def __init__(
         """
         self.id = id
         if not string and self.pluralizable:
-            string = (u'', u'')
+            string = ('', '')
         self.string = string
         self.locations = list(distinct(locations))
         self.flags = set(flags)
@@ -233,7 +233,7 @@ class TranslationError(Exception):
     translations are encountered."""
 
 
-DEFAULT_HEADER = u"""\
+DEFAULT_HEADER = """\
 # Translations template for PROJECT.
 # Copyright (C) YEAR ORGANIZATION
 # This file is distributed under the same license as the PROJECT project.
@@ -444,7 +444,7 @@ def _set_mime_headers(self, headers: Iterable[tuple[str, str]]) -> None:
             value = self._force_text(value, encoding=self.charset)
             if name == 'project-id-version':
                 parts = value.split(' ')
-                self.project = u' '.join(parts[:-1])
+                self.project = ' '.join(parts[:-1])
                 self.version = parts[-1]
             elif name == 'report-msgid-bugs-to':
                 self.msgid_bugs_address = value
@@ -591,7 +591,7 @@ def __iter__(self) -> Iterator[Message]:
         flags = set()
         if self.fuzzy:
             flags |= {'fuzzy'}
-        yield Message(u'', '\n'.join(buf), flags=flags)
+        yield Message('', '\n'.join(buf), flags=flags)
         for key in self._messages:
             yield self._messages[key]
 
@@ -831,7 +831,7 @@ def _merge(message: Message, oldkey: tuple[str, str] | str, newkey: tuple[str, s
                 if not isinstance(message.string, (list, tuple)):
                     fuzzy = True
                     message.string = tuple(
-                        [message.string] + ([u''] * (len(message.id) - 1))
+                        [message.string] + ([''] * (len(message.id) - 1))
                     )
                 elif len(message.string) != self.num_plurals:
                     fuzzy = True
@@ -841,7 +841,7 @@ def _merge(message: Message, oldkey: tuple[str, str] | str, newkey: tuple[str, s
                 message.string = message.string[0]
             message.flags |= oldmsg.flags
             if fuzzy:
-                message.flags |= {u'fuzzy'}
+                message.flags |= {'fuzzy'}
             self[message.id] = message
 
         for message in template:
diff --git a/babel/messages/frontend.py b/babel/messages/frontend.py
index 98a1ca89a..de17b1ea5 100644
--- a/babel/messages/frontend.py
+++ b/babel/messages/frontend.py
@@ -948,7 +948,7 @@ def run(self, argv=None):
             identifiers = localedata.locale_identifiers()
             longest = max(len(identifier) for identifier in identifiers)
             identifiers.sort()
-            format = u'%%-%ds %%s' % (longest + 1)
+            format = '%%-%ds %%s' % (longest + 1)
             for identifier in identifiers:
                 locale = Locale.parse(identifier)
                 print(format % (identifier, locale.english_name))
diff --git a/babel/messages/jslexer.py b/babel/messages/jslexer.py
index e6d20aec5..6eab92075 100644
--- a/babel/messages/jslexer.py
+++ b/babel/messages/jslexer.py
@@ -154,7 +154,7 @@ def unquote_string(string: str) -> str:
     if pos < len(string):
         add(string[pos:])
 
-    return u''.join(result)
+    return ''.join(result)
 
 
 def tokenize(source: str, jsx: bool = True, dotted: bool = True, template_string: bool = True, lineno: int = 1) -> Generator[Token, None, None]:
diff --git a/babel/messages/pofile.py b/babel/messages/pofile.py
index 76d3123e7..a9180a719 100644
--- a/babel/messages/pofile.py
+++ b/babel/messages/pofile.py
@@ -184,7 +184,7 @@ def _add_message(self) -> None:
             string = ['' for _ in range(self.catalog.num_plurals)]
             for idx, translation in self.translations:
                 if idx >= self.catalog.num_plurals:
-                    self._invalid_pofile(u"", self.offset, "msg has more translations than num_plurals of catalog")
+                    self._invalid_pofile("", self.offset, "msg has more translations than num_plurals of catalog")
                     continue
                 string[idx] = translation.denormalize()
             string = tuple(string)
@@ -320,8 +320,8 @@ def parse(self, fileobj: IO[AnyStr]) -> None:
         # No actual messages found, but there was some info in comments, from which
         # we'll construct an empty header message
         if not self.counter and (self.flags or self.user_comments or self.auto_comments):
-            self.messages.append(_NormalizedString(u'""'))
-            self.translations.append([0, _NormalizedString(u'""')])
+            self.messages.append(_NormalizedString('""'))
+            self.translations.append([0, _NormalizedString('""')])
             self._add_message()
 
     def _invalid_pofile(self, line, lineno, msg) -> None:
@@ -462,7 +462,7 @@ def normalize(string: str, prefix: str = '', width: int = 76) -> str:
                                 # separate line
                                 buf.append(chunks.pop())
                             break
-                    lines.append(u''.join(buf))
+                    lines.append(''.join(buf))
             else:
                 lines.append(line)
     else:
@@ -475,7 +475,7 @@ def normalize(string: str, prefix: str = '', width: int = 76) -> str:
     if lines and not lines[-1]:
         del lines[-1]
         lines[-1] += '\n'
-    return u'""\n' + u'\n'.join([(prefix + escape(line)) for line in lines])
+    return '""\n' + '\n'.join([(prefix + escape(line)) for line in lines])
 
 
 def write_po(
@@ -586,7 +586,7 @@ def _write_message(message, prefix=''):
                 for line in comment_header.splitlines():
                     lines += wraptext(line, width=width,
                                       subsequent_indent='# ')
-                comment_header = u'\n'.join(lines)
+                comment_header = '\n'.join(lines)
             _write(f"{comment_header}\n")
 
         for comment in message.user_comments:
diff --git a/babel/numbers.py b/babel/numbers.py
index 6ecd7dc11..399b70b5c 100644
--- a/babel/numbers.py
+++ b/babel/numbers.py
@@ -324,7 +324,7 @@ def get_decimal_symbol(locale: Locale | str | None = LC_NUMERIC) -> str:
 
     :param locale: the `Locale` object or locale identifier
     """
-    return Locale.parse(locale).number_symbols.get('decimal', u'.')
+    return Locale.parse(locale).number_symbols.get('decimal', '.')
 
 
 def get_plus_sign_symbol(locale: Locale | str | None = LC_NUMERIC) -> str:
@@ -335,7 +335,7 @@ def get_plus_sign_symbol(locale: Locale | str | None = LC_NUMERIC) -> str:
 
     :param locale: the `Locale` object or locale identifier
     """
-    return Locale.parse(locale).number_symbols.get('plusSign', u'+')
+    return Locale.parse(locale).number_symbols.get('plusSign', '+')
 
 
 def get_minus_sign_symbol(locale: Locale | str | None = LC_NUMERIC) -> str:
@@ -346,7 +346,7 @@ def get_minus_sign_symbol(locale: Locale | str | None = LC_NUMERIC) -> str:
 
     :param locale: the `Locale` object or locale identifier
     """
-    return Locale.parse(locale).number_symbols.get('minusSign', u'-')
+    return Locale.parse(locale).number_symbols.get('minusSign', '-')
 
 
 def get_exponential_symbol(locale: Locale | str | None = LC_NUMERIC) -> str:
@@ -357,7 +357,7 @@ def get_exponential_symbol(locale: Locale | str | None = LC_NUMERIC) -> str:
 
     :param locale: the `Locale` object or locale identifier
     """
-    return Locale.parse(locale).number_symbols.get('exponential', u'E')
+    return Locale.parse(locale).number_symbols.get('exponential', 'E')
 
 
 def get_group_symbol(locale: Locale | str | None = LC_NUMERIC) -> str:
@@ -368,11 +368,11 @@ def get_group_symbol(locale: Locale | str | None = LC_NUMERIC) -> str:
 
     :param locale: the `Locale` object or locale identifier
     """
-    return Locale.parse(locale).number_symbols.get('group', u',')
+    return Locale.parse(locale).number_symbols.get('group', ',')
 
 
 def format_number(number: float | decimal.Decimal | str, locale: Locale | str | None = LC_NUMERIC) -> str:
-    u"""Return the given number formatted for a specific locale.
+    """Return the given number formatted for a specific locale.
 
     >>> format_number(1099, locale='en_US')  # doctest: +SKIP
     u'1,099'
@@ -418,7 +418,7 @@ def format_decimal(
     decimal_quantization: bool = True,
     group_separator: bool = True,
 ) -> str:
-    u"""Return the given decimal number formatted for a specific locale.
+    """Return the given decimal number formatted for a specific locale.
 
     >>> format_decimal(1.2345, locale='en_US')
     u'1.234'
@@ -473,7 +473,7 @@ def format_compact_decimal(
     locale: Locale | str | None = LC_NUMERIC,
     fraction_digits: int = 0,
 ) -> str:
-    u"""Return the given decimal number formatted for a specific locale in compact form.
+    """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'
@@ -555,7 +555,7 @@ def format_currency(
     decimal_quantization: bool = True,
     group_separator: bool = True,
 ) -> str:
-    u"""Return formatted currency value.
+    """Return formatted currency value.
 
     >>> format_currency(1099.98, 'USD', locale='en_US')
     u'$1,099.98'
@@ -711,7 +711,7 @@ def format_compact_currency(
     locale: Locale | str | None = LC_NUMERIC,
     fraction_digits: int = 0
 ) -> str:
-    u"""Format a number as a currency value in compact form.
+    """Format a number as a currency value in compact form.
 
     >>> format_compact_currency(12345, 'USD', locale='en_US')
     u'$12K'
@@ -916,7 +916,7 @@ def parse_decimal(string: str, locale: Locale | str | None = LC_NUMERIC, strict:
     decimal_symbol = get_decimal_symbol(locale)
 
     if not strict and (
-        group_symbol == u'\xa0' and  # if the grouping symbol is U+00A0 NO-BREAK SPACE,
+        group_symbol == '\xa0' and  # if the grouping symbol is U+00A0 NO-BREAK SPACE,
         group_symbol not in string and  # and the string to be parsed does not contain it,
         ' ' in string  # but it does contain a space instead,
     ):
@@ -1095,7 +1095,7 @@ def compute_scale(self) -> Literal[0, 2, 3]:
         scale = 0
         if '%' in ''.join(self.prefix + self.suffix):
             scale = 2
-        elif u'‰' in ''.join(self.prefix + self.suffix):
+        elif '‰' in ''.join(self.prefix + self.suffix):
             scale = 3
         return scale
 
@@ -1222,11 +1222,11 @@ def apply(
             number if self.number_pattern != '' else '',
             self.suffix[is_negative]])
 
-        if u'¤' in retval:
-            retval = retval.replace(u'¤¤¤',
+        if '¤' in retval:
+            retval = retval.replace('¤¤¤',
                                     get_currency_name(currency, value, locale))
-            retval = retval.replace(u'¤¤', currency.upper())
-            retval = retval.replace(u'¤', get_currency_symbol(currency, 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
diff --git a/docs/conf.py b/docs/conf.py
index 84bbd7ed2..5118f72f6 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -43,8 +43,8 @@
 master_doc = 'index'
 
 # General information about the project.
-project = u'Babel'
-copyright = u'2022, The Babel Team'
+project = 'Babel'
+copyright = '2022, The Babel Team'
 
 # The version info for the project you're documenting, acts as replacement for
 # |version| and |release|, also used in various other places throughout the
@@ -194,8 +194,8 @@
 # Grouping the document tree into LaTeX files. List of tuples
 # (source start file, target name, title, author, documentclass [howto/manual]).
 latex_documents = [
-  ('index', 'Babel.tex', u'Babel Documentation',
-   u'The Babel Team', 'manual'),
+  ('index', 'Babel.tex', 'Babel Documentation',
+   'The Babel Team', 'manual'),
 ]
 
 # The name of an image file (relative to this directory) to place at the top of
@@ -224,7 +224,7 @@
 # One entry per manual page. List of tuples
 # (source start file, name, description, authors, manual section).
 man_pages = [
-    ('index', 'babel', u'Babel Documentation', [u'The Babel Team'], 1),
+    ('index', 'babel', 'Babel Documentation', ['The Babel Team'], 1),
 ]
 
 # If true, show URL addresses after external links.
@@ -237,8 +237,8 @@
 # (source start file, target name, title, author,
 #  dir menu entry, description, category)
 texinfo_documents = [
-  ('index_', 'Babel', u'Babel Documentation',
-   u'The Babel Team', 'Babel', 'One line description of project.',
+  ('index_', 'Babel', 'Babel Documentation',
+   'The Babel Team', 'Babel', 'One line description of project.',
    'Miscellaneous'),
 ]
 
diff --git a/pyproject.toml b/pyproject.toml
index a7915af10..10c1db8b3 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -7,12 +7,14 @@ select = [
     "F",
     "I",
     "SIM300",
+    "UP025",
 ]
 ignore = [
     "C901",  # Complexity
     "E501",  # Line length
     "E731",  # Do not assign a lambda expression (we use them on purpose)
     "E741",  # Ambiguous variable name
+    "UP012",  # "utf-8" is on purpose
 ]
 extend-exclude = [
     "tests/messages/data",
diff --git a/scripts/import_cldr.py b/scripts/import_cldr.py
index 0dc47382f..b5034073e 100755
--- a/scripts/import_cldr.py
+++ b/scripts/import_cldr.py
@@ -43,7 +43,7 @@ def _text(elem):
     for child in elem:
         buf.append(_text(child))
     buf.append(elem.tail or '')
-    return u''.join(filter(None, buf)).strip()
+    return ''.join(filter(None, buf)).strip()
 
 
 NAME_RE = re.compile(r"^\w+$")
diff --git a/tests/messages/test_catalog.py b/tests/messages/test_catalog.py
index eb1e308f2..29cfc0d65 100644
--- a/tests/messages/test_catalog.py
+++ b/tests/messages/test_catalog.py
@@ -89,33 +89,33 @@ def test_duplicate_location(self):
 
     def test_update_message_changed_to_plural(self):
         cat = catalog.Catalog()
-        cat.add(u'foo', u'Voh')
+        cat.add('foo', 'Voh')
         tmpl = catalog.Catalog()
-        tmpl.add((u'foo', u'foos'))
+        tmpl.add(('foo', 'foos'))
         cat.update(tmpl)
         assert cat['foo'].string == ('Voh', '')
         assert cat['foo'].fuzzy
 
     def test_update_message_changed_to_simple(self):
         cat = catalog.Catalog()
-        cat.add(u'foo' u'foos', (u'Voh', u'Vöhs'))
+        cat.add('foo' u'foos', ('Voh', 'Vöhs'))
         tmpl = catalog.Catalog()
-        tmpl.add(u'foo')
+        tmpl.add('foo')
         cat.update(tmpl)
         assert cat['foo'].string == 'Voh'
         assert cat['foo'].fuzzy
 
     def test_update_message_updates_comments(self):
         cat = catalog.Catalog()
-        cat[u'foo'] = catalog.Message('foo', locations=[('main.py', 5)])
+        cat['foo'] = catalog.Message('foo', locations=[('main.py', 5)])
         assert cat['foo'].auto_comments == []
         assert cat['foo'].user_comments == []
         # Update cat[u'foo'] with a new location and a comment
-        cat[u'foo'] = catalog.Message('foo', locations=[('main.py', 7)],
+        cat['foo'] = catalog.Message('foo', locations=[('main.py', 7)],
                                       user_comments=['Foo Bar comment 1'])
         assert cat['foo'].user_comments == ['Foo Bar comment 1']
         # now add yet another location with another comment
-        cat[u'foo'] = catalog.Message('foo', locations=[('main.py', 9)],
+        cat['foo'] = catalog.Message('foo', locations=[('main.py', 9)],
                                       auto_comments=['Foo Bar comment 2'])
         assert cat['foo'].auto_comments == ['Foo Bar comment 2']
 
@@ -404,21 +404,21 @@ def test_catalog_plural_forms():
 
 def test_catalog_setitem():
     cat = catalog.Catalog()
-    cat[u'foo'] = catalog.Message(u'foo')
-    assert cat[u'foo'].id == 'foo'
+    cat['foo'] = catalog.Message('foo')
+    assert cat['foo'].id == 'foo'
 
     cat = catalog.Catalog()
-    cat[u'foo'] = catalog.Message(u'foo', locations=[('main.py', 1)])
-    assert cat[u'foo'].locations == [('main.py', 1)]
-    cat[u'foo'] = catalog.Message(u'foo', locations=[('utils.py', 5)])
-    assert cat[u'foo'].locations == [('main.py', 1), ('utils.py', 5)]
+    cat['foo'] = catalog.Message('foo', locations=[('main.py', 1)])
+    assert cat['foo'].locations == [('main.py', 1)]
+    cat['foo'] = catalog.Message('foo', locations=[('utils.py', 5)])
+    assert cat['foo'].locations == [('main.py', 1), ('utils.py', 5)]
 
 
 def test_catalog_add():
     cat = catalog.Catalog()
-    foo = cat.add(u'foo')
+    foo = cat.add('foo')
     assert foo.id == 'foo'
-    assert cat[u'foo'] is foo
+    assert cat['foo'] is foo
 
 
 def test_catalog_update():
@@ -427,9 +427,9 @@ def test_catalog_update():
     template.add('blue', locations=[('main.py', 100)])
     template.add(('salad', 'salads'), locations=[('util.py', 42)])
     cat = catalog.Catalog(locale='de_DE')
-    cat.add('blue', u'blau', locations=[('main.py', 98)])
-    cat.add('head', u'Kopf', locations=[('util.py', 33)])
-    cat.add(('salad', 'salads'), (u'Salat', u'Salate'),
+    cat.add('blue', 'blau', locations=[('main.py', 98)])
+    cat.add('head', 'Kopf', locations=[('util.py', 33)])
+    cat.add(('salad', 'salads'), ('Salat', 'Salate'),
             locations=[('util.py', 38)])
 
     cat.update(template)
@@ -440,11 +440,11 @@ def test_catalog_update():
     assert msg1.locations == [('main.py', 99)]
 
     msg2 = cat['blue']
-    assert msg2.string == u'blau'
+    assert msg2.string == 'blau'
     assert msg2.locations == [('main.py', 100)]
 
     msg3 = cat['salad']
-    assert msg3.string == (u'Salat', u'Salate')
+    assert msg3.string == ('Salat', 'Salate')
     assert msg3.locations == [('util.py', 42)]
 
     assert 'head' not in cat
diff --git a/tests/messages/test_extract.py b/tests/messages/test_extract.py
index 387319113..7a0df8ecb 100644
--- a/tests/messages/test_extract.py
+++ b/tests/messages/test_extract.py
@@ -41,14 +41,14 @@ def test_nested_calls(self):
         assert messages == [
             (1, '_', None, []),
             (2, 'ungettext', (None, None, None), []),
-            (3, 'ungettext', (u'Babel', None, None), []),
-            (4, 'ungettext', (None, u'Babels', None), []),
-            (5, 'ungettext', (u'bunny', u'bunnies', None), []),
-            (6, 'ungettext', (None, u'bunnies', None), []),
+            (3, 'ungettext', ('Babel', None, None), []),
+            (4, 'ungettext', (None, 'Babels', None), []),
+            (5, 'ungettext', ('bunny', 'bunnies', None), []),
+            (6, 'ungettext', (None, 'bunnies', None), []),
             (7, '_', None, []),
-            (8, 'gettext', u'Rabbit', []),
-            (9, 'dgettext', (u'wiki', None), []),
-            (10, 'dngettext', (None, u'Page', u'Pages', None), []),
+            (8, 'gettext', 'Rabbit', []),
+            (9, 'dgettext', ('wiki', None), []),
+            (10, 'dngettext', (None, 'Page', 'Pages', None), []),
         ]
 
     def test_extract_default_encoding_ascii(self):
@@ -60,7 +60,7 @@ def test_extract_default_encoding_ascii(self):
         assert messages == [(1, '_', 'a', [])]
 
     def test_extract_default_encoding_utf8(self):
-        buf = BytesIO(u'_("☃")'.encode('UTF-8'))
+        buf = BytesIO('_("☃")'.encode('UTF-8'))
         messages = list(extract.extract_python(
             buf, list(extract.DEFAULT_KEYWORDS), [], {},
         ))
@@ -351,7 +351,7 @@ def test_utf8_message(self):
         assert messages[0][3] == ['NOTE: hello']
 
     def test_utf8_message_with_magic_comment(self):
-        buf = BytesIO(u"""# -*- coding: utf-8 -*-
+        buf = BytesIO("""# -*- coding: utf-8 -*-
 # NOTE: hello
 msg = _('Bonjour à tous')
 """.encode('utf-8'))
@@ -360,7 +360,7 @@ def test_utf8_message_with_magic_comment(self):
         assert messages[0][3] == ['NOTE: hello']
 
     def test_utf8_message_with_utf8_bom(self):
-        buf = BytesIO(codecs.BOM_UTF8 + u"""
+        buf = BytesIO(codecs.BOM_UTF8 + """
 # NOTE: hello
 msg = _('Bonjour à tous')
 """.encode('utf-8'))
@@ -369,7 +369,7 @@ def test_utf8_message_with_utf8_bom(self):
         assert messages[0][3] == ['NOTE: hello']
 
     def test_utf8_message_with_utf8_bom_and_magic_comment(self):
-        buf = BytesIO(codecs.BOM_UTF8 + u"""# -*- coding: utf-8 -*-
+        buf = BytesIO(codecs.BOM_UTF8 + """# -*- coding: utf-8 -*-
 # NOTE: hello
 msg = _('Bonjour à tous')
 """.encode('utf-8'))
@@ -378,7 +378,7 @@ def test_utf8_message_with_utf8_bom_and_magic_comment(self):
         assert messages[0][3] == ['NOTE: hello']
 
     def test_utf8_bom_with_latin_magic_comment_fails(self):
-        buf = BytesIO(codecs.BOM_UTF8 + u"""# -*- coding: latin-1 -*-
+        buf = BytesIO(codecs.BOM_UTF8 + """# -*- coding: latin-1 -*-
 # NOTE: hello
 msg = _('Bonjour à tous')
 """.encode('utf-8'))
@@ -386,7 +386,7 @@ def test_utf8_bom_with_latin_magic_comment_fails(self):
             list(extract.extract_python(buf, ('_',), ['NOTE:'], {}))
 
     def test_utf8_raw_strings_match_unicode_strings(self):
-        buf = BytesIO(codecs.BOM_UTF8 + u"""
+        buf = BytesIO(codecs.BOM_UTF8 + """
 msg = _('Bonjour à tous')
 msgu = _(u'Bonjour à tous')
 """.encode('utf-8'))
@@ -527,7 +527,7 @@ def test_future(self):
 """)
         messages = list(extract.extract('python', buf,
                                         extract.DEFAULT_KEYWORDS, [], {}))
-        assert messages[0][1] == u'\xa0'
+        assert messages[0][1] == '\xa0'
 
     def test_f_strings(self):
         buf = BytesIO(br"""
@@ -542,10 +542,10 @@ def test_f_strings(self):
 """)
         messages = list(extract.extract('python', buf, extract.DEFAULT_KEYWORDS, [], {}))
         assert len(messages) == 4
-        assert messages[0][1] == u'foobar'
-        assert messages[1][1] == u'spameggsfeast'
-        assert messages[2][1] == u'spameggskerroshampurilainen'
-        assert messages[3][1] == u'whoa! a flying shark... hello'
+        assert messages[0][1] == 'foobar'
+        assert messages[1][1] == 'spameggsfeast'
+        assert messages[2][1] == 'spameggskerroshampurilainen'
+        assert messages[3][1] == 'whoa! a flying shark... hello'
 
     def test_f_strings_non_utf8(self):
         buf = BytesIO(b"""
@@ -554,4 +554,4 @@ def test_f_strings_non_utf8(self):
 """)
         messages = list(extract.extract('python', buf, extract.DEFAULT_KEYWORDS, [], {}))
         assert len(messages) == 1
-        assert messages[0][1] == u'åäöÅÄÖ'
+        assert messages[0][1] == 'åäöÅÄÖ'
diff --git a/tests/messages/test_js_extract.py b/tests/messages/test_js_extract.py
index 7d4392150..82f5379ea 100644
--- a/tests/messages/test_js_extract.py
+++ b/tests/messages/test_js_extract.py
@@ -37,32 +37,32 @@ def test_various_calls():
         list(extract.extract('javascript', buf, extract.DEFAULT_KEYWORDS, [],
                              {}))
     assert messages == [
-        (5, (u'bunny', u'bunnies'), [], None),
-        (8, u'Rabbit', [], None),
-        (10, (u'Page', u'Pages'), [], None)
+        (5, ('bunny', 'bunnies'), [], None),
+        (8, 'Rabbit', [], None),
+        (10, ('Page', 'Pages'), [], None)
     ]
 
 
 def test_message_with_line_comment():
-    buf = BytesIO(u"""\
+    buf = BytesIO("""\
 // NOTE: hello
 msg = _('Bonjour à tous')
 """.encode('utf-8'))
     messages = list(extract.extract_javascript(buf, ('_',), ['NOTE:'], {}))
-    assert messages[0][2] == u'Bonjour à tous'
-    assert messages[0][3] == [u'NOTE: hello']
+    assert messages[0][2] == 'Bonjour à tous'
+    assert messages[0][3] == ['NOTE: hello']
 
 
 def test_message_with_multiline_comment():
-    buf = BytesIO(u"""\
+    buf = BytesIO("""\
 /* NOTE: hello
 and bonjour
   and servus */
 msg = _('Bonjour à tous')
 """.encode('utf-8'))
     messages = list(extract.extract_javascript(buf, ('_',), ['NOTE:'], {}))
-    assert messages[0][2] == u'Bonjour à tous'
-    assert messages[0][3] == [u'NOTE: hello', 'and bonjour', '  and servus']
+    assert messages[0][2] == 'Bonjour à tous'
+    assert messages[0][3] == ['NOTE: hello', 'and bonjour', '  and servus']
 
 
 def test_ignore_function_definitions():
@@ -93,11 +93,11 @@ def test_misplaced_comments():
 _('no comment here')
 """)
     messages = list(extract.extract_javascript(buf, ('_',), ['NOTE:'], {}))
-    assert messages[0][2] == u'Something'
-    assert messages[0][3] == [u'NOTE: this will']
-    assert messages[1][2] == u'Something else'
-    assert messages[1][3] == [u'NOTE: this will show up', 'too.']
-    assert messages[2][2] == u'no comment here'
+    assert messages[0][2] == 'Something'
+    assert messages[0][3] == ['NOTE: this will']
+    assert messages[1][2] == 'Something else'
+    assert messages[1][3] == ['NOTE: this will show up', 'too.']
+    assert messages[2][2] == 'no comment here'
     assert messages[2][3] == []
 
 
diff --git a/tests/messages/test_jslexer.py b/tests/messages/test_jslexer.py
index bd6322e9e..3889f0b3a 100644
--- a/tests/messages/test_jslexer.py
+++ b/tests/messages/test_jslexer.py
@@ -3,9 +3,9 @@
 
 def test_unquote():
     assert jslexer.unquote_string('""') == ''
-    assert jslexer.unquote_string(r'"h\u00ebllo"') == u"hëllo"
-    assert jslexer.unquote_string(r'"h\xebllo"') == u"hëllo"
-    assert jslexer.unquote_string(r'"\xebb"') == u"ëb"
+    assert jslexer.unquote_string(r'"h\u00ebllo"') == "hëllo"
+    assert jslexer.unquote_string(r'"h\xebllo"') == "hëllo"
+    assert jslexer.unquote_string(r'"\xebb"') == "ëb"
 
 
 def test_dollar_in_identifier():
diff --git a/tests/messages/test_mofile.py b/tests/messages/test_mofile.py
index ff7c2ed0b..6a702edb4 100644
--- a/tests/messages/test_mofile.py
+++ b/tests/messages/test_mofile.py
@@ -42,12 +42,12 @@ def test_sorting(self):
         # can be applied to all subsequent messages by GNUTranslations
         # (ensuring all messages are safely converted to unicode)
         catalog = Catalog(locale='en_US')
-        catalog.add(u'', '''\
+        catalog.add('', '''\
 "Content-Type: text/plain; charset=utf-8\n"
 "Content-Transfer-Encoding: 8bit\n''')
-        catalog.add(u'foo', 'Voh')
-        catalog.add((u'There is', u'There are'), (u'Es gibt', u'Es gibt'))
-        catalog.add(u'Fizz', '')
+        catalog.add('foo', 'Voh')
+        catalog.add(('There is', 'There are'), ('Es gibt', 'Es gibt'))
+        catalog.add('Fizz', '')
         catalog.add(('Fuzz', 'Fuzzes'), ('', ''))
         buf = BytesIO()
         mofile.write_mo(buf, catalog)
@@ -67,18 +67,18 @@ def test_more_plural_forms(self):
 
     def test_empty_translation_with_fallback(self):
         catalog1 = Catalog(locale='fr_FR')
-        catalog1.add(u'', '''\
+        catalog1.add('', '''\
 "Content-Type: text/plain; charset=utf-8\n"
 "Content-Transfer-Encoding: 8bit\n''')
-        catalog1.add(u'Fuzz', '')
+        catalog1.add('Fuzz', '')
         buf1 = BytesIO()
         mofile.write_mo(buf1, catalog1)
         buf1.seek(0)
         catalog2 = Catalog(locale='fr')
-        catalog2.add(u'', '''\
+        catalog2.add('', '''\
 "Content-Type: text/plain; charset=utf-8\n"
 "Content-Transfer-Encoding: 8bit\n''')
-        catalog2.add(u'Fuzz', 'Flou')
+        catalog2.add('Fuzz', 'Flou')
         buf2 = BytesIO()
         mofile.write_mo(buf2, catalog2)
         buf2.seek(0)
diff --git a/tests/messages/test_pofile.py b/tests/messages/test_pofile.py
index fb5799b16..f668ea033 100644
--- a/tests/messages/test_pofile.py
+++ b/tests/messages/test_pofile.py
@@ -51,7 +51,7 @@ def test_preserve_domain(self):
         assert catalog.domain == 'mydomain'
 
     def test_applies_specified_encoding_during_read(self):
-        buf = BytesIO(u'''
+        buf = BytesIO('''
 msgid ""
 msgstr ""
 "Project-Id-Version:  3.15\\n"
@@ -206,7 +206,7 @@ def test_multi_line_obsolete_message(self):
 ''')
         catalog = pofile.read_po(buf)
         assert len(catalog.obsolete) == 1
-        message = catalog.obsolete[u'foofoo']
+        message = catalog.obsolete['foofoo']
         assert message.id == 'foofoo'
         assert message.string == 'VohVooooh'
         assert message.user_comments == ['This is an obsolete message']
@@ -227,7 +227,7 @@ def test_unit_following_multi_line_obsolete_message(self):
 ''')
         catalog = pofile.read_po(buf)
         assert len(catalog) == 1
-        message = catalog[u'bar']
+        message = catalog['bar']
         assert message.id == 'bar'
         assert message.string == 'Bahr'
         assert message.user_comments == ['This message is not obsolete']
@@ -249,7 +249,7 @@ def test_unit_before_obsolete_is_not_obsoleted(self):
 ''')
         catalog = pofile.read_po(buf)
         assert len(catalog) == 1
-        message = catalog[u'bar']
+        message = catalog['bar']
         assert message.id == 'bar'
         assert message.string == 'Bahr'
         assert message.user_comments == ['This message is not obsolete']
@@ -298,7 +298,7 @@ def test_obsolete_message_with_context(self):
         catalog = pofile.read_po(buf)
         assert len(catalog) == 2
         assert len(catalog.obsolete) == 1
-        message = catalog.obsolete[u"foo"]
+        message = catalog.obsolete["foo"]
         assert message.context == 'other'
         assert message.string == 'Voh'
 
@@ -486,7 +486,7 @@ def test_abort_invalid_po_file(self):
     def test_invalid_pofile_with_abort_flag(self):
         parser = pofile.PoFileParser(None, abort_invalid=True)
         lineno = 10
-        line = u'Algo esta mal'
+        line = 'Algo esta mal'
         msg = 'invalid file'
         with pytest.raises(pofile.PoFileError):
             parser._invalid_pofile(line, lineno, msg)
@@ -496,8 +496,8 @@ class WritePoTestCase(unittest.TestCase):
 
     def test_join_locations(self):
         catalog = Catalog()
-        catalog.add(u'foo', locations=[('main.py', 1)])
-        catalog.add(u'foo', locations=[('utils.py', 3)])
+        catalog.add('foo', locations=[('main.py', 1)])
+        catalog.add('foo', locations=[('utils.py', 3)])
         buf = BytesIO()
         pofile.write_po(buf, catalog, omit_header=True)
         assert buf.getvalue().strip() == b'''#: main.py:1 utils.py:3
@@ -506,17 +506,17 @@ def test_join_locations(self):
 
     def test_write_po_file_with_specified_charset(self):
         catalog = Catalog(charset='iso-8859-1')
-        catalog.add('foo', u'äöü', locations=[('main.py', 1)])
+        catalog.add('foo', 'äöü', locations=[('main.py', 1)])
         buf = BytesIO()
         pofile.write_po(buf, catalog, omit_header=False)
         po_file = buf.getvalue().strip()
         assert b'"Content-Type: text/plain; charset=iso-8859-1\\n"' in po_file
-        assert u'msgstr "äöü"'.encode('iso-8859-1') in po_file
+        assert 'msgstr "äöü"'.encode('iso-8859-1') in po_file
 
     def test_duplicate_comments(self):
         catalog = Catalog()
-        catalog.add(u'foo', auto_comments=['A comment'])
-        catalog.add(u'foo', auto_comments=['A comment'])
+        catalog.add('foo', auto_comments=['A comment'])
+        catalog.add('foo', auto_comments=['A comment'])
         buf = BytesIO()
         pofile.write_po(buf, catalog, omit_header=True)
         assert buf.getvalue().strip() == b'''#. A comment
@@ -579,10 +579,10 @@ def test_wrap_long_lines_in_header(self):
 
     def test_wrap_locations_with_hyphens(self):
         catalog = Catalog()
-        catalog.add(u'foo', locations=[
+        catalog.add('foo', locations=[
             ('doupy/templates/base/navmenu.inc.html.py', 60)
         ])
-        catalog.add(u'foo', locations=[
+        catalog.add('foo', locations=[
             ('doupy/templates/job-offers/helpers.html', 22)
         ])
         buf = BytesIO()
@@ -625,9 +625,9 @@ def test_no_wrap_and_width_behaviour_on_comments(self):
 
     def test_pot_with_translator_comments(self):
         catalog = Catalog()
-        catalog.add(u'foo', locations=[('main.py', 1)],
+        catalog.add('foo', locations=[('main.py', 1)],
                     auto_comments=['Comment About `foo`'])
-        catalog.add(u'bar', locations=[('utils.py', 3)],
+        catalog.add('bar', locations=[('utils.py', 3)],
                     user_comments=['Comment About `bar` with',
                                    'multiple lines.'])
         buf = BytesIO()
@@ -645,8 +645,8 @@ def test_pot_with_translator_comments(self):
 
     def test_po_with_obsolete_message(self):
         catalog = Catalog()
-        catalog.add(u'foo', u'Voh', locations=[('main.py', 1)])
-        catalog.obsolete['bar'] = Message(u'bar', u'Bahr',
+        catalog.add('foo', 'Voh', locations=[('main.py', 1)])
+        catalog.obsolete['bar'] = Message('bar', 'Bahr',
                                           locations=[('utils.py', 3)],
                                           user_comments=['User comment'])
         buf = BytesIO()
@@ -661,7 +661,7 @@ def test_po_with_obsolete_message(self):
 
     def test_po_with_multiline_obsolete_message(self):
         catalog = Catalog()
-        catalog.add(u'foo', u'Voh', locations=[('main.py', 1)])
+        catalog.add('foo', 'Voh', locations=[('main.py', 1)])
         msgid = r"""Here's a message that covers
 multiple lines, and should still be handled
 correctly.
@@ -689,8 +689,8 @@ def test_po_with_multiline_obsolete_message(self):
 
     def test_po_with_obsolete_message_ignored(self):
         catalog = Catalog()
-        catalog.add(u'foo', u'Voh', locations=[('main.py', 1)])
-        catalog.obsolete['bar'] = Message(u'bar', u'Bahr',
+        catalog.add('foo', 'Voh', locations=[('main.py', 1)])
+        catalog.obsolete['bar'] = Message('bar', 'Bahr',
                                           locations=[('utils.py', 3)],
                                           user_comments=['User comment'])
         buf = BytesIO()
@@ -701,8 +701,8 @@ def test_po_with_obsolete_message_ignored(self):
 
     def test_po_with_previous_msgid(self):
         catalog = Catalog()
-        catalog.add(u'foo', u'Voh', locations=[('main.py', 1)],
-                    previous_id=u'fo')
+        catalog.add('foo', 'Voh', locations=[('main.py', 1)],
+                    previous_id='fo')
         buf = BytesIO()
         pofile.write_po(buf, catalog, omit_header=True, include_previous=True)
         assert buf.getvalue().strip() == b'''#: main.py:1
@@ -712,8 +712,8 @@ def test_po_with_previous_msgid(self):
 
     def test_po_with_previous_msgid_plural(self):
         catalog = Catalog()
-        catalog.add((u'foo', u'foos'), (u'Voh', u'Voeh'),
-                    locations=[('main.py', 1)], previous_id=(u'fo', u'fos'))
+        catalog.add(('foo', 'foos'), ('Voh', 'Voeh'),
+                    locations=[('main.py', 1)], previous_id=('fo', 'fos'))
         buf = BytesIO()
         pofile.write_po(buf, catalog, omit_header=True, include_previous=True)
         assert buf.getvalue().strip() == b'''#: main.py:1
@@ -726,10 +726,10 @@ def test_po_with_previous_msgid_plural(self):
 
     def test_sorted_po(self):
         catalog = Catalog()
-        catalog.add(u'bar', locations=[('utils.py', 3)],
+        catalog.add('bar', locations=[('utils.py', 3)],
                     user_comments=['Comment About `bar` with',
                                    'multiple lines.'])
-        catalog.add((u'foo', u'foos'), (u'Voh', u'Voeh'),
+        catalog.add(('foo', 'foos'), ('Voh', 'Voeh'),
                     locations=[('main.py', 1)])
         buf = BytesIO()
         pofile.write_po(buf, catalog, sort_output=True)
@@ -750,12 +750,12 @@ def test_sorted_po(self):
 
     def test_sorted_po_context(self):
         catalog = Catalog()
-        catalog.add((u'foo', u'foos'), (u'Voh', u'Voeh'),
+        catalog.add(('foo', 'foos'), ('Voh', 'Voeh'),
                     locations=[('main.py', 1)],
                     context='there')
-        catalog.add((u'foo', u'foos'), (u'Voh', u'Voeh'),
+        catalog.add(('foo', 'foos'), ('Voh', 'Voeh'),
                     locations=[('main.py', 1)])
-        catalog.add((u'foo', u'foos'), (u'Voh', u'Voeh'),
+        catalog.add(('foo', 'foos'), ('Voh', 'Voeh'),
                     locations=[('main.py', 1)],
                     context='here')
         buf = BytesIO()
@@ -785,8 +785,8 @@ def test_sorted_po_context(self):
 
     def test_file_sorted_po(self):
         catalog = Catalog()
-        catalog.add(u'bar', locations=[('utils.py', 3)])
-        catalog.add((u'foo', u'foos'), (u'Voh', u'Voeh'), locations=[('main.py', 1)])
+        catalog.add('bar', locations=[('utils.py', 3)])
+        catalog.add(('foo', 'foos'), ('Voh', 'Voeh'), locations=[('main.py', 1)])
         buf = BytesIO()
         pofile.write_po(buf, catalog, sort_by_file=True)
         value = buf.getvalue().strip()
@@ -794,7 +794,7 @@ def test_file_sorted_po(self):
 
     def test_file_with_no_lineno(self):
         catalog = Catalog()
-        catalog.add(u'bar', locations=[('utils.py', None)],
+        catalog.add('bar', locations=[('utils.py', None)],
                     user_comments=['Comment About `bar` with',
                                    'multiple lines.'])
         buf = BytesIO()
@@ -822,8 +822,8 @@ def test_silent_location_fallback(self):
 
     def test_include_lineno(self):
         catalog = Catalog()
-        catalog.add(u'foo', locations=[('main.py', 1)])
-        catalog.add(u'foo', locations=[('utils.py', 3)])
+        catalog.add('foo', locations=[('main.py', 1)])
+        catalog.add('foo', locations=[('utils.py', 3)])
         buf = BytesIO()
         pofile.write_po(buf, catalog, omit_header=True, include_lineno=True)
         assert buf.getvalue().strip() == b'''#: main.py:1 utils.py:3
@@ -832,9 +832,9 @@ def test_include_lineno(self):
 
     def test_no_include_lineno(self):
         catalog = Catalog()
-        catalog.add(u'foo', locations=[('main.py', 1)])
-        catalog.add(u'foo', locations=[('main.py', 2)])
-        catalog.add(u'foo', locations=[('utils.py', 3)])
+        catalog.add('foo', locations=[('main.py', 1)])
+        catalog.add('foo', locations=[('main.py', 2)])
+        catalog.add('foo', locations=[('utils.py', 3)])
         buf = BytesIO()
         pofile.write_po(buf, catalog, omit_header=True, include_lineno=False)
         assert buf.getvalue().strip() == b'''#: main.py utils.py
@@ -845,8 +845,8 @@ def test_no_include_lineno(self):
 class PofileFunctionsTestCase(unittest.TestCase):
 
     def test_unescape(self):
-        escaped = u'"Say:\\n  \\"hello, world!\\"\\n"'
-        unescaped = u'Say:\n  "hello, world!"\n'
+        escaped = '"Say:\\n  \\"hello, world!\\"\\n"'
+        unescaped = 'Say:\n  "hello, world!"\n'
         assert unescaped != escaped
         assert unescaped == pofile.unescape(escaped)
 
@@ -858,7 +858,7 @@ def test_denormalize_on_msgstr_without_empty_first_line(self):
         # handle irregular multi-line msgstr (no "" as first line)
         # gracefully (#171)
         msgstr = '"multi-line\\n"\n" translation"'
-        expected_denormalized = u'multi-line\n translation'
+        expected_denormalized = 'multi-line\n translation'
 
         assert expected_denormalized == pofile.denormalize(msgstr)
         assert expected_denormalized == pofile.denormalize(f'""\n{msgstr}')
diff --git a/tests/test_core.py b/tests/test_core.py
index cc234550e..c0e0b3d94 100644
--- a/tests/test_core.py
+++ b/tests/test_core.py
@@ -18,8 +18,8 @@
 
 def test_locale_provides_access_to_cldr_locale_data():
     locale = Locale('en', 'US')
-    assert locale.display_name == u'English (United States)'
-    assert locale.number_symbols['decimal'] == u'.'
+    assert locale.display_name == 'English (United States)'
+    assert locale.number_symbols['decimal'] == '.'
 
 
 def test_locale_repr():
@@ -169,9 +169,9 @@ def test_decimal_formats(self):
 
     def test_currency_formats_property(self):
         assert (Locale('en', 'US').currency_formats['standard'].pattern ==
-                u'\xa4#,##0.00')
+                '\xa4#,##0.00')
         assert (Locale('en', 'US').currency_formats['accounting'].pattern ==
-                u'\xa4#,##0.00;(\xa4#,##0.00)')
+                '\xa4#,##0.00;(\xa4#,##0.00)')
 
     def test_percent_formats_property(self):
         assert Locale('en', 'US').percent_formats[None].pattern == '#,##0%'
@@ -199,7 +199,7 @@ def test_time_zones_property(self):
         time_zones = Locale('en', 'US').time_zones
         assert (time_zones['Europe/London']['long']['daylight'] ==
                 'British Summer Time')
-        assert time_zones['America/St_Johns']['city'] == u'St. John\u2019s'
+        assert time_zones['America/St_Johns']['city'] == 'St. John\u2019s'
 
     def test_meta_zones_property(self):
         meta_zones = Locale('en', 'US').meta_zones
@@ -208,7 +208,7 @@ def test_meta_zones_property(self):
 
     def test_zone_formats_property(self):
         assert Locale('en', 'US').zone_formats['fallback'] == '%(1)s (%(0)s)'
-        assert Locale('pt', 'BR').zone_formats['region'] == u'Hor\xe1rio %s'
+        assert Locale('pt', 'BR').zone_formats['region'] == 'Hor\xe1rio %s'
 
     def test_first_week_day_property(self):
         assert Locale('de', 'DE').first_week_day == 0
@@ -232,12 +232,12 @@ def test_time_formats_property(self):
         assert Locale('fr', 'FR').time_formats['long'].pattern == 'HH:mm:ss z'
 
     def test_datetime_formats_property(self):
-        assert Locale('en').datetime_formats['full'] == u"{1} 'at' {0}"
-        assert Locale('th').datetime_formats['medium'] == u'{1} {0}'
+        assert Locale('en').datetime_formats['full'] == "{1} 'at' {0}"
+        assert Locale('th').datetime_formats['medium'] == '{1} {0}'
 
     def test_datetime_skeleton_property(self):
-        assert Locale('en').datetime_skeletons['Md'].pattern == u"M/d"
-        assert Locale('th').datetime_skeletons['Md'].pattern == u'd/M'
+        assert Locale('en').datetime_skeletons['Md'].pattern == "M/d"
+        assert Locale('th').datetime_skeletons['Md'].pattern == 'd/M'
 
     def test_plural_form_property(self):
         assert Locale('en').plural_form(1) == 'one'
diff --git a/tests/test_date_intervals.py b/tests/test_date_intervals.py
index 8e84a9eb6..556585488 100644
--- a/tests/test_date_intervals.py
+++ b/tests/test_date_intervals.py
@@ -46,8 +46,8 @@ def test_format_interval_12_hour():
 def test_format_interval_invalid_skeleton():
     t1 = TEST_DATE
     t2 = TEST_DATE + datetime.timedelta(days=1)
-    assert dates.format_interval(t1, t2, "mumumu", fuzzy=False, locale="fi") == u"8.1.2016\u20139.1.2016"
-    assert dates.format_interval(t1, t2, fuzzy=False, locale="fi") == u"8.1.2016\u20139.1.2016"
+    assert dates.format_interval(t1, t2, "mumumu", fuzzy=False, locale="fi") == "8.1.2016\u20139.1.2016"
+    assert dates.format_interval(t1, t2, fuzzy=False, locale="fi") == "8.1.2016\u20139.1.2016"
 
 
 def test_issue_825():
diff --git a/tests/test_dates.py b/tests/test_dates.py
index b4abaf934..fd85a1b97 100644
--- a/tests/test_dates.py
+++ b/tests/test_dates.py
@@ -213,7 +213,7 @@ def test_timezone_walltime_short(self, timezone_getter):
     def test_timezone_walltime_long(self, timezone_getter):
         tz = timezone_getter('Europe/Paris')
         t = time(15, 30, tzinfo=tz)
-        assert dates.DateTimeFormat(t, locale='fr_FR')['vvvv'] == u'heure d’Europe centrale'
+        assert dates.DateTimeFormat(t, locale='fr_FR')['vvvv'] == 'heure d’Europe centrale'
 
     def test_hour_formatting(self):
         l = 'en_US'
@@ -252,75 +252,75 @@ def test_with_float(self, timezone_getter):
         d = datetime(2012, 4, 1, 15, 30, 29, tzinfo=UTC)
         epoch = float(calendar.timegm(d.timetuple()))
         formatted_string = dates.format_datetime(epoch, format='long', locale='en_US')
-        assert formatted_string == u'April 1, 2012 at 3:30:29 PM UTC'
+        assert formatted_string == 'April 1, 2012 at 3:30:29 PM UTC'
 
     def test_timezone_formats_los_angeles(self, timezone_getter):
         tz = timezone_getter('America/Los_Angeles')
         dt = _localize(tz, datetime(2016, 1, 13, 7, 8, 35))
-        assert dates.format_datetime(dt, 'z', locale='en') == u'PST'
-        assert dates.format_datetime(dt, 'zz', locale='en') == u'PST'
-        assert dates.format_datetime(dt, 'zzz', locale='en') == u'PST'
-        assert dates.format_datetime(dt, 'zzzz', locale='en') == u'Pacific Standard Time'
-        assert dates.format_datetime(dt, 'Z', locale='en') == u'-0800'
-        assert dates.format_datetime(dt, 'ZZ', locale='en') == u'-0800'
-        assert dates.format_datetime(dt, 'ZZZ', locale='en') == u'-0800'
-        assert dates.format_datetime(dt, 'ZZZZ', locale='en') == u'GMT-08:00'
-        assert dates.format_datetime(dt, 'ZZZZZ', locale='en') == u'-08:00'
-        assert dates.format_datetime(dt, 'OOOO', locale='en') == u'GMT-08:00'
-        assert dates.format_datetime(dt, 'VV', locale='en') == u'America/Los_Angeles'
-        assert dates.format_datetime(dt, 'VVV', locale='en') == u'Los Angeles'
-        assert dates.format_datetime(dt, 'X', locale='en') == u'-08'
-        assert dates.format_datetime(dt, 'XX', locale='en') == u'-0800'
-        assert dates.format_datetime(dt, 'XXX', locale='en') == u'-08:00'
-        assert dates.format_datetime(dt, 'XXXX', locale='en') == u'-0800'
-        assert dates.format_datetime(dt, 'XXXXX', locale='en') == u'-08:00'
-        assert dates.format_datetime(dt, 'x', locale='en') == u'-08'
-        assert dates.format_datetime(dt, 'xx', locale='en') == u'-0800'
-        assert dates.format_datetime(dt, 'xxx', locale='en') == u'-08:00'
-        assert dates.format_datetime(dt, 'xxxx', locale='en') == u'-0800'
-        assert dates.format_datetime(dt, 'xxxxx', locale='en') == u'-08:00'
+        assert dates.format_datetime(dt, 'z', locale='en') == 'PST'
+        assert dates.format_datetime(dt, 'zz', locale='en') == 'PST'
+        assert dates.format_datetime(dt, 'zzz', locale='en') == 'PST'
+        assert dates.format_datetime(dt, 'zzzz', locale='en') == 'Pacific Standard Time'
+        assert dates.format_datetime(dt, 'Z', locale='en') == '-0800'
+        assert dates.format_datetime(dt, 'ZZ', locale='en') == '-0800'
+        assert dates.format_datetime(dt, 'ZZZ', locale='en') == '-0800'
+        assert dates.format_datetime(dt, 'ZZZZ', locale='en') == 'GMT-08:00'
+        assert dates.format_datetime(dt, 'ZZZZZ', locale='en') == '-08:00'
+        assert dates.format_datetime(dt, 'OOOO', locale='en') == 'GMT-08:00'
+        assert dates.format_datetime(dt, 'VV', locale='en') == 'America/Los_Angeles'
+        assert dates.format_datetime(dt, 'VVV', locale='en') == 'Los Angeles'
+        assert dates.format_datetime(dt, 'X', locale='en') == '-08'
+        assert dates.format_datetime(dt, 'XX', locale='en') == '-0800'
+        assert dates.format_datetime(dt, 'XXX', locale='en') == '-08:00'
+        assert dates.format_datetime(dt, 'XXXX', locale='en') == '-0800'
+        assert dates.format_datetime(dt, 'XXXXX', locale='en') == '-08:00'
+        assert dates.format_datetime(dt, 'x', locale='en') == '-08'
+        assert dates.format_datetime(dt, 'xx', locale='en') == '-0800'
+        assert dates.format_datetime(dt, 'xxx', locale='en') == '-08:00'
+        assert dates.format_datetime(dt, 'xxxx', locale='en') == '-0800'
+        assert dates.format_datetime(dt, 'xxxxx', locale='en') == '-08:00'
 
     def test_timezone_formats_utc(self, timezone_getter):
         tz = timezone_getter('UTC')
         dt = _localize(tz, datetime(2016, 1, 13, 7, 8, 35))
-        assert dates.format_datetime(dt, 'Z', locale='en') == u'+0000'
-        assert dates.format_datetime(dt, 'ZZ', locale='en') == u'+0000'
-        assert dates.format_datetime(dt, 'ZZZ', locale='en') == u'+0000'
-        assert dates.format_datetime(dt, 'ZZZZ', locale='en') == u'GMT+00:00'
-        assert dates.format_datetime(dt, 'ZZZZZ', locale='en') == u'Z'
-        assert dates.format_datetime(dt, 'OOOO', locale='en') == u'GMT+00:00'
-        assert dates.format_datetime(dt, 'VV', locale='en') == u'Etc/UTC'
-        assert dates.format_datetime(dt, 'VVV', locale='en') == u'UTC'
-        assert dates.format_datetime(dt, 'X', locale='en') == u'Z'
-        assert dates.format_datetime(dt, 'XX', locale='en') == u'Z'
-        assert dates.format_datetime(dt, 'XXX', locale='en') == u'Z'
-        assert dates.format_datetime(dt, 'XXXX', locale='en') == u'Z'
-        assert dates.format_datetime(dt, 'XXXXX', locale='en') == u'Z'
-        assert dates.format_datetime(dt, 'x', locale='en') == u'+00'
-        assert dates.format_datetime(dt, 'xx', locale='en') == u'+0000'
-        assert dates.format_datetime(dt, 'xxx', locale='en') == u'+00:00'
-        assert dates.format_datetime(dt, 'xxxx', locale='en') == u'+0000'
-        assert dates.format_datetime(dt, 'xxxxx', locale='en') == u'+00:00'
+        assert dates.format_datetime(dt, 'Z', locale='en') == '+0000'
+        assert dates.format_datetime(dt, 'ZZ', locale='en') == '+0000'
+        assert dates.format_datetime(dt, 'ZZZ', locale='en') == '+0000'
+        assert dates.format_datetime(dt, 'ZZZZ', locale='en') == 'GMT+00:00'
+        assert dates.format_datetime(dt, 'ZZZZZ', locale='en') == 'Z'
+        assert dates.format_datetime(dt, 'OOOO', locale='en') == 'GMT+00:00'
+        assert dates.format_datetime(dt, 'VV', locale='en') == 'Etc/UTC'
+        assert dates.format_datetime(dt, 'VVV', locale='en') == 'UTC'
+        assert dates.format_datetime(dt, 'X', locale='en') == 'Z'
+        assert dates.format_datetime(dt, 'XX', locale='en') == 'Z'
+        assert dates.format_datetime(dt, 'XXX', locale='en') == 'Z'
+        assert dates.format_datetime(dt, 'XXXX', locale='en') == 'Z'
+        assert dates.format_datetime(dt, 'XXXXX', locale='en') == 'Z'
+        assert dates.format_datetime(dt, 'x', locale='en') == '+00'
+        assert dates.format_datetime(dt, 'xx', locale='en') == '+0000'
+        assert dates.format_datetime(dt, 'xxx', locale='en') == '+00:00'
+        assert dates.format_datetime(dt, 'xxxx', locale='en') == '+0000'
+        assert dates.format_datetime(dt, 'xxxxx', locale='en') == '+00:00'
 
     def test_timezone_formats_kolkata(self, timezone_getter):
         tz = timezone_getter('Asia/Kolkata')
         dt = _localize(tz, datetime(2016, 1, 13, 7, 8, 35))
-        assert dates.format_datetime(dt, 'zzzz', locale='en') == u'India Standard Time'
-        assert dates.format_datetime(dt, 'ZZZZ', locale='en') == u'GMT+05:30'
-        assert dates.format_datetime(dt, 'ZZZZZ', locale='en') == u'+05:30'
-        assert dates.format_datetime(dt, 'OOOO', locale='en') == u'GMT+05:30'
-        assert dates.format_datetime(dt, 'VV', locale='en') == u'Asia/Calcutta'
-        assert dates.format_datetime(dt, 'VVV', locale='en') == u'Kolkata'
-        assert dates.format_datetime(dt, 'X', locale='en') == u'+0530'
-        assert dates.format_datetime(dt, 'XX', locale='en') == u'+0530'
-        assert dates.format_datetime(dt, 'XXX', locale='en') == u'+05:30'
-        assert dates.format_datetime(dt, 'XXXX', locale='en') == u'+0530'
-        assert dates.format_datetime(dt, 'XXXXX', locale='en') == u'+05:30'
-        assert dates.format_datetime(dt, 'x', locale='en') == u'+0530'
-        assert dates.format_datetime(dt, 'xx', locale='en') == u'+0530'
-        assert dates.format_datetime(dt, 'xxx', locale='en') == u'+05:30'
-        assert dates.format_datetime(dt, 'xxxx', locale='en') == u'+0530'
-        assert dates.format_datetime(dt, 'xxxxx', locale='en') == u'+05:30'
+        assert dates.format_datetime(dt, 'zzzz', locale='en') == 'India Standard Time'
+        assert dates.format_datetime(dt, 'ZZZZ', locale='en') == 'GMT+05:30'
+        assert dates.format_datetime(dt, 'ZZZZZ', locale='en') == '+05:30'
+        assert dates.format_datetime(dt, 'OOOO', locale='en') == 'GMT+05:30'
+        assert dates.format_datetime(dt, 'VV', locale='en') == 'Asia/Calcutta'
+        assert dates.format_datetime(dt, 'VVV', locale='en') == 'Kolkata'
+        assert dates.format_datetime(dt, 'X', locale='en') == '+0530'
+        assert dates.format_datetime(dt, 'XX', locale='en') == '+0530'
+        assert dates.format_datetime(dt, 'XXX', locale='en') == '+05:30'
+        assert dates.format_datetime(dt, 'XXXX', locale='en') == '+0530'
+        assert dates.format_datetime(dt, 'XXXXX', locale='en') == '+05:30'
+        assert dates.format_datetime(dt, 'x', locale='en') == '+0530'
+        assert dates.format_datetime(dt, 'xx', locale='en') == '+0530'
+        assert dates.format_datetime(dt, 'xxx', locale='en') == '+05:30'
+        assert dates.format_datetime(dt, 'xxxx', locale='en') == '+0530'
+        assert dates.format_datetime(dt, 'xxxxx', locale='en') == '+05:30'
 
 
 class FormatTimeTestCase:
@@ -337,7 +337,7 @@ def test_with_float(self, timezone_getter):
         tz = timezone_getter('UTC')
         d = _localize(tz, datetime(2012, 4, 1, 15, 30, 29))
         epoch = float(calendar.timegm(d.timetuple()))
-        assert dates.format_time(epoch, format='long', locale='en_US') == u'3:30:29 PM UTC'
+        assert dates.format_time(epoch, format='long', locale='en_US') == '3:30:29 PM UTC'
 
     def test_with_date_fields_in_pattern(self):
         with pytest.raises(AttributeError):
@@ -398,122 +398,122 @@ def test_can_format_time_with_custom_timezone(self):
 
 
 def test_get_period_names():
-    assert dates.get_period_names(locale='en_US')['am'] == u'AM'
+    assert dates.get_period_names(locale='en_US')['am'] == 'AM'
 
 
 def test_get_day_names():
-    assert dates.get_day_names('wide', locale='en_US')[1] == u'Tuesday'
-    assert dates.get_day_names('short', locale='en_US')[1] == u'Tu'
-    assert dates.get_day_names('abbreviated', locale='es')[1] == u'mar'
+    assert dates.get_day_names('wide', locale='en_US')[1] == 'Tuesday'
+    assert dates.get_day_names('short', locale='en_US')[1] == 'Tu'
+    assert dates.get_day_names('abbreviated', locale='es')[1] == 'mar'
     de = dates.get_day_names('narrow', context='stand-alone', locale='de_DE')
-    assert de[1] == u'D'
+    assert de[1] == 'D'
 
 
 def test_get_month_names():
-    assert dates.get_month_names('wide', locale='en_US')[1] == u'January'
-    assert dates.get_month_names('abbreviated', locale='es')[1] == u'ene'
+    assert dates.get_month_names('wide', locale='en_US')[1] == 'January'
+    assert dates.get_month_names('abbreviated', locale='es')[1] == 'ene'
     de = dates.get_month_names('narrow', context='stand-alone', locale='de_DE')
-    assert de[1] == u'J'
+    assert de[1] == 'J'
 
 
 def test_get_quarter_names():
-    assert dates.get_quarter_names('wide', locale='en_US')[1] == u'1st quarter'
-    assert dates.get_quarter_names('abbreviated', locale='de_DE')[1] == u'Q1'
-    assert dates.get_quarter_names('narrow', locale='de_DE')[1] == u'1'
+    assert dates.get_quarter_names('wide', locale='en_US')[1] == '1st quarter'
+    assert dates.get_quarter_names('abbreviated', locale='de_DE')[1] == 'Q1'
+    assert dates.get_quarter_names('narrow', locale='de_DE')[1] == '1'
 
 
 def test_get_era_names():
-    assert dates.get_era_names('wide', locale='en_US')[1] == u'Anno Domini'
-    assert dates.get_era_names('abbreviated', locale='de_DE')[1] == u'n. Chr.'
+    assert dates.get_era_names('wide', locale='en_US')[1] == 'Anno Domini'
+    assert dates.get_era_names('abbreviated', locale='de_DE')[1] == 'n. Chr.'
 
 
 def test_get_date_format():
     us = dates.get_date_format(locale='en_US')
-    assert us.pattern == u'MMM d, y'
+    assert us.pattern == 'MMM d, y'
     de = dates.get_date_format('full', locale='de_DE')
-    assert de.pattern == u'EEEE, d. MMMM y'
+    assert de.pattern == 'EEEE, d. MMMM y'
 
 
 def test_get_datetime_format():
-    assert dates.get_datetime_format(locale='en_US') == u'{1}, {0}'
+    assert dates.get_datetime_format(locale='en_US') == '{1}, {0}'
 
 
 def test_get_time_format():
-    assert dates.get_time_format(locale='en_US').pattern == u'h:mm:ss a'
+    assert dates.get_time_format(locale='en_US').pattern == 'h:mm:ss a'
     assert (dates.get_time_format('full', locale='de_DE').pattern ==
-            u'HH:mm:ss zzzz')
+            'HH:mm:ss zzzz')
 
 
 def test_get_timezone_gmt(timezone_getter):
     dt = datetime(2007, 4, 1, 15, 30)
-    assert dates.get_timezone_gmt(dt, locale='en') == u'GMT+00:00'
+    assert dates.get_timezone_gmt(dt, locale='en') == 'GMT+00:00'
     assert dates.get_timezone_gmt(dt, locale='en', return_z=True) == 'Z'
-    assert dates.get_timezone_gmt(dt, locale='en', width='iso8601_short') == u'+00'
+    assert dates.get_timezone_gmt(dt, locale='en', width='iso8601_short') == '+00'
     tz = timezone_getter('America/Los_Angeles')
     dt = _localize(tz, datetime(2007, 4, 1, 15, 30))
-    assert dates.get_timezone_gmt(dt, locale='en') == u'GMT-07:00'
-    assert dates.get_timezone_gmt(dt, 'short', locale='en') == u'-0700'
-    assert dates.get_timezone_gmt(dt, locale='en', width='iso8601_short') == u'-07'
-    assert dates.get_timezone_gmt(dt, 'long', locale='fr_FR') == u'UTC-07:00'
+    assert dates.get_timezone_gmt(dt, locale='en') == 'GMT-07:00'
+    assert dates.get_timezone_gmt(dt, 'short', locale='en') == '-0700'
+    assert dates.get_timezone_gmt(dt, locale='en', width='iso8601_short') == '-07'
+    assert dates.get_timezone_gmt(dt, 'long', locale='fr_FR') == 'UTC-07:00'
 
 
 def test_get_timezone_location(timezone_getter):
     tz = timezone_getter('America/St_Johns')
     assert (dates.get_timezone_location(tz, locale='de_DE') ==
-            u"Kanada (St. John\u2019s) Zeit")
+            "Kanada (St. John\u2019s) Zeit")
     assert (dates.get_timezone_location(tz, locale='en') ==
-            u'Canada (St. John’s) Time')
+            'Canada (St. John’s) Time')
     assert (dates.get_timezone_location(tz, locale='en', return_city=True) ==
-            u'St. John’s')
+            'St. John’s')
 
     tz = timezone_getter('America/Mexico_City')
     assert (dates.get_timezone_location(tz, locale='de_DE') ==
-            u'Mexiko (Mexiko-Stadt) Zeit')
+            'Mexiko (Mexiko-Stadt) Zeit')
 
     tz = timezone_getter('Europe/Berlin')
     assert (dates.get_timezone_location(tz, locale='de_DE') ==
-            u'Deutschland (Berlin) Zeit')
+            'Deutschland (Berlin) Zeit')
 
 
 @pytest.mark.parametrize(
     "tzname, params, expected",
     [
-        ("America/Los_Angeles", {"locale": "en_US"}, u"Pacific Time"),
-        ("America/Los_Angeles", {"width": "short", "locale": "en_US"}, u"PT"),
-        ("Europe/Berlin", {"locale": "de_DE"}, u"Mitteleurop\xe4ische Zeit"),
-        ("Europe/Berlin", {"locale": "pt_BR"}, u"Hor\xe1rio da Europa Central"),
-        ("America/St_Johns", {"locale": "de_DE"}, u"Neufundland-Zeit"),
+        ("America/Los_Angeles", {"locale": "en_US"}, "Pacific Time"),
+        ("America/Los_Angeles", {"width": "short", "locale": "en_US"}, "PT"),
+        ("Europe/Berlin", {"locale": "de_DE"}, "Mitteleurop\xe4ische Zeit"),
+        ("Europe/Berlin", {"locale": "pt_BR"}, "Hor\xe1rio da Europa Central"),
+        ("America/St_Johns", {"locale": "de_DE"}, "Neufundland-Zeit"),
         (
             "America/Los_Angeles",
             {"locale": "en", "width": "short", "zone_variant": "generic"},
-            u"PT",
+            "PT",
         ),
         (
             "America/Los_Angeles",
             {"locale": "en", "width": "short", "zone_variant": "standard"},
-            u"PST",
+            "PST",
         ),
         (
             "America/Los_Angeles",
             {"locale": "en", "width": "short", "zone_variant": "daylight"},
-            u"PDT",
+            "PDT",
         ),
         (
             "America/Los_Angeles",
             {"locale": "en", "width": "long", "zone_variant": "generic"},
-            u"Pacific Time",
+            "Pacific Time",
         ),
         (
             "America/Los_Angeles",
             {"locale": "en", "width": "long", "zone_variant": "standard"},
-            u"Pacific Standard Time",
+            "Pacific Standard Time",
         ),
         (
             "America/Los_Angeles",
             {"locale": "en", "width": "long", "zone_variant": "daylight"},
-            u"Pacific Daylight Time",
+            "Pacific Daylight Time",
         ),
-        ("Europe/Berlin", {"locale": "en_US"}, u"Central European Time"),
+        ("Europe/Berlin", {"locale": "en_US"}, "Central European Time"),
     ],
 )
 def test_get_timezone_name_tzinfo(timezone_getter, tzname, params, expected):
@@ -525,13 +525,13 @@ def test_get_timezone_name_tzinfo(timezone_getter, tzname, params, expected):
 @pytest.mark.parametrize(
     "tzname, params, expected",
     [
-        ("America/Los_Angeles", {"locale": "en_US"}, u"Pacific Standard Time"),
+        ("America/Los_Angeles", {"locale": "en_US"}, "Pacific Standard Time"),
         (
             "America/Los_Angeles",
             {"locale": "en_US", "return_zone": True},
-            u"America/Los_Angeles",
+            "America/Los_Angeles",
         ),
-        ("America/Los_Angeles", {"width": "short", "locale": "en_US"}, u"PST"),
+        ("America/Los_Angeles", {"width": "short", "locale": "en_US"}, "PST"),
     ],
 )
 def test_get_timezone_name_time_pytz(timezone_getter, tzname, params, expected):
@@ -554,40 +554,40 @@ def test_get_timezone_name_misc(timezone_getter):
 
 def test_format_date():
     d = date(2007, 4, 1)
-    assert dates.format_date(d, locale='en_US') == u'Apr 1, 2007'
+    assert dates.format_date(d, locale='en_US') == 'Apr 1, 2007'
     assert (dates.format_date(d, format='full', locale='de_DE') ==
-            u'Sonntag, 1. April 2007')
+            'Sonntag, 1. April 2007')
     assert (dates.format_date(d, "EEE, MMM d, ''yy", locale='en') ==
-            u"Sun, Apr 1, '07")
+            "Sun, Apr 1, '07")
 
 
 def test_format_datetime(timezone_getter):
     dt = datetime(2007, 4, 1, 15, 30)
     assert (dates.format_datetime(dt, locale='en_US') ==
-            u'Apr 1, 2007, 3:30:00 PM')
+            'Apr 1, 2007, 3:30:00 PM')
 
     full = dates.format_datetime(
         dt, 'full',
         tzinfo=timezone_getter('Europe/Paris'),
         locale='fr_FR'
     )
-    assert full == (u'dimanche 1 avril 2007 à 17:30:00 heure '
+    assert full == ('dimanche 1 avril 2007 à 17:30:00 heure '
                     u'd\u2019\xe9t\xe9 d\u2019Europe centrale')
     custom = dates.format_datetime(
         dt, "yyyy.MM.dd G 'at' HH:mm:ss zzz",
         tzinfo=timezone_getter('US/Eastern'),
         locale='en'
     )
-    assert custom == u'2007.04.01 AD at 11:30:00 EDT'
+    assert custom == '2007.04.01 AD at 11:30:00 EDT'
 
 
 def test_format_time(timezone_getter):
     t = time(15, 30)
-    assert dates.format_time(t, locale='en_US') == u'3:30:00 PM'
-    assert dates.format_time(t, format='short', locale='de_DE') == u'15:30'
+    assert dates.format_time(t, locale='en_US') == '3:30:00 PM'
+    assert dates.format_time(t, format='short', locale='de_DE') == '15:30'
 
     assert (dates.format_time(t, "hh 'o''clock' a", locale='en') ==
-            u"03 o'clock PM")
+            "03 o'clock PM")
 
     paris = timezone_getter('Europe/Paris')
     eastern = timezone_getter('US/Eastern')
@@ -597,41 +597,41 @@ def test_format_time(timezone_getter):
     assert fr == '15:30:00 heure d’été d’Europe centrale'
 
     custom = dates.format_time(t, "hh 'o''clock' a, zzzz", tzinfo=eastern, locale='en')
-    assert custom == u"09 o'clock AM, Eastern Daylight Time"
+    assert custom == "09 o'clock AM, Eastern Daylight Time"
 
     t = time(15, 30)
     paris = dates.format_time(t, format='full', tzinfo=paris, locale='fr_FR')
     assert paris == '15:30:00 heure normale d’Europe centrale'
 
     us_east = dates.format_time(t, format='full', tzinfo=eastern, locale='en_US')
-    assert us_east == u'3:30:00 PM Eastern Standard Time'
+    assert us_east == '3:30:00 PM Eastern Standard Time'
 
 
 def test_format_skeleton(timezone_getter):
     dt = datetime(2007, 4, 1, 15, 30)
-    assert (dates.format_skeleton('yMEd', dt, locale='en_US') == u'Sun, 4/1/2007')
-    assert (dates.format_skeleton('yMEd', dt, locale='th') == u'อา. 1/4/2007')
+    assert (dates.format_skeleton('yMEd', dt, locale='en_US') == 'Sun, 4/1/2007')
+    assert (dates.format_skeleton('yMEd', dt, locale='th') == 'อา. 1/4/2007')
 
-    assert (dates.format_skeleton('EHm', dt, locale='en') == u'Sun 15:30')
-    assert (dates.format_skeleton('EHm', dt, tzinfo=timezone_getter('Asia/Bangkok'), locale='th') == u'อา. 22:30 น.')
+    assert (dates.format_skeleton('EHm', dt, locale='en') == 'Sun 15:30')
+    assert (dates.format_skeleton('EHm', dt, tzinfo=timezone_getter('Asia/Bangkok'), locale='th') == 'อา. 22:30 น.')
 
 
 def test_format_timedelta():
     assert (dates.format_timedelta(timedelta(weeks=12), locale='en_US')
-            == u'3 months')
+            == '3 months')
     assert (dates.format_timedelta(timedelta(seconds=1), locale='es')
-            == u'1 segundo')
+            == '1 segundo')
 
     assert (dates.format_timedelta(timedelta(hours=3), granularity='day',
                                    locale='en_US')
-            == u'1 day')
+            == '1 day')
 
     assert (dates.format_timedelta(timedelta(hours=23), threshold=0.9,
                                    locale='en_US')
-            == u'1 day')
+            == '1 day')
     assert (dates.format_timedelta(timedelta(hours=23), threshold=1.1,
                                    locale='en_US')
-            == u'23 hours')
+            == '23 hours')
 
 
 def test_parse_date():
@@ -679,24 +679,24 @@ def test_datetime_format_get_week_number():
 
 
 def test_parse_pattern():
-    assert dates.parse_pattern("MMMMd").format == u'%(MMMM)s%(d)s'
+    assert dates.parse_pattern("MMMMd").format == '%(MMMM)s%(d)s'
     assert (dates.parse_pattern("MMM d, yyyy").format ==
-            u'%(MMM)s %(d)s, %(yyyy)s')
+            '%(MMM)s %(d)s, %(yyyy)s')
     assert (dates.parse_pattern("H:mm' Uhr 'z").format ==
-            u'%(H)s:%(mm)s Uhr %(z)s')
-    assert dates.parse_pattern("hh' o''clock'").format == u"%(hh)s o'clock"
+            '%(H)s:%(mm)s Uhr %(z)s')
+    assert dates.parse_pattern("hh' o''clock'").format == "%(hh)s o'clock"
 
 
 def test_lithuanian_long_format():
     assert (
         dates.format_date(date(2015, 12, 10), locale='lt_LT', format='long') ==
-        u'2015 m. gruodžio 10 d.'
+        '2015 m. gruodžio 10 d.'
     )
 
 
 def test_zh_TW_format():
     # Refs GitHub issue #378
-    assert dates.format_time(datetime(2016, 4, 8, 12, 34, 56), locale='zh_TW') == u'中午12:34:56'
+    assert dates.format_time(datetime(2016, 4, 8, 12, 34, 56), locale='zh_TW') == '中午12:34:56'
 
 
 def test_format_current_moment():
diff --git a/tests/test_lists.py b/tests/test_lists.py
index e51f18b23..ca9c6ab41 100644
--- a/tests/test_lists.py
+++ b/tests/test_lists.py
@@ -6,11 +6,11 @@
 def test_format_list():
     for list, locale, expected in [
         ([], 'en', ''),
-        ([u'string'], 'en', u'string'),
-        (['string1', 'string2'], 'en', u'string1 and string2'),
-        (['string1', 'string2', 'string3'], 'en', u'string1, string2, and string3'),
-        (['string1', 'string2', 'string3'], 'zh', u'string1、string2和string3'),
-        (['string1', 'string2', 'string3', 'string4'], 'ne', u'string1,string2, string3 र string4'),
+        (['string'], 'en', 'string'),
+        (['string1', 'string2'], 'en', 'string1 and string2'),
+        (['string1', 'string2', 'string3'], 'en', 'string1, string2, and string3'),
+        (['string1', 'string2', 'string3'], 'zh', 'string1、string2和string3'),
+        (['string1', 'string2', 'string3', 'string4'], 'ne', 'string1,string2, string3 र string4'),
     ]:
         assert lists.format_list(list, locale=locale) == expected
 
diff --git a/tests/test_numbers.py b/tests/test_numbers.py
index ca33c1e2b..a6f79f01c 100644
--- a/tests/test_numbers.py
+++ b/tests/test_numbers.py
@@ -38,7 +38,7 @@ def test_patterns(self):
         # regression test for #183, fraction digits were not correctly cut
         # if the input was a float value and the value had more than 7
         # significant digits
-        assert numbers.format_decimal(12345678.051, '#,##0.00', locale='en_US') == u'12,345,678.05'
+        assert numbers.format_decimal(12345678.051, '#,##0.00', locale='en_US') == '12,345,678.05'
 
     def test_subpatterns(self):
         assert numbers.format_decimal((- 12345), '#,##0.##;-#', locale='en_US') == '-12,345'
@@ -115,57 +115,57 @@ def test_group_separator(self):
         assert numbers.format_decimal(29567.12, locale='en_US', group_separator=False) == '29567.12'
         assert numbers.format_decimal(29567.12, locale='fr_CA', group_separator=False) == '29567,12'
         assert numbers.format_decimal(29567.12, locale='pt_BR', group_separator=False) == '29567,12'
-        assert numbers.format_currency(1099.98, 'USD', locale='en_US', group_separator=False) == u'$1099.98'
-        assert numbers.format_currency(101299.98, 'EUR', locale='fr_CA', group_separator=False) == u'101299,98\xa0€'
+        assert numbers.format_currency(1099.98, 'USD', locale='en_US', group_separator=False) == '$1099.98'
+        assert numbers.format_currency(101299.98, 'EUR', locale='fr_CA', group_separator=False) == '101299,98\xa0€'
         assert numbers.format_currency(101299.98, 'EUR', locale='en_US', group_separator=False, format_type='name') == '101299.98 euros'
-        assert numbers.format_percent(251234.1234, locale='sv_SE', group_separator=False) == u'25123412\xa0%'
+        assert numbers.format_percent(251234.1234, locale='sv_SE', group_separator=False) == '25123412\xa0%'
 
-        assert numbers.format_decimal(29567.12, locale='en_US', group_separator=True) == u'29,567.12'
-        assert numbers.format_decimal(29567.12, locale='fr_CA', group_separator=True) == u'29\xa0567,12'
-        assert numbers.format_decimal(29567.12, locale='pt_BR', group_separator=True) == u'29.567,12'
-        assert numbers.format_currency(1099.98, 'USD', locale='en_US', group_separator=True) == u'$1,099.98'
-        assert numbers.format_currency(101299.98, 'EUR', locale='fr_CA', group_separator=True) == u'101\xa0299,98\xa0€'
-        assert numbers.format_currency(101299.98, 'EUR', locale='en_US', group_separator=True, format_type='name') == u'101,299.98 euros'
-        assert numbers.format_percent(251234.1234, locale='sv_SE', group_separator=True) == u'25\xa0123\xa0412\xa0%'
+        assert numbers.format_decimal(29567.12, locale='en_US', group_separator=True) == '29,567.12'
+        assert numbers.format_decimal(29567.12, locale='fr_CA', group_separator=True) == '29\xa0567,12'
+        assert numbers.format_decimal(29567.12, locale='pt_BR', group_separator=True) == '29.567,12'
+        assert numbers.format_currency(1099.98, 'USD', locale='en_US', group_separator=True) == '$1,099.98'
+        assert numbers.format_currency(101299.98, 'EUR', locale='fr_CA', group_separator=True) == '101\xa0299,98\xa0€'
+        assert numbers.format_currency(101299.98, 'EUR', locale='en_US', group_separator=True, format_type='name') == '101,299.98 euros'
+        assert numbers.format_percent(251234.1234, locale='sv_SE', group_separator=True) == '25\xa0123\xa0412\xa0%'
 
     def test_compact(self):
-        assert numbers.format_compact_decimal(1, locale='en_US', format_type="short") == u'1'
-        assert numbers.format_compact_decimal(999, locale='en_US', format_type="short") == u'999'
-        assert numbers.format_compact_decimal(1000, locale='en_US', format_type="short") == u'1K'
-        assert numbers.format_compact_decimal(9000, locale='en_US', format_type="short") == u'9K'
-        assert numbers.format_compact_decimal(9123, locale='en_US', format_type="short", fraction_digits=2) == u'9.12K'
-        assert numbers.format_compact_decimal(10000, locale='en_US', format_type="short") == u'10K'
-        assert numbers.format_compact_decimal(10000, locale='en_US', format_type="short", fraction_digits=2) == u'10K'
-        assert numbers.format_compact_decimal(1000000, locale='en_US', format_type="short") == u'1M'
-        assert numbers.format_compact_decimal(9000999, locale='en_US', format_type="short") == u'9M'
-        assert numbers.format_compact_decimal(9000900099, locale='en_US', format_type="short", fraction_digits=5) == u'9.0009B'
-        assert numbers.format_compact_decimal(1, locale='en_US', format_type="long") == u'1'
-        assert numbers.format_compact_decimal(999, locale='en_US', format_type="long") == u'999'
-        assert numbers.format_compact_decimal(1000, locale='en_US', format_type="long") == u'1 thousand'
-        assert numbers.format_compact_decimal(9000, locale='en_US', format_type="long") == u'9 thousand'
-        assert numbers.format_compact_decimal(9000, locale='en_US', format_type="long", fraction_digits=2) == u'9 thousand'
-        assert numbers.format_compact_decimal(10000, locale='en_US', format_type="long") == u'10 thousand'
-        assert numbers.format_compact_decimal(10000, locale='en_US', format_type="long", fraction_digits=2) == u'10 thousand'
-        assert numbers.format_compact_decimal(1000000, locale='en_US', format_type="long") == u'1 million'
-        assert numbers.format_compact_decimal(9999999, locale='en_US', format_type="long") == u'10 million'
-        assert numbers.format_compact_decimal(9999999999, locale='en_US', format_type="long", fraction_digits=5) == u'10 billion'
-        assert numbers.format_compact_decimal(1, locale='ja_JP', format_type="short") == u'1'
-        assert numbers.format_compact_decimal(999, locale='ja_JP', format_type="short") == u'999'
-        assert numbers.format_compact_decimal(1000, locale='ja_JP', format_type="short") == u'1000'
-        assert numbers.format_compact_decimal(9123, locale='ja_JP', format_type="short") == u'9123'
-        assert numbers.format_compact_decimal(10000, locale='ja_JP', format_type="short") == u'1万'
-        assert numbers.format_compact_decimal(1234567, locale='ja_JP', format_type="long") == u'123万'
-        assert numbers.format_compact_decimal(-1, locale='en_US', format_type="short") == u'-1'
-        assert numbers.format_compact_decimal(-1234, locale='en_US', format_type="short", fraction_digits=2) == u'-1.23K'
-        assert numbers.format_compact_decimal(-123456789, format_type='short', locale='en_US') == u'-123M'
-        assert numbers.format_compact_decimal(-123456789, format_type='long', locale='en_US') == u'-123 million'
-        assert numbers.format_compact_decimal(2345678, locale='mk', format_type='long') == u'2 милиони'
-        assert numbers.format_compact_decimal(21000000, locale='mk', format_type='long') == u'21 милион'
-        assert numbers.format_compact_decimal(21345, locale="gv", format_type="short") == u'21K'
-        assert numbers.format_compact_decimal(1000, locale='it', format_type='long') == u'mille'
-        assert numbers.format_compact_decimal(1234, locale='it', format_type='long') == u'1 mila'
-        assert numbers.format_compact_decimal(1000, locale='fr', format_type='long') == u'mille'
-        assert numbers.format_compact_decimal(1234, locale='fr', format_type='long') == u'1 millier'
+        assert numbers.format_compact_decimal(1, locale='en_US', format_type="short") == '1'
+        assert numbers.format_compact_decimal(999, locale='en_US', format_type="short") == '999'
+        assert numbers.format_compact_decimal(1000, locale='en_US', format_type="short") == '1K'
+        assert numbers.format_compact_decimal(9000, locale='en_US', format_type="short") == '9K'
+        assert numbers.format_compact_decimal(9123, locale='en_US', format_type="short", fraction_digits=2) == '9.12K'
+        assert numbers.format_compact_decimal(10000, locale='en_US', format_type="short") == '10K'
+        assert numbers.format_compact_decimal(10000, locale='en_US', format_type="short", fraction_digits=2) == '10K'
+        assert numbers.format_compact_decimal(1000000, locale='en_US', format_type="short") == '1M'
+        assert numbers.format_compact_decimal(9000999, locale='en_US', format_type="short") == '9M'
+        assert numbers.format_compact_decimal(9000900099, locale='en_US', format_type="short", fraction_digits=5) == '9.0009B'
+        assert numbers.format_compact_decimal(1, locale='en_US', format_type="long") == '1'
+        assert numbers.format_compact_decimal(999, locale='en_US', format_type="long") == '999'
+        assert numbers.format_compact_decimal(1000, locale='en_US', format_type="long") == '1 thousand'
+        assert numbers.format_compact_decimal(9000, locale='en_US', format_type="long") == '9 thousand'
+        assert numbers.format_compact_decimal(9000, locale='en_US', format_type="long", fraction_digits=2) == '9 thousand'
+        assert numbers.format_compact_decimal(10000, locale='en_US', format_type="long") == '10 thousand'
+        assert numbers.format_compact_decimal(10000, locale='en_US', format_type="long", fraction_digits=2) == '10 thousand'
+        assert numbers.format_compact_decimal(1000000, locale='en_US', format_type="long") == '1 million'
+        assert numbers.format_compact_decimal(9999999, locale='en_US', format_type="long") == '10 million'
+        assert numbers.format_compact_decimal(9999999999, locale='en_US', format_type="long", fraction_digits=5) == '10 billion'
+        assert numbers.format_compact_decimal(1, locale='ja_JP', format_type="short") == '1'
+        assert numbers.format_compact_decimal(999, locale='ja_JP', format_type="short") == '999'
+        assert numbers.format_compact_decimal(1000, locale='ja_JP', format_type="short") == '1000'
+        assert numbers.format_compact_decimal(9123, locale='ja_JP', format_type="short") == '9123'
+        assert numbers.format_compact_decimal(10000, locale='ja_JP', format_type="short") == '1万'
+        assert numbers.format_compact_decimal(1234567, locale='ja_JP', format_type="long") == '123万'
+        assert numbers.format_compact_decimal(-1, locale='en_US', format_type="short") == '-1'
+        assert numbers.format_compact_decimal(-1234, locale='en_US', format_type="short", fraction_digits=2) == '-1.23K'
+        assert numbers.format_compact_decimal(-123456789, format_type='short', locale='en_US') == '-123M'
+        assert numbers.format_compact_decimal(-123456789, format_type='long', locale='en_US') == '-123 million'
+        assert numbers.format_compact_decimal(2345678, locale='mk', format_type='long') == '2 милиони'
+        assert numbers.format_compact_decimal(21000000, locale='mk', format_type='long') == '21 милион'
+        assert numbers.format_compact_decimal(21345, locale="gv", format_type="short") == '21K'
+        assert numbers.format_compact_decimal(1000, locale='it', format_type='long') == 'mille'
+        assert numbers.format_compact_decimal(1234, locale='it', format_type='long') == '1 mila'
+        assert numbers.format_compact_decimal(1000, locale='fr', format_type='long') == 'mille'
+        assert numbers.format_compact_decimal(1234, locale='fr', format_type='long') == '1 millier'
 
 class NumberParsingTestCase(unittest.TestCase):
 
@@ -255,12 +255,12 @@ def test_normalize_currency():
 
 
 def test_get_currency_name():
-    assert numbers.get_currency_name('USD', locale='en_US') == u'US Dollar'
-    assert numbers.get_currency_name('USD', count=2, locale='en_US') == u'US dollars'
+    assert numbers.get_currency_name('USD', locale='en_US') == 'US Dollar'
+    assert numbers.get_currency_name('USD', count=2, locale='en_US') == 'US dollars'
 
 
 def test_get_currency_symbol():
-    assert numbers.get_currency_symbol('USD', 'en_US') == u'$'
+    assert numbers.get_currency_symbol('USD', 'en_US') == '$'
 
 
 def test_get_currency_precision():
@@ -301,24 +301,24 @@ def test_get_territory_currencies():
 
 
 def test_get_decimal_symbol():
-    assert numbers.get_decimal_symbol('en_US') == u'.'
+    assert numbers.get_decimal_symbol('en_US') == '.'
 
 
 def test_get_plus_sign_symbol():
-    assert numbers.get_plus_sign_symbol('en_US') == u'+'
+    assert numbers.get_plus_sign_symbol('en_US') == '+'
 
 
 def test_get_minus_sign_symbol():
-    assert numbers.get_minus_sign_symbol('en_US') == u'-'
-    assert numbers.get_minus_sign_symbol('nl_NL') == u'-'
+    assert numbers.get_minus_sign_symbol('en_US') == '-'
+    assert numbers.get_minus_sign_symbol('nl_NL') == '-'
 
 
 def test_get_exponential_symbol():
-    assert numbers.get_exponential_symbol('en_US') == u'E'
+    assert numbers.get_exponential_symbol('en_US') == 'E'
 
 
 def test_get_group_symbol():
-    assert numbers.get_group_symbol('en_US') == u','
+    assert numbers.get_group_symbol('en_US') == ','
 
 
 def test_decimal_precision():
@@ -328,18 +328,18 @@ def test_decimal_precision():
 
 
 def test_format_decimal():
-    assert numbers.format_decimal(1099, locale='en_US') == u'1,099'
-    assert numbers.format_decimal(1099, locale='de_DE') == u'1.099'
-    assert numbers.format_decimal(1.2345, locale='en_US') == u'1.234'
-    assert numbers.format_decimal(1.2346, locale='en_US') == u'1.235'
-    assert numbers.format_decimal(-1.2346, locale='en_US') == u'-1.235'
-    assert numbers.format_decimal(1.2345, locale='sv_SE') == u'1,234'
-    assert numbers.format_decimal(1.2345, locale='de') == u'1,234'
-    assert numbers.format_decimal(12345.5, locale='en_US') == u'12,345.5'
-    assert numbers.format_decimal(0001.2345000, locale='en_US') == u'1.234'
-    assert numbers.format_decimal(-0001.2346000, locale='en_US') == u'-1.235'
-    assert numbers.format_decimal(0000000.5, locale='en_US') == u'0.5'
-    assert numbers.format_decimal(000, locale='en_US') == u'0'
+    assert numbers.format_decimal(1099, locale='en_US') == '1,099'
+    assert numbers.format_decimal(1099, locale='de_DE') == '1.099'
+    assert numbers.format_decimal(1.2345, locale='en_US') == '1.234'
+    assert numbers.format_decimal(1.2346, locale='en_US') == '1.235'
+    assert numbers.format_decimal(-1.2346, locale='en_US') == '-1.235'
+    assert numbers.format_decimal(1.2345, locale='sv_SE') == '1,234'
+    assert numbers.format_decimal(1.2345, locale='de') == '1,234'
+    assert numbers.format_decimal(12345.5, locale='en_US') == '12,345.5'
+    assert numbers.format_decimal(0001.2345000, locale='en_US') == '1.234'
+    assert numbers.format_decimal(-0001.2346000, locale='en_US') == '-1.235'
+    assert numbers.format_decimal(0000000.5, locale='en_US') == '0.5'
+    assert numbers.format_decimal(000, locale='en_US') == '0'
 
 
 @pytest.mark.parametrize('input_value, expected_value', [
@@ -379,43 +379,43 @@ def test_format_decimal_quantization():
 
 def test_format_currency():
     assert (numbers.format_currency(1099.98, 'USD', locale='en_US')
-            == u'$1,099.98')
+            == '$1,099.98')
     assert (numbers.format_currency(0, 'USD', locale='en_US')
-            == u'$0.00')
+            == '$0.00')
     assert (numbers.format_currency(1099.98, 'USD', locale='es_CO')
-            == u'US$\xa01.099,98')
+            == 'US$\xa01.099,98')
     assert (numbers.format_currency(1099.98, 'EUR', locale='de_DE')
-            == u'1.099,98\xa0\u20ac')
-    assert (numbers.format_currency(1099.98, 'EUR', u'\xa4\xa4 #,##0.00',
+            == '1.099,98\xa0\u20ac')
+    assert (numbers.format_currency(1099.98, 'EUR', '\xa4\xa4 #,##0.00',
                                     locale='en_US')
-            == u'EUR 1,099.98')
+            == 'EUR 1,099.98')
     assert (numbers.format_currency(1099.98, 'EUR', locale='nl_NL')
             != numbers.format_currency(-1099.98, 'EUR', locale='nl_NL'))
     assert (numbers.format_currency(1099.98, 'USD', format=None,
                                     locale='en_US')
-            == u'$1,099.98')
+            == '$1,099.98')
     assert (numbers.format_currency(1, 'USD', locale='es_AR')
-            == u'US$\xa01,00')          # one
+            == 'US$\xa01,00')          # one
     assert (numbers.format_currency(1000000, 'USD', locale='es_AR')
-            == u'US$\xa01.000.000,00')  # many
+            == 'US$\xa01.000.000,00')  # many
     assert (numbers.format_currency(0, 'USD', locale='es_AR')
-            == u'US$\xa00,00')          # other
+            == 'US$\xa00,00')          # other
 
 
 def test_format_currency_format_type():
     assert (numbers.format_currency(1099.98, 'USD', locale='en_US',
                                     format_type="standard")
-            == u'$1,099.98')
+            == '$1,099.98')
     assert (numbers.format_currency(0, 'USD', locale='en_US',
                                     format_type="standard")
-            == u'$0.00')
+            == '$0.00')
 
     assert (numbers.format_currency(1099.98, 'USD', locale='en_US',
                                     format_type="accounting")
-            == u'$1,099.98')
+            == '$1,099.98')
     assert (numbers.format_currency(0, 'USD', locale='en_US',
                                     format_type="accounting")
-            == u'$0.00')
+            == '$0.00')
 
     with pytest.raises(numbers.UnknownCurrencyFormatError) as excinfo:
         numbers.format_currency(1099.98, 'USD', locale='en_US',
@@ -423,27 +423,27 @@ def test_format_currency_format_type():
     assert excinfo.value.args[0] == "'unknown' is not a known currency format type"
 
     assert (numbers.format_currency(1099.98, 'JPY', locale='en_US')
-            == u'\xa51,100')
-    assert (numbers.format_currency(1099.98, 'COP', u'#,##0.00', locale='es_ES')
-            == u'1.099,98')
+            == '\xa51,100')
+    assert (numbers.format_currency(1099.98, 'COP', '#,##0.00', locale='es_ES')
+            == '1.099,98')
     assert (numbers.format_currency(1099.98, 'JPY', locale='en_US',
                                     currency_digits=False)
-            == u'\xa51,099.98')
-    assert (numbers.format_currency(1099.98, 'COP', u'#,##0.00', locale='es_ES',
+            == '\xa51,099.98')
+    assert (numbers.format_currency(1099.98, 'COP', '#,##0.00', locale='es_ES',
                                     currency_digits=False)
-            == u'1.099,98')
+            == '1.099,98')
 
 
 def test_format_compact_currency():
-    assert numbers.format_compact_currency(1, 'USD', locale='en_US', format_type="short") == u'$1'
-    assert numbers.format_compact_currency(999, 'USD', locale='en_US', format_type="short") == u'$999'
-    assert numbers.format_compact_currency(123456789, 'USD', locale='en_US', format_type="short") == u'$123M'
-    assert numbers.format_compact_currency(123456789, 'USD', locale='en_US', fraction_digits=2, format_type="short") == u'$123.46M'
-    assert numbers.format_compact_currency(-123456789, 'USD', locale='en_US', fraction_digits=2, format_type="short") == u'-$123.46M'
-    assert numbers.format_compact_currency(1, 'JPY', locale='ja_JP', format_type="short") == u'￥1'
-    assert numbers.format_compact_currency(1234, 'JPY', locale='ja_JP', format_type="short") == u'￥1234'
-    assert numbers.format_compact_currency(123456, 'JPY', locale='ja_JP', format_type="short") == u'￥12万'
-    assert numbers.format_compact_currency(123456, 'JPY', locale='ja_JP', format_type="short", fraction_digits=2) == u'￥12.35万'
+    assert numbers.format_compact_currency(1, 'USD', locale='en_US', format_type="short") == '$1'
+    assert numbers.format_compact_currency(999, 'USD', locale='en_US', format_type="short") == '$999'
+    assert numbers.format_compact_currency(123456789, 'USD', locale='en_US', format_type="short") == '$123M'
+    assert numbers.format_compact_currency(123456789, 'USD', locale='en_US', fraction_digits=2, format_type="short") == '$123.46M'
+    assert numbers.format_compact_currency(-123456789, 'USD', locale='en_US', fraction_digits=2, format_type="short") == '-$123.46M'
+    assert numbers.format_compact_currency(1, 'JPY', locale='ja_JP', format_type="short") == '￥1'
+    assert numbers.format_compact_currency(1234, 'JPY', locale='ja_JP', format_type="short") == '￥1234'
+    assert numbers.format_compact_currency(123456, 'JPY', locale='ja_JP', format_type="short") == '￥12万'
+    assert numbers.format_compact_currency(123456, 'JPY', locale='ja_JP', format_type="short", fraction_digits=2) == '￥12.35万'
     assert numbers.format_compact_currency(123, 'EUR', locale='yav', format_type="short") == '123\xa0€'
     assert numbers.format_compact_currency(12345, 'EUR', locale='yav', format_type="short") == '12K\xa0€'
     assert numbers.format_compact_currency(123456789, 'EUR', locale='de_DE', fraction_digits=1) == '123,5\xa0Mio.\xa0€'
@@ -492,30 +492,30 @@ def test_format_currency_quantization():
 
 def test_format_currency_long_display_name():
     assert (numbers.format_currency(1099.98, 'USD', locale='en_US', format_type='name')
-            == u'1,099.98 US dollars')
+            == '1,099.98 US dollars')
     assert (numbers.format_currency(1.00, 'USD', locale='en_US', format_type='name')
-            == u'1.00 US dollar')
+            == '1.00 US dollar')
     assert (numbers.format_currency(1.00, 'EUR', locale='en_US', format_type='name')
-            == u'1.00 euro')
+            == '1.00 euro')
     assert (numbers.format_currency(2, 'EUR', locale='en_US', format_type='name')
-            == u'2.00 euros')
+            == '2.00 euros')
     # This tests that '{1} {0}' unitPatterns are found:
     assert (numbers.format_currency(1, 'USD', locale='sw', format_type='name')
-            == u'dola ya Marekani 1.00')
+            == 'dola ya Marekani 1.00')
     # This tests unicode chars:
     assert (numbers.format_currency(1099.98, 'USD', locale='es_GT', format_type='name')
-            == u'dólares estadounidenses 1,099.98')
+            == 'dólares estadounidenses 1,099.98')
     # Test for completely unknown currency, should fallback to currency code
     assert (numbers.format_currency(1099.98, 'XAB', locale='en_US', format_type='name')
-            == u'1,099.98 XAB')
+            == '1,099.98 XAB')
 
     # Test for finding different unit patterns depending on count
     assert (numbers.format_currency(1, 'USD', locale='ro', format_type='name')
-            == u'1,00 dolar american')
+            == '1,00 dolar american')
     assert (numbers.format_currency(2, 'USD', locale='ro', format_type='name')
-            == u'2,00 dolari americani')
+            == '2,00 dolari americani')
     assert (numbers.format_currency(100, 'USD', locale='ro', format_type='name')
-            == u'100,00 de dolari americani')
+            == '100,00 de dolari americani')
 
 
 def test_format_currency_long_display_name_all():
@@ -537,15 +537,15 @@ def test_format_currency_long_display_name_custom_format():
 
 
 def test_format_percent():
-    assert numbers.format_percent(0.34, locale='en_US') == u'34%'
-    assert numbers.format_percent(0, locale='en_US') == u'0%'
-    assert numbers.format_percent(0.34, u'##0%', locale='en_US') == u'34%'
-    assert numbers.format_percent(34, u'##0', locale='en_US') == u'34'
-    assert numbers.format_percent(25.1234, locale='en_US') == u'2,512%'
+    assert numbers.format_percent(0.34, locale='en_US') == '34%'
+    assert numbers.format_percent(0, locale='en_US') == '0%'
+    assert numbers.format_percent(0.34, '##0%', locale='en_US') == '34%'
+    assert numbers.format_percent(34, '##0', locale='en_US') == '34'
+    assert numbers.format_percent(25.1234, locale='en_US') == '2,512%'
     assert (numbers.format_percent(25.1234, locale='sv_SE')
-            == u'2\xa0512\xa0%')
-    assert (numbers.format_percent(25.1234, u'#,##0\u2030', locale='en_US')
-            == u'25,123\u2030')
+            == '2\xa0512\xa0%')
+    assert (numbers.format_percent(25.1234, '#,##0\u2030', locale='en_US')
+            == '25,123\u2030')
 
 
 @pytest.mark.parametrize('input_value, expected_value', [
@@ -583,25 +583,25 @@ def test_format_percent_quantization():
 
 
 def test_format_scientific():
-    assert numbers.format_scientific(10000, locale='en_US') == u'1E4'
-    assert numbers.format_scientific(4234567, u'#.#E0', locale='en_US') == u'4.2E6'
-    assert numbers.format_scientific(4234567, u'0E0000', locale='en_US') == u'4.234567E0006'
-    assert numbers.format_scientific(4234567, u'##0E00', locale='en_US') == u'4.234567E06'
-    assert numbers.format_scientific(4234567, u'##00E00', locale='en_US') == u'42.34567E05'
-    assert numbers.format_scientific(4234567, u'0,000E00', locale='en_US') == u'4,234.567E03'
-    assert numbers.format_scientific(4234567, u'##0.#####E00', locale='en_US') == u'4.23457E06'
-    assert numbers.format_scientific(4234567, u'##0.##E00', locale='en_US') == u'4.23E06'
-    assert numbers.format_scientific(42, u'00000.000000E0000', locale='en_US') == u'42000.000000E-0003'
+    assert numbers.format_scientific(10000, locale='en_US') == '1E4'
+    assert numbers.format_scientific(4234567, '#.#E0', locale='en_US') == '4.2E6'
+    assert numbers.format_scientific(4234567, '0E0000', locale='en_US') == '4.234567E0006'
+    assert numbers.format_scientific(4234567, '##0E00', locale='en_US') == '4.234567E06'
+    assert numbers.format_scientific(4234567, '##00E00', locale='en_US') == '42.34567E05'
+    assert numbers.format_scientific(4234567, '0,000E00', locale='en_US') == '4,234.567E03'
+    assert numbers.format_scientific(4234567, '##0.#####E00', locale='en_US') == '4.23457E06'
+    assert numbers.format_scientific(4234567, '##0.##E00', locale='en_US') == '4.23E06'
+    assert numbers.format_scientific(42, '00000.000000E0000', locale='en_US') == '42000.000000E-0003'
 
 
 def test_default_scientific_format():
     """ Check the scientific format method auto-correct the rendering pattern
     in case of a missing fractional part.
     """
-    assert numbers.format_scientific(12345, locale='en_US') == u'1.2345E4'
-    assert numbers.format_scientific(12345.678, locale='en_US') == u'1.2345678E4'
-    assert numbers.format_scientific(12345, u'#E0', locale='en_US') == u'1.2345E4'
-    assert numbers.format_scientific(12345.678, u'#E0', locale='en_US') == u'1.2345678E4'
+    assert numbers.format_scientific(12345, locale='en_US') == '1.2345E4'
+    assert numbers.format_scientific(12345.678, locale='en_US') == '1.2345678E4'
+    assert numbers.format_scientific(12345, '#E0', locale='en_US') == '1.2345E4'
+    assert numbers.format_scientific(12345.678, '#E0', locale='en_US') == '1.2345678E4'
 
 
 @pytest.mark.parametrize('input_value, expected_value', [
@@ -667,18 +667,18 @@ def test_parse_grouping():
 def test_parse_pattern():
 
     # Original pattern is preserved
-    np = numbers.parse_pattern(u'¤#,##0.00')
-    assert np.pattern == u'¤#,##0.00'
+    np = numbers.parse_pattern('¤#,##0.00')
+    assert np.pattern == '¤#,##0.00'
 
-    np = numbers.parse_pattern(u'¤#,##0.00;(¤#,##0.00)')
-    assert np.pattern == u'¤#,##0.00;(¤#,##0.00)'
+    np = numbers.parse_pattern('¤#,##0.00;(¤#,##0.00)')
+    assert np.pattern == '¤#,##0.00;(¤#,##0.00)'
 
     # Given a NumberPattern object, we don't return a new instance.
     # However, we don't cache NumberPattern objects, so calling
     # parse_pattern with the same format string will create new
     # instances
-    np1 = numbers.parse_pattern(u'¤ #,##0.00')
-    np2 = numbers.parse_pattern(u'¤ #,##0.00')
+    np1 = numbers.parse_pattern('¤ #,##0.00')
+    np2 = numbers.parse_pattern('¤ #,##0.00')
     assert np1 is not np2
     assert np1 is numbers.parse_pattern(np1)
 
@@ -686,19 +686,19 @@ def test_parse_pattern():
 def test_parse_pattern_negative():
 
     # No negative format specified
-    np = numbers.parse_pattern(u'¤#,##0.00')
-    assert np.prefix == (u'¤', u'-¤')
-    assert np.suffix == (u'', u'')
+    np = numbers.parse_pattern('¤#,##0.00')
+    assert np.prefix == ('¤', '-¤')
+    assert np.suffix == ('', '')
 
     # Negative format is specified
-    np = numbers.parse_pattern(u'¤#,##0.00;(¤#,##0.00)')
-    assert np.prefix == (u'¤', u'(¤')
-    assert np.suffix == (u'', u')')
+    np = numbers.parse_pattern('¤#,##0.00;(¤#,##0.00)')
+    assert np.prefix == ('¤', '(¤')
+    assert np.suffix == ('', ')')
 
     # Negative sign is a suffix
-    np = numbers.parse_pattern(u'¤ #,##0.00;¤ #,##0.00-')
-    assert np.prefix == (u'¤ ', u'¤ ')
-    assert np.suffix == (u'', u'-')
+    np = numbers.parse_pattern('¤ #,##0.00;¤ #,##0.00-')
+    assert np.prefix == ('¤ ', '¤ ')
+    assert np.suffix == ('', '-')
 
 
 def test_numberpattern_repr():
@@ -706,7 +706,7 @@ def test_numberpattern_repr():
 
     # This implementation looks a bit funny, but that's cause strings are
     # repr'd differently in Python 2 vs 3 and this test runs under both.
-    format = u'¤#,##0.00;(¤#,##0.00)'
+    format = '¤#,##0.00;(¤#,##0.00)'
     np = numbers.parse_pattern(format)
     assert repr(format) in repr(np)
 
diff --git a/tests/test_support.py b/tests/test_support.py
index fe1040264..36bdcf665 100644
--- a/tests/test_support.py
+++ b/tests/test_support.py
@@ -71,8 +71,8 @@ def test_pgettext(self):
                                                                      'foo'))
 
     def test_upgettext(self):
-        self.assertEqualTypeToo(u'Voh', self.translations.ugettext('foo'))
-        self.assertEqualTypeToo(u'VohCTX', self.translations.upgettext('foo',
+        self.assertEqualTypeToo('Voh', self.translations.ugettext('foo'))
+        self.assertEqualTypeToo('VohCTX', self.translations.upgettext('foo',
                                                                        'foo'))
 
     @pytest.mark.skipif(SKIP_LGETTEXT, reason="lgettext is deprecated")
@@ -94,14 +94,14 @@ def test_npgettext(self):
                                                             'foos1', 2))
 
     def test_unpgettext(self):
-        self.assertEqualTypeToo(u'Voh1',
+        self.assertEqualTypeToo('Voh1',
                                 self.translations.ungettext('foo1', 'foos1', 1))
-        self.assertEqualTypeToo(u'Vohs1',
+        self.assertEqualTypeToo('Vohs1',
                                 self.translations.ungettext('foo1', 'foos1', 2))
-        self.assertEqualTypeToo(u'VohCTX1',
+        self.assertEqualTypeToo('VohCTX1',
                                 self.translations.unpgettext('foo', 'foo1',
                                                              'foos1', 1))
-        self.assertEqualTypeToo(u'VohsCTX1',
+        self.assertEqualTypeToo('VohsCTX1',
                                 self.translations.unpgettext('foo', 'foo1',
                                                              'foos1', 2))
 
@@ -126,9 +126,9 @@ def test_dpgettext(self):
 
     def test_dupgettext(self):
         self.assertEqualTypeToo(
-            u'VohD', self.translations.dugettext('messages1', 'foo'))
+            'VohD', self.translations.dugettext('messages1', 'foo'))
         self.assertEqualTypeToo(
-            u'VohCTXD', self.translations.dupgettext('messages1', 'foo', 'foo'))
+            'VohCTXD', self.translations.dupgettext('messages1', 'foo', 'foo'))
 
     @pytest.mark.skipif(SKIP_LGETTEXT, reason="lgettext is deprecated")
     def test_ldpgettext(self):
@@ -151,14 +151,14 @@ def test_dnpgettext(self):
 
     def test_dunpgettext(self):
         self.assertEqualTypeToo(
-            u'VohD1', self.translations.dungettext('messages1', 'foo1', 'foos1', 1))
+            'VohD1', self.translations.dungettext('messages1', 'foo1', 'foos1', 1))
         self.assertEqualTypeToo(
-            u'VohsD1', self.translations.dungettext('messages1', 'foo1', 'foos1', 2))
+            'VohsD1', self.translations.dungettext('messages1', 'foo1', 'foos1', 2))
         self.assertEqualTypeToo(
-            u'VohCTXD1', self.translations.dunpgettext('messages1', 'foo', 'foo1',
+            'VohCTXD1', self.translations.dunpgettext('messages1', 'foo', 'foo1',
                                                        'foos1', 1))
         self.assertEqualTypeToo(
-            u'VohsCTXD1', self.translations.dunpgettext('messages1', 'foo', 'foo1',
+            'VohsCTXD1', self.translations.dunpgettext('messages1', 'foo', 'foo1',
                                                         'foos1', 2))
 
     @pytest.mark.skipif(SKIP_LGETTEXT, reason="lgettext is deprecated")
@@ -219,9 +219,9 @@ def test_method_signature_compatibility(self):
 
     def test_same_return_values(self):
         data = {
-            'message': u'foo', 'domain': u'domain', 'context': 'tests',
-            'singular': u'bar', 'plural': u'baz', 'num': 1,
-            'msgid1': u'bar', 'msgid2': u'baz', 'n': 1,
+            'message': 'foo', 'domain': 'domain', 'context': 'tests',
+            'singular': 'bar', 'plural': 'baz', 'num': 1,
+            'msgid1': 'bar', 'msgid2': 'baz', 'n': 1,
         }
         for name in self.method_names():
             method = getattr(self.translations, name)
@@ -346,9 +346,9 @@ def greeting(name='world'):
         return f"Hello, {name}!"
 
     lazy_greeting = support.LazyProxy(greeting, name='Joe')
-    assert str(lazy_greeting) == u"Hello, Joe!"
-    assert u'  ' + lazy_greeting == u'  Hello, Joe!'
-    assert u'(%s)' % lazy_greeting == u'(Hello, Joe!)'
+    assert str(lazy_greeting) == "Hello, Joe!"
+    assert '  ' + lazy_greeting == '  Hello, Joe!'
+    assert '(%s)' % lazy_greeting == '(Hello, Joe!)'
     assert f"[{lazy_greeting}]" == "[Hello, Joe!]"
 
     greetings = [
@@ -358,9 +358,9 @@ def greeting(name='world'):
     ]
     greetings.sort()
     assert [str(g) for g in greetings] == [
-        u"Hello, Joe!",
-        u"Hello, universe!",
-        u"Hello, world!",
+        "Hello, Joe!",
+        "Hello, universe!",
+        "Hello, world!",
     ]
 
 
diff --git a/tests/test_util.py b/tests/test_util.py
index f58fc2443..d21c723f3 100644
--- a/tests/test_util.py
+++ b/tests/test_util.py
@@ -62,15 +62,15 @@ def parse_encoding(s):
 
 
 def test_parse_encoding_defined():
-    assert parse_encoding(u'# coding: utf-8') == 'utf-8'
+    assert parse_encoding('# coding: utf-8') == 'utf-8'
 
 
 def test_parse_encoding_undefined():
-    assert parse_encoding(u'') is None
+    assert parse_encoding('') is None
 
 
 def test_parse_encoding_non_ascii():
-    assert parse_encoding(u'K\xf6ln') is None
+    assert parse_encoding('K\xf6ln') is None
 
 
 @pytest.mark.parametrize('source, result', [

From cb0269fc63f5af4ade770f7a8872de8090bf697d Mon Sep 17 00:00:00 2001
From: Aarni Koskela <akx@iki.fi>
Date: Wed, 18 Jan 2023 21:00:31 +0200
Subject: [PATCH 28/53] Apply ruff UP (Pyupgrade) fixes

---
 babel/messages/jslexer.py | 1 -
 pyproject.toml            | 2 +-
 scripts/import_cldr.py    | 2 +-
 3 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/babel/messages/jslexer.py b/babel/messages/jslexer.py
index 6eab92075..d2ffbbe76 100644
--- a/babel/messages/jslexer.py
+++ b/babel/messages/jslexer.py
@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 """
     babel.messages.jslexer
     ~~~~~~~~~~~~~~~~~~~~~~
diff --git a/pyproject.toml b/pyproject.toml
index 10c1db8b3..dbd137cff 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -7,7 +7,7 @@ select = [
     "F",
     "I",
     "SIM300",
-    "UP025",
+    "UP",
 ]
 ignore = [
     "C901",  # Complexity
diff --git a/scripts/import_cldr.py b/scripts/import_cldr.py
index b5034073e..33e4a6099 100755
--- a/scripts/import_cldr.py
+++ b/scripts/import_cldr.py
@@ -129,7 +129,7 @@ def _time_to_seconds_past_midnight(time_expr):
         return None
     if time_expr.count(":") == 1:
         time_expr += ":00"
-    hour, minute, second = [int(p, 10) for p in time_expr.split(":")]
+    hour, minute, second = (int(p, 10) for p in time_expr.split(":"))
     return hour * 60 * 60 + minute * 60 + second
 
 

From 82d345a66e850f643607ac9fcafd9b9a2a89d1e1 Mon Sep 17 00:00:00 2001
From: Aarni Koskela <akx@iki.fi>
Date: Wed, 18 Jan 2023 20:27:44 +0200
Subject: [PATCH 29/53] Apply some small miscellaneous formatting fixes

---
 babel/core.py                   |  1 +
 babel/dates.py                  | 10 ++++------
 babel/localtime/_helpers.py     |  1 +
 babel/messages/catalog.py       |  4 +++-
 babel/messages/extract.py       |  7 ++-----
 babel/messages/frontend.py      |  3 +--
 babel/messages/jslexer.py       |  4 +++-
 babel/messages/pofile.py        |  9 +++++----
 babel/plural.py                 |  2 ++
 babel/support.py                |  1 +
 babel/units.py                  |  1 +
 babel/util.py                   |  2 ++
 scripts/download_import_cldr.py |  2 +-
 scripts/import_cldr.py          |  1 -
 tests/messages/test_catalog.py  |  6 +++---
 tests/test_dates.py             | 12 +++++++-----
 tests/test_localedata.py        |  9 ++++-----
 tests/test_numbers.py           | 22 +++++++++++-----------
 tests/test_support.py           | 12 ++++++------
 tests/test_util.py              |  9 +++++----
 20 files changed, 63 insertions(+), 55 deletions(-)

diff --git a/babel/core.py b/babel/core.py
index 604e5d9ee..ce564d750 100644
--- a/babel/core.py
+++ b/babel/core.py
@@ -46,6 +46,7 @@
 _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 '
diff --git a/babel/dates.py b/babel/dates.py
index 26766a695..e626df5c2 100644
--- a/babel/dates.py
+++ b/babel/dates.py
@@ -1349,8 +1349,7 @@ def parse_date(
         month_idx = format_str.index('l')
     day_idx = format_str.index('d')
 
-    indexes = [(year_idx, 'Y'), (month_idx, 'M'), (day_idx, 'D')]
-    indexes.sort()
+    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
@@ -1399,8 +1398,7 @@ def parse_time(
     min_idx = format_str.index('m')
     sec_idx = format_str.index('s')
 
-    indexes = [(hour_idx, 'H'), (min_idx, 'M'), (sec_idx, 'S')]
-    indexes.sort()
+    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
@@ -1436,7 +1434,7 @@ def __str__(self) -> str:
         return pat
 
     def __mod__(self, other: DateTimeFormat) -> str:
-        if type(other) is not DateTimeFormat:
+        if not isinstance(other, DateTimeFormat):
             return NotImplemented
         return self.format % other
 
@@ -1829,7 +1827,7 @@ def parse_pattern(pattern: str) -> DateTimePattern:
 
     :param pattern: the formatting pattern to parse
     """
-    if type(pattern) is DateTimePattern:
+    if isinstance(pattern, DateTimePattern):
         return pattern
 
     if pattern in _pattern_cache:
diff --git a/babel/localtime/_helpers.py b/babel/localtime/_helpers.py
index b7238f6a6..159f9a569 100644
--- a/babel/localtime/_helpers.py
+++ b/babel/localtime/_helpers.py
@@ -24,6 +24,7 @@ def _get_tzinfo(tzenv: str):
 
     return None
 
+
 def _get_tzinfo_or_raise(tzenv: str):
     tzinfo = _get_tzinfo(tzenv)
     if tzinfo is None:
diff --git a/babel/messages/catalog.py b/babel/messages/catalog.py
index 85f16b259..dead4aac7 100644
--- a/babel/messages/catalog.py
+++ b/babel/messages/catalog.py
@@ -240,6 +240,7 @@ class TranslationError(Exception):
 # FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
 #"""
 
+
 def parse_separated_header(value: str) -> dict[str, str]:
     # Adapted from https://peps.python.org/pep-0594/#cgi
     from email.message import Message
@@ -736,7 +737,8 @@ def delete(self, id: _MessageID, context: str | None = None) -> None:
         if key in self._messages:
             del self._messages[key]
 
-    def update(self,
+    def update(
+        self,
         template: Catalog,
         no_fuzzy_matching: bool = False,
         update_header_comment: bool = False,
diff --git a/babel/messages/extract.py b/babel/messages/extract.py
index 0934937c8..453742ed0 100644
--- a/babel/messages/extract.py
+++ b/babel/messages/extract.py
@@ -90,7 +90,6 @@ def tell(self) -> int: ...
 DEFAULT_MAPPING: list[tuple[str, str]] = [('**.py', 'python')]
 
 
-
 def _strip_comment_tags(comments: MutableSequence[str], tags: Iterable[str]):
     """Helper function for `extract` that strips comment tags from strings
     in a list of comment lines.  This functions operates in-place.
@@ -660,8 +659,7 @@ def extract_javascript(
             token = Token('operator', ')', token.lineno)
 
         if options.get('parse_template_string') and not funcname and token.type == 'template_string':
-            for item in parse_template_string(token.value, keywords, comment_tags, options, token.lineno):
-                yield item
+            yield from parse_template_string(token.value, keywords, comment_tags, options, token.lineno)
 
         elif token.type == 'operator' and token.value == '(':
             if funcname:
@@ -794,8 +792,7 @@ def parse_template_string(
                 if level == 0 and expression_contents:
                     expression_contents = expression_contents[0:-1]
                     fake_file_obj = io.BytesIO(expression_contents.encode())
-                    for item in extract_javascript(fake_file_obj, keywords, comment_tags, options, lineno):
-                        yield item
+                    yield from extract_javascript(fake_file_obj, keywords, comment_tags, options, lineno)
                     lineno += len(line_re.findall(expression_contents))
                     expression_contents = ''
         prev_character = character
diff --git a/babel/messages/frontend.py b/babel/messages/frontend.py
index de17b1ea5..ab094ecd4 100644
--- a/babel/messages/frontend.py
+++ b/babel/messages/frontend.py
@@ -56,7 +56,6 @@
     from distutils.errors import DistutilsSetupError as SetupError
 
 
-
 def listify_value(arg, split=None):
     """
     Make a list out of an argument.
@@ -853,7 +852,7 @@ def run(self):
                              omit_header=self.omit_header,
                              ignore_obsolete=self.ignore_obsolete,
                              include_previous=self.previous, width=self.width)
-            except:
+            except Exception:
                 os.remove(tmpname)
                 raise
 
diff --git a/babel/messages/jslexer.py b/babel/messages/jslexer.py
index d2ffbbe76..0563f6221 100644
--- a/babel/messages/jslexer.py
+++ b/babel/messages/jslexer.py
@@ -32,11 +32,13 @@
 uni_escape_re = re.compile(r'[a-fA-F0-9]{1,4}')
 hex_escape_re = re.compile(r'[a-fA-F0-9]{1,2}')
 
+
 class Token(NamedTuple):
     type: str
     value: str
     lineno: int
 
+
 _rules: list[tuple[str | None, re.Pattern[str]]] = [
     (None, re.compile(r'\s+', re.UNICODE)),
     (None, re.compile(r'<!--.*')),
@@ -100,7 +102,7 @@ def unquote_string(string: str) -> str:
     add = result.append
     pos = 0
 
-    while 1:
+    while True:
         # scan for the next escape
         escape_pos = string.find('\\', pos)
         if escape_pos < 0:
diff --git a/babel/messages/pofile.py b/babel/messages/pofile.py
index a9180a719..88cc0430f 100644
--- a/babel/messages/pofile.py
+++ b/babel/messages/pofile.py
@@ -134,7 +134,6 @@ def __ne__(self, other: object) -> bool:
         return self.__cmp__(other) != 0
 
 
-
 class PoFileParser:
     """Support class to  read messages from a ``gettext`` PO (portable object) file
     and add them to a `Catalog`
@@ -615,11 +614,13 @@ def _write_message(message, prefix=''):
                     locs.append(location)
             _write_comment(' '.join(locs), prefix=':')
         if message.flags:
-            _write('#%s\n' % ', '.join([''] + sorted(message.flags)))
+            _write(f"#{', '.join(['', *sorted(message.flags)])}\n")
 
         if message.previous_id and include_previous:
-            _write_comment('msgid %s' % _normalize(message.previous_id[0]),
-                           prefix='|')
+            _write_comment(
+                f'msgid {_normalize(message.previous_id[0])}',
+                prefix='|',
+            )
             if len(message.previous_id) > 1:
                 _write_comment('msgid_plural %s' % _normalize(
                     message.previous_id[1]
diff --git a/babel/plural.py b/babel/plural.py
index fd0d0da52..fe1ee2553 100644
--- a/babel/plural.py
+++ b/babel/plural.py
@@ -325,6 +325,7 @@ def cldr_modulo(a: float, b: float) -> float:
 class RuleError(Exception):
     """Raised if a rule is malformed."""
 
+
 _VARS = {
     'n',  # absolute value of the source number.
     'i',  # integer digits of n.
@@ -363,6 +364,7 @@ def tokenize_rule(s: str) -> list[tuple[str, str]]:
                             'Got unexpected %r' % s[pos])
     return result[::-1]
 
+
 def test_next_token(
     tokens: list[tuple[str, str]],
     type_: str,
diff --git a/babel/support.py b/babel/support.py
index 70925997c..242b492bf 100644
--- a/babel/support.py
+++ b/babel/support.py
@@ -35,6 +35,7 @@
 
     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.
diff --git a/babel/units.py b/babel/units.py
index 1180bd125..0c72ee97a 100644
--- a/babel/units.py
+++ b/babel/units.py
@@ -9,6 +9,7 @@
 if TYPE_CHECKING:
     from typing_extensions import Literal
 
+
 class UnknownUnitError(ValueError):
     def __init__(self, unit: str, locale: Locale) -> None:
         ValueError.__init__(self, f"{unit} is not a known unit in {locale}")
diff --git a/babel/util.py b/babel/util.py
index cf86f20f5..a5403e653 100644
--- a/babel/util.py
+++ b/babel/util.py
@@ -24,6 +24,7 @@
 
 _T = TypeVar("_T")
 
+
 def distinct(iterable: Iterable[_T]) -> Generator[_T, None, None]:
     """Yield all items in an iterable collection that are distinct.
 
@@ -43,6 +44,7 @@ def distinct(iterable: Iterable[_T]) -> Generator[_T, None, None]:
             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)
diff --git a/scripts/download_import_cldr.py b/scripts/download_import_cldr.py
index 926e74760..ab455ac14 100755
--- a/scripts/download_import_cldr.py
+++ b/scripts/download_import_cldr.py
@@ -37,7 +37,7 @@ def is_good_file(filename):
         return False
     h = hashlib.sha512()
     with open(filename, 'rb') as f:
-        while 1:
+        while True:
             blk = f.read(BLKSIZE)
             if not blk:
                 break
diff --git a/scripts/import_cldr.py b/scripts/import_cldr.py
index 33e4a6099..5630ba896 100755
--- a/scripts/import_cldr.py
+++ b/scripts/import_cldr.py
@@ -990,6 +990,5 @@ def parse_measurement_systems(data, tree):
             _import_type_text(measurement_systems, measurement_system, type=type)
 
 
-
 if __name__ == '__main__':
     main()
diff --git a/tests/messages/test_catalog.py b/tests/messages/test_catalog.py
index 29cfc0d65..273c83f51 100644
--- a/tests/messages/test_catalog.py
+++ b/tests/messages/test_catalog.py
@@ -98,7 +98,7 @@ def test_update_message_changed_to_plural(self):
 
     def test_update_message_changed_to_simple(self):
         cat = catalog.Catalog()
-        cat.add('foo' u'foos', ('Voh', 'Vöhs'))
+        cat.add('foo' 'foos', ('Voh', 'Vöhs'))
         tmpl = catalog.Catalog()
         tmpl.add('foo')
         cat.update(tmpl)
@@ -112,11 +112,11 @@ def test_update_message_updates_comments(self):
         assert cat['foo'].user_comments == []
         # Update cat[u'foo'] with a new location and a comment
         cat['foo'] = catalog.Message('foo', locations=[('main.py', 7)],
-                                      user_comments=['Foo Bar comment 1'])
+                                     user_comments=['Foo Bar comment 1'])
         assert cat['foo'].user_comments == ['Foo Bar comment 1']
         # now add yet another location with another comment
         cat['foo'] = catalog.Message('foo', locations=[('main.py', 9)],
-                                      auto_comments=['Foo Bar comment 2'])
+                                     auto_comments=['Foo Bar comment 2'])
         assert cat['foo'].auto_comments == ['Foo Bar comment 2']
 
     def test_update_fuzzy_matching_with_case_change(self):
diff --git a/tests/test_dates.py b/tests/test_dates.py
index fd85a1b97..2e3c880c5 100644
--- a/tests/test_dates.py
+++ b/tests/test_dates.py
@@ -68,7 +68,7 @@ def test_week_of_year_last_us_extra_week(self):
         assert dates.DateTimeFormat(d, locale='en_US')['w'] == '53'
 
     def test_week_of_year_de_first_us_last_with_year(self):
-        d = date(2018,12,31)
+        d = date(2018, 12, 31)
         fmt = dates.DateTimeFormat(d, locale='de_DE')
         assert fmt['w'] == '1'
         assert fmt['YYYY'] == '2019'
@@ -571,8 +571,10 @@ def test_format_datetime(timezone_getter):
         tzinfo=timezone_getter('Europe/Paris'),
         locale='fr_FR'
     )
-    assert full == ('dimanche 1 avril 2007 à 17:30:00 heure '
-                    u'd\u2019\xe9t\xe9 d\u2019Europe centrale')
+    assert full == (
+        'dimanche 1 avril 2007 à 17:30:00 heure '
+        'd\u2019\xe9t\xe9 d\u2019Europe centrale'
+    )
     custom = dates.format_datetime(
         dt, "yyyy.MM.dd G 'at' HH:mm:ss zzz",
         tzinfo=timezone_getter('US/Eastern'),
@@ -727,8 +729,8 @@ def test_no_inherit_metazone_formatting(timezone_getter):
 def test_russian_week_numbering():
     # See https://github.com/python-babel/babel/issues/485
     v = date(2017, 1, 1)
-    assert dates.format_date(v, format='YYYY-ww',locale='ru_RU') == '2016-52'  # This would have returned 2017-01 prior to CLDR 32
-    assert dates.format_date(v, format='YYYY-ww',locale='de_DE') == '2016-52'
+    assert dates.format_date(v, format='YYYY-ww', locale='ru_RU') == '2016-52'  # This would have returned 2017-01 prior to CLDR 32
+    assert dates.format_date(v, format='YYYY-ww', locale='de_DE') == '2016-52'
 
 
 def test_en_gb_first_weekday():
diff --git a/tests/test_localedata.py b/tests/test_localedata.py
index 7672ddc15..36f3e7354 100644
--- a/tests/test_localedata.py
+++ b/tests/test_localedata.py
@@ -94,19 +94,18 @@ def test_locale_argument_acceptance():
     # Testing None input.
     normalized_locale = localedata.normalize_locale(None)
     assert normalized_locale is None
-    locale_exist = localedata.exists(None)
-    assert locale_exist is False
+    assert not localedata.exists(None)
 
-    # # Testing list input.
+    # Testing list input.
     normalized_locale = localedata.normalize_locale(['en_us', None])
     assert normalized_locale is None
-    locale_exist = localedata.exists(['en_us', None])
-    assert locale_exist is False
+    assert not localedata.exists(['en_us', None])
 
 
 def test_locale_identifiers_cache(monkeypatch):
     original_listdir = localedata.os.listdir
     listdir_calls = []
+
     def listdir_spy(*args):
         rv = original_listdir(*args)
         listdir_calls.append((args, rv))
diff --git a/tests/test_numbers.py b/tests/test_numbers.py
index a6f79f01c..04a186510 100644
--- a/tests/test_numbers.py
+++ b/tests/test_numbers.py
@@ -167,6 +167,7 @@ def test_compact(self):
         assert numbers.format_compact_decimal(1000, locale='fr', format_type='long') == 'mille'
         assert numbers.format_compact_decimal(1234, locale='fr', format_type='long') == '1 millier'
 
+
 class NumberParsingTestCase(unittest.TestCase):
 
     def test_can_parse_decimals(self):
@@ -231,15 +232,15 @@ def test_validate_currency():
 
 
 def test_is_currency():
-    assert is_currency('EUR') is True
-    assert is_currency('eUr') is False
-    assert is_currency('FUU') is False
-    assert is_currency('') is False
-    assert is_currency(None) is False
-    assert is_currency('   EUR    ') is False
-    assert is_currency('   ') is False
-    assert is_currency([]) is False
-    assert is_currency(set()) is False
+    assert is_currency('EUR')
+    assert not is_currency('eUr')
+    assert not is_currency('FUU')
+    assert not is_currency('')
+    assert not is_currency(None)
+    assert not is_currency('   EUR    ')
+    assert not is_currency('   ')
+    assert not is_currency([])
+    assert not is_currency(set())
 
 
 def test_normalize_currency():
@@ -451,8 +452,7 @@ def test_format_compact_currency():
 
 def test_format_compact_currency_invalid_format_type():
     with pytest.raises(numbers.UnknownCurrencyFormatError):
-        numbers.format_compact_currency(1099.98, 'USD', locale='en_US',
-                                format_type='unknown')
+        numbers.format_compact_currency(1099.98, 'USD', locale='en_US', format_type='unknown')
 
 
 @pytest.mark.parametrize('input_value, expected_value', [
diff --git a/tests/test_support.py b/tests/test_support.py
index 36bdcf665..0b7cba067 100644
--- a/tests/test_support.py
+++ b/tests/test_support.py
@@ -27,6 +27,7 @@
 
 SKIP_LGETTEXT = sys.version_info >= (3, 8)
 
+
 @pytest.mark.usefixtures("os_environ")
 class TranslationsTestCase(unittest.TestCase):
 
@@ -73,7 +74,7 @@ def test_pgettext(self):
     def test_upgettext(self):
         self.assertEqualTypeToo('Voh', self.translations.ugettext('foo'))
         self.assertEqualTypeToo('VohCTX', self.translations.upgettext('foo',
-                                                                       'foo'))
+                                                                      'foo'))
 
     @pytest.mark.skipif(SKIP_LGETTEXT, reason="lgettext is deprecated")
     def test_lpgettext(self):
@@ -156,10 +157,10 @@ def test_dunpgettext(self):
             'VohsD1', self.translations.dungettext('messages1', 'foo1', 'foos1', 2))
         self.assertEqualTypeToo(
             'VohCTXD1', self.translations.dunpgettext('messages1', 'foo', 'foo1',
-                                                       'foos1', 1))
+                                                      'foos1', 1))
         self.assertEqualTypeToo(
             'VohsCTXD1', self.translations.dunpgettext('messages1', 'foo', 'foo1',
-                                                        'foos1', 2))
+                                                       'foos1', 2))
 
     @pytest.mark.skipif(SKIP_LGETTEXT, reason="lgettext is deprecated")
     def test_ldnpgettext(self):
@@ -351,12 +352,11 @@ def greeting(name='world'):
     assert '(%s)' % lazy_greeting == '(Hello, Joe!)'
     assert f"[{lazy_greeting}]" == "[Hello, Joe!]"
 
-    greetings = [
+    greetings = sorted([
         support.LazyProxy(greeting, 'world'),
         support.LazyProxy(greeting, 'Joe'),
         support.LazyProxy(greeting, 'universe'),
-    ]
-    greetings.sort()
+    ])
     assert [str(g) for g in greetings] == [
         "Hello, Joe!",
         "Hello, universe!",
diff --git a/tests/test_util.py b/tests/test_util.py
index d21c723f3..ae861ddc0 100644
--- a/tests/test_util.py
+++ b/tests/test_util.py
@@ -22,11 +22,12 @@
 
 
 class _FF:
-    division         = __future__.division.compiler_flag
-    print_function   = __future__.print_function.compiler_flag
-    with_statement   = __future__.with_statement.compiler_flag
+    division = __future__.division.compiler_flag
+    print_function = __future__.print_function.compiler_flag
+    with_statement = __future__.with_statement.compiler_flag
     unicode_literals = __future__.unicode_literals.compiler_flag
 
+
 def test_distinct():
     assert list(util.distinct([1, 2, 1, 3, 4, 4])) == [1, 2, 3, 4]
     assert list(util.distinct('foobar')) == ['f', 'o', 'b', 'a', 'r']
@@ -48,7 +49,7 @@ def test_pathmatch():
 class FixedOffsetTimezoneTestCase(unittest.TestCase):
 
     def test_zone_negative_offset(self):
-        assert util.FixedOffsetTimezone((-60)).zone == 'Etc/GMT-60'
+        assert util.FixedOffsetTimezone(-60).zone == 'Etc/GMT-60'
 
     def test_zone_zero_offset(self):
         assert util.FixedOffsetTimezone(0).zone == 'Etc/GMT+0'

From d14f9565c03ba10d493437784db439ca260ba69d Mon Sep 17 00:00:00 2001
From: Aarni Koskela <akx@iki.fi>
Date: Wed, 18 Jan 2023 20:30:25 +0200
Subject: [PATCH 30/53] Enable E741 (ambiguous variable name) lint

---
 babel/messages/pofile.py |  6 ++---
 babel/plural.py          |  2 +-
 tests/test_core.py       | 52 ++++++++++++++++++++--------------------
 tests/test_dates.py      | 18 +++++++-------
 tests/test_localedata.py |  8 +++----
 5 files changed, 43 insertions(+), 43 deletions(-)

diff --git a/babel/messages/pofile.py b/babel/messages/pofile.py
index 88cc0430f..aef8cbf7c 100644
--- a/babel/messages/pofile.py
+++ b/babel/messages/pofile.py
@@ -451,10 +451,10 @@ def normalize(string: str, prefix: str = '', width: int = 76) -> str:
                     buf = []
                     size = 2
                     while chunks:
-                        l = len(escape(chunks[-1])) - 2 + prefixlen
-                        if size + l < width:
+                        length = len(escape(chunks[-1])) - 2 + prefixlen
+                        if size + length < width:
                             buf.append(chunks.pop())
-                            size += l
+                            size += length
                         else:
                             if not buf:
                                 # handle long chunks by putting them on a
diff --git a/babel/plural.py b/babel/plural.py
index fe1ee2553..26073ff8f 100644
--- a/babel/plural.py
+++ b/babel/plural.py
@@ -521,7 +521,7 @@ def value(self):
 
 def _binary_compiler(tmpl):
     """Compiler factory for the `_Compiler`."""
-    return lambda self, l, r: tmpl % (self.compile(l), self.compile(r))
+    return lambda self, left, right: tmpl % (self.compile(left), self.compile(right))
 
 
 def _unary_compiler(tmpl):
diff --git a/tests/test_core.py b/tests/test_core.py
index c0e0b3d94..d315018b7 100644
--- a/tests/test_core.py
+++ b/tests/test_core.py
@@ -96,36 +96,36 @@ def test_negotiate_custom_separator(self):
         assert (de_DE.language, de_DE.territory) == ('de', 'DE')
 
     def test_parse(self):
-        l = Locale.parse('de-DE', sep='-')
-        assert l.display_name == 'Deutsch (Deutschland)'
+        locale = Locale.parse('de-DE', sep='-')
+        assert locale.display_name == 'Deutsch (Deutschland)'
 
-        de_DE = Locale.parse(l)
+        de_DE = Locale.parse(locale)
         assert (de_DE.language, de_DE.territory) == ('de', 'DE')
 
     def test_parse_likely_subtags(self):
-        l = Locale.parse('zh-TW', sep='-')
-        assert l.language == 'zh'
-        assert l.territory == 'TW'
-        assert l.script == 'Hant'
-
-        l = Locale.parse('zh_CN')
-        assert l.language == 'zh'
-        assert l.territory == 'CN'
-        assert l.script == 'Hans'
-
-        l = Locale.parse('zh_SG')
-        assert l.language == 'zh'
-        assert l.territory == 'SG'
-        assert l.script == 'Hans'
-
-        l = Locale.parse('und_AT')
-        assert l.language == 'de'
-        assert l.territory == 'AT'
-
-        l = Locale.parse('und_UK')
-        assert l.language == 'en'
-        assert l.territory == 'GB'
-        assert l.script is None
+        locale = Locale.parse('zh-TW', sep='-')
+        assert locale.language == 'zh'
+        assert locale.territory == 'TW'
+        assert locale.script == 'Hant'
+
+        locale = Locale.parse('zh_CN')
+        assert locale.language == 'zh'
+        assert locale.territory == 'CN'
+        assert locale.script == 'Hans'
+
+        locale = Locale.parse('zh_SG')
+        assert locale.language == 'zh'
+        assert locale.territory == 'SG'
+        assert locale.script == 'Hans'
+
+        locale = Locale.parse('und_AT')
+        assert locale.language == 'de'
+        assert locale.territory == 'AT'
+
+        locale = Locale.parse('und_UK')
+        assert locale.language == 'en'
+        assert locale.territory == 'GB'
+        assert locale.script is None
 
     def test_get_display_name(self):
         zh_CN = Locale('zh', 'CN', script='Hans')
diff --git a/tests/test_dates.py b/tests/test_dates.py
index 2e3c880c5..0c8bd178f 100644
--- a/tests/test_dates.py
+++ b/tests/test_dates.py
@@ -216,17 +216,17 @@ def test_timezone_walltime_long(self, timezone_getter):
         assert dates.DateTimeFormat(t, locale='fr_FR')['vvvv'] == 'heure d’Europe centrale'
 
     def test_hour_formatting(self):
-        l = 'en_US'
+        locale = 'en_US'
         t = time(0, 0, 0)
-        assert dates.format_time(t, 'h a', locale=l) == '12 AM'
-        assert dates.format_time(t, 'H', locale=l) == '0'
-        assert dates.format_time(t, 'k', locale=l) == '24'
-        assert dates.format_time(t, 'K a', locale=l) == '0 AM'
+        assert dates.format_time(t, 'h a', locale=locale) == '12 AM'
+        assert dates.format_time(t, 'H', locale=locale) == '0'
+        assert dates.format_time(t, 'k', locale=locale) == '24'
+        assert dates.format_time(t, 'K a', locale=locale) == '0 AM'
         t = time(12, 0, 0)
-        assert dates.format_time(t, 'h a', locale=l) == '12 PM'
-        assert dates.format_time(t, 'H', locale=l) == '12'
-        assert dates.format_time(t, 'k', locale=l) == '12'
-        assert dates.format_time(t, 'K a', locale=l) == '0 PM'
+        assert dates.format_time(t, 'h a', locale=locale) == '12 PM'
+        assert dates.format_time(t, 'H', locale=locale) == '12'
+        assert dates.format_time(t, 'k', locale=locale) == '12'
+        assert dates.format_time(t, 'K a', locale=locale) == '0 PM'
 
 
 class FormatDateTestCase:
diff --git a/tests/test_localedata.py b/tests/test_localedata.py
index 36f3e7354..913922ee4 100644
--- a/tests/test_localedata.py
+++ b/tests/test_localedata.py
@@ -70,8 +70,8 @@ def test_merge():
 
 
 def test_locale_identification():
-    for l in localedata.locale_identifiers():
-        assert localedata.exists(l)
+    for locale in localedata.locale_identifiers():
+        assert localedata.exists(locale)
 
 
 def test_unique_ids():
@@ -84,9 +84,9 @@ def test_unique_ids():
 
 
 def test_mixedcased_locale():
-    for l in localedata.locale_identifiers():
+    for locale in localedata.locale_identifiers():
         locale_id = ''.join([
-            methodcaller(random.choice(['lower', 'upper']))(c) for c in l])
+            methodcaller(random.choice(['lower', 'upper']))(c) for c in locale])
         assert localedata.exists(locale_id)
 
 

From 3cb2496317b76f3dddd4725408082f59fc2f0ff8 Mon Sep 17 00:00:00 2001
From: Aarni Koskela <akx@iki.fi>
Date: Fri, 20 Jan 2023 16:24:51 +0200
Subject: [PATCH 31/53] Import CLDR 42

---
 scripts/download_import_cldr.py | 8 ++++----
 scripts/import_cldr.py          | 4 ++++
 2 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/scripts/download_import_cldr.py b/scripts/download_import_cldr.py
index ab455ac14..c08c7fc08 100755
--- a/scripts/download_import_cldr.py
+++ b/scripts/download_import_cldr.py
@@ -9,10 +9,10 @@
 import zipfile
 from urllib.request import urlretrieve
 
-URL = 'http://unicode.org/Public/cldr/41/cldr-common-41.0.zip'
-FILENAME = 'cldr-common-41.0.zip'
-# Via https://unicode.org/Public/cldr/41/hashes/SHASUM512
-FILESUM = 'c64f3338e292962817b043dd11e9c47f533c9b70d432f83e80654e20f4937c72b37e66a60485df43f734b1ff94ebf0452547a063076917889303c9653b4d6ce5'
+URL = 'http://unicode.org/Public/cldr/42/cldr-common-42.0.zip'
+FILENAME = 'cldr-common-42.0.zip'
+# Via https://unicode.org/Public/cldr/42/hashes/SHASUM512
+FILESUM = '315448fe6a9ac2d5a6a7fd1a27b38c5db30fed053654a803d50e3a8d06aa08ad153e8e57089fa094c561f41a54f37eecda0701b47a1813879902be71945aa38a'
 BLKSIZE = 131072
 
 
diff --git a/scripts/import_cldr.py b/scripts/import_cldr.py
index 5630ba896..5d40e818a 100755
--- a/scripts/import_cldr.py
+++ b/scripts/import_cldr.py
@@ -925,6 +925,10 @@ def parse_currency_formats(data, tree):
                         )
                     elif child.tag == 'pattern':
                         pattern_type = child.attrib.get('type')
+                        if child.attrib.get('draft') or child.attrib.get('alt'):
+                            # Skip drafts and alternates.
+                            # The `noCurrency` alternate for currencies was added in CLDR 42.
+                            continue
                         pattern = numbers.parse_pattern(str(child.text))
                         if pattern_type:
                             # This is a compact currency format, see:

From 87ba449463cf590947ecd664a5c9ad8a3881e488 Mon Sep 17 00:00:00 2001
From: Aarni Koskela <akx@iki.fi>
Date: Fri, 20 Jan 2023 16:24:59 +0200
Subject: [PATCH 32/53] Add test for #942

---
 tests/test_numbers.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/tests/test_numbers.py b/tests/test_numbers.py
index 04a186510..88df37619 100644
--- a/tests/test_numbers.py
+++ b/tests/test_numbers.py
@@ -300,6 +300,10 @@ def test_get_territory_currencies():
 
     assert numbers.get_territory_currencies('QO', date(2013, 1, 1)) == []
 
+    # Croatia uses Euro starting in January 2023; this is in CLDR 42.
+    # See https://github.com/python-babel/babel/issues/942
+    assert 'EUR' in numbers.get_territory_currencies('HR', date(2023, 1, 1))
+
 
 def test_get_decimal_symbol():
     assert numbers.get_decimal_symbol('en_US') == '.'

From d76db13414a6104019edc0dbafa82410e8d08e63 Mon Sep 17 00:00:00 2001
From: Aarni Koskela <akx@iki.fi>
Date: Fri, 20 Jan 2023 16:55:38 +0200
Subject: [PATCH 33/53] Adjust tests for CLDR 42

The space changes around English seem to be on purpose, see:

* https://unicode-org.atlassian.net/browse/CLDR-14032
* https://github.com/unicode-org/cldr/commit/a83026ab8c8fa6ed88f1047c4d0c6089f88b7e5d
---
 babel/core.py                |  4 ++--
 babel/dates.py               | 18 +++++++++---------
 babel/numbers.py             |  4 ++--
 babel/support.py             |  4 ++--
 tests/test_core.py           |  4 ++--
 tests/test_date_intervals.py |  4 ++--
 tests/test_dates.py          | 20 ++++++++++----------
 tests/test_numbers.py        | 18 +++++++++++-------
 tests/test_support.py        |  4 ++--
 9 files changed, 42 insertions(+), 38 deletions(-)

diff --git a/babel/core.py b/babel/core.py
index ce564d750..7d3191002 100644
--- a/babel/core.py
+++ b/babel/core.py
@@ -855,7 +855,7 @@ def time_formats(self) -> localedata.LocaleDataDict:
                   Babel versions.
 
         >>> Locale('en', 'US').time_formats['short']
-        <DateTimePattern u'h:mm a'>
+        <DateTimePattern u'h:mm\u202fa'>
         >>> Locale('fr', 'FR').time_formats['long']
         <DateTimePattern u'HH:mm:ss z'>
         """
@@ -869,7 +869,7 @@ def datetime_formats(self) -> localedata.LocaleDataDict:
                   Babel versions.
 
         >>> Locale('en').datetime_formats['full']
-        u"{1} 'at' {0}"
+        u'{1}, {0}'
         >>> Locale('th').datetime_formats['medium']
         u'{1} {0}'
         """
diff --git a/babel/dates.py b/babel/dates.py
index e626df5c2..ce79318d0 100644
--- a/babel/dates.py
+++ b/babel/dates.py
@@ -497,7 +497,7 @@ def get_time_format(format: _PredefinedTimeFormat = 'medium', locale: Locale | s
     format.
 
     >>> get_time_format(locale='en_US')
-    <DateTimePattern u'h:mm:ss a'>
+    <DateTimePattern u'h:mm:ss\u202fa'>
     >>> get_time_format('full', locale='de_DE')
     <DateTimePattern u'HH:mm:ss zzzz'>
 
@@ -580,14 +580,14 @@ def get_timezone_location(
 
     >>> tz = get_timezone('America/St_Johns')
     >>> print(get_timezone_location(tz, locale='de_DE'))
-    Kanada (St. John’s) Zeit
+    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) Zeit'
+    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:
@@ -823,13 +823,13 @@ def format_datetime(
     >>> from datetime import datetime
     >>> dt = datetime(2007, 4, 1, 15, 30)
     >>> format_datetime(dt, locale='en_US')
-    u'Apr 1, 2007, 3:30:00 PM'
+    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'
+    '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'
@@ -864,7 +864,7 @@ def format_time(
     >>> from datetime import datetime, time
     >>> t = time(15, 30)
     >>> format_time(t, locale='en_US')
-    u'3:30:00 PM'
+    u'3:30:00\u202fPM'
     >>> format_time(t, format='short', locale='de_DE')
     u'15:30'
 
@@ -905,7 +905,7 @@ def format_time(
     u'15:30:00 heure normale d\u2019Europe centrale'
     >>> format_time(t, format='full', tzinfo=get_timezone('US/Eastern'),
     ...             locale='en_US')
-    u'3:30:00 PM Eastern Standard Time'
+    u'3:30:00\u202fPM Eastern Standard Time'
 
     :param time: the ``time`` or ``datetime`` object; if `None`, the current
                  time in UTC is used
@@ -1137,7 +1137,7 @@ def format_interval(
     '12:12\u201316:16'
 
     >>> format_interval(time(5, 12), time(16, 16), "hm", locale="en_US")
-    '5:12 AM \u2013 4:16 PM'
+    '5:12\u202fAM\u2009–\u20094:16\u202fPM'
 
     >>> format_interval(time(16, 18), time(16, 24), "Hm", locale="it")
     '16:18\u201316:24'
@@ -1156,7 +1156,7 @@ def format_interval(
     '16:18:00\uff5e16:24:00'
 
     >>> format_interval(date(2016, 1, 15), date(2016, 1, 17), "xxx", locale="de")
-    '15.01.2016 \u2013 17.01.2016'
+    '15.01.2016\u2009–\u200917.01.2016'
 
     :param start: First instant (datetime/date/time)
     :param end: Second instant (datetime/date/time)
diff --git a/babel/numbers.py b/babel/numbers.py
index 399b70b5c..d107046c1 100644
--- a/babel/numbers.py
+++ b/babel/numbers.py
@@ -558,9 +558,9 @@ def format_currency(
     """Return formatted currency value.
 
     >>> format_currency(1099.98, 'USD', locale='en_US')
-    u'$1,099.98'
+    '$1,099.98'
     >>> format_currency(1099.98, 'USD', locale='es_CO')
-    u'US$\\xa01.099,98'
+    u'US$1.099,98'
     >>> format_currency(1099.98, 'EUR', locale='de_DE')
     u'1.099,98\\xa0\\u20ac'
 
diff --git a/babel/support.py b/babel/support.py
index 242b492bf..aa7d82726 100644
--- a/babel/support.py
+++ b/babel/support.py
@@ -83,7 +83,7 @@ def 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 AM'
+        u'Apr 1, 2007, 11:30:00\u202fAM'
         """
         return format_datetime(datetime, format, tzinfo=self.tzinfo, locale=self.locale)
 
@@ -98,7 +98,7 @@ def time(
         >>> 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 AM'
+        u'11:30:00\u202fAM'
         """
         return format_time(time, format, tzinfo=self.tzinfo, locale=self.locale)
 
diff --git a/tests/test_core.py b/tests/test_core.py
index d315018b7..2a7e605c2 100644
--- a/tests/test_core.py
+++ b/tests/test_core.py
@@ -228,11 +228,11 @@ def test_date_formats_property(self):
         assert Locale('fr', 'FR').date_formats['long'].pattern == 'd MMMM y'
 
     def test_time_formats_property(self):
-        assert Locale('en', 'US').time_formats['short'].pattern == 'h:mm a'
+        assert Locale('en', 'US').time_formats['short'].pattern == 'h:mm\u202fa'
         assert Locale('fr', 'FR').time_formats['long'].pattern == 'HH:mm:ss z'
 
     def test_datetime_formats_property(self):
-        assert Locale('en').datetime_formats['full'] == "{1} 'at' {0}"
+        assert Locale('en').datetime_formats['full'] == "{1}, {0}"
         assert Locale('th').datetime_formats['medium'] == '{1} {0}'
 
     def test_datetime_skeleton_property(self):
diff --git a/tests/test_date_intervals.py b/tests/test_date_intervals.py
index 556585488..55992b595 100644
--- a/tests/test_date_intervals.py
+++ b/tests/test_date_intervals.py
@@ -13,7 +13,7 @@ def test_format_interval_same_instant_1():
 
 
 def test_format_interval_same_instant_2():
-    assert dates.format_interval(TEST_DT, TEST_DT, "xxx", fuzzy=False, locale="fi") == "8.1.2016 klo 11.46.15"
+    assert dates.format_interval(TEST_DT, TEST_DT, "xxx", fuzzy=False, locale="fi") == "8.1.2016 11.46.15"
 
 
 def test_format_interval_same_instant_3():
@@ -40,7 +40,7 @@ def test_format_interval_in_tz(timezone_getter):
 def test_format_interval_12_hour():
     t2 = TEST_DT
     t1 = t2 - datetime.timedelta(hours=1)
-    assert dates.format_interval(t1, t2, "hm", locale="en") == "10:46 \u2013 11:46 AM"
+    assert dates.format_interval(t1, t2, "hm", locale="en") == "10:46\u2009\u2013\u200911:46\u202fAM"
 
 
 def test_format_interval_invalid_skeleton():
diff --git a/tests/test_dates.py b/tests/test_dates.py
index 0c8bd178f..7ec4dc7cd 100644
--- a/tests/test_dates.py
+++ b/tests/test_dates.py
@@ -439,7 +439,7 @@ def test_get_datetime_format():
 
 
 def test_get_time_format():
-    assert dates.get_time_format(locale='en_US').pattern == 'h:mm:ss a'
+    assert dates.get_time_format(locale='en_US').pattern == 'h:mm:ss\u202fa'
     assert (dates.get_time_format('full', locale='de_DE').pattern ==
             'HH:mm:ss zzzz')
 
@@ -460,7 +460,7 @@ def test_get_timezone_gmt(timezone_getter):
 def test_get_timezone_location(timezone_getter):
     tz = timezone_getter('America/St_Johns')
     assert (dates.get_timezone_location(tz, locale='de_DE') ==
-            "Kanada (St. John\u2019s) Zeit")
+            "Kanada (St. John\u2019s) (Ortszeit)")
     assert (dates.get_timezone_location(tz, locale='en') ==
             'Canada (St. John’s) Time')
     assert (dates.get_timezone_location(tz, locale='en', return_city=True) ==
@@ -468,11 +468,11 @@ def test_get_timezone_location(timezone_getter):
 
     tz = timezone_getter('America/Mexico_City')
     assert (dates.get_timezone_location(tz, locale='de_DE') ==
-            'Mexiko (Mexiko-Stadt) Zeit')
+            'Mexiko (Mexiko-Stadt) (Ortszeit)')
 
     tz = timezone_getter('Europe/Berlin')
     assert (dates.get_timezone_location(tz, locale='de_DE') ==
-            'Deutschland (Berlin) Zeit')
+            'Deutschland (Berlin) (Ortszeit)')
 
 
 @pytest.mark.parametrize(
@@ -564,7 +564,7 @@ def test_format_date():
 def test_format_datetime(timezone_getter):
     dt = datetime(2007, 4, 1, 15, 30)
     assert (dates.format_datetime(dt, locale='en_US') ==
-            'Apr 1, 2007, 3:30:00 PM')
+            'Apr 1, 2007, 3:30:00\u202fPM')
 
     full = dates.format_datetime(
         dt, 'full',
@@ -572,8 +572,8 @@ def test_format_datetime(timezone_getter):
         locale='fr_FR'
     )
     assert full == (
-        'dimanche 1 avril 2007 à 17:30:00 heure '
-        'd\u2019\xe9t\xe9 d\u2019Europe centrale'
+        'dimanche 1 avril 2007, 17:30:00 heure '
+        'd’été d’Europe centrale'
     )
     custom = dates.format_datetime(
         dt, "yyyy.MM.dd G 'at' HH:mm:ss zzz",
@@ -585,7 +585,7 @@ def test_format_datetime(timezone_getter):
 
 def test_format_time(timezone_getter):
     t = time(15, 30)
-    assert dates.format_time(t, locale='en_US') == '3:30:00 PM'
+    assert dates.format_time(t, locale='en_US') == '3:30:00\u202fPM'
     assert dates.format_time(t, format='short', locale='de_DE') == '15:30'
 
     assert (dates.format_time(t, "hh 'o''clock' a", locale='en') ==
@@ -606,7 +606,7 @@ def test_format_time(timezone_getter):
     assert paris == '15:30:00 heure normale d’Europe centrale'
 
     us_east = dates.format_time(t, format='full', tzinfo=eastern, locale='en_US')
-    assert us_east == '3:30:00 PM Eastern Standard Time'
+    assert us_east == '3:30:00\u202fPM Eastern Standard Time'
 
 
 def test_format_skeleton(timezone_getter):
@@ -720,7 +720,7 @@ def test_no_inherit_metazone_formatting(timezone_getter):
     # See: https://github.com/python-babel/babel/issues/428
     tz = timezone_getter('America/Los_Angeles')
     t = _localize(tz, datetime(2016, 1, 6, 7))
-    assert dates.format_time(t, format='long', locale='en_US') == "7:00:00 AM PST"
+    assert dates.format_time(t, format='long', locale='en_US') == "7:00:00\u202fAM PST"
     assert dates.format_time(t, format='long', locale='en_GB') == "07:00:00 Pacific Standard Time"
     assert dates.get_timezone_name(t, width='short', locale='en_US') == "PST"
     assert dates.get_timezone_name(t, width='short', locale='en_GB') == "Pacific Standard Time"
diff --git a/tests/test_numbers.py b/tests/test_numbers.py
index 88df37619..c8a04d696 100644
--- a/tests/test_numbers.py
+++ b/tests/test_numbers.py
@@ -388,7 +388,7 @@ def test_format_currency():
     assert (numbers.format_currency(0, 'USD', locale='en_US')
             == '$0.00')
     assert (numbers.format_currency(1099.98, 'USD', locale='es_CO')
-            == 'US$\xa01.099,98')
+            == 'US$1.099,98')
     assert (numbers.format_currency(1099.98, 'EUR', locale='de_DE')
             == '1.099,98\xa0\u20ac')
     assert (numbers.format_currency(1099.98, 'EUR', '\xa4\xa4 #,##0.00',
@@ -400,11 +400,11 @@ def test_format_currency():
                                     locale='en_US')
             == '$1,099.98')
     assert (numbers.format_currency(1, 'USD', locale='es_AR')
-            == 'US$\xa01,00')          # one
+            == 'US$1,00')          # one
     assert (numbers.format_currency(1000000, 'USD', locale='es_AR')
-            == 'US$\xa01.000.000,00')  # many
+            == 'US$1.000.000,00')  # many
     assert (numbers.format_currency(0, 'USD', locale='es_AR')
-            == 'US$\xa00,00')          # other
+            == 'US$0,00')          # other
 
 
 def test_format_currency_format_type():
@@ -449,8 +449,8 @@ def test_format_compact_currency():
     assert numbers.format_compact_currency(1234, 'JPY', locale='ja_JP', format_type="short") == '￥1234'
     assert numbers.format_compact_currency(123456, 'JPY', locale='ja_JP', format_type="short") == '￥12万'
     assert numbers.format_compact_currency(123456, 'JPY', locale='ja_JP', format_type="short", fraction_digits=2) == '￥12.35万'
-    assert numbers.format_compact_currency(123, 'EUR', locale='yav', format_type="short") == '123\xa0€'
-    assert numbers.format_compact_currency(12345, 'EUR', locale='yav', format_type="short") == '12K\xa0€'
+    assert numbers.format_compact_currency(123, 'EUR', locale='yav', format_type="short") == '€\xa0123'
+    assert numbers.format_compact_currency(12345, 'EUR', locale='yav', format_type="short") == '€\xa012K'
     assert numbers.format_compact_currency(123456789, 'EUR', locale='de_DE', fraction_digits=1) == '123,5\xa0Mio.\xa0€'
 
 
@@ -484,7 +484,11 @@ def test_format_compact_currency_invalid_format_type():
 def test_format_currency_precision(input_value, expected_value):
     # Test precision conservation.
     assert numbers.format_currency(
-        decimal.Decimal(input_value), 'USD', locale='en_US', decimal_quantization=False) == expected_value
+        decimal.Decimal(input_value),
+        currency='USD',
+        locale='en_US',
+        decimal_quantization=False,
+    ) == expected_value
 
 
 def test_format_currency_quantization():
diff --git a/tests/test_support.py b/tests/test_support.py
index 0b7cba067..a47113775 100644
--- a/tests/test_support.py
+++ b/tests/test_support.py
@@ -304,12 +304,12 @@ def test_format_date():
 def test_format_datetime(timezone_getter):
     fmt = support.Format('en_US', tzinfo=timezone_getter('US/Eastern'))
     when = datetime(2007, 4, 1, 15, 30)
-    assert fmt.datetime(when) == 'Apr 1, 2007, 11:30:00 AM'
+    assert fmt.datetime(when) == 'Apr 1, 2007, 11:30:00\u202fAM'
 
 
 def test_format_time(timezone_getter):
     fmt = support.Format('en_US', tzinfo=timezone_getter('US/Eastern'))
-    assert fmt.time(datetime(2007, 4, 1, 15, 30)) == '11:30:00 AM'
+    assert fmt.time(datetime(2007, 4, 1, 15, 30)) == '11:30:00\u202fAM'
 
 
 def test_format_timedelta():

From 61be9dc5d6c9ed7d1fb9116ae81a205a5fbee473 Mon Sep 17 00:00:00 2001
From: Jonah Lawrence <jonah@freshidea.com>
Date: Fri, 20 Jan 2023 09:41:39 -0700
Subject: [PATCH 34/53] Update test dependencies (tox v4) (#953)

---
 .github/workflows/test.yml |  4 ++--
 tox.ini                    | 16 ++++++++--------
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 1e8986179..c584fd983 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -40,11 +40,11 @@ jobs:
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip setuptools wheel
-        python -m pip install 'tox<4.0.0' 'tox-gh-actions==2.12.0'
+        python -m pip install 'tox~=4.0' 'tox-gh~=1.0'
     - name: Run test via Tox
       run: tox --skip-missing-interpreters
       env:
         COVERAGE_XML_PATH: ${{ runner.temp }}
-    - uses: codecov/codecov-action@v2
+    - uses: codecov/codecov-action@v3
       with:
         directory: ${{ runner.temp }}
diff --git a/tox.ini b/tox.ini
index 8b640015d..551d20115 100644
--- a/tox.ini
+++ b/tox.ini
@@ -10,7 +10,7 @@ deps =
     freezegun==0.3.12
     backports.zoneinfo;python_version<"3.9"
     tzdata;sys_platform == 'win32'
-whitelist_externals = make
+allowlist_externals = make
 commands = make clean-cldr test
 setenv =
     PYTEST_FLAGS=--cov=babel --cov-report=xml:{env:COVERAGE_XML_PATH:.coverage_cache}/coverage.{envname}.xml
@@ -19,11 +19,11 @@ passenv =
     PYTEST_*
     PYTHON_*
 
-[gh-actions]
+[gh]
 python =
-    pypy3: pypy3
-    3.7: py37
-    3.8: py38
-    3.9: py39
-    3.10: py310
-    3.11: py311
+    pypy3 = pypy3
+    3.7 = py37
+    3.8 = py38
+    3.9 = py39
+    3.10 = py310
+    3.11 = py311

From 2a4b78446f6553957d6181b9baad3ba2ecf4a2cc Mon Sep 17 00:00:00 2001
From: Aarni Koskela <akx@iki.fi>
Date: Fri, 20 Jan 2023 18:53:47 +0200
Subject: [PATCH 35/53] Remove redundant tests for babel.support (#954)

The doctests test the exact same things.
---
 babel/support.py      |  5 +++++
 tests/test_support.py | 42 ++++--------------------------------------
 2 files changed, 9 insertions(+), 38 deletions(-)

diff --git a/babel/support.py b/babel/support.py
index aa7d82726..c1851cf29 100644
--- a/babel/support.py
+++ b/babel/support.py
@@ -151,6 +151,8 @@ def compact_decimal(
         >>> 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,
@@ -170,6 +172,9 @@ def compact_currency(
     ) -> 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)
diff --git a/tests/test_support.py b/tests/test_support.py
index a47113775..7c0235ca6 100644
--- a/tests/test_support.py
+++ b/tests/test_support.py
@@ -10,13 +10,13 @@
 # individuals. For the exact contribution history, see the revision
 # history and logs, available at http://babel.edgewall.org/log/.
 
+import datetime
 import inspect
 import os
 import shutil
 import sys
 import tempfile
 import unittest
-from datetime import date, datetime, timedelta
 from io import BytesIO
 
 import pytest
@@ -296,50 +296,16 @@ def raise_attribute_error():
         assert str(exception.value) == 'message'
 
 
-def test_format_date():
-    fmt = support.Format('en_US')
-    assert fmt.date(date(2007, 4, 1)) == 'Apr 1, 2007'
-
+WHEN = datetime.datetime(2007, 4, 1, 15, 30)
 
 def test_format_datetime(timezone_getter):
     fmt = support.Format('en_US', tzinfo=timezone_getter('US/Eastern'))
-    when = datetime(2007, 4, 1, 15, 30)
-    assert fmt.datetime(when) == 'Apr 1, 2007, 11:30:00\u202fAM'
+    assert fmt.datetime(WHEN) == 'Apr 1, 2007, 11:30:00\u202fAM'
 
 
 def test_format_time(timezone_getter):
     fmt = support.Format('en_US', tzinfo=timezone_getter('US/Eastern'))
-    assert fmt.time(datetime(2007, 4, 1, 15, 30)) == '11:30:00\u202fAM'
-
-
-def test_format_timedelta():
-    fmt = support.Format('en_US')
-    assert fmt.timedelta(timedelta(weeks=11)) == '3 months'
-
-
-def test_format_number():
-    fmt = support.Format('en_US')
-    assert fmt.number(1099) == '1,099'
-
-
-def test_format_decimal():
-    fmt = support.Format('en_US')
-    assert fmt.decimal(1.2345) == '1.234'
-
-
-def test_format_compact_decimal():
-    fmt = support.Format('en_US')
-    assert fmt.compact_decimal(1234567, format_type='long', fraction_digits=2) == '1.23 million'
-
-
-def test_format_compact_currency():
-    fmt = support.Format('en_US')
-    assert fmt.compact_currency(1234567, "USD", format_type='short', fraction_digits=2) == '$1.23M'
-
-
-def test_format_percent():
-    fmt = support.Format('en_US')
-    assert fmt.percent(0.34) == '34%'
+    assert fmt.time(WHEN) == '11:30:00\u202fAM'
 
 
 def test_lazy_proxy():

From 79bcdf2640b400a56577d93e7fde026290c7a04c Mon Sep 17 00:00:00 2001
From: Jonah Lawrence <jonah@freshidea.com>
Date: Wed, 25 Jan 2023 11:17:24 -0700
Subject: [PATCH 36/53] Support for formatting NaN, Infinity (#955)

---
 babel/numbers.py      | 24 ++++++++++++++++++++++--
 tests/test_numbers.py | 10 ++++++++++
 2 files changed, 32 insertions(+), 2 deletions(-)

diff --git a/babel/numbers.py b/babel/numbers.py
index d107046c1..ee9a133b8 100644
--- a/babel/numbers.py
+++ b/babel/numbers.py
@@ -126,7 +126,10 @@ def get_currency_name(
     """
     loc = Locale.parse(locale)
     if count is not None:
-        plural_form = loc.plural_form(count)
+        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]
@@ -371,6 +374,17 @@ def get_group_symbol(locale: Locale | str | None = LC_NUMERIC) -> str:
     return Locale.parse(locale).number_symbols.get('group', ',')
 
 
+def get_infinity_symbol(locale: Locale | str | None = LC_NUMERIC) -> str:
+    """Return the symbol used by the locale to represent infinity.
+
+    >>> get_infinity_symbol('en_US')
+    u'∞'
+
+    :param locale: the `Locale` object or locale identifier
+    """
+    return Locale.parse(locale).number_symbols.get('infinity', '∞')
+
+
 def format_number(number: float | decimal.Decimal | str, locale: Locale | str | None = LC_NUMERIC) -> str:
     """Return the given number formatted for a specific locale.
 
@@ -400,7 +414,8 @@ def get_decimal_precision(number: decimal.Decimal) -> int:
     # Copied from: https://github.com/mahmoud/boltons/pull/59
     assert isinstance(number, decimal.Decimal)
     decimal_tuple = number.normalize().as_tuple()
-    if decimal_tuple.exponent >= 0:
+    # 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)
 
@@ -515,6 +530,8 @@ def _get_compact_format(
     """
     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:
@@ -1287,6 +1304,9 @@ def _format_int(self, value: str, min: int, max: int, locale: Locale | str | Non
         return value + ret
 
     def _quantize_value(self, value: decimal.Decimal, locale: Locale | str | None, frac_prec: tuple[int, int], group_separator: bool) -> str:
+        # If the number is +/-Infinity, we can't quantize it
+        if value.is_infinite():
+            return get_infinity_symbol(locale)
         quantum = get_decimal_quantum(frac_prec[1])
         rounded = value.quantize(quantum)
         a, sep, b = f"{rounded:f}".partition(".")
diff --git a/tests/test_numbers.py b/tests/test_numbers.py
index c8a04d696..d6028b351 100644
--- a/tests/test_numbers.py
+++ b/tests/test_numbers.py
@@ -111,6 +111,16 @@ def test_formatting_of_very_small_decimals(self):
         number = decimal.Decimal("7E-7")
         assert numbers.format_decimal(number, format="@@@", locale='en_US') == '0.000000700'
 
+    def test_nan_and_infinity(self):
+        assert numbers.format_decimal(decimal.Decimal('Infinity'), locale='en_US') == '∞'
+        assert numbers.format_decimal(decimal.Decimal('-Infinity'), locale='en_US') == '-∞'
+        assert numbers.format_decimal(decimal.Decimal('NaN'), locale='en_US') == 'NaN'
+        assert numbers.format_compact_decimal(decimal.Decimal('Infinity'), locale='en_US', format_type="short") == '∞'
+        assert numbers.format_compact_decimal(decimal.Decimal('-Infinity'), locale='en_US', format_type="short") == '-∞'
+        assert numbers.format_compact_decimal(decimal.Decimal('NaN'), locale='en_US', format_type="short") == 'NaN'
+        assert numbers.format_currency(decimal.Decimal('Infinity'), 'USD', locale='en_US') == '$∞'
+        assert numbers.format_currency(decimal.Decimal('-Infinity'), 'USD', locale='en_US') == '-$∞'
+
     def test_group_separator(self):
         assert numbers.format_decimal(29567.12, locale='en_US', group_separator=False) == '29567.12'
         assert numbers.format_decimal(29567.12, locale='fr_CA', group_separator=False) == '29567,12'

From 2c1875e57415974a76fbe022c16b7893576d185b Mon Sep 17 00:00:00 2001
From: Aarni Koskela <akx@iki.fi>
Date: Wed, 25 Jan 2023 20:37:51 +0200
Subject: [PATCH 37/53] Clean up babel.localtime (#952)

* Remove vestigial babel.localtime cache bits
* Give _FallbackLocalTimezone its own module
---
 babel/localtime/__init__.py  | 48 +++++++-----------------------------
 babel/localtime/_fallback.py | 47 +++++++++++++++++++++++++++++++++++
 babel/util.py                |  2 +-
 3 files changed, 57 insertions(+), 40 deletions(-)
 create mode 100644 babel/localtime/_fallback.py

diff --git a/babel/localtime/__init__.py b/babel/localtime/__init__.py
index 1d65fb207..29577fa37 100644
--- a/babel/localtime/__init__.py
+++ b/babel/localtime/__init__.py
@@ -11,8 +11,6 @@
 
 import datetime
 import sys
-import time
-from threading import RLock
 
 if sys.platform == 'win32':
     from babel.localtime._win32 import _get_localzone
@@ -20,43 +18,15 @@
     from babel.localtime._unix import _get_localzone
 
 
-_cached_tz = None
-_cache_lock = RLock()
-
-STDOFFSET = datetime.timedelta(seconds=-time.timezone)
-if time.daylight:
-    DSTOFFSET = datetime.timedelta(seconds=-time.altzone)
-else:
-    DSTOFFSET = STDOFFSET
-
-DSTDIFF = DSTOFFSET - STDOFFSET
-ZERO = datetime.timedelta(0)
-
-
-class _FallbackLocalTimezone(datetime.tzinfo):
-
-    def utcoffset(self, dt: datetime.datetime) -> datetime.timedelta:
-        if self._isdst(dt):
-            return DSTOFFSET
-        else:
-            return STDOFFSET
-
-    def dst(self, dt: datetime.datetime) -> datetime.timedelta:
-        if self._isdst(dt):
-            return DSTDIFF
-        else:
-            return ZERO
-
-    def tzname(self, dt: datetime.datetime) -> str:
-        return time.tzname[self._isdst(dt)]
-
-    def _isdst(self, dt: datetime.datetime) -> bool:
-        tt = (dt.year, dt.month, dt.day,
-              dt.hour, dt.minute, dt.second,
-              dt.weekday(), 0, -1)
-        stamp = time.mktime(tt)
-        tt = time.localtime(stamp)
-        return tt.tm_isdst > 0
+# TODO(3.0): the offset constants are not part of the public API
+#            and should be removed
+from babel.localtime._fallback import (
+    DSTDIFF,  # noqa: F401
+    DSTOFFSET,  # noqa: F401
+    STDOFFSET,  # noqa: F401
+    ZERO,  # noqa: F401
+    _FallbackLocalTimezone,
+)
 
 
 def get_localzone() -> datetime.tzinfo:
diff --git a/babel/localtime/_fallback.py b/babel/localtime/_fallback.py
new file mode 100644
index 000000000..836f5962c
--- /dev/null
+++ b/babel/localtime/_fallback.py
@@ -0,0 +1,47 @@
+"""
+    babel.localtime._fallback
+    ~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    Emulated fallback local timezone when all else fails.
+
+    :copyright: (c) 2013-2023 by the Babel Team.
+    :license: BSD, see LICENSE for more details.
+"""
+
+import datetime
+import time
+
+STDOFFSET = datetime.timedelta(seconds=-time.timezone)
+if time.daylight:
+    DSTOFFSET = datetime.timedelta(seconds=-time.altzone)
+else:
+    DSTOFFSET = STDOFFSET
+
+DSTDIFF = DSTOFFSET - STDOFFSET
+ZERO = datetime.timedelta(0)
+
+
+class _FallbackLocalTimezone(datetime.tzinfo):
+
+    def utcoffset(self, dt: datetime.datetime) -> datetime.timedelta:
+        if self._isdst(dt):
+            return DSTOFFSET
+        else:
+            return STDOFFSET
+
+    def dst(self, dt: datetime.datetime) -> datetime.timedelta:
+        if self._isdst(dt):
+            return DSTDIFF
+        else:
+            return ZERO
+
+    def tzname(self, dt: datetime.datetime) -> str:
+        return time.tzname[self._isdst(dt)]
+
+    def _isdst(self, dt: datetime.datetime) -> bool:
+        tt = (dt.year, dt.month, dt.day,
+              dt.hour, dt.minute, dt.second,
+              dt.weekday(), 0, -1)
+        stamp = time.mktime(tt)
+        tt = time.localtime(stamp)
+        return tt.tm_isdst > 0
diff --git a/babel/util.py b/babel/util.py
index a5403e653..100e37dd1 100644
--- a/babel/util.py
+++ b/babel/util.py
@@ -255,10 +255,10 @@ def dst(self, dt: datetime.datetime) -> datetime.timedelta:
 
 # 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

From 50e1857b3b4469f9dc652849bf2fa053739bcf61 Mon Sep 17 00:00:00 2001
From: Aarni Koskela <akx@iki.fi>
Date: Wed, 25 Jan 2023 21:43:16 +0200
Subject: [PATCH 38/53] Use standard library UTC (#957)

---
 babel/dates.py | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/babel/dates.py b/babel/dates.py
index ce79318d0..83ce72862 100644
--- a/babel/dates.py
+++ b/babel/dates.py
@@ -51,11 +51,7 @@
 
 NO_INHERITANCE_MARKER = '\u2205\u2205\u2205'
 
-
-if pytz:
-    UTC = pytz.utc
-else:
-    UTC = zoneinfo.ZoneInfo('UTC')
+UTC = datetime.timezone.utc
 LOCALTZ = localtime.LOCALTZ
 
 LC_TIME = default_locale('LC_TIME')

From a87422fe5e01c6292c9bd0fd35832f789872213c Mon Sep 17 00:00:00 2001
From: Aarni Koskela <akx@iki.fi>
Date: Wed, 25 Jan 2023 21:44:22 +0200
Subject: [PATCH 39/53] Fix unbound `exc` in babel.dates (#959)

See https://stackoverflow.com/a/24271786/51685
---
 babel/dates.py | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/babel/dates.py b/babel/dates.py
index 83ce72862..e1e581a30 100644
--- a/babel/dates.py
+++ b/babel/dates.py
@@ -239,18 +239,17 @@ def get_timezone(zone: str | datetime.tzinfo | None = None) -> datetime.tzinfo:
     if not isinstance(zone, str):
         return zone
 
-    exc = None
     if pytz:
         try:
             return pytz.timezone(zone)
-        except pytz.UnknownTimeZoneError as exc:  # noqa: F841
-            pass
+        except pytz.UnknownTimeZoneError as e:
+            exc = e
     else:
         assert zoneinfo
         try:
             return zoneinfo.ZoneInfo(zone)
-        except zoneinfo.ZoneInfoNotFoundError as exc:  # noqa: F841
-            pass
+        except zoneinfo.ZoneInfoNotFoundError as e:
+            exc = e
 
     raise LookupError(f"Unknown timezone {zone}") from exc
 

From b3d33811ece8d3a3de2ffa8ad7f134b94c96d95d Mon Sep 17 00:00:00 2001
From: Aarni Koskela <akx@iki.fi>
Date: Wed, 25 Jan 2023 21:46:40 +0200
Subject: [PATCH 40/53] Finally remove get_next_timezone_transition (#958)

---
 babel/dates.py     | 116 ---------------------------------------------
 docs/api/dates.rst |   2 -
 docs/dates.rst     |  23 +--------
 3 files changed, 1 insertion(+), 140 deletions(-)

diff --git a/babel/dates.py b/babel/dates.py
index e1e581a30..0c8abd6cb 100644
--- a/babel/dates.py
+++ b/babel/dates.py
@@ -28,7 +28,6 @@
     import zoneinfo
 
 import datetime
-from bisect import bisect_right
 from collections.abc import Iterable
 
 from babel import localtime
@@ -254,121 +253,6 @@ def get_timezone(zone: str | datetime.tzinfo | None = None) -> datetime.tzinfo:
     raise LookupError(f"Unknown timezone {zone}") from exc
 
 
-def get_next_timezone_transition(zone: datetime.tzinfo | None = None, dt: _Instant = None) -> TimezoneTransition:
-    """Given a timezone it will return a :class:`TimezoneTransition` object
-    that holds the information about the next timezone transition that's going
-    to happen.  For instance this can be used to detect when the next DST
-    change is going to happen and how it looks like.
-
-    The transition is calculated relative to the given datetime object.  The
-    next transition that follows the date is used.  If a transition cannot
-    be found the return value will be `None`.
-
-    Transition information can only be provided for timezones returned by
-    the :func:`get_timezone` function.
-
-    This function is pending deprecation with no replacement planned in the
-    Babel library.
-
-    :param zone: the timezone for which the transition should be looked up.
-                 If not provided the local timezone is used.
-    :param dt: the date after which the next transition should be found.
-               If not given the current time is assumed.
-    """
-    warnings.warn(
-        "get_next_timezone_transition() is deprecated and will be "
-        "removed in the next version of Babel. "
-        "Please see https://github.com/python-babel/babel/issues/716 "
-        "for discussion.",
-        category=DeprecationWarning,
-    )
-    zone = get_timezone(zone)
-    dt = _get_datetime(dt).replace(tzinfo=None)
-
-    if not hasattr(zone, '_utc_transition_times'):
-        raise TypeError('Given timezone does not have UTC transition '
-                        'times.  This can happen because the operating '
-                        'system fallback local timezone is used or a '
-                        'custom timezone object')
-
-    try:
-        idx = max(0, bisect_right(zone._utc_transition_times, dt))
-        old_trans = zone._transition_info[idx - 1]
-        new_trans = zone._transition_info[idx]
-        old_tz = zone._tzinfos[old_trans]
-        new_tz = zone._tzinfos[new_trans]
-    except (LookupError, ValueError):
-        return None
-
-    return TimezoneTransition(
-        activates=zone._utc_transition_times[idx],
-        from_tzinfo=old_tz,
-        to_tzinfo=new_tz,
-        reference_date=dt
-    )
-
-
-class TimezoneTransition:
-    """A helper object that represents the return value from
-    :func:`get_next_timezone_transition`.
-
-    This class is pending deprecation with no replacement planned in the
-    Babel library.
-
-    :field activates:
-        The time of the activation of the timezone transition in UTC.
-    :field from_tzinfo:
-        The timezone from where the transition starts.
-    :field to_tzinfo:
-        The timezone for after the transition.
-    :field reference_date:
-        The reference date that was provided.  This is the `dt` parameter
-        to the :func:`get_next_timezone_transition`.
-    """
-
-    def __init__(
-        self,
-        activates: datetime.datetime,
-        from_tzinfo: datetime.tzinfo,
-        to_tzinfo: datetime.tzinfo,
-        reference_date: datetime.datetime | None = None,
-    ) -> None:
-        warnings.warn(
-            "TimezoneTransition is deprecated and will be "
-            "removed in the next version of Babel. "
-            "Please see https://github.com/python-babel/babel/issues/716 "
-            "for discussion.",
-            category=DeprecationWarning,
-        )
-        self.activates = activates
-        self.from_tzinfo = from_tzinfo
-        self.to_tzinfo = to_tzinfo
-        self.reference_date = reference_date
-
-    @property
-    def from_tz(self) -> str:
-        """The name of the timezone before the transition."""
-        return self.from_tzinfo._tzname
-
-    @property
-    def to_tz(self) -> str:
-        """The name of the timezone after the transition."""
-        return self.to_tzinfo._tzname
-
-    @property
-    def from_offset(self) -> int:
-        """The UTC offset in seconds before the transition."""
-        return int(self.from_tzinfo._utcoffset.total_seconds())
-
-    @property
-    def to_offset(self) -> int:
-        """The UTC offset in seconds after the transition."""
-        return int(self.to_tzinfo._utcoffset.total_seconds())
-
-    def __repr__(self) -> str:
-        return f"<TimezoneTransition {self.from_tz} -> {self.to_tz} ({self.activates})>"
-
-
 def get_period_names(width: Literal['abbreviated', 'narrow', 'wide'] = 'wide',
                      context: _Context = 'stand-alone', locale: Locale | str | None = LC_TIME) -> LocaleDataDict:
     """Return the names for day periods (AM/PM) used by the locale.
diff --git a/docs/api/dates.rst b/docs/api/dates.rst
index 55ea2b16c..cbdac593b 100644
--- a/docs/api/dates.rst
+++ b/docs/api/dates.rst
@@ -32,8 +32,6 @@ Timezone Functionality
 
 .. autofunction:: get_timezone_name
 
-.. autofunction:: get_next_timezone_transition
-
 .. data:: UTC
 
     A timezone object for UTC.
diff --git a/docs/dates.rst b/docs/dates.rst
index 8b3509115..1827a9a20 100644
--- a/docs/dates.rst
+++ b/docs/dates.rst
@@ -308,28 +308,7 @@ applied to ``format_time``, but because the actual date is unknown in that
 case, the current day is assumed to determine whether DST or standard time
 should be used.
 
-For many timezones it's also possible to ask for the next timezone
-transition.  This for instance is useful to answer the question “when do I
-have to move the clock forward next”:
-
-.. warning:: ``get_next_timezone_transition`` is deprecated and will be removed
-             in the next version of Babel
-
-.. code-block:: pycon
-
-    >>> t = get_next_timezone_transition('Europe/Vienna', datetime(2011, 3, 2))
-    >>> t
-    <TimezoneTransition CET -> CEST (2011-03-27 01:00:00)>
-    >>> t.from_offset
-    3600.0
-    >>> t.to_offset
-    7200.0
-    >>> t.from_tz
-    'CET'
-    >>> t.to_tz
-    'CEST'
-
-Lastly Babel also provides support for working with the local timezone of
+Babel also provides support for working with the local timezone of
 your operating system.  It's provided through the ``LOCALTZ`` constant:
 
 .. code-block:: pycon

From 28ea5feebed2f83262d6240354900b07d2633bce Mon Sep 17 00:00:00 2001
From: Aarni Koskela <akx@iki.fi>
Date: Wed, 25 Jan 2023 21:51:37 +0200
Subject: [PATCH 41/53] Apply some simplification fixes courtesy of Ruff

---
 babel/core.py                | 14 +++++------
 babel/dates.py               | 49 +++++++++++++-----------------------
 babel/localedata.py          |  5 +---
 babel/localtime/_fallback.py |  5 +---
 babel/messages/extract.py    | 10 ++------
 babel/messages/frontend.py   |  5 +---
 babel/messages/pofile.py     | 10 ++------
 babel/numbers.py             | 11 +++-----
 babel/plural.py              |  2 +-
 babel/support.py             |  5 +---
 10 files changed, 36 insertions(+), 80 deletions(-)

diff --git a/babel/core.py b/babel/core.py
index 7d3191002..6b0c45d77 100644
--- a/babel/core.py
+++ b/babel/core.py
@@ -1175,9 +1175,8 @@ def parse_locale(identifier: str, sep: str = '_') -> tuple[str, str | None, str
         raise ValueError(f"expected only letters, got {lang!r}")
 
     script = territory = variant = None
-    if parts:
-        if len(parts[0]) == 4 and parts[0].isalpha():
-            script = parts.pop(0).title()
+    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():
@@ -1185,10 +1184,11 @@ def parse_locale(identifier: str, sep: str = '_') -> tuple[str, str | None, str
         elif len(parts[0]) == 3 and parts[0].isdigit():
             territory = parts.pop(0)
 
-    if parts:
-        if 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 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")
diff --git a/babel/dates.py b/babel/dates.py
index 0c8abd6cb..ce439eecd 100644
--- a/babel/dates.py
+++ b/babel/dates.py
@@ -92,10 +92,7 @@ def _get_dt_and_tzinfo(dt_or_tzinfo: _DtOrTzinfo) -> tuple[datetime.datetime | N
         tzinfo = UTC
     elif isinstance(dt_or_tzinfo, (datetime.datetime, datetime.time)):
         dt = _get_datetime(dt_or_tzinfo)
-        if dt.tzinfo is not None:
-            tzinfo = dt.tzinfo
-        else:
-            tzinfo = UTC
+        tzinfo = dt.tzinfo if dt.tzinfo is not None else UTC
     else:
         dt = None
         tzinfo = dt_or_tzinfo
@@ -150,7 +147,7 @@ def _get_datetime(instant: _Instant) -> datetime.datetime:
     """
     if instant is None:
         return datetime.datetime.utcnow()
-    elif isinstance(instant, int) or isinstance(instant, float):
+    elif isinstance(instant, (int, float)):
         return datetime.datetime.utcfromtimestamp(instant)
     elif isinstance(instant, datetime.time):
         return datetime.datetime.combine(datetime.date.today(), instant)
@@ -615,10 +612,7 @@ def get_timezone_name(
             zone_variant = 'generic'
         else:
             dst = tzinfo.dst(dt)
-            if dst:
-                zone_variant = 'daylight'
-            else:
-                zone_variant = 'standard'
+            zone_variant = "daylight" if dst else "standard"
     else:
         if zone_variant not in ('generic', 'standard', 'daylight'):
             raise ValueError('Invalid zone variation')
@@ -629,9 +623,8 @@ def get_timezone_name(
         return zone
     info = locale.time_zones.get(zone, {})
     # Try explicitly translated zone names first
-    if width in info:
-        if zone_variant in info[width]:
-            return info[width][zone_variant]
+    if width in info and zone_variant in info[width]:
+        return info[width][zone_variant]
 
     metazone = get_global('meta_zones').get(zone)
     if metazone:
@@ -1088,15 +1081,14 @@ def format_interval(
     # > single date using availableFormats, and return.
 
     for field in PATTERN_CHAR_ORDER:  # These are in largest-to-smallest order
-        if field in skel_formats:
-            if 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))
-                )
+        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.
 
@@ -1235,10 +1227,7 @@ def parse_date(
     #        names, both in the requested locale, and english
 
     year = numbers[indexes['Y']]
-    if len(year) == 2:
-        year = 2000 + int(year)
-    else:
-        year = int(year)
+    year = 2000 + int(year) if len(year) == 2 else int(year)
     month = int(numbers[indexes['M']])
     day = int(numbers[indexes['D']])
     if month > 12:
@@ -1285,9 +1274,8 @@ def parse_time(
     # 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:
-        if 'pm' in string.lower():
-            hour_offset = 12
+    if 'a' in format_str and 'pm' in string.lower():
+        hour_offset = 12
 
     # Parse up to three numbers from the string.
     minute = second = 0
@@ -1490,10 +1478,7 @@ def format_weekday(self, char: str = 'E', num: int = 4) -> str:
             num = 3
         weekday = self.value.weekday()
         width = {3: 'abbreviated', 4: 'wide', 5: 'narrow', 6: 'short'}[num]
-        if char == 'c':
-            context = 'stand-alone'
-        else:
-            context = 'format'
+        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:
diff --git a/babel/localedata.py b/babel/localedata.py
index c14391aa7..f765a1ea3 100644
--- a/babel/localedata.py
+++ b/babel/localedata.py
@@ -136,10 +136,7 @@ def load(name: os.PathLike[str] | str, merge_inherited: bool = True) -> dict[str
                 parent = get_global('parent_exceptions').get(name)
                 if not parent:
                     parts = name.split('_')
-                    if len(parts) == 1:
-                        parent = 'root'
-                    else:
-                        parent = '_'.join(parts[:-1])
+                    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:
diff --git a/babel/localtime/_fallback.py b/babel/localtime/_fallback.py
index 836f5962c..14979a53b 100644
--- a/babel/localtime/_fallback.py
+++ b/babel/localtime/_fallback.py
@@ -12,10 +12,7 @@
 import time
 
 STDOFFSET = datetime.timedelta(seconds=-time.timezone)
-if time.daylight:
-    DSTOFFSET = datetime.timedelta(seconds=-time.altzone)
-else:
-    DSTOFFSET = STDOFFSET
+DSTOFFSET = datetime.timedelta(seconds=-time.altzone) if time.daylight else STDOFFSET
 
 DSTDIFF = DSTOFFSET - STDOFFSET
 ZERO = datetime.timedelta(0)
diff --git a/babel/messages/extract.py b/babel/messages/extract.py
index 453742ed0..39e26a9c7 100644
--- a/babel/messages/extract.py
+++ b/babel/messages/extract.py
@@ -400,10 +400,7 @@ def extract(
                    options=options or {})
 
     for lineno, funcname, messages, comments in results:
-        if funcname:
-            spec = keywords[funcname] or (1,)
-        else:
-            spec = (1,)
+        spec = keywords[funcname] or (1,) if funcname else (1,)
         if not isinstance(messages, (list, tuple)):
             messages = [messages]
         if not messages:
@@ -540,10 +537,7 @@ def extract_python(
                 else:
                     messages.append(None)
 
-                if len(messages) > 1:
-                    messages = tuple(messages)
-                else:
-                    messages = messages[0]
+                messages = tuple(messages) if len(messages) > 1 else messages[0]
                 # Comments don't apply unless they immediately
                 # precede the message
                 if translator_comments and \
diff --git a/babel/messages/frontend.py b/babel/messages/frontend.py
index ab094ecd4..b10bb6821 100644
--- a/babel/messages/frontend.py
+++ b/babel/messages/frontend.py
@@ -412,10 +412,7 @@ def finalize_options(self):
                     'input-dirs and input-paths are mutually exclusive'
                 )
 
-        if self.no_default_keywords:
-            keywords = {}
-        else:
-            keywords = DEFAULT_KEYWORDS.copy()
+        keywords = {} if self.no_default_keywords else DEFAULT_KEYWORDS.copy()
 
         keywords.update(parse_keywords(listify_value(self.keywords)))
 
diff --git a/babel/messages/pofile.py b/babel/messages/pofile.py
index aef8cbf7c..73d8cbe61 100644
--- a/babel/messages/pofile.py
+++ b/babel/messages/pofile.py
@@ -189,10 +189,7 @@ def _add_message(self) -> None:
             string = tuple(string)
         else:
             string = self.translations[0][1].denormalize()
-        if self.context:
-            msgctxt = self.context.denormalize()
-        else:
-            msgctxt = None
+        msgctxt = self.context.denormalize() if self.context else None
         message = Message(msgid, string, list(self.locations), set(self.flags),
                           self.auto_comments, self.user_comments, lineno=self.offset + 1,
                           context=msgctxt)
@@ -543,10 +540,7 @@ def _write(text):
     def _write_comment(comment, prefix=''):
         # xgettext always wraps comments even if --no-wrap is passed;
         # provide the same behaviour
-        if width and width > 0:
-            _width = width
-        else:
-            _width = 76
+        _width = width if width and width > 0 else 76
         for line in wraptext(comment, _width):
             _write(f"#{prefix} {line.strip()}\n")
 
diff --git a/babel/numbers.py b/babel/numbers.py
index ee9a133b8..59acee212 100644
--- a/babel/numbers.py
+++ b/babel/numbers.py
@@ -696,10 +696,7 @@ def _format_currency_long_name(
     # Step 2.
 
     # Correct number to numeric type, important for looking up plural rules:
-    if isinstance(number, str):
-        number_n = float(number)
-    else:
-        number_n = number
+    number_n = float(number) if isinstance(number, str) else number
 
     # Step 3.
     unit_pattern = get_currency_unit_pattern(currency, count=number_n, locale=locale)
@@ -1032,10 +1029,8 @@ def _match_number(pattern):
         number, exp = number.split('E', 1)
     else:
         exp = None
-    if '@' in number:
-        if '.' in number and '0' in number:
-            raise ValueError('Significant digit patterns can not contain '
-                             '"@" or "0"')
+    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:
diff --git a/babel/plural.py b/babel/plural.py
index 26073ff8f..6cead04e9 100644
--- a/babel/plural.py
+++ b/babel/plural.py
@@ -334,7 +334,7 @@ class RuleError(Exception):
     '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.
+    'e',  # currently, synonym for `c`. however, may be redefined in the future.
 }
 
 _RULES: list[tuple[str | None, re.Pattern[str]]] = [
diff --git a/babel/support.py b/babel/support.py
index c1851cf29..59593b86f 100644
--- a/babel/support.py
+++ b/babel/support.py
@@ -542,10 +542,7 @@ def unpgettext(self, context: str, singular: str, plural: str, num: int) -> str:
         except KeyError:
             if self._fallback:
                 return self._fallback.unpgettext(context, singular, plural, num)
-            if num == 1:
-                tmsg = str(singular)
-            else:
-                tmsg = str(plural)
+            tmsg = str(singular) if num == 1 else str(plural)
         return tmsg
 
     def dpgettext(self, domain: str, context: str, message: str) -> str | object:

From 6bf793ae5b902b3e3f2cb494f2fc230c2641890c Mon Sep 17 00:00:00 2001
From: Aarni Koskela <akx@iki.fi>
Date: Wed, 25 Jan 2023 22:08:33 +0200
Subject: [PATCH 42/53] Modernize some string formatting

---
 babel/messages/extract.py  |  2 +-
 babel/messages/frontend.py | 16 ++++++----------
 2 files changed, 7 insertions(+), 11 deletions(-)

diff --git a/babel/messages/extract.py b/babel/messages/extract.py
index 39e26a9c7..5a34f645d 100644
--- a/babel/messages/extract.py
+++ b/babel/messages/extract.py
@@ -276,7 +276,7 @@ def check_and_call_extract_file(
             options=options,
             strip_comment_tags=strip_comment_tags
         ):
-            yield (filename, ) + message_tuple
+            yield (filename, *message_tuple)
 
         break
 
diff --git a/babel/messages/frontend.py b/babel/messages/frontend.py
index b10bb6821..5baefbbb3 100644
--- a/babel/messages/frontend.py
+++ b/babel/messages/frontend.py
@@ -942,12 +942,10 @@ def run(self, argv=None):
         self._configure_logging(options.loglevel)
         if options.list_locales:
             identifiers = localedata.locale_identifiers()
-            longest = max(len(identifier) for identifier in identifiers)
-            identifiers.sort()
-            format = '%%-%ds %%s' % (longest + 1)
-            for identifier in identifiers:
+            id_width = max(len(identifier) for identifier in identifiers) + 1
+            for identifier in sorted(identifiers):
                 locale = Locale.parse(identifier)
-                print(format % (identifier, locale.english_name))
+                print(f"{identifier:<{id_width}} {locale.english_name}")
             return 0
 
         if not args:
@@ -979,11 +977,9 @@ def _configure_logging(self, loglevel):
     def _help(self):
         print(self.parser.format_help())
         print("commands:")
-        longest = max(len(command) for command in self.commands)
-        format = "  %%-%ds %%s" % max(8, longest + 1)
-        commands = sorted(self.commands.items())
-        for name, description in commands:
-            print(format % (name, description))
+        cmd_width = max(8, max(len(command) for command in self.commands) + 1)
+        for name, description in sorted(self.commands.items()):
+            print(f"  {name:<{cmd_width}} {description}")
 
     def _configure_command(self, cmdname, argv):
         """

From d019ed198d90c5dee2b5dd5f39ffa922263f50e4 Mon Sep 17 00:00:00 2001
From: "martin f. krafft" <github.com@pobox.madduck.net>
Date: Thu, 26 Jan 2023 18:46:06 +0100
Subject: [PATCH 43/53] Keep @modifiers when parsing locales (#947)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Locale modifiers ("@variants") are described in the GNU gettext
documentation like this:

> The ‘@variant’ can denote any kind of characteristics that is not
> already implied by the language ll and the country CC. […] It can also
> denote a dialect of the language, …

Wherein Babel previously would discard these, this patch stores the
modifier information in the `Locale` objects, handling string
representation accordingly.

Resolves: #946
Signed-off-by: martin f. krafft <madduck@madduck.net>
Co-authored-by: Aarni Koskela <akx@iki.fi>
---
 babel/core.py      | 115 +++++++++++++++++++++++++++++++++------------
 tests/test_core.py |   6 ++-
 2 files changed, 88 insertions(+), 33 deletions(-)

diff --git a/babel/core.py b/babel/core.py
index 6b0c45d77..bdd176aca 100644
--- a/babel/core.py
+++ b/babel/core.py
@@ -168,6 +168,7 @@ def __init__(
         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.
 
@@ -181,6 +182,7 @@ def __init__(
         :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
         """
@@ -192,10 +194,13 @@ def __init__(
         self.script = script
         #: the variant code
         self.variant = variant
+        #: the modifier
+        self.modifier = modifier
         self.__data = None
 
         identifier = str(self)
-        if not localedata.exists(identifier):
+        identifier_without_modifier = identifier.partition('@')[0]
+        if not localedata.exists(identifier_without_modifier):
             raise UnknownLocaleError(identifier)
 
     @classmethod
@@ -290,6 +295,11 @@ def parse(
         >>> 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
@@ -348,7 +358,11 @@ def _try_load_reducing(parts):
         # implement ICU like fuzzy locale objects and provide a way to
         # maximize and minimize locale tags.
 
-        language, territory, script, variant = parts
+        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, (territory,))[0]
         script = get_global('script_aliases').get(script, script)
@@ -359,7 +373,7 @@ def _try_load_reducing(parts):
         if script == 'Zzzz':
             script = None
 
-        parts = language, territory, script, variant
+        parts = language, territory, script, variant, modifier
 
         # First match: try the whole identifier
         new_id = get_locale_identifier(parts)
@@ -373,33 +387,40 @@ def _try_load_reducing(parts):
         # simplified identifier that is just the language
         likely_subtag = get_global('likely_subtags').get(language)
         if likely_subtag is not None:
-            language2, _, script2, variant2 = parse_locale(likely_subtag)
-            locale = _try_load_reducing((language2, territory, script2, variant2))
+            parts2 = parse_locale(likely_subtag)
+            if len(parts2) == 5:
+                language2, _, script2, variant2, modifier2 = parse_locale(likely_subtag)
+            else:
+                language2, _, script2, variant2 = parse_locale(likely_subtag)
+                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'):
+        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')  # 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))
+        return hash((self.language, self.territory, self.script,
+                     self.variant, self.modifier))
 
     def __repr__(self) -> str:
         parameters = ['']
-        for key in ('territory', 'script', 'variant'):
+        for key in ('territory', 'script', 'variant', 'modifier'):
             value = getattr(self, key)
             if value is not None:
                 parameters.append(f"{key}={value!r}")
@@ -407,7 +428,8 @@ def __repr__(self) -> str:
 
     def __str__(self) -> str:
         return get_locale_identifier((self.language, self.territory,
-                                      self.script, self.variant))
+                                      self.script, self.variant,
+                                      self.modifier))
 
     @property
     def _data(self) -> localedata.LocaleDataDict:
@@ -424,6 +446,11 @@ def get_display_name(self, locale: Locale | str | None = None) -> str | None:
         >>> 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:
@@ -438,6 +465,8 @@ def get_display_name(self, locale: Locale | str | None = None) -> str | None:
                 details.append(locale.territories.get(self.territory))
             if self.variant:
                 details.append(locale.variants.get(self.variant))
+            if self.modifier:
+                details.append(self.modifier)
             details = filter(None, details)
             if details:
                 retval += f" ({', '.join(details)})"
@@ -1115,9 +1144,12 @@ def negotiate_locale(preferred: Iterable[str], available: Iterable[str], sep: st
     return None
 
 
-def parse_locale(identifier: str, sep: str = '_') -> tuple[str, str | None, str | None, str | None]:
+def parse_locale(
+    identifier: str,
+    sep: str = '_'
+) -> tuple[str, str | None, str | None, str | None, str | None]:
     """Parse a locale identifier into a tuple of the form ``(language,
-    territory, script, variant)``.
+    territory, script, variant, modifier)``.
 
     >>> parse_locale('zh_CN')
     ('zh', 'CN', None, None)
@@ -1129,12 +1161,22 @@ def parse_locale(identifier: str, sep: str = '_') -> tuple[str, str | None, str
     ('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:
+    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:
@@ -1144,14 +1186,13 @@ def parse_locale(identifier: str, sep: str = '_') -> tuple[str, str | None, str
       ...
     ValueError: 'not_a_LOCALE_String' is not a valid locale identifier
 
-    Encoding information and locale modifiers are removed from the identifier:
+    Encoding information is removed from the identifier, while modifiers are
+    kept:
 
-    >>> parse_locale('it_IT@euro')
-    ('it', 'IT', None, None)
     >>> parse_locale('en_US.UTF-8')
     ('en', 'US', None, None)
     >>> parse_locale('de_DE.iso885915@euro')
-    ('de', 'DE', None, None)
+    ('de', 'DE', None, None, 'euro')
 
     See :rfc:`4646` for more information.
 
@@ -1161,13 +1202,10 @@ def parse_locale(identifier: str, sep: str = '_') -> tuple[str, str | None, str
     :raise `ValueError`: if the string does not appear to be a valid 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]
-    if '@' in identifier:
-        # this is a locale modifier such as @euro, which we don't care about
-        # either
-        identifier = identifier.split('@', 1)[0]
 
     parts = identifier.split(sep)
     lang = parts.pop(0).lower()
@@ -1193,22 +1231,37 @@ def parse_locale(identifier: str, sep: str = '_') -> tuple[str, str | None, str
     if parts:
         raise ValueError(f"{identifier!r} is not a valid locale identifier")
 
-    return lang, territory, script, variant
-
-
-def get_locale_identifier(tup: tuple[str, str | None, str | None, str | None], sep: str = '_') -> str:
+    # 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)`` tuple.  Items can be set to
+    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'))
-    'de_DE_1999'
+    >>> 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[:4])
-    lang, territory, script, variant = tup + (None,) * (4 - len(tup))
-    return sep.join(filter(None, (lang, script, territory, variant)))
+    tup = tuple(tup[: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
diff --git a/tests/test_core.py b/tests/test_core.py
index 2a7e605c2..0023824f4 100644
--- a/tests/test_core.py
+++ b/tests/test_core.py
@@ -283,10 +283,12 @@ def test_parse_locale():
     assert (excinfo.value.args[0] ==
             "'not_a_LOCALE_String' is not a valid locale identifier")
 
-    assert core.parse_locale('it_IT@euro') == ('it', 'IT', None, None)
+    assert core.parse_locale('it_IT@euro') == ('it', 'IT', None, None, 'euro')
+    assert core.parse_locale('it_IT@something') == ('it', 'IT', None, None, 'something')
+
     assert core.parse_locale('en_US.UTF-8') == ('en', 'US', None, None)
     assert (core.parse_locale('de_DE.iso885915@euro') ==
-            ('de', 'DE', None, None))
+            ('de', 'DE', None, None, 'euro'))
 
 
 @pytest.mark.parametrize('filename', [

From 25e436016970443226d0ec19cf74ac8476369b33 Mon Sep 17 00:00:00 2001
From: Maciej Olko <maciej.olko@affirm.com>
Date: Fri, 3 Feb 2023 10:34:35 +0100
Subject: [PATCH 44/53] Add two new options in cmdline.rst docs (#963)

Added in #720 and #832.
---
 docs/cmdline.rst | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/docs/cmdline.rst b/docs/cmdline.rst
index 91dc4fe72..8d9742fbf 100644
--- a/docs/cmdline.rst
+++ b/docs/cmdline.rst
@@ -125,6 +125,12 @@ a collection of source files::
       --input-dirs=INPUT_DIRS
                             alias for input-paths (does allow files as well as
                             directories).
+      --ignore-dirs=IGNORE_DIRS
+                            Patterns for directories to ignore when scanning for
+                            messages. Separate multiple patterns with spaces
+                            (default ".* ._")
+      --header-comment=HEADER_COMMENT
+                            header comment for the catalog
 
 
 init

From 9b67367950e2ae95fdea585886a564f3ce8cdb5d Mon Sep 17 00:00:00 2001
From: Jonah Lawrence <jonah@freshidea.com>
Date: Fri, 3 Feb 2023 08:35:09 -0700
Subject: [PATCH 45/53] Numbers and core type fixes

---
 babel/core.py    | 31 +++++++++++--------------------
 babel/numbers.py | 45 +++++++++++++++++++++++----------------------
 2 files changed, 34 insertions(+), 42 deletions(-)

diff --git a/babel/core.py b/babel/core.py
index bdd176aca..56f9e4171 100644
--- a/babel/core.py
+++ b/babel/core.py
@@ -13,7 +13,7 @@
 import os
 import pickle
 from collections.abc import Iterable, Mapping
-from typing import TYPE_CHECKING, Any, overload
+from typing import TYPE_CHECKING, Any
 
 from babel import localedata
 from babel.plural import PluralRule
@@ -260,21 +260,13 @@ def negotiate(
         if identifier:
             return Locale.parse(identifier, sep=sep)
 
-    @overload
-    @classmethod
-    def parse(cls, identifier: None, sep: str = ..., resolve_likely_subtags: bool = ...) -> None: ...
-
-    @overload
-    @classmethod
-    def parse(cls, identifier: str | Locale, sep: str = ..., resolve_likely_subtags: bool = ...) -> Locale: ...
-
     @classmethod
     def parse(
         cls,
         identifier: str | Locale | None,
         sep: str = '_',
         resolve_likely_subtags: bool = True,
-    ) -> Locale | None:
+    ) -> Locale:
         """Create a `Locale` instance for the given locale identifier.
 
         >>> l = Locale.parse('de-DE', sep='-')
@@ -317,10 +309,9 @@ def parse(
                              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`
         """
-        if identifier is None:
-            return None
-        elif isinstance(identifier, Locale):
+        if isinstance(identifier, Locale):
             return identifier
         elif not isinstance(identifier, str):
             raise TypeError(f"Unexpected value for identifier: {identifier!r}")
@@ -364,9 +355,9 @@ def _try_load_reducing(parts):
             language, territory, script, variant = parts
             modifier = None
         language = get_global('language_aliases').get(language, language)
-        territory = get_global('territory_aliases').get(territory, (territory,))[0]
-        script = get_global('script_aliases').get(script, script)
-        variant = get_global('variant_aliases').get(variant, variant)
+        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
@@ -389,9 +380,9 @@ def _try_load_reducing(parts):
         if likely_subtag is not None:
             parts2 = parse_locale(likely_subtag)
             if len(parts2) == 5:
-                language2, _, script2, variant2, modifier2 = parse_locale(likely_subtag)
+                language2, _, script2, variant2, modifier2 = parts2
             else:
-                language2, _, script2, variant2 = parse_locale(likely_subtag)
+                language2, _, script2, variant2 = parts2
                 modifier2 = None
             locale = _try_load_reducing((language2, territory, script2, variant2, modifier2))
             if locale is not None:
@@ -1147,7 +1138,7 @@ def negotiate_locale(preferred: Iterable[str], available: Iterable[str], sep: st
 def parse_locale(
     identifier: str,
     sep: str = '_'
-) -> tuple[str, str | None, str | None, str | None, str | None]:
+) -> 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)``.
 
@@ -1261,7 +1252,7 @@ def get_locale_identifier(
     :param tup: the tuple as returned by :func:`parse_locale`.
     :param sep: the separator for the identifier.
     """
-    tup = tuple(tup[:5])
+    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
diff --git a/babel/numbers.py b/babel/numbers.py
index 59acee212..1a86d9e62 100644
--- a/babel/numbers.py
+++ b/babel/numbers.py
@@ -23,7 +23,7 @@
 import decimal
 import re
 import warnings
-from typing import TYPE_CHECKING, Any, overload
+from typing import TYPE_CHECKING, Any, cast, overload
 
 from babel.core import Locale, default_locale, get_global
 from babel.localedata import LocaleDataDict
@@ -428,7 +428,7 @@ def get_decimal_quantum(precision: int | decimal.Decimal) -> decimal.Decimal:
 
 def format_decimal(
     number: float | decimal.Decimal | str,
-    format: str | None = None,
+    format: str | NumberPattern | None = None,
     locale: Locale | str | None = LC_NUMERIC,
     decimal_quantization: bool = True,
     group_separator: bool = True,
@@ -474,8 +474,8 @@ def format_decimal(
                             number format.
     """
     locale = Locale.parse(locale)
-    if not format:
-        format = locale.decimal_formats.get(format)
+    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)
@@ -513,7 +513,7 @@ def format_compact_decimal(
     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.get(None)
+        format = locale.decimal_formats[None]
     pattern = parse_pattern(format)
     return pattern.apply(number, locale, decimal_quantization=False)
 
@@ -521,7 +521,7 @@ def format_compact_decimal(
 def _get_compact_format(
     number: float | decimal.Decimal | str,
     compact_format: LocaleDataDict,
-    locale: Locale | str | None,
+    locale: Locale,
     fraction_digits: int,
 ) -> tuple[decimal.Decimal, NumberPattern | None]:
     """Returns the number after dividing by the unit and the format pattern to use.
@@ -543,7 +543,7 @@ def _get_compact_format(
                 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 = number / (magnitude // (10 ** (pattern.count("0") - 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
@@ -565,7 +565,7 @@ class UnknownCurrencyFormatError(KeyError):
 def format_currency(
     number: float | decimal.Decimal | str,
     currency: str,
-    format: str | None = None,
+    format: str | NumberPattern | None = None,
     locale: Locale | str | None = LC_NUMERIC,
     currency_digits: bool = True,
     format_type: Literal["name", "standard", "accounting"] = "standard",
@@ -680,7 +680,7 @@ def format_currency(
 def _format_currency_long_name(
     number: float | decimal.Decimal | str,
     currency: str,
-    format: str | None = None,
+    format: str | NumberPattern | None = None,
     locale: Locale | str | None = LC_NUMERIC,
     currency_digits: bool = True,
     format_type: Literal["name", "standard", "accounting"] = "standard",
@@ -706,7 +706,7 @@ def _format_currency_long_name(
 
     # Step 5.
     if not format:
-        format = locale.decimal_formats.get(format)
+        format = locale.decimal_formats[format]
 
     pattern = parse_pattern(format)
 
@@ -758,13 +758,15 @@ def format_compact_currency(
             # 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)
 
 
 def format_percent(
     number: float | decimal.Decimal | str,
-    format: str | None = None,
+    format: str | NumberPattern | None = None,
     locale: Locale | str | None = LC_NUMERIC,
     decimal_quantization: bool = True,
     group_separator: bool = True,
@@ -808,7 +810,7 @@ def format_percent(
     """
     locale = Locale.parse(locale)
     if not format:
-        format = locale.percent_formats.get(format)
+        format = locale.percent_formats[format]
     pattern = parse_pattern(format)
     return pattern.apply(
         number, locale, decimal_quantization=decimal_quantization, group_separator=group_separator)
@@ -816,7 +818,7 @@ def format_percent(
 
 def format_scientific(
         number: float | decimal.Decimal | str,
-        format: str | None = None,
+        format: str | NumberPattern | None = None,
         locale: Locale | str | None = LC_NUMERIC,
         decimal_quantization: bool = True,
 ) -> str:
@@ -847,7 +849,7 @@ def format_scientific(
     """
     locale = Locale.parse(locale)
     if not format:
-        format = locale.scientific_formats.get(format)
+        format = locale.scientific_formats[format]
     pattern = parse_pattern(format)
     return pattern.apply(
         number, locale, decimal_quantization=decimal_quantization)
@@ -856,7 +858,7 @@ def format_scientific(
 class NumberFormatError(ValueError):
     """Exception raised when a string cannot be parsed into a number."""
 
-    def __init__(self, message: str, suggestions: str | None = None) -> None:
+    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
@@ -1140,7 +1142,7 @@ def scientific_notation_elements(self, value: decimal.Decimal, locale: Locale |
 
     def apply(
         self,
-        value: float | decimal.Decimal,
+        value: float | decimal.Decimal | str,
         locale: Locale | str | None,
         currency: str | None = None,
         currency_digits: bool = True,
@@ -1211,9 +1213,9 @@ def apply(
             number = ''.join([
                 self._quantize_value(value, locale, frac_prec, group_separator),
                 get_exponential_symbol(locale),
-                exp_sign,
-                self._format_int(
-                    str(exp), self.exp_prec[0], self.exp_prec[1], locale)])
+                exp_sign,  # type: ignore  # exp_sign is always defined here
+                self._format_int(str(exp), self.exp_prec[0], self.exp_prec[1], locale)  # type: ignore  # exp is always defined here
+            ])
 
         # Is it a significant digits pattern?
         elif '@' in self.pattern:
@@ -1234,9 +1236,8 @@ def apply(
             number if self.number_pattern != '' else '',
             self.suffix[is_negative]])
 
-        if '¤' in retval:
-            retval = retval.replace('¤¤¤',
-                                    get_currency_name(currency, value, locale))
+        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))
 

From 053c242d2943adbc2d2cc90f41eb8c48383fd895 Mon Sep 17 00:00:00 2001
From: Jonah Lawrence <jonah@freshidea.com>
Date: Fri, 3 Feb 2023 08:42:23 -0700
Subject: [PATCH 46/53] Type fixes from 961

---
 babel/core.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/babel/core.py b/babel/core.py
index 56f9e4171..57a6b63b3 100644
--- a/babel/core.py
+++ b/babel/core.py
@@ -503,7 +503,7 @@ def get_territory_name(self, locale: Locale | str | None = None) -> str | None:
         if locale is None:
             locale = self
         locale = Locale.parse(locale)
-        return locale.territories.get(self.territory)
+        return locale.territories.get(self.territory or '')
 
     territory_name = property(get_territory_name, doc="""\
         The localized territory name of the locale if available.
@@ -517,7 +517,7 @@ def get_script_name(self, locale: Locale | str | None = None) -> str | None:
         if locale is None:
             locale = self
         locale = Locale.parse(locale)
-        return locale.scripts.get(self.script)
+        return locale.scripts.get(self.script or '')
 
     script_name = property(get_script_name, doc="""\
         The localized script name of the locale if available.

From 221c937af65e6691a0958ec9bbc29a9bbbd77383 Mon Sep 17 00:00:00 2001
From: Aarni Koskela <akx@iki.fi>
Date: Tue, 7 Feb 2023 15:58:00 +0200
Subject: [PATCH 47/53] Replace babel.dates._pattern_cache with an LRU cache

Fixes #962
---
 babel/dates.py | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

diff --git a/babel/dates.py b/babel/dates.py
index ce439eecd..78c7facaf 100644
--- a/babel/dates.py
+++ b/babel/dates.py
@@ -19,6 +19,7 @@
 
 import re
 import warnings
+from functools import lru_cache
 from typing import TYPE_CHECKING, SupportsInt
 
 try:
@@ -1667,10 +1668,8 @@ def get_week_number(self, day_of_period: int, day_of_week: int | None = None) ->
 #: in order of decreasing magnitude.
 PATTERN_CHAR_ORDER = "GyYuUQqMLlwWdDFgEecabBChHKkjJmsSAzZOvVXx"
 
-_pattern_cache = {}
 
-
-def parse_pattern(pattern: str) -> DateTimePattern:
+def parse_pattern(pattern: str | DateTimePattern) -> DateTimePattern:
     """Parse date, time, and datetime format patterns.
 
     >>> parse_pattern("MMMMd").format
@@ -1693,10 +1692,11 @@ def parse_pattern(pattern: str) -> DateTimePattern:
     """
     if isinstance(pattern, DateTimePattern):
         return pattern
+    return _cached_parse_pattern(pattern)
 
-    if pattern in _pattern_cache:
-        return _pattern_cache[pattern]
 
+@lru_cache(maxsize=1024)
+def _cached_parse_pattern(pattern: str) -> DateTimePattern:
     result = []
 
     for tok_type, tok_value in tokenize_pattern(pattern):
@@ -1710,9 +1710,7 @@ def parse_pattern(pattern: str) -> DateTimePattern:
             result.append('%%(%s)s' % (fieldchar * fieldnum))
         else:
             raise NotImplementedError(f"Unknown token type: {tok_type}")
-
-    _pattern_cache[pattern] = pat = DateTimePattern(pattern, ''.join(result))
-    return pat
+    return DateTimePattern(pattern, ''.join(result))
 
 
 def tokenize_pattern(pattern: str) -> list[tuple[str, str | tuple[str, int]]]:

From 08af5e2bab184c1b5d357ebde8c0efdbe6288e2c Mon Sep 17 00:00:00 2001
From: Aarni Koskela <akx@iki.fi>
Date: Tue, 7 Feb 2023 16:00:41 +0200
Subject: [PATCH 48/53] Replace babel.localedata.locale_identifiers cache with
 LRU cache

---
 babel/localedata.py      | 23 ++++++++++-------------
 tests/test_localedata.py | 13 +++++--------
 2 files changed, 15 insertions(+), 21 deletions(-)

diff --git a/babel/localedata.py b/babel/localedata.py
index f765a1ea3..a9c7c75ec 100644
--- a/babel/localedata.py
+++ b/babel/localedata.py
@@ -20,6 +20,7 @@
 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
 
@@ -74,28 +75,24 @@ def exists(name: str) -> bool:
     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 in `locale_identifiers.cache`.
-
-    Removing the `locale_identifiers.cache` attribute or setting it to `None`
-    will cause this function to re-read the list from disk.
+    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)
     """
-    data = getattr(locale_identifiers, 'cache', None)
-    if data is None:
-        locale_identifiers.cache = data = [
-            stem
-            for stem, extension in
-            (os.path.splitext(filename) for filename in os.listdir(_dirname))
-            if extension == '.dat' and stem != 'root'
-        ]
-    return data
+    return [
+        stem
+        for stem, extension in
+        (os.path.splitext(filename) for filename in os.listdir(_dirname))
+        if extension == '.dat' and stem != 'root'
+    ]
 
 
 def load(name: os.PathLike[str] | str, merge_inherited: bool = True) -> dict[str, Any]:
diff --git a/tests/test_localedata.py b/tests/test_localedata.py
index 913922ee4..75c34b19b 100644
--- a/tests/test_localedata.py
+++ b/tests/test_localedata.py
@@ -110,18 +110,15 @@ def listdir_spy(*args):
         rv = original_listdir(*args)
         listdir_calls.append((args, rv))
         return rv
-    monkeypatch.setattr(localedata.os, 'listdir', listdir_spy)
-
-    # In case we've already run some tests...
-    if hasattr(localedata.locale_identifiers, 'cache'):
-        del localedata.locale_identifiers.cache
 
+    monkeypatch.setattr(localedata.os, 'listdir', listdir_spy)
+    localedata.locale_identifiers.cache_clear()
     assert not listdir_calls
-    assert localedata.locale_identifiers()
+    l = localedata.locale_identifiers()
     assert len(listdir_calls) == 1
-    assert localedata.locale_identifiers() is localedata.locale_identifiers.cache
+    assert localedata.locale_identifiers() is l
     assert len(listdir_calls) == 1
-    localedata.locale_identifiers.cache = None
+    localedata.locale_identifiers.cache_clear()
     assert localedata.locale_identifiers()
     assert len(listdir_calls) == 2
 

From 63bb71a5acd0d49a2ceee15098485bc34b0e8864 Mon Sep 17 00:00:00 2001
From: Jean Abou Samra <jean@abou-samra.fr>
Date: Sun, 12 Feb 2023 02:46:30 +0100
Subject: [PATCH 49/53] In fuzzy matching, also .lower().strip() fuzzy
 candidates

This seems intended at easing fuzzy matching with trivial edits in the
msgstr (changing case and adding whitespace), but it was only done on
the new msgstr, not on the old mgstr candidates, so it was possible for
merging catalogs to miss messages.
---
 babel/messages/catalog.py      | 15 +++++++++------
 tests/messages/test_catalog.py | 10 +++++-----
 2 files changed, 14 insertions(+), 11 deletions(-)

diff --git a/babel/messages/catalog.py b/babel/messages/catalog.py
index dead4aac7..190264346 100644
--- a/babel/messages/catalog.py
+++ b/babel/messages/catalog.py
@@ -803,10 +803,13 @@ def update(
         # Prepare for fuzzy matching
         fuzzy_candidates = []
         if not no_fuzzy_matching:
-            fuzzy_candidates = {
-                self._key_for(msgid): messages[msgid].context
-                for msgid in messages if msgid and messages[msgid].string
-            }
+            fuzzy_candidates = {}
+            for msgid in messages:
+                if msgid and messages[msgid].string:
+                    key = self._key_for(msgid)
+                    ctxt = messages[msgid].context
+                    modified_key = key.lower().strip()
+                    fuzzy_candidates[modified_key] = (key, ctxt)
         fuzzy_matches = set()
 
         def _merge(message: Message, oldkey: tuple[str, str] | str, newkey: tuple[str, str] | str) -> None:
@@ -861,8 +864,8 @@ def _merge(message: Message, oldkey: tuple[str, str] | str, newkey: tuple[str, s
                         matches = get_close_matches(matchkey.lower().strip(),
                                                     fuzzy_candidates.keys(), 1)
                         if matches:
-                            newkey = matches[0]
-                            newctxt = fuzzy_candidates[newkey]
+                            modified_key = matches[0]
+                            newkey, newctxt = fuzzy_candidates[modified_key]
                             if newctxt is not None:
                                 newkey = newkey, newctxt
                             _merge(message, newkey, key)
diff --git a/tests/messages/test_catalog.py b/tests/messages/test_catalog.py
index 273c83f51..c2e7aeda0 100644
--- a/tests/messages/test_catalog.py
+++ b/tests/messages/test_catalog.py
@@ -121,16 +121,16 @@ def test_update_message_updates_comments(self):
 
     def test_update_fuzzy_matching_with_case_change(self):
         cat = catalog.Catalog()
-        cat.add('foo', 'Voh')
+        cat.add('FOO', 'Voh')
         cat.add('bar', 'Bahr')
         tmpl = catalog.Catalog()
-        tmpl.add('Foo')
+        tmpl.add('foo')
         cat.update(tmpl)
         assert len(cat.obsolete) == 1
-        assert 'foo' not in cat
+        assert 'FOO' not in cat
 
-        assert cat['Foo'].string == 'Voh'
-        assert cat['Foo'].fuzzy is True
+        assert cat['foo'].string == 'Voh'
+        assert cat['foo'].fuzzy is True
 
     def test_update_fuzzy_matching_with_char_change(self):
         cat = catalog.Catalog()

From c8b7ac5b7ae1428aa6315abb6b90af0c03ab4e30 Mon Sep 17 00:00:00 2001
From: Jean Abou Samra <jean@abou-samra.fr>
Date: Sun, 12 Feb 2023 02:49:28 +0100
Subject: [PATCH 50/53] Turn off difflib "autojunk" heuristic in fuzzy matching

difflib has a heuristic that used to make fuzzy matching unreliable for
>200char strings.  See

https://github.com/python/cpython/issues/90825

Fixes #969
---
 babel/messages/catalog.py      | 28 +++++++++++++++++++++++++++-
 tests/messages/test_catalog.py | 19 +++++++++++++++++++
 2 files changed, 46 insertions(+), 1 deletion(-)

diff --git a/babel/messages/catalog.py b/babel/messages/catalog.py
index 190264346..a500e77b7 100644
--- a/babel/messages/catalog.py
+++ b/babel/messages/catalog.py
@@ -14,8 +14,9 @@
 from collections import OrderedDict
 from collections.abc import Iterable, Iterator
 from copy import copy
-from difflib import get_close_matches
+from difflib import SequenceMatcher
 from email import message_from_string
+from heapq import nlargest
 from typing import TYPE_CHECKING
 
 from babel import __version__ as VERSION
@@ -31,6 +32,31 @@
 
 __all__ = ['Message', 'Catalog', 'TranslationError']
 
+def get_close_matches(word, possibilities, n=3, cutoff=0.6):
+    """A modified version of ``difflib.get_close_matches``.
+
+    It just passes ``autojunk=False`` to the ``SequenceMatcher``, to work
+    around https://github.com/python/cpython/issues/90825.
+    """
+    if not n >  0:
+        raise ValueError("n must be > 0: %r" % (n,))
+    if not 0.0 <= cutoff <= 1.0:
+        raise ValueError("cutoff must be in [0.0, 1.0]: %r" % (cutoff,))
+    result = []
+    s = SequenceMatcher(autojunk=False) # only line changed from difflib.py
+    s.set_seq2(word)
+    for x in possibilities:
+        s.set_seq1(x)
+        if s.real_quick_ratio() >= cutoff and \
+           s.quick_ratio() >= cutoff and \
+           s.ratio() >= cutoff:
+            result.append((s.ratio(), x))
+
+    # Move the best scorers to head of list
+    result = nlargest(n, result)
+    # Strip scores for the best n matches
+    return [x for score, x in result]
+
 
 PYTHON_FORMAT = re.compile(r'''
     \%
diff --git a/tests/messages/test_catalog.py b/tests/messages/test_catalog.py
index c2e7aeda0..b9d72bc39 100644
--- a/tests/messages/test_catalog.py
+++ b/tests/messages/test_catalog.py
@@ -209,6 +209,25 @@ def test_update_fuzzy_matching_no_cascading(self):
         assert cat['fooo'].string == 'Vohe'
         assert cat['fooo'].fuzzy is True
 
+    def test_update_fuzzy_matching_long_string(self):
+        lipsum = "\
+Lorem Ipsum is simply dummy text of the printing and typesetting \
+industry. Lorem Ipsum has been the industry's standard dummy text ever \
+since the 1500s, when an unknown printer took a galley of type and \
+scrambled it to make a type specimen book. It has survived not only \
+five centuries, but also the leap into electronic typesetting, \
+remaining essentially unchanged. It was popularised in the 1960s with \
+the release of Letraset sheets containing Lorem Ipsum passages, and \
+more recently with desktop publishing software like Aldus PageMaker \
+including versions of Lorem Ipsum."
+        cat = catalog.Catalog()
+        cat.add("ZZZZZZ " + lipsum, "foo")
+        tmpl = catalog.Catalog()
+        tmpl.add(lipsum + " ZZZZZZ")
+        cat.update(tmpl)
+        assert cat[lipsum + " ZZZZZZ"].fuzzy is True
+        assert len(cat.obsolete) == 0
+
     def test_update_without_fuzzy_matching(self):
         cat = catalog.Catalog()
         cat.add('fo', 'Voh')

From 373a52f0425d0af1e578e8562a8db93fc3a02488 Mon Sep 17 00:00:00 2001
From: Aarni Koskela <akx@iki.fi>
Date: Mon, 20 Feb 2023 17:27:36 +0200
Subject: [PATCH 51/53] Renovate CI tools a bit (#972)

* Update GitHub Actions versions

* Update pre-commit tools
---
 .github/workflows/test.yml | 2 +-
 .pre-commit-config.yaml    | 3 +--
 babel/messages/catalog.py  | 8 ++++----
 3 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index c584fd983..e87f23e5f 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -27,7 +27,7 @@ jobs:
       BABEL_CLDR_QUIET: "1"
     steps:
     - uses: actions/checkout@v3
-    - uses: actions/cache@v2
+    - uses: actions/cache@v3
       with:
         path: cldr
         key: cldr-${{ hashFiles('scripts/*cldr*') }}
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 4c3eb9c30..d1935c006 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -1,11 +1,10 @@
 repos:
   - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: v0.0.224
+    rev: v0.0.247
     hooks:
       - id: ruff
         args:
           - --fix
-          - --force-exclude
   - repo: https://github.com/pre-commit/pre-commit-hooks
     rev: v4.4.0
     hooks:
diff --git a/babel/messages/catalog.py b/babel/messages/catalog.py
index a500e77b7..47b9e62ea 100644
--- a/babel/messages/catalog.py
+++ b/babel/messages/catalog.py
@@ -38,10 +38,10 @@ def get_close_matches(word, possibilities, n=3, cutoff=0.6):
     It just passes ``autojunk=False`` to the ``SequenceMatcher``, to work
     around https://github.com/python/cpython/issues/90825.
     """
-    if not n >  0:
-        raise ValueError("n must be > 0: %r" % (n,))
-    if not 0.0 <= cutoff <= 1.0:
-        raise ValueError("cutoff must be in [0.0, 1.0]: %r" % (cutoff,))
+    if not n > 0:  # pragma: no cover
+        raise ValueError(f"n must be > 0: {n!r}")
+    if not 0.0 <= cutoff <= 1.0:  # pragma: no cover
+        raise ValueError(f"cutoff must be in [0.0, 1.0]: {cutoff!r}")
     result = []
     s = SequenceMatcher(autojunk=False) # only line changed from difflib.py
     s.set_seq2(word)

From d597370bfcaa8c7421ec5639ecda7b55467167dc Mon Sep 17 00:00:00 2001
From: Aarni Koskela <akx@iki.fi>
Date: Tue, 28 Feb 2023 09:40:35 +0200
Subject: [PATCH 52/53] Tox: also test with pytz installed (#974)

* Tox: also test with pytz installed
* Tox: return to tox-gh-actions (which now supports Tox 4)
---
 .github/workflows/test.yml |  2 +-
 tox.ini                    | 16 +++++++++-------
 2 files changed, 10 insertions(+), 8 deletions(-)

diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index e87f23e5f..a35a1b4f3 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -40,7 +40,7 @@ jobs:
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip setuptools wheel
-        python -m pip install 'tox~=4.0' 'tox-gh~=1.0'
+        python -m pip install 'tox~=4.0' 'tox-gh-actions~=3.0'
     - name: Run test via Tox
       run: tox --skip-missing-interpreters
       env:
diff --git a/tox.ini b/tox.ini
index 551d20115..1156fecc6 100644
--- a/tox.ini
+++ b/tox.ini
@@ -2,6 +2,7 @@
 envlist =
     py{37,38,39,310,311}
     pypy3
+    py{37,38}-pytz
 
 [testenv]
 deps =
@@ -10,6 +11,7 @@ deps =
     freezegun==0.3.12
     backports.zoneinfo;python_version<"3.9"
     tzdata;sys_platform == 'win32'
+    pytz: pytz
 allowlist_externals = make
 commands = make clean-cldr test
 setenv =
@@ -19,11 +21,11 @@ passenv =
     PYTEST_*
     PYTHON_*
 
-[gh]
+[gh-actions]
 python =
-    pypy3 = pypy3
-    3.7 = py37
-    3.8 = py38
-    3.9 = py39
-    3.10 = py310
-    3.11 = py311
+    pypy3: pypy3
+    3.7: py37
+    3.8: py38
+    3.9: py39
+    3.10: py310
+    3.11: py311

From f5bb5bffdbc7923bc0297b99fd9dc2cb69afd6e7 Mon Sep 17 00:00:00 2001
From: Aarni Koskela <akx@iki.fi>
Date: Tue, 28 Feb 2023 09:17:25 +0200
Subject: [PATCH 53/53] Become 2.12.0

---
 AUTHORS           |  8 +++++++-
 CHANGES.rst       | 37 +++++++++++++++++++++++++++++++++----
 babel/__init__.py |  2 +-
 docs/conf.py      |  4 ++--
 4 files changed, 43 insertions(+), 8 deletions(-)

diff --git a/AUTHORS b/AUTHORS
index 5b88f338e..0d2d12168 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -14,6 +14,7 @@ Babel is written and maintained by the Babel team and various contributors:
 - Isaac Jurado
 - Tobias Bieniek
 - Erick Wilder
+- Jonah Lawrence
 - Michael Birtwell
 - Jonas Borgström
 - Kevin Deldycke
@@ -33,6 +34,7 @@ Babel is written and maintained by the Babel team and various contributors:
 - Jennifer Wang
 - Lukas Balaga
 - sudheesh001
+- Jean Abou Samra
 - Niklas Hambüchen
 - Changaco
 - Xavier Fernandez
@@ -47,8 +49,12 @@ Babel is written and maintained by the Babel team and various contributors:
 - Arturas Moskvinas
 - Leonardo Pistone
 - Hyunjun Kim
+- Maciej Olko
+- martin f. krafft
+- DS/Charlie
+- lilinjie
+- Johannes Wilm
 - Eric L
-- Jonah Lawrence
 - Przemyslaw Wegrzyn
 - Lukas Kahwe Smith
 - Lukas Juhrich
diff --git a/CHANGES.rst b/CHANGES.rst
index a146e8fba..b5e4718eb 100644
--- a/CHANGES.rst
+++ b/CHANGES.rst
@@ -1,12 +1,41 @@
 Babel Changelog
 ===============
 
-Unreleased
-----------
+Version 2.12.0
+--------------
+
+Deprecations & breaking changes
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+* Python 3.6 is no longer supported (:gh:`919`) - Aarni Koskela
+* The `get_next_timezone_transition` function is no more (:gh:`958`) - Aarni Koskela
+
+New features
+~~~~~~~~~~~~
+
+* CLDR: Babel now uses CLDR 42 (:gh:`951`) - Aarni Koskela
+* Dates: `pytz` is now optional; Babel will prefer it but will use `zoneinfo` when available. (:gh:`940`) - @ds-cbo
+* General: Babel now ships type annotations, thanks to Jonah Lawrence's work in multiple PRs.
+* Locales: @modifiers are now retained when parsing locales (:gh:`947`) - martin f. krafft
+* Messages: JavaScript template string expression extraction is now smarter. (:gh:`939`) - Johannes Wilm
+* Numbers: NaN and Infinity are now better supported (:gh:`955`) - Jonah Lawrence
+* Numbers: Short compact currency formats are now supported (:gh:`926`) - Jonah Lawrence
+* Numbers: There's now a `Format.compact_decimal` utility function. (:gh:`921`) - Jonah Lawrence
+
+Bugfixes
+~~~~~~~~
+
+* Dates: The cache for parsed datetime patterns is now bounded (:gh:`967`) - Aarni Koskela
+* Messages: Fuzzy candidate matching accuracy is improved (:gh:`970`) - Jean Abou Samra
+* Numbers: Compact singular formats and patterns with no numbers work correctly (:gh:`930`, :gh:`932`) - Jonah Lawrence, Jun Omae
 
-* Use `zoneinfo` timezone resolving on python 3.9+, while keeping pytz support
-  for lower versions
+Improvements & cleanup
+~~~~~~~~~~~~~~~~~~~~~~
 
+* Dates: `babel.dates.UTC` is now an alias for `datetime.timezone.utc` (:gh:`957`) - Aarni Koskela
+* Dates: `babel.localtime` was slightly cleaned up. (:gh:`952`) - Aarni Koskela
+* Documentation: Documentation was improved by Maciej Olko, Jonah Lawrence, lilinjie, and Aarni Koskela.
+* Infrastructure: Babel is now being linted with pre-commit and ruff. - Aarni Koskela
 
 Version 2.11.0
 --------------
diff --git a/babel/__init__.py b/babel/__init__.py
index be35c0361..225ec143c 100644
--- a/babel/__init__.py
+++ b/babel/__init__.py
@@ -25,7 +25,7 @@
     parse_locale,
 )
 
-__version__ = '2.11.0'
+__version__ = '2.12.0'
 
 __all__ = [
     'Locale',
diff --git a/docs/conf.py b/docs/conf.py
index 5118f72f6..45ce059fd 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -51,9 +51,9 @@
 # built documents.
 #
 # The short X.Y version.
-version = '2.11'
+version = '2.12'
 # The full version, including alpha/beta/rc tags.
-release = '2.11.0'
+release = '2.12.0'
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.