### Install Quart-Babel Python Package

Source: https://github.com/quart-addons/quart-babel/blob/master/docs/how_to_guides/installation.rst

Installs the Quart-Babel extension and its required dependencies (Quart, Babel, pytz) using the pip package manager. Ensure Python 3.7 or higher is installed; Python 3.8+ is recommended to avoid specific error messages.

```Console
pip install quart-babel
```

--------------------------------

### Install Quart-Babel Extension

Source: https://github.com/quart-addons/quart-babel/blob/master/README.md

This command installs the Quart-Babel extension using pip3, ensuring all necessary dependencies like babel and pytz are also installed.

```Shell
$ pip3 install quart-babel
```

--------------------------------

### Initialize a New Translation Language

Source: https://github.com/quart-addons/quart-babel/blob/master/docs/how_to_guides/translating.rst

To start a new translation, use `pybabel init` with the generated `messages.pot` file, specifying the desired output directory (e.g., `translations`) and the target language locale (e.g., `de` for German). This creates a `.po` file ready for translation.

```shell
$ pybabel init -i messages.pot -d translations -l de
```

--------------------------------

### Format Datetime with Quart-Babel Examples

Source: https://github.com/quart-addons/quart-babel/blob/master/docs/how_to_guides/formatting_dates.rst

Illustrates various ways to format a `datetime` object using `format_datetime` from `quart_babel`. Examples include default formatting, 'full', 'short', and custom format strings, showcasing the flexibility of the function.

```python
from quart_babel import format_datetime
from datetime import datetime

# Default format
result_default = format_datetime(datetime(1987, 3, 5, 17, 12))
# result_default: u'Mar 5, 1987 5:12:00 PM'

# Full format
result_full = format_datetime(datetime(1987, 3, 5, 17, 12), 'full')
# result_full: u'Thursday, March 5, 1987 5:12:00 PM World (GMT) Time'

# Short format
result_short = format_datetime(datetime(1987, 3, 5, 17, 12), 'short')
# result_short: u'3/5/87 5:12 PM'

# Custom format 'dd mm yyy'
result_custom1 = format_datetime(datetime(1987, 3, 5, 17, 12), 'dd mm yyy')
# result_custom1: u'05 12 1987'

# Custom format 'dd mm yyyy'
result_custom2 = format_datetime(datetime(1987, 3, 5, 17, 12), 'dd mm yyyy')
# result_custom2: u'05 12 1987'
```

--------------------------------

### Configure Babel Mapping for Python and Jinja2 Files

Source: https://github.com/quart-addons/quart-babel/blob/master/docs/how_to_guides/translating.rst

Create a `babel.cfg` file to specify which file types (e.g., Python source files, Jinja2 templates) Babel should scan for translatable strings. This configuration guides the string extraction process.

```ini
[python: **.py]
[jinja2: **/templates/**.html]
```

--------------------------------

### Get Current Locale (Quart-Babel)

Source: https://github.com/quart-addons/quart-babel/blob/master/docs/references/api/locale.rst

Retrieves the current active locale for the Quart application. This function typically determines the locale based on request headers or application configuration.

```APIDOC
quart_babel.get_locale()
  Purpose: Retrieves the current active locale for the Quart application.
  Returns: str: The current locale string (e.g., 'en', 'fr_FR').
```

--------------------------------

### Initialize Quart-Babel Extension

Source: https://github.com/quart-addons/quart-babel/blob/master/docs/how_to_guides/configuration.rst

Demonstrates two methods for initializing the Quart-Babel extension: direct instantiation with the application object and using the factory `init_app` method for deferred initialization.

```python
from quart import Quart
from quart_babel import Babel

app = Quart(__name__)
babel = Babel(app)
```

```python
babel.init_app(app)
```

--------------------------------

### Set up Quart Test Request Context

Source: https://github.com/quart-addons/quart-babel/blob/master/docs/how_to_guides/formatting_dates.rst

Demonstrates how to push a test request context onto the application stack, which is necessary for testing date formatting functions outside of a live request environment.

```python
app.test_request_context().push()
```

--------------------------------

### Extract Translatable Strings to a POT File

Source: https://github.com/quart-addons/quart-babel/blob/master/docs/how_to_guides/translating.rst

