Added types for babel.core and babel.numbers (#9111)

stubs/babel/babel/core.pyi

@@ -1,121 +1,135 @@
-from typing import Any
+from collections.abc import Iterable, Mapping
+from typing import Any, overload
 from typing_extensions import Literal, TypeAlias
 
+from babel.localedata import LocaleDataDict
+from babel.plural import PluralRule
+
 class UnknownLocaleError(Exception):
-    identifier: Any
-    def __init__(self, identifier) -> None: ...
+    identifier: str
+    def __init__(self, identifier: str) -> None: ...
 
 class Locale:
-    language: Any
-    territory: Any
-    script: Any
-    variant: Any
-    def __init__(self, language, territory: Any | None = ..., script: Any | None = ..., variant: Any | None = ...) -> None: ...
+    language: str
+    territory: str | None
+    script: str | None
+    variant: str | None
+    def __init__(
+        self, language: str, territory: str | None = ..., script: str | None = ..., variant: str | None = ...
+    ) -> None: ...
     @classmethod
-    def default(cls, category: Any | None = ..., aliases=...): ...
+    def default(cls, category: str | None = ..., aliases: Mapping[str, str] = ...) -> Locale: ...
     @classmethod
-    def negotiate(cls, preferred, available, sep: str = ..., aliases=...): ...
+    def negotiate(
+        cls, preferred: Iterable[str], available: Iterable[str], sep: str = ..., aliases: Mapping[str, str] = ...
+    ) -> Locale | None: ...
+    @overload
     @classmethod
-    def parse(cls, identifier, sep: str = ..., resolve_likely_subtags: bool = ...): ...
-    def __eq__(self, other): ...
-    def __ne__(self, other): ...
-    def __hash__(self): ...
-    def get_display_name(self, locale: Any | None = ...): ...
+    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: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __ne__(self, other: object) -> bool: ...
+    def __hash__(self) -> int: ...
+    def get_display_name(self, locale: Locale | str | None = ...) -> str | None: ...
     @property
-    def display_name(self): ...
-    def get_language_name(self, locale: Any | None = ...): ...
+    def display_name(self) -> str | None: ...
+    def get_language_name(self, locale: Locale | str | None = ...) -> str | None: ...
     @property
-    def language_name(self): ...
-    def get_territory_name(self, locale: Any | None = ...): ...
+    def language_name(self) -> str | None: ...
+    def get_territory_name(self, locale: Locale | str | None = ...) -> str | None: ...
     @property
-    def territory_name(self): ...
-    def get_script_name(self, locale: Any | None = ...): ...
+    def territory_name(self) -> str | None: ...
+    def get_script_name(self, locale: Locale | str | None = ...) -> str | None: ...
     @property
-    def script_name(self): ...
+    def script_name(self) -> str | None: ...
     @property
-    def english_name(self): ...
+    def english_name(self) -> str | None: ...
     @property
-    def languages(self): ...
+    def languages(self) -> LocaleDataDict: ...
     @property
-    def scripts(self): ...
+    def scripts(self) -> LocaleDataDict: ...
     @property
-    def territories(self): ...
+    def territories(self) -> LocaleDataDict: ...
     @property
-    def variants(self): ...
+    def variants(self) -> LocaleDataDict: ...
     @property
-    def currencies(self): ...
+    def currencies(self) -> LocaleDataDict: ...
     @property
-    def currency_symbols(self): ...
+    def currency_symbols(self) -> LocaleDataDict: ...
     @property
-    def number_symbols(self): ...
+    def number_symbols(self) -> LocaleDataDict: ...
     @property
-    def decimal_formats(self): ...
+    def decimal_formats(self) -> LocaleDataDict: ...
     @property
-    def compact_decimal_formats(self): ...
+    def compact_decimal_formats(self) -> LocaleDataDict: ...
     @property
-    def currency_formats(self): ...
+    def currency_formats(self) -> LocaleDataDict: ...
     @property
-    def percent_formats(self): ...
+    def percent_formats(self) -> LocaleDataDict: ...
     @property
-    def scientific_formats(self): ...
+    def scientific_formats(self) -> LocaleDataDict: ...
     @property
-    def periods(self): ...
+    def periods(self) -> LocaleDataDict: ...
     @property
-    def day_periods(self): ...
+    def day_periods(self) -> LocaleDataDict: ...
     @property
-    def day_period_rules(self): ...
+    def day_period_rules(self) -> LocaleDataDict: ...
     @property
-    def days(self): ...
+    def days(self) -> LocaleDataDict: ...
     @property
-    def months(self): ...
+    def months(self) -> LocaleDataDict: ...
     @property
-    def quarters(self): ...
+    def quarters(self) -> LocaleDataDict: ...
     @property
-    def eras(self): ...
+    def eras(self) -> LocaleDataDict: ...
     @property
-    def time_zones(self): ...
+    def time_zones(self) -> LocaleDataDict: ...
     @property
-    def meta_zones(self): ...
+    def meta_zones(self) -> LocaleDataDict: ...
     @property
-    def zone_formats(self): ...
+    def zone_formats(self) -> LocaleDataDict: ...
     @property
-    def first_week_day(self): ...
+    def first_week_day(self) -> int: ...
     @property
-    def weekend_start(self): ...
+    def weekend_start(self) -> int: ...
     @property
-    def weekend_end(self): ...
+    def weekend_end(self) -> int: ...
     @property
-    def min_week_days(self): ...
+    def min_week_days(self) -> int: ...
     @property
-    def date_formats(self): ...
+    def date_formats(self) -> LocaleDataDict: ...
     @property
-    def time_formats(self): ...
+    def time_formats(self) -> LocaleDataDict: ...
     @property
-    def datetime_formats(self): ...
+    def datetime_formats(self) -> LocaleDataDict: ...
     @property
-    def datetime_skeletons(self): ...
+    def datetime_skeletons(self) -> LocaleDataDict: ...
     @property
-    def interval_formats(self): ...
+    def interval_formats(self) -> LocaleDataDict: ...
     @property
-    def plural_form(self): ...
+    def plural_form(self) -> PluralRule: ...
     @property
-    def list_patterns(self): ...
+    def list_patterns(self) -> LocaleDataDict: ...
     @property
-    def ordinal_form(self): ...
+    def ordinal_form(self) -> PluralRule: ...
     @property
-    def measurement_systems(self): ...
+    def measurement_systems(self) -> LocaleDataDict: ...
     @property
-    def character_order(self): ...
+    def character_order(self) -> str: ...
     @property
-    def text_direction(self): ...
+    def text_direction(self) -> str: ...
     @property
-    def unit_display_names(self): ...
+    def unit_display_names(self) -> LocaleDataDict: ...
 
-def default_locale(category: Any | None = ..., aliases=...): ...
-def negotiate_locale(preferred, available, sep: str = ..., aliases=...): ...
-def parse_locale(identifier, sep: str = ...): ...
-def get_locale_identifier(tup, sep: str = ...): ...
-def get_global(key: _GLOBAL_KEY): ...
+def default_locale(category: str | None = ..., aliases: Mapping[str, str] = ...) -> str | None: ...
+def negotiate_locale(
+    preferred: Iterable[str], available: Iterable[str], sep: str = ..., aliases: Mapping[str, str] = ...
+) -> str | None: ...
+def parse_locale(identifier: str, sep: str = ...) -> tuple[str, str | None, str | None, str | None]: ...
+def get_locale_identifier(tup: tuple[str, str | None, str | None, str | None], sep: str = ...) -> str: ...
+def get_global(key: _GLOBAL_KEY) -> Mapping[str, Any]: ...
 
 _GLOBAL_KEY: TypeAlias = Literal[
     "all_currencies",

stubs/babel/babel/numbers.pyi

@@ -1,99 +1,124 @@
-from typing import Any
+import decimal
+from datetime import date
+from re import Pattern
+from typing_extensions import Literal
 
 from babel.core import Locale
 
 long = int
-LC_NUMERIC: Any
+LC_NUMERIC: str | None
 
 class UnknownCurrencyError(Exception):
-    identifier: Any
-    def __init__(self, identifier) -> None: ...
+    identifier: str
+    def __init__(self, identifier: str) -> None: ...
 
-def list_currencies(locale: Any | None = ...): ...
-def validate_currency(currency, locale: Any | None = ...) -> None: ...
-def is_currency(currency, locale: Any | None = ...): ...
-def normalize_currency(currency, locale: Any | None = ...): ...
-def get_currency_name(currency, count: Any | None = ..., locale=...): ...
-def get_currency_symbol(currency, locale=...): ...
-def get_currency_precision(currency): ...
-def get_currency_unit_pattern(currency, count: Any | None = ..., locale=...): ...
+def list_currencies(locale: Locale | str | None = ...) -> set[str]: ...
+def validate_currency(currency: str, locale: Locale | str | None = ...) -> None: ...
+def is_currency(currency: str, locale: Locale | str | None = ...) -> bool: ...
+def normalize_currency(currency: str, locale: Locale | str | None = ...) -> str | None: ...
+def get_currency_name(currency: str, count: float | decimal.Decimal | None = ..., locale: Locale | str | None = ...) -> str: ...
+def get_currency_symbol(currency: str, locale: Locale | str | None = ...) -> str: ...
+def get_currency_precision(currency: str) -> int: ...
+def get_currency_unit_pattern(currency: str, count: float | None = ..., locale: Locale | str | None = ...) -> str: ...
 def get_territory_currencies(
-    territory,
-    start_date: Any | None = ...,
-    end_date: Any | None = ...,
+    territory: str,
+    start_date: date | None = ...,
+    end_date: date | None = ...,
     tender: bool = ...,
     non_tender: bool = ...,
     include_details: bool = ...,
-): ...
-def get_decimal_symbol(locale=...): ...
-def get_plus_sign_symbol(locale=...): ...
-def get_minus_sign_symbol(locale=...): ...
-def get_exponential_symbol(locale=...): ...
-def get_group_symbol(locale=...): ...
-def format_number(number, locale=...): ...
-def get_decimal_precision(number): ...
-def get_decimal_quantum(precision): ...
+) -> list[str]: ...
+def get_decimal_symbol(locale: Locale | str | None = ...) -> str: ...
+def get_plus_sign_symbol(locale: Locale | str | None = ...) -> str: ...
+def get_minus_sign_symbol(locale: Locale | str | None = ...) -> str: ...
+def get_exponential_symbol(locale: Locale | str | None = ...) -> str: ...
+def get_group_symbol(locale: Locale | str | None = ...) -> str: ...
+def format_number(number: float | decimal.Decimal, locale: Locale | str | None = ...) -> str: ...
+def get_decimal_precision(number: decimal.Decimal) -> int: ...
+def get_decimal_quantum(precision: int | decimal.Decimal) -> decimal.Decimal: ...
 def format_decimal(
-    number, format: Any | None = ..., locale=..., decimal_quantization: bool = ..., group_separator: bool = ...
+    number: float | decimal.Decimal,
+    format: str | None = ...,
+    locale: Locale | str | None = ...,
+    decimal_quantization: bool = ...,
+    group_separator: bool = ...,
 ): ...
 def format_compact_decimal(
-    number: float, *, format_type: str = ..., locale: Locale | str | None = ..., fraction_digits: int = ...
+    number: float, *, format_type: Literal["short", "long"] = ..., locale: Locale | str | None = ..., fraction_digits: int = ...
 ) -> str: ...
 
 class UnknownCurrencyFormatError(KeyError): ...
 
 def format_currency(
-    number,
-    currency,
-    format: Any | None = ...,
-    locale=...,
+    number: float | decimal.Decimal,
+    currency: str,
+    format: str | None = ...,
+    locale: Locale | str | None = ...,
     currency_digits: bool = ...,
-    format_type: str = ...,
+    format_type: Literal["name", "standard", "accounting"] = ...,
     decimal_quantization: bool = ...,
     group_separator: bool = ...,
-): ...
+) -> str: ...
 def format_percent(
-    number, format: Any | None = ..., locale=..., decimal_quantization: bool = ..., group_separator: bool = ...
-): ...
-def format_scientific(number, format: Any | None = ..., locale=..., decimal_quantization: bool = ...): ...
+    number: float | decimal.Decimal,
+    format: str | None = ...,
+    locale: Locale | str | None = ...,
+    decimal_quantization: bool = ...,
+    group_separator: bool = ...,
+) -> str: ...
+def format_scientific(
+    number: float | decimal.Decimal, format: str | None = ..., locale: Locale | str | None = ..., decimal_quantization: bool = ...
+) -> str: ...
 
 class NumberFormatError(ValueError):
