220      :param locale: the `Locale` object or locale identifier
   221      :param numbering_system: The numbering system used for fetching the symbol. Defaults to "latn".
   222                               The special value "default" will use the default numbering system of the locale.
   223      :raise `UnsupportedNumberingSystemError`: if the numbering system is not supported by the locale.
   224      """
   225      pass
   226
   227  def get_minus_sign_symbol(locale: Locale | str | None=LC_NUMERIC, *, numbering_system: Literal['default'] | str='latn') -> str:
   228      """Return the plus sign symbol used by the current locale.
   229
   230      >>> get_minus_sign_symbol('en_US')
   231      u'-'
   232      >>> get_minus_sign_symbol('ar_EG', numbering_system='default')
   233      u'\u061c-'
   234      >>> get_minus_sign_symbol('ar_EG', numbering_system='latn')
   235      u'\u200e-'
   236
   237      :param locale: the `Locale` object or locale identifier
   238      :param numbering_system: The numbering system used for fetching the symbol. Defaults to "latn".
   239                               The special value "default" will use the default numbering system of the locale.
   240      :raise `UnsupportedNumberingSystemError`: if the numbering system is not supported by the locale.
   241      """
   242      pass
   243
   244  def get_exponential_symbol(locale: Locale | str | None=LC_NUMERIC, *, numbering_system: Literal['default'] | str='latn') -> str:
   245      """Return the symbol used by the locale to separate mantissa and exponent.
   246
   247      >>> get_exponential_symbol('en_US')
   248      u'E'
   249      >>> get_exponential_symbol('ar_EG', numbering_system='default')
   250      u'اس'
   251      >>> get_exponential_symbol('ar_EG', numbering_system='latn')
   252      u'E'
   253
   254      :param locale: the `Locale` object or locale identifier
   255      :param numbering_system: The numbering system used for fetching the symbol. Defaults to "latn".
   256                               The special value "default" will use the default numbering system of the locale.
   257      :raise `UnsupportedNumberingSystemError`: if the numbering system is not supported by the locale.
   258      """
   259      pass
   260
   261  def get_group_symbol(locale: Locale | str | None=LC_NUMERIC, *, numbering_system: Literal['default'] | str='latn') -> str:
   262      """Return the symbol used by the locale to separate groups of thousands.
   263
   264      >>> get_group_symbol('en_US')
   265      u','
   266      >>> get_group_symbol('ar_EG', numbering_system='default')
   267      u'٬'
   268      >>> get_group_symbol('ar_EG', numbering_system='latn')
   269      u','
   270
   271      :param locale: the `Locale` object or locale identifier
   272      :param numbering_system: The numbering system used for fetching the symbol. Defaults to "latn".
   273                               The special value "default" will use the default numbering system of the locale.
   274      :raise `UnsupportedNumberingSystemError`: if the numbering system is not supported by the locale.
   275      """
   276      pass
   277
   278  def get_infinity_symbol(locale: Locale | str | None=LC_NUMERIC, *, numbering_system: Literal['default'] | str='latn') -> str:
   279      """Return the symbol used by the locale to represent infinity.
   280
   281      >>> get_infinity_symbol('en_US')
   282      u'∞'
   283      >>> get_infinity_symbol('ar_EG', numbering_system='default')
   284      u'∞'
   285      >>> get_infinity_symbol('ar_EG', numbering_system='latn')
   286      u'∞'
   287
   288      :param locale: the `Locale` object or locale identifier
   289      :param numbering_system: The numbering system used for fetching the symbol. Defaults to "latn".
   290                               The special value "default" will use the default numbering system of the locale.
   291      :raise `UnsupportedNumberingSystemError`: if the numbering system is not supported by the locale.
   292      """
   293      pass
   294
   295  def format_number(number: float | decimal.Decimal | str, locale: Locale | str | None=LC_NUMERIC) -> str:
   296      """Return the given number formatted for a specific locale.
   297
   298      >>> format_number(1099, locale='en_US')  # doctest: +SKIP
   299      u'1,099'
   300      >>> format_number(1099, locale='de_DE')  # doctest: +SKIP
   301      u'1.099'
   302
   303      .. deprecated:: 2.6.0
   304
   305         Use babel.numbers.format_decimal() instead.
   306
   307      :param number: the number to format
   308      :param locale: the `Locale` object or locale identifier
   309
   310
   311      """
   312      pass
   313
   314  def get_decimal_precision(number: decimal.Decimal) -> int:
   315      """Return maximum precision of a decimal instance's fractional part.
   316
   317      Precision is extracted from the fractional part only.
   318      """
   319      pass
   320
   321  def get_decimal_quantum(precision: int | decimal.Decimal) -> decimal.Decimal:
   322      """Return minimal quantum of a number, as defined by precision."""
   323      pass
   324
   325  def format_decimal(number: float | decimal.Decimal | str, format: str | NumberPattern | None=None, locale: Locale | str | None=LC_NUMERIC, decimal_quantization: bool=True, group_separator: bool=True, *, numbering_system: Literal['default'] | str='latn') -> str:
   326      """Return the given decimal number formatted for a specific locale.
   327
   328      >>> format_decimal(1.2345, locale='en_US')
   329      u'1.234'
   330      >>> format_decimal(1.2346, locale='en_US')
   331      u'1.235'
   332      >>> format_decimal(-1.2346, locale='en_US')
   333      u'-1.235'
   334      >>> format_decimal(1.2345, locale='sv_SE')
   335      u'1,234'
   336      >>> format_decimal(1.2345, locale='de')
   337      u'1,234'
   338      >>> format_decimal(1.2345, locale='ar_EG', numbering_system='default')
   339      u'1٫234'
   340      >>> format_decimal(1.2345, locale='ar_EG', numbering_system='latn')
   341      u'1.234'
   342
   343      The appropriate thousands grouping and the decimal separator are used for
   344      each locale:
   345
   346      >>> format_decimal(12345.5, locale='en_US')
   347      u'12,345.5'
   348
   349      By default the locale is allowed to truncate and round a high-precision
   350      number by forcing its format pattern onto the decimal part. You can bypass
   351      this behavior with the `decimal_quantization` parameter:
   352
   353      >>> format_decimal(1.2346, locale='en_US')
   354      u'1.235'
   355      >>> format_decimal(1.2346, locale='en_US', decimal_quantization=False)
   356      u'1.2346'
   357      >>> format_decimal(12345.67, locale='fr_CA', group_separator=False)
   358      u'12345,67'
   359      >>> format_decimal(12345.67, locale='en_US', group_separator=True)
   360      u'12,345.67'
   361
   362      :param number: the number to format
   363      :param format:
   364      :param locale: the `Locale` object or locale identifier
   365      :param decimal_quantization: Truncate and round high-precision numbers to
   366                                   the format pattern. Defaults to `True`.
   367      :param group_separator: Boolean to switch group separator on/off in a locale's
   368                              number format.
   369      :param numbering_system: The numbering system used for formatting number symbols. Defaults to "latn".
   370                               The special value "default" will use the default numbering system of the locale.
   371      :raise `UnsupportedNumberingSystemError`: If the numbering system is not supported by the locale.
   372      """
   373      pass
   374
   375  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, numbering_system: Literal['default'] | str='latn') -> str:
   376      """Return the given decimal number formatted for a specific locale in compact form.
   377
   378      >>> format_compact_decimal(12345, format_type="short", locale='en_US')
   379      u'12K'
   380      >>> format_compact_decimal(12345, format_type="long", locale='en_US')
   381      u'12 thousand'
   382      >>> format_compact_decimal(12345, format_type="short", locale='en_US', fraction_digits=2)
   383      u'12.34K'
   384      >>> format_compact_decimal(1234567, format_type="short", locale="ja_JP")
   385      u'123万'
   386      >>> format_compact_decimal(2345678, format_type="long", locale="mk")
   387      u'2 милиони'
   388      >>> format_compact_decimal(21000000, format_type="long", locale="mk")
   389      u'21 милион'
   390      >>> format_compact_decimal(12345, format_type="short", locale='ar_EG', fraction_digits=2, numbering_system='default')
   391      u'12٫34\xa0ألف'
   392
   393      :param number: the number to format
   394      :param format_type: Compact format to use ("short" or "long")
   395      :param locale: the `Locale` object or locale identifier
   396      :param fraction_digits: Number of digits after the decimal point to use. Defaults to `0`.
   397      :param numbering_system: The numbering system used for formatting number symbols. Defaults to "latn".
   398                               The special value "default" will use the default numbering system of the locale.
   399      :raise `UnsupportedNumberingSystemError`: If the numbering system is not supported by the locale.
   400      """
   401      pass
   402
   403  def _get_compact_format(number: float | decimal.Decimal | str, compact_format: LocaleDataDict, locale: Locale, fraction_digits: int) -> tuple[decimal.Decimal, NumberPattern | None]:
   404      """Returns the number after dividing by the unit and the format pattern to use.
   405      The algorithm is described here:
   406      https://www.unicode.org/reports/tr35/tr35-45/tr35-numbers.html#Compact_Number_Formats.
   407      """
   408      pass
   409
   410  class UnknownCurrencyFormatError(KeyError):
   411      """Exception raised when an unknown currency format is requested."""
   412
   413  def format_currency(number: float | decimal.Decimal | str, currency: str, format: str | NumberPattern | 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, *, numbering_system: Literal['default'] | str='latn') -> str:
   414      """Return formatted currency value.
   415
   416      >>> format_currency(1099.98, 'USD', locale='en_US')
   417      '$1,099.98'
   418      >>> format_currency(1099.98, 'USD', locale='es_CO')
   419      u'US$1.099,98'
   420      >>> format_currency(1099.98, 'EUR', locale='de_DE')
   421      u'1.099,98\\xa0\\u20ac'
   422      >>> format_currency(1099.98, 'EGP', locale='ar_EG', numbering_system='default')
   423      u'\u200f1٬099٫98\xa0ج.م.\u200f'
   424
   425      The format can also be specified explicitly.  The currency is
   426      placed with the '¤' sign.  As the sign gets repeated the format
   427      expands (¤ being the symbol, ¤¤ is the currency abbreviation and
   428      ¤¤¤ is the full name of the currency):
   429
   430      >>> format_currency(1099.98, 'EUR', u'¤¤ #,##0.00', locale='en_US')
   431      u'EUR 1,099.98'
   432      >>> format_currency(1099.98, 'EUR', u'#,##0.00 ¤¤¤', locale='en_US')
   433      u'1,099.98 euros'
   434
   435      Currencies usually have a specific number of decimal digits. This function
   436      favours that information over the given format:
   437
   438      >>> format_currency(1099.98, 'JPY', locale='en_US')
   439      u'\\xa51,100'
   440      >>> format_currency(1099.98, 'COP', u'#,##0.00', locale='es_ES')
   441      u'1.099,98'
   442
   443      However, the number of decimal digits can be overridden from the currency
   444      information, by setting the last parameter to ``False``:
   445
   446      >>> format_currency(1099.98, 'JPY', locale='en_US', currency_digits=False)
   447      u'\\xa51,099.98'
   448      >>> format_currency(1099.98, 'COP', u'#,##0.00', locale='es_ES', currency_digits=False)
   449      u'1.099,98'
   450
   451      If a format is not specified the type of currency format to use
   452      from the locale can be specified:
   453
   454      >>> format_currency(1099.98, 'EUR', locale='en_US', format_type='standard')
   455      u'\\u20ac1,099.98'
   456
   457      When the given currency format type is not available, an exception is
   458      raised:
   459
   460      >>> format_currency('1099.98', 'EUR', locale='root', format_type='unknown')
   461      Traceback (most recent call last):
   462          ...
   463      UnknownCurrencyFormatError: "'unknown' is not a known currency format type"
   464
   465      >>> format_currency(101299.98, 'USD', locale='en_US', group_separator=False)
   466      u'$101299.98'
   467
   468      >>> format_currency(101299.98, 'USD', locale='en_US', group_separator=True)
   469      u'$101,299.98'
   470
   471      You can also pass format_type='name' to use long display names. The order of
   472      the number and currency name, along with the correct localized plural form
   473      of the currency name, is chosen according to locale:
   474
   475      >>> format_currency(1, 'USD', locale='en_US', format_type='name')
   476      u'1.00 US dollar'
   477      >>> format_currency(1099.98, 'USD', locale='en_US', format_type='name')
   478      u'1,099.98 US dollars'
   479      >>> format_currency(1099.98, 'USD', locale='ee', format_type='name')
   480      u'us ga dollar 1,099.98'
   481
   482      By default the locale is allowed to truncate and round a high-precision
   483      number by forcing its format pattern onto the decimal part. You can bypass
   484      this behavior with the `decimal_quantization` parameter:
   485
   486      >>> format_currency(1099.9876, 'USD', locale='en_US')
   487      u'$1,099.99'
   488      >>> format_currency(1099.9876, 'USD', locale='en_US', decimal_quantization=False)
   489      u'$1,099.9876'
   490
   491      :param number: the number to format
   492      :param currency: the currency code
   493      :param format: the format string to use
   494      :param locale: the `Locale` object or locale identifier
   495      :param currency_digits: use the currency's natural number of decimal digits
   496      :param format_type: the currency format type to use
   497      :param decimal_quantization: Truncate and round high-precision numbers to
   498                                   the format pattern. Defaults to `True`.
   499      :param group_separator: Boolean to switch group separa<response clipped><NOTE>Due to the max output limit, only part of the full response has been shown to you.</NOTE>US', fraction_digits=2)
   513      u'$123.46M'
   514      >>> format_compact_currency(123456789, 'EUR', locale='de_DE', fraction_digits=1)
   515      '123,5\xa0Mio.\xa0€'
   516
   517      :param number: the number to format
   518      :param currency: the currency code
   519      :param format_type: the compact format type to use. Defaults to "short".
   520      :param locale: the `Locale` object or locale identifier
   521      :param fraction_digits: Number of digits after the decimal point to use. Defaults to `0`.
   522      :param numbering_system: The numbering system used for formatting number symbols. Defaults to "latn".
   523                               The special value "default" will use the default numbering system of the locale.
   524      :raise `UnsupportedNumberingSystemError`: If the numbering system is not supported by the locale.
   525      """
   526      pass
   527
   528  def format_percent(number: float | decimal.Decimal | str, format: str | NumberPattern | None=None, locale: Locale | str | None=LC_NUMERIC, decimal_quantization: bool=True, group_separator: bool=True, *, numbering_system: Literal['default'] | str='latn') -> str:
   529      """Return formatted percent value for a specific locale.
   530
   531      >>> format_percent(0.34, locale='en_US')
   532      u'34%'
   533      >>> format_percent(25.1234, locale='en_US')
   534      u'2,512%'
   535      >>> format_percent(25.1234, locale='sv_SE')
   536      u'2\\xa0512\\xa0%'
   537      >>> format_percent(25.1234, locale='ar_EG', numbering_system='default')
   538      u'2٬512%'
   539
   540      The format pattern can also be specified explicitly:
   541
   542      >>> format_percent(25.1234, u'#,##0‰', locale='en_US')
   543      u'25,123‰'
   544
   545      By default the locale is allowed to truncate and round a high-precision
   546      number by forcing its format pattern onto the decimal part. You can bypass
   547      this behavior with the `decimal_quantization` parameter:
   548
   549      >>> format_percent(23.9876, locale='en_US')
   550      u'2,399%'
   551      >>> format_percent(23.9876, locale='en_US', decimal_quantization=False)
   552      u'2,398.76%'
   553
   554      >>> format_percent(229291.1234, locale='pt_BR', group_separator=False)
   555      u'22929112%'
   556
   557      >>> format_percent(229291.1234, locale='pt_BR', group_separator=True)
   558      u'22.929.112%'
   559
   560      :param number: the percent number to format
   561      :param format:
   562      :param locale: the `Locale` object or locale identifier
   563      :param decimal_quantization: Truncate and round high-precision numbers to
   564                                   the format pattern. Defaults to `True`.
   565      :param group_separator: Boolean to switch group separator on/off in a locale's
   566                              number format.
   567      :param numbering_system: The numbering system used for formatting number symbols. Defaults to "latn".
   568                               The special value "default" will use the default numbering system of the locale.
   569      :raise `UnsupportedNumberingSystemError`: If the numbering system is not supported by the locale.
   570      """
   571      pass
   572
   573  def format_scientific(number: float | decimal.Decimal | str, format: str | NumberPattern | None=None, locale: Locale | str | None=LC_NUMERIC, decimal_quantization: bool=True, *, numbering_system: Literal['default'] | str='latn') -> str:
   574      """Return value formatted in scientific notation for a specific locale.
   575
   576      >>> format_scientific(10000, locale='en_US')
   577      u'1E4'
   578      >>> format_scientific(10000, locale='ar_EG', numbering_system='default')
   579      u'1اس4'
   580
   581      The format pattern can also be specified explicitly:
   582
   583      >>> format_scientific(1234567, u'##0.##E00', locale='en_US')
   584      u'1.23E06'
   585
   586      By default the locale is allowed to truncate and round a high-precision
   587      number by forcing its format pattern onto the decimal part. You can bypass
   588      this behavior with the `decimal_quantization` parameter:
   589
   590      >>> format_scientific(1234.9876, u'#.##E0', locale='en_US')
   591      u'1.23E3'
   592      >>> format_scientific(1234.9876, u'#.##E0', locale='en_US', decimal_quantization=False)
   593      u'1.2349876E3'
   594
   595      :param number: the number to format
   596      :param format:
   597      :param locale: the `Locale` object or locale identifier
   598      :param decimal_quantization: Truncate and round high-precision numbers to
   599                                   the format pattern. Defaults to `True`.
   600      :param numbering_system: The numbering system used for formatting number symbols. Defaults to "latn".
   601                               The special value "default" will use the default numbering system of the locale.
   602      :raise `UnsupportedNumberingSystemError`: If the numbering system is not supported by the locale.
   603      """
   604      pass
   605
   606  class NumberFormatError(ValueError):
   607      """Exception raised when a string cannot be parsed into a number."""
   608
   609      def __init__(self, message: str, suggestions: list[str] | None=None) -> None:
   610          super().__init__(message)
   611          self.suggestions = suggestions
   612
   613  def parse_number(string: str, locale: Locale | str | None=LC_NUMERIC, *, numbering_system: Literal['default'] | str='latn') -> int:
   614      """Parse localized number string into an integer.
   615
   616      >>> parse_number('1,099', locale='en_US')
   617      1099
   618      >>> parse_number('1.099', locale='de_DE')
   619      1099
   620
   621      When the given string cannot be parsed, an exception is raised:
   622
   623      >>> parse_number('1.099,98', locale='de')
   624      Traceback (most recent call last):
   625          ...
   626      NumberFormatError: '1.099,98' is not a valid number
   627
   628      :param string: the string to parse
   629      :param locale: the `Locale` object or locale identifier
   630      :param numbering_system: The numbering system used for formatting number symbols. Defaults to "latn".
   631                               The special value "default" will use the default numbering system of the locale.
   632      :return: the parsed number
   633      :raise `NumberFormatError`: if the string can not be converted to a number
   634      :raise `UnsupportedNumberingSystemError`: if the numbering system is not supported by the locale.
   635      """
   636      pass
   637
   638  def parse_decimal(string: str, locale: Locale | str | None=LC_NUMERIC, strict: bool=False, *, numbering_system: Literal['default'] | str='latn') -> decimal.Decimal:
   639      """Parse localized decimal string into a decimal.
   640
   641      >>> parse_decimal('1,099.98', locale='en_US')
   642      Decimal('1099.98')
   643      >>> parse_decimal('1.099,98', locale='de')
   644      Decimal('1099.98')
   645      >>> parse_decimal('12 345,123', locale='ru')
   646      Decimal('12345.123')
   647      >>> parse_decimal('1٬099٫98', locale='ar_EG', numbering_system='default')
   648      Decimal('1099.98')
   649
   650      When the given string cannot be parsed, an exception is raised:
   651
   652      >>> parse_decimal('2,109,998', locale='de')
   653      Traceback (most recent call last):
   654          ...
   655      NumberFormatError: '2,109,998' is not a valid decimal number
   656
   657      If `strict` is set to `True` and the given string contains a number
   658      formatted in an irregular way, an exception is raised:
   659
   660      >>> parse_decimal('30.00', locale='de', strict=True)
   661      Traceback (most recent call last):
   662          ...
   663      NumberFormatError: '30.00' is not a properly formatted decimal number. Did you mean '3.000'? Or maybe '30,00'?
   664
   665      >>> parse_decimal('0.00', locale='de', strict=True)
   666      Traceback (most recent call last):
   667          ...
   668      NumberFormatError: '0.00' is not a properly formatted decimal number. Did you mean '0'?
   669
   670      :param string: the string to parse
   671      :param locale: the `Locale` object or locale identifier
   672      :param strict: controls whether numbers formatted in a weird way are
   673                     accepted or rejected
   674      :param numbering_system: The numbering system used for formatting number symbols. Defaults to "latn".
   675                               The special value "default" will use the default numbering system of the locale.
   676      :raise NumberFormatError: if the string can not be converted to a
   677                                decimal number
   678      :raise UnsupportedNumberingSystemError: if the numbering system is not supported by the locale.
   679      """
   680      pass
   681
   682  def _remove_trailing_zeros_after_decimal(string: str, decimal_symbol: str) -> str:
   683      """
   684      Remove trailing zeros from the decimal part of a numeric string.
   685
   686      This function takes a string representing a numeric value and a decimal symbol.
   687      It removes any trailing zeros that appear after the decimal symbol in the number.
   688      If the decimal part becomes empty after removing trailing zeros, the decimal symbol
   689      is also removed. If the string does not contain the decimal symbol, it is returned unchanged.
   690
   691      :param string: The numeric string from which to remove trailing zeros.
   692      :type string: str
   693      :param decimal_symbol: The symbol used to denote the decimal point.
   694      :type decimal_symbol: str
   695      :return: The numeric string with trailing zeros removed from its decimal part.
   696      :rtype: str
   697
   698      Example:
   699      >>> _remove_trailing_zeros_after_decimal("123.4500", ".")
   700      '123.45'
   701      >>> _remove_trailing_zeros_after_decimal("100.000", ".")
   702      '100'
   703      >>> _remove_trailing_zeros_after_decimal("100", ".")
   704      '100'
   705      """
   706      pass
   707  PREFIX_END = '[^0-9@#.,]'
   708  NUMBER_TOKEN = '[0-9@#.,E+]'
   709  PREFIX_PATTERN = "(?P<prefix>(?:'[^']*'|%s)*)" % PREFIX_END
   710  NUMBER_PATTERN = '(?P<number>%s*)' % NUMBER_TOKEN
   711  SUFFIX_PATTERN = '(?P<suffix>.*)'
   712  number_re = re.compile(f'{PREFIX_PATTERN}{NUMBER_PATTERN}{SUFFIX_PATTERN}')
   713
   714  def parse_grouping(p: str) -> tuple[int, int]:
   715      """Parse primary and secondary digit grouping
   716
   717      >>> parse_grouping('##')
   718      (1000, 1000)
   719      >>> parse_grouping('#,###')
   720      (3, 3)
   721      >>> parse_grouping('#,####,###')
   722      (3, 4)
   723      """
   724      pass
   725
   726  def parse_pattern(pattern: NumberPattern | str) -> NumberPattern:
   727      """Parse number format patterns"""
   728      pass
   729
   730  class NumberPattern:
   731
   732      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:
   733          self.pattern = pattern
   734          self.prefix = prefix
   735          self.suffix = suffix
   736          self.number_pattern = number_pattern
   737          self.grouping = grouping
   738          self.int_prec = int_prec
   739          self.frac_prec = frac_prec
   740          self.exp_prec = exp_prec
   741          self.exp_plus = exp_plus
   742          self.scale = self.compute_scale()
   743
   744      def __repr__(self) -> str:
   745          return f'<{type(self).__name__} {self.pattern!r}>'
   746
   747      def compute_scale(self) -> Literal[0, 2, 3]:
   748          """Return the scaling factor to apply to the number before rendering.
   749
   750          Auto-set to a factor of 2 or 3 if presence of a ``%`` or ``‰`` sign is
   751          detected in the prefix or suffix of the pattern. Default is to not mess
   752          with the scale at all and keep it to 0.
   753          """
   754          pass
   755
   756      def scientific_notation_elements(self, value: decimal.Decimal, locale: Locale | str | None, *, numbering_system: Literal['default'] | str='latn') -> tuple[decimal.Decimal, int, str]:
   757          """ Returns normalized scientific notation components of a value.
   758          """
   759          pass
   760
   761      def apply(self, value: float | decimal.Decimal | str, locale: Locale | str | None, currency: str | None=None, currency_digits: bool=True, decimal_quantization: bool=True, force_frac: tuple[int, int] | None=None, group_separator: bool=True, *, numbering_system: Literal['default'] | str='latn'):
   762          """Renders into a string a number following the defined pattern.
   763
   764          Forced decimal quantization is active by default so we'll produce a
   765          number string that is strictly following CLDR pattern definitions.
   766
   767          :param value: The value to format. If this is not a Decimal object,
   768                        it will be cast to one.
   769          :type value: decimal.Decimal|float|int
   770          :param locale: The locale to use for formatting.
   771          :type locale: str|babel.core.Locale
   772          :param currency: Which currency, if any, to format as.
   773          :type currency: str|None
   774          :param currency_digits: Whether or not to use the currency's precision.
   775                                  If false, the pattern's precision is used.
   776          :type currency_digits: bool
   777          :param decimal_quantization: Whether decimal numbers should be forcibly
   778                                       quantized to produce a formatted output
   779                                       strictly matching the CLDR definition for
   780                                       the locale.
   781          :type decimal_quantization: bool
   782          :param force_frac: DEPRECATED - a forced override for `self.frac_prec`
   783                             for a single formatting invocation.
   784          :param numbering_system: The numbering system used for formatting number symbols. Defaults to "latn".
   785                                   The special value "default" will use the default numbering system of the locale.
   786          :return: Formatted decimal string.
   787          :rtype: str
   788          :raise UnsupportedNumberingSystemError: If the numbering system is not supported by the locale.
   789          """
   790          pass
[The command completed with exit code 0.]
[Current working directory: /workspace/babel]
[Python interpreter: /usr/bin/python]
[Command finished with exit code 0]