Use the `pybabel extract` command with your `babel.cfg` mapping file to scan your application's source code and generate a `messages.pot` (Portable Object Template) file. This file contains all marked strings and serves as a template for translations.

```shell
$ pybabel extract -F babel.cfg -o messages.pot .
```

--------------------------------

### Compile Translations for Application Use

Source: https://github.com/quart-addons/quart-babel/blob/master/docs/how_to_guides/translating.rst

After editing the `.po` translation files, compile them into binary `.mo` files using `pybabel compile`. These compiled files are what your application will use at runtime to display translated strings.

```shell
$ pybabel compile -d translations
```

--------------------------------

### Pushing Quart Test Request Context

Source: https://github.com/quart-addons/quart-babel/blob/master/docs/how_to_guides/formatting_numbers.rst

Demonstrates how to push a test request context onto the application stack, which is useful for interacting with Quart's features from a console or script.

```python
>>> app.test_request_context().push()
```

--------------------------------

### Initialize Quart-Babel with Quart App

Source: https://github.com/quart-addons/quart-babel/blob/master/README.md

This snippet demonstrates how to import the Babel class from quart_babel and initialize it by passing a Quart application instance, enabling i18n/l10n features for the application.

```Python
from quart import Quart
from quart_babel import Babel 

app = Quart(__name__)
babel = Babel(app)
```

--------------------------------

### Quart-Babel Core Classes API Reference

Source: https://github.com/quart-addons/quart-babel/blob/master/docs/references/api/core.rst

Documentation for the main classes `quart_babel.BabelConfiguration` and `quart_babel.Babel`, outlining their purpose and available members as generated by Sphinx's `autoclass` directive.

```APIDOC
quart_babel.BabelConfiguration:
  Type: Class
  Description: Manages configuration settings for Babel within a Quart application, typically used for setting up locales, timezones, and default values.
  Members:
    (All public methods and attributes of BabelConfiguration are documented here)

quart_babel.Babel:
  Type: Class
  Description: The main extension class for integrating Babel with Quart, providing internationalization and localization support by handling locale selection and text translation.
  Members:
    (All public methods and attributes of Babel are documented here)
```

--------------------------------

### Quart-Babel API Module Index

Source: https://github.com/quart-addons/quart-babel/blob/master/docs/references/api/index.rst

Lists the main modules comprising the Quart-Babel API, including core functionalities, domain-specific features, data formatting, lazy string implementation, locale and timezone handling, and general utilities.

```APIDOC
API Reference Modules:
  core.rst
  domain.rst
  formats.rst
  lazystring.rst
  locale.rst
  timezone.rst
  utils.rst
```

--------------------------------

### Quart-Babel Utility Functions API

Source: https://github.com/quart-addons/quart-babel/blob/master/docs/references/api/utils.rst

Provides API documentation for core utility functions within the Quart-Babel extension.

```APIDOC
Utilities:
  - quart_babel.get_babel
  - quart_babel.refresh
```

--------------------------------

### Quart-Babel Configuration Variables

Source: https://github.com/quart-addons/quart-babel/blob/master/docs/how_to_guides/configuration.rst

Details the configuration variables available for customizing Quart-Babel's behavior, including default locale, timezone, translation domain, and translation directories.

```APIDOC
BABEL_DEFAULT_LOCALE:
  Type: str
  Default: 'en_US'
  Description: The default locale to use if no locale selector is registered.
BABEL_DEFAULT_TIMEZONE:
  Type: str
  Default: 'UTC'
  Description: The timezone to use for user facing dates.
BABEL_DOMAIN:
  Type: str | list[str]
  Default: "messages"
  Description: The default translation domain(s).
BABEL_TRANSLATION_DIRECTORIES:
  Type: str | list[str]
  Default: "translations"
  Description: The directories where translations can be found.
```

--------------------------------

### Formatting Numbers with Default English Locale

Source: https://github.com/quart-addons/quart-babel/blob/master/docs/how_to_guides/formatting_numbers.rst

Illustrates the usage of various `quart-babel` functions for number formatting, including `format_number`, `format_decimal`, `format_currency`, `format_percent`, and `format_scientific`, showing their output with the default English locale.

