More type annotations

Author: DenverCoder1

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.
 

babel/lists.py

@@ -13,13 +13,20 @@
     :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_extensions import Literal
 
 from babel.core import Locale, default_locale
 
 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.
 

babel/localedata.py

@@ -219,7 +219,7 @@ def resolve(self, data: Mapping[str | int | None, Any]) -> Mapping[str | int | N
         return data
 
 
-class LocaleDataDict(abc.MutableMapping[Any, Any]):
+class LocaleDataDict(abc.MutableMapping):
     """Dictionary wrapper that automatically resolves aliases to the actual
     values.
     """

babel/plural.py

@@ -7,15 +7,18 @@
     :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 Any
 
 _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, int]:
     """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 +100,7 @@ class PluralRule:
 
     __slots__ = ('abstract', '_func')
 
-    def __init__(self, rules):
+    def __init__(self, rules: Mapping[str, str] | Iterable[tuple[str, str]]):
         """Initialize the rule instance.
 
         :param rules: a list of ``(tag, expr)``) tuples with the rules
@@ -108,7 +111,7 @@ def __init__(self, rules):
         if isinstance(rules, dict):
             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 +122,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,18 +150,21 @@ 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)

babel/support.py

@@ -10,16 +10,24 @@
     :copyright: (c) 2013-2022 by the Babel Team.
     :license: BSD, see LICENSE for more details.
 """
+from __future__ import annotations
 
 import gettext
 import locale
+from datetime import date as _date, datetime as _datetime, time as _time, timedelta as _timedelta
+from typing import TYPE_CHECKING, Literal
+
+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 babel.dates import _PredefinedTimeFormat
 
 class Format:
     """Wrapper class providing the various date and number formatting functions
@@ -34,7 +42,7 @@ class Format:
     u'1.234'
     """
 
-    def __init__(self, locale, tzinfo=None):
+    def __init__(self, locale: Locale | str, tzinfo: BaseTzInfo | None = None):
         """Initialize the formatter.
 
         :param locale: the locale identifier or `Locale` instance
@@ -43,7 +51,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 +61,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 +73,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 +84,10 @@ 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 = .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 +100,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 +109,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 +118,8 @@ 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 +130,20 @@ 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', 'long'] = '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 +152,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)