-    suggestions: Any
-    def __init__(self, message, suggestions: Any | None = ...) -> None: ...
+    suggestions: str | None
+    def __init__(self, message: str, suggestions: str | None = ...) -> None: ...
 
-def parse_number(string, locale=...): ...
-def parse_decimal(string, locale=..., strict: bool = ...): ...
+def parse_number(string: str, locale: Locale | str | None = ...) -> int: ...
+def parse_decimal(string: str, locale: Locale | str | None = ..., strict: bool = ...) -> decimal.Decimal: ...
 
 PREFIX_END: str
 NUMBER_TOKEN: str
-PREFIX_PATTERN: Any
-NUMBER_PATTERN: Any
+PREFIX_PATTERN: str
+NUMBER_PATTERN: str
 SUFFIX_PATTERN: str
-number_re: Any
+number_re: Pattern[str]
 
-def parse_grouping(p): ...
-def parse_pattern(pattern): ...
+def parse_grouping(p: str) -> tuple[int, int]: ...
+def parse_pattern(pattern: NumberPattern | str) -> NumberPattern: ...
 
 class NumberPattern:
-    pattern: Any
-    prefix: Any
-    suffix: Any
-    grouping: Any
-    int_prec: Any
-    frac_prec: Any
-    exp_prec: Any
-    exp_plus: Any
-    scale: Any
-    def __init__(self, pattern, prefix, suffix, grouping, int_prec, frac_prec, exp_prec, exp_plus) -> None: ...
-    def compute_scale(self): ...
-    def scientific_notation_elements(self, value, locale): ...
+    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
+    scale: Literal[0, 2, 3]
+    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,
+    ) -> None: ...
+    def compute_scale(self) -> Literal[0, 2, 3]: ...
+    def scientific_notation_elements(
+        self, value: decimal.Decimal, locale: Locale | str | None
+    ) -> tuple[decimal.Decimal, int, str]: ...
     def apply(
         self,
-        value,
-        locale,
-        currency: Any | None = ...,
+        value: float | decimal.Decimal,
+        locale: Locale | str | None,
+        currency: str | None = ...,
         currency_digits: bool = ...,
         decimal_quantization: bool = ...,
-        force_frac: Any | None = ...,
+        force_frac: int | None = ...,
         group_separator: bool = ...,
-    ): ...
+    ) -> str: ...