```python
>>> from quart_babel import format_number
>>> format_number(1099)
'1,099'

>>> from quart_babel import format_decimal
>>> format_decimal(1.2346)
u'1.235'

>>> from quart_babel import format_currency
>>> format_currency(1099.98, 'USD')
'$1,099.98'

>>> from quart_babel import format_percent
>>> format_percent(0.34)
'34%'

>>> from quart_babel import format_scientific
>>> format_scientific(10000)
'1E4'
```

--------------------------------

### Implement Custom Locale and Timezone Selectors

Source: https://github.com/quart-addons/quart-babel/blob/master/docs/how_to_guides/configuration.rst

Demonstrates how to implement custom locale and timezone selector functions (`get_locale`, `get_timezone`) for Quart-Babel, allowing dynamic determination of user-specific locale and timezone based on user settings or request headers.

```python
from quart import Quart, g, request

def get_locale():
    # if a user is logged in, use the locale from the user settings
    user = getattr(g, 'user', None)
    if user is not None:
        return user.locale
    # otherwise try to guess the language from the user accept
    # header the browser transmits.  We support de/fr/en in this
    # example.  The best match wins.
    return request.accept_languages.best_match(['de', 'fr', 'en'])

def get_timezone():
    user = getattr(g, 'user', None)
    if user is not None:
        return user.timezone

app = Quart(__name__)
babel = Babel(app, locale_selector=get_locale, timezone_selector=get_timezone)
```

--------------------------------

### API Reference for quart_babel Internationalization Functions

Source: https://github.com/quart-addons/quart-babel/blob/master/docs/references/api/domain.rst

Documents various `gettext` functions provided by `quart_babel` for handling string translation. This includes functions for singular/plural forms (`ngettext`), context-aware translation (`pgettext`), and lazy evaluation versions for deferred translation.

```APIDOC
quart_babel.gettext
quart_babel.ngettext
quart_babel.npgettext
quart_babel.pgettext
quart_babel.lazy_gettext
quart_babel.lazy_ngettext
quart_babel.lazy_pgettext
```

--------------------------------

### Extract Strings Including lazy_gettext Calls

Source: https://github.com/quart-addons/quart-babel/blob/master/docs/how_to_guides/translating.rst

If your application uses `lazy_gettext` for deferred string translation, you must explicitly tell `pybabel` to look for these calls during extraction using the `-k` flag. This ensures all relevant strings are included in the `messages.pot` file.

```shell
$ pybabel extract -F babel.cfg -k lazy_gettext -o messages.pot .
```

--------------------------------

### Configure Quart Development Server for Translation Reloading

Source: https://github.com/quart-addons/quart-babel/blob/master/docs/how_to_guides/reloading.rst

This snippet demonstrates how to configure the Quart development server to automatically reload translations by watching compiled `.mo` files. It shows two methods: directly passing `--extra-files` to `quart run` or setting the `QUART_RUN_EXTRA_FILES` environment variable before running the server. This ensures that changes to translation files are reflected without manual server restarts.

```Shell
$ quart run --extra-files app/translations/en_GB/LC_MESSAGES/messages.mo
```

```Shell
export QUART_RUN_EXTRA_FILES=app/translations/en_GB/LC_MESSAGES/messages.mo
quart run
```

--------------------------------

### API Reference for quart_babel.Domain Class

Source: https://github.com/quart-addons/quart-babel/blob/master/docs/references/api/domain.rst

Documents the `Domain` class within `quart_babel`, which is responsible for managing translation domains. It typically involves specifying a translation directory and a default language for internationalization.

```APIDOC
quart_babel.Domain
  :members:
```

--------------------------------

### Jinja Date and Time Formatting Filters

Source: https://github.com/quart-addons/quart-babel/blob/master/docs/how_to_guides/jinja_filters.rst

Lists Jinja template filters provided by quart-babel for formatting datetime, date, time, and timedelta objects, mapping them to their corresponding Python formatting functions.

```Jinja
Jinja Date and Time Filters:
- <datetime>|datetimeformat -> format_datetime
- <date>|dateformat -> format_date
- <time>|timeformat -> format_time
- <timedelta>|timedeltaformat -> format_timedelta
```

--------------------------------

### API Reference: quart_babel.speaklater.LazyString

Source: https://github.com/quart-addons/quart-babel/blob/master/docs/references/api/lazystring.rst

