Chalice-Babel Package

Are you looking for a way to take your Chalice micro framework application global? Look no further! In this blog post, we are thrilled to introduce you to Chalice-Babel - our localization (L10n) and internationalization (i18n) library for Chalice.

As businesses expand worldwide, it's becoming increasingly important to offer a personalized experience to users in their own language. Chalice-Babel simplifies this process, enabling you to easily translate your application into multiple languages.

We're excited to share this powerful tool with you and help you create a truly global application that your users will love. Let's get started!

What is Chalice Microframework?

Chalice is an open-source microframework that makes it simple for programmers to create and distribute serverless applications. Built using Python, Chalice allows developers to write code in a style that is similar to Flask web framework, making it simple for programmers already familiar with Flask to get up and running quickly.

For integrating with a variety of AWS services, such as Amazon API Gateway, Amazon S3, Amazon SNS, Amazon SQS, and others, Chalice offers a straightforward and user-friendly API. This microframework is made to streamline and speed up the creation of serverless apps, freeing developers to concentrate on creating code rather than handling infrastructure administration.

Chalice is great for building serverless apps quickly and effectively since it is lightweight and speedy. Chalice enables developers to quickly design and deploy Lambda apps on AWS, giving them the ability to create dependable, scalable, and affordable services.

Here is a simple Rest API example.

    from chalice import Chalice
     app = Chalice(app_name="helloworld")
     @app.route("/")
     def index():
        return {"hello": "world"}

Why did we need to develop the Chalice-Babel package?

At Sufle, we have been focused on building projects that are as serverless as possible. In one of our projects we decided to use Chalice for sending welcome emails to the users who have different languages. We soon discovered that the Chalice package lacked any built-in i18n support for localization, though. For the two languages we intended to offer, we thought about utilizing two different email templates, but that approach would not have been scalable if we had been required to support more than two. It would have been a complicated and messy solution.

As a result of this insight, we created the Chalice-Babel package to simplify the localization of the Chalice microframework. You may rapidly and simply support various languages in your serverless apps by integrating Chalice-Babel, which offers an easy-to-use i18n and L10n solution, into your Chalice application.

Capabilities and Usage of Chalice-Babel

Chalice-Babel is a powerful localization and internationalization library that utilizes two popular Python packages - Babel and pytz. With Chalice-Babel, you can easily format numbers, dates, and translate your strings or sentences to support multiple languages.

The Babel package is used for extracting and compiling translations from your source code, while the pytz package provides timezone support for datetime objects. Together, these packages enable Chalice-Babel to provide a comprehensive localization solution for your Chalice microframework application.

This is a Python package so you can install the package using pip. To install it, simply run the following command:

    pip install chalice_babel

Once installed, Chalice-Babel may be easily configured in your Chalice application. You can import the Chalice-Babel module into the Chalice app and initialize it with the languages you want to support as well as the default language.

Here's how to configure Chalice-Babel to support English and Spanish, with English as the default language:

For that purpose you need to add "babel_config" json file into chalicelib/init.py file.

    # __init__.py

    babel_config = {
        "BABEL_DEFAULT_LOCALE": "en",
        "LANGUAGES": ["en", "es"],
    }

When you install and make your default configuration you are ready to go as demonstrated in the example below.

    from chalice import Chalice
    from chalice_babel import Babel

    app = Chalice(app_name="chalice_babel")
    babel = Babel(app)

    @babel.localeselector
    def get_locale():
        langs = babel.parse_language_header()
        return babel.best_match(langs)

@babel.localeselector decorator and get_locale() functions are must to use in the package. This block parses language used in your browser.

Format Numbers & Dates

Once Chalice-Babel is configured, you can utilize its functions to format dates and numbers in accordance with the user's desired locale. The available functions are listed below:

Here are some examples:

    #format_number()

    >>> from chalice_babel import format_number

    >>> format_number(2022)

    2,022


    #format_currency()

    >>> from chalice_babel import format_currency

    >>> format_currency(2.022, "USD")

    $2,022.00


    #format_datetime()

    >>> format_datetime(datetime(1987, 3, 5, 17, 12))

    Mar 5, 1987 5:12:00 PM

These functions make it simple to format dates and numbers in accordance with the user's locale. This can assist in improving the usability and accessibility of your program for users everywhere.

Formatting Strings & Sentences

Formatting numbers and dates are only additional features, the main functionality actually is to translate strings or sentences. For this purpose you only need to import gettext or ngettext functions as shown in the example.

After running the compile command, .po and .mo files will be generated, and by using these files, you can make your translations for your application.

    from chalice_babel import gettext, ngettext

    gettext(u'A simple string')

    gettext(u'Value: %(value)s', value=42)

    ngettext(u'%(num)s Apple', u'%(num)s Apples', number_of_apples)

Export & Import

To be honest this functionalty is my favorite. This feature is especially useful when your application has multiple languages and as it grows, updating translation files manually can be time-consuming and prone to errors. With the export and import option, you can easily check which strings need to be translated or which translations need to be updated.

With export and import option you can export all marked strings from .po files as a json file. This allows you to easily identify which strings and texts have been translated correctly and which ones still require translation.

Consider an exported JSON file that supports three languages as an example. The translation for "currency" is absent in the target languages in this case. You can simply modify this JSON file and add the missing translations. The corresponding .po files will be automatically updated.

{
  "currency": {
    "en": "",
    "ja": "",
    "de": ""
  },
  "message": {
    "en": "",
    "ja": "メッセージ",
    "de": "Botschaft"
  },
  "Hello": {
    "en": "",
    "ja": "こんにちわ",
    "de": "Halo"
  }
}

Contribution

At the heart of open-source communities lies collaboration and a shared passion for innovation. With this in mind, we are thrilled to offer the Chalice-Babel library to the community and invite all to utilize its powerful capabilities.

We believe that the contributions of developers, users, and enthusiasts alike are what fuels the growth and development of open-source projects. Therefore, we welcome and encourage contributions to our library to further improve its features and make it even more useful for users.

We are grateful for any feedback or suggestions and look forward to working together to make Chalice-Babel a valuable resource for the community.

We look forward to working with you to help you achieve your goals on the AWS platform. Reach out to usand build your infrastructure with the best in the industry.