Detailed API documentation for the `LazyString` class, including its constructor and special methods. This class allows for the delayed resolution of string values, improving performance and flexibility in applications, especially those requiring dynamic content or internationalization.

```APIDOC
Class: quart_babel.speaklater.LazyString
Description: A class that defers the evaluation of a string until it is explicitly converted to a string.
Purpose: To provide lazy string evaluation, commonly used in internationalization (i18n) to delay translation until the string is actually used.

Methods:
  __init__(func, *args, **kwargs)
    Description: Initializes a LazyString instance.
    Parameters:
      func (callable): The function to call to produce the string.
      *args: Positional arguments to pass to 'func'.
      **kwargs: Keyword arguments to pass to 'func'.
    Returns: None

  __str__()
    Description: Resolves and returns the string value.
    Parameters: None
    Returns: str: The resolved string value.

  __repr__()
    Description: Returns a developer-friendly representation of the LazyString instance.
    Parameters: None
    Returns: str: A string representation indicating the lazy nature.

  __add__(other)
    Description: Implements string concatenation.
    Parameters:
      other (str): The string to concatenate with.
    Returns: LazyString: A new LazyString representing the concatenated result.

  __radd__(other)
    Description: Implements reverse string concatenation.
    Parameters:
      other (str): The string to concatenate with.
    Returns: LazyString: A new LazyString representing the concatenated result.

  __mod__(args)
    Description: Implements string formatting using the '%' operator.
    Parameters:
      args (tuple or dict): Arguments for string formatting.
    Returns: LazyString: A new LazyString representing the formatted result.

  __rmod__(args)
    Description: Implements reverse string formatting using the '%' operator.
    Parameters:
      args (tuple or dict): Arguments for string formatting.
    Returns: LazyString: A new LazyString representing the formatted result.

  __len__()
    Description: Returns the length of the resolved string.
    Parameters: None
    Returns: int: The length of the resolved string.

  __getitem__(key)
    Description: Implements item access (e.g., slicing) on the resolved string.
    Parameters:
      key (slice or int): The index or slice.
    Returns: str or LazyString: The result of the item access.

  __eq__(other)
    Description: Implements equality comparison.
    Parameters:
      other (any): The object to compare with.
    Returns: bool: True if equal, False otherwise.

  __ne__(other)
    Description: Implements inequality comparison.
    Parameters:
      other (any): The object to compare with.
    Returns: bool: True if not equal, False otherwise.

  __lt__(other)
    Description: Implements less than comparison.
    Parameters:
      other (any): The object to compare with.
    Returns: bool: True if less than, False otherwise.

  __le__(other)
    Description: Implements less than or equal to comparison.
    Parameters:
      other (any): The object to compare with.
    Returns: bool: True if less than or equal to, False otherwise.

  __gt__(other)
    Description: Implements greater than comparison.
    Parameters:
      other (any): The object to compare with.
    Returns: bool: True if greater than, False otherwise.

  __ge__(other)
    Description: Implements greater than or equal to comparison.
    Parameters:
      other (any): The object to compare with.
    Returns: bool: True if greater than or equal to, False otherwise.

  __hash__()
    Description: Implements hashing for the object.
    Parameters: None
    Returns: int: The hash value.

  __contains__(item)
    Description: Implements 'in' operator.
    Parameters:
      item (str): The substring to check for.
    Returns: bool: True if 'item' is in the resolved string, False otherwise.

  __bool__()
    Description: Implements boolean conversion.
    Parameters: None
    Returns: bool: True if the resolved string is truthy, False otherwise.
```

--------------------------------

### Quart-Babel Formatting Functions API Reference

Source: https://github.com/quart-addons/quart-babel/blob/master/docs/references/api/formats.rst

Detailed API documentation for `quart-babel` functions used to format various data types including dates, times, numbers, currencies, percentages, and scientific notation.

```APIDOC
quart_babel.format_date(date, format='medium', locale=None)
  Description: Formats a date value according to the specified format and locale.
  Parameters:
    date: (date-like object) The date value to format.
    format: (str, optional) The format string or predefined format ('short', 'medium', 'long', 'full'). Defaults to 'medium'.
    locale: (str, optional) The locale to use for formatting. If None, the current locale is used.
  Returns: str - The formatted date string.
```

```APIDOC
quart_babel.format_datetime(datetime, format='medium', locale=None)
  Description: Formats a datetime value according to the specified format and locale.
  Parameters:
    datetime: (datetime-like object) The datetime value to format.
    format: (str, optional) The format string or predefined format ('short', 'medium', 'long', 'full'). Defaults to 'medium'.
    locale: (str, optional) The locale to use for formatting. If None, the current locale is used.
  Returns: str - The formatted datetime string.
```

```APIDOC
quart_babel.format_time(time, format='medium', locale=None)
  Description: Formats a time value according to the specified format and locale.
  Parameters:
    time: (time-like object) The time value to format.
    format: (str, optional) The format string or predefined format ('short', 'medium', 'long', 'full'). Defaults to 'medium'.
    locale: (str, optional) The locale to use for formatting. If None, the current locale is used.
  Returns: str - The formatted time string.
```

```APIDOC
quart_babel.format_timedelta(timedelta, format='medium', locale=None)
  Description: Formats a timedelta value according to the specified format and locale.
  Parameters:
    timedelta: (timedelta object) The timedelta value to format.
    format: (str, optional) The format string or predefined format ('short', 'medium', 'long', 'full'). Defaults to 'medium'.
    locale: (str, optional) The locale to use for formatting. If None, the current locale is used.
  Returns: str - The formatted timedelta string.
```

```APIDOC
quart_babel.format_currency(value, currency='USD', format=None, locale=None)
  Description: Formats a numeric value as a currency string.
  Parameters:
    value: (numeric) The number to format.
    currency: (str) The currency code (e.g., 'USD', 'EUR'). Defaults to 'USD'.
    format: (str, optional) The format string.
    locale: (str, optional) The locale to use for formatting. If None, the current locale is used.
  Returns: str - The formatted currency string.
```

```APIDOC
quart_babel.format_decimal(value, format=None, locale=None)
  Description: Formats a numeric value as a decimal string.
  Parameters:
    value: (numeric) The number to format.
    format: (str, optional) The format string.
    locale: (str, optional) The locale to use for formatting. If None, the current locale is used.
  Returns: str - The formatted decimal string.
```

```APIDOC
quart_babel.format_number(value, format=None, locale=None)
  Description: Formats a numeric value as a general number string.
  Parameters:
    value: (numeric) The number to format.
    format: (str, optional) The format string.
    locale: (str, optional) The locale to use for formatting. If None, the current locale is used.
  Returns: str - The formatted number string.
```

```APIDOC
quart_babel.format_percent(value, format=None, locale=None)
  Description: Formats a numeric value as a percentage string.
  Parameters:
    value: (numeric) The number to format.
    format: (str, optional) The format string.
    locale: (str, optional) The locale to use for formatting. If None, the current locale is used.
  Returns: str - The formatted percentage string.
```

```APIDOC
quart_babel.format_scientific(value, format=None, locale=None)
  Description: Formats a numeric value in scientific notation.
  Parameters:
    value: (numeric) The number to format.
    format: (str, optional) The format string.
    locale: (str, optional) The locale to use for formatting. If None, the current locale is used.
  Returns: str - The formatted scientific notation string.
```

--------------------------------

### Update Existing Translations After String Changes

Source: https://github.com/quart-addons/quart-babel/blob/master/docs/how_to_guides/translating.rst

When source strings change, regenerate the `messages.pot` file and then use `pybabel update` to merge the changes into your existing `.po` translation files. This command helps identify new or modified strings, often marking them as 'fuzzy' for manual review.

```shell
$ pybabel update -i messages.pot -d translations
```

--------------------------------

### Jinja Number Formatting Filters

Source: https://github.com/quart-addons/quart-babel/blob/master/docs/how_to_guides/jinja_filters.rst

Lists Jinja template filters provided by quart-babel for formatting various number types, mapping them to their corresponding Python formatting functions.

```Jinja
Jinja Number Filters:
- <number>|numberformat -> format_number
- <number>|decimalformat -> format_decimal
- <number>|currencyformat -> format_currency
- <number>|percentformat -> format_percent
- <number>|scientificformat -> format_scientific
```

--------------------------------

### Formatting Numbers with German Locale

Source: https://github.com/quart-addons/quart-babel/blob/master/docs/how_to_guides/formatting_numbers.rst

Shows the behavior of `quart-babel` number formatting functions (`format_number`, `format_decimal`, `format_currency`, `format_percent`, `format_scientific`) when the default locale is set to German, highlighting locale-specific formatting differences.

```python
>>> format_number(1099)
'1.099'

>>> format_decimal(1.2346)
'1,235'

>>> format_currency(1099.98, 'USD')
'1.099,98\xa0$'

>>> format_percent(0.34)
'34\xa0%'

>>> format_scientific(10000)
'1E4'
```

--------------------------------

### Verify LC_CTYPE Encoding on macOS

Source: https://github.com/quart-addons/quart-babel/blob/master/docs/how_to_guides/troubleshooting.rst

This command checks the current value of the LC_CTYPE environment variable. On macOS, especially older versions like Snow Leopard, pybabel may fail if this is not set to UTF-8, indicating a locale configuration issue.

```console
$ echo $LC_CTYPE
```

--------------------------------

### Quart-Babel Timezone API Reference

Source: https://github.com/quart-addons/quart-babel/blob/master/docs/references/api/timezone.rst

Detailed API documentation for functions within the `quart_babel` library that facilitate timezone management, including fetching the current timezone, converting datetimes to a user's local timezone, and converting datetimes to UTC.

```APIDOC
quart_babel.get_timezone:
  Purpose: Retrieves the current timezone configured for the application or user.
  Returns: A timezone object (e.g., pytz.timezone or similar).

quart_babel.to_user_timezone(datetime_obj):
  Purpose: Converts a given datetime object to the user's local timezone.
  Parameters:
    datetime_obj: The datetime object to convert. It is typically timezone-aware.
  Returns: A new datetime object adjusted to the user's timezone.

quart_babel.to_utc(datetime_obj):
  Purpose: Converts a given datetime object to Coordinated Universal Time (UTC).
  Parameters:
    datetime_obj: The datetime object to convert. It is typically timezone-aware.
  Returns: A new datetime object adjusted to UTC.
```

--------------------------------

### Setting Quart-Babel Default Locale to German

Source: https://github.com/quart-addons/quart-babel/blob/master/docs/how_to_guides/formatting_numbers.rst

Demonstrates how to change the default locale for `quart-babel` to 'de' (German) using `app.config` and then refreshes the Babel settings to apply the change.

```python
>>> app.config['BABEL_DEFAULT_LOCALE'] = 'de'
>>> from quart_babel import refresh; refresh()
```

--------------------------------

### Set LC_CTYPE to UTF-8 for pybabel on macOS

Source: https://github.com/quart-addons/quart-babel/blob/master/docs/how_to_guides/troubleshooting.rst

To resolve pybabel failures caused by incorrect character encoding on macOS, add this line to your ~/.profile file. It explicitly sets the LC_CTYPE environment variable to en_US.utf-8, ensuring proper locale configuration for pybabel. A terminal restart is required after modification.

```console
export LC_CTYPE=en_US.utf-8
```

--------------------------------

### Format Datetime with Custom Locale in Quart-Babel

Source: https://github.com/quart-addons/quart-babel/blob/master/docs/how_to_guides/formatting_dates.rst

Demonstrates how to change the default locale for `quart-babel` by setting `BABEL_DEFAULT_LOCALE` in the application configuration and refreshing the settings. This allows for formatting datetime objects according to different language conventions, such as German.

```python
app.config['BABEL_DEFAULT_LOCALE'] = 'de'
from quart_babel import refresh; refresh()

# Format datetime in German locale
result_de = format_datetime(datetime(1987, 3, 5, 17, 12), 'EEEE, d. MMMM yyyy H:mm')
# result_de: u'Donnerstag, 5. M\xe4rz 1987 17:12'
```

--------------------------------

### Force Locale (Quart-Babel)

Source: https://github.com/quart-addons/quart-babel/blob/master/docs/references/api/locale.rst

Temporarily forces the locale for the current request context. This function can be used to override the automatically detected locale for specific operations or user preferences.

```APIDOC
quart_babel.force_locale(locale: str)
  Purpose: Forces the locale for the current request context.
  Parameters:
    locale (str): The locale string to set (e.g., 'en', 'de_DE').
  Returns: None
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.