# FastAPI Babel

***

**1. Set Up a Multilingual API with FastAPI-Babel**

```python
from fastapi import FastAPI, Request
from fastapi.responses import HTMLResponse
from fastapi_babel import Babel, gettext

app = FastAPI()
babel = Babel(app)

@app.get("/")
async def home(request: Request):
    return HTMLResponse(gettext("Welcome to the API!"))
```

**2. Display Translated Text in HTML Templates**

```python
from fastapi import FastAPI, Request, TemplateResponse
from fastapi_babel import Babel, gettext

app = FastAPI()
babel = Babel(app)

@app.get("/")
async def home(request: Request):
    return TemplateResponse("index.html", {"message": gettext("Welcome to the API!")})
```

**3. Get Current Language Code and Name**

```python
from fastapi import FastAPI, Request
from fastapi_babel import Babel

app = FastAPI()
babel = Babel(app)

@app.get("/language")
async def get_language(request: Request):
    lang_code = babel.get_current_locale()
    lang_name = babel.get_locale_display_name(lang_code)
    return {"language_code": lang_code, "language_name": lang_name}
```

**4. Handle Language Negotiation in Requests**

```python
from fastapi import FastAPI, Request, HTTPException
from fastapi_babel import Babel, Negotiator

app = FastAPI()
babel = Babel(app)

@app.middleware("http")
async def negotiate_middleware(request: Request, negotiator: Negotiator):
    lang_code = negotiator.negotiate_language(request)
    if lang_code is None:
        raise HTTPException(406, "Language not acceptable")
    babel.negotiator_set_locale(lang_code)

@app.get("/")
async def home(request: Request):
    return HTMLResponse(gettext("Welcome to the API!"))
```

**5. Get All Supported Languages**

```python
from fastapi import FastAPI, Request
from fastapi_babel import Babel

app = FastAPI()
babel = Babel(app)

@app.get("/supported-languages")
async def get_supported_languages(request: Request):
    return babel.get_supported_locales()
```

**6. Load Custom Translations from File**

```python
from fastapi import FastAPI
from fastapi_babel import Babel

app = FastAPI()
babel = Babel(app, relative_path="translations/custom")
```

**7. Load Translations from Database**

```python
from fastapi import FastAPI
from fastapi_babel import Babel

app = FastAPI()

class Translation:
    def __init__(self, language_code, domain, message):
        self.language_code = language_code
        self.domain = domain
        self.message = message

def get_translation(language_code, domain, message):
    translation = Translation.query.filter_by(language_code=language_code, domain=domain, message=message).first()
    return translation.message

babel = Babel(app, backend=babel.backends.DatabaseBackend, get_translation=get_translation)
```

**8. Extend Default Message Extraction**

```python
from fastapi import FastAPI
from fastapi_babel import Babel, Domain

app = FastAPI()
babel = Babel(app)

class MyDomain(Domain):
    def get_messages(self, app):
        return ["Special message for my domain"]

babel.domains["my_domain"] = MyDomain()
```

**9. Use Babel's Integration for Jinja2 Templates**

```python
from fastapi import FastAPI, staticfiles, Request, TemplateResponse
from fastapi_babel import Babel, lazy_gettext
from jinja2 import Environment, PackageLoader

app = FastAPI()
babel = Babel(app)
app.mount("/static", staticfiles.StaticFiles(directory="static"), name="static")

jinja_env = Environment(
    loader=PackageLoader("my_app", "templates"),
)
jinja_env.globals.update(
    _=_l=lazy_gettext,
)

@app.get("/")
async def home(request: Request):
    return TemplateResponse("index.html")
```

**10. Use Babel's Integration for Starlette Templates**

```python
from fastapi import FastAPI, Request, TemplateResponse
from fastapi_babel import Babel, lazy_gettext
from starlette.templating import Jinja2Templates

app = FastAPI()
babel = Babel(app)

templates = Jinja2Templates(directory="templates")
templates.env.globals.update(
    _=_l=lazy_gettext,
)

@app.get("/")
async def home(request: Request):
    return TemplateResponse("index.html")
```

**11. Set Default Language**

```python
from fastapi import FastAPI
from fastapi_babel import Babel

app = FastAPI()
babel = Babel(app, default_locale="fr")
```

**12. Override Default Translation Function**

```python
from fastapi import FastAPI
from fastapi_babel import Babel, T

app = FastAPI()
babel = Babel(app)

def my_gettext(message):
    # Custom translation logic here
    return message

babel.set_gettext(my_gettext)
```

**13. Use Pluralization**

```python
from fastapi import FastAPI, Request
from fastapi_babel import Babel, gettext

app = FastAPI()
babel = Babel(app)

@app.get("/{quantity}")
async def home(request: Request, quantity: int):
    message = gettext("There are %(quantity)s apples", count=quantity)
    return HTMLResponse(message)
```

**14. Use I18n Middleware**

```python
from fastapi import FastAPI, Request
from fastapi_babel import Babel, I18nMiddleware

app = FastAPI()
babel = Babel(app)

app.add_middleware(I18nMiddleware, babel=babel)

@app.get("/")
async def home(request: Request):
    return HTMLResponse(gettext("Welcome to the API!"))
```

**15. Use Locale Selector**

```python
from fastapi import FastAPI, Request, HTMLResponse
from fastapi_babel import Babel, LocaleSelector

app = FastAPI()
babel = Babel(app)

@app.get("/locale-selector")
async def locale_selector(request: Request):
    return HTMLResponse(LocaleSelector(request).render())
```

**16. Get Current Locale as a String**

```python
from fastapi import FastAPI, Request
from fastapi_babel import Babel

app = FastAPI()
babel = Babel(app)

@app.get("/locale")
async def get_locale(request: Request):
    return babel.get_current_locale().to_s()
```

**17. Get Current Locale as a Tuple**

```python
from fastapi import FastAPI, Request
from fastapi_babel import Babel

app = FastAPI()
babel = Babel(app)

@app.get("/locale")
async def get_locale(request: Request):
    return babel.get_current_locale().to_tuple()
```

**18. Set Fallback Language**

```python
from fastapi import FastAPI
from fastapi_babel import Babel

app = FastAPI()
babel = Babel(app, fallback_locale="en")
```

**19. Set Default Timezone**

```python
from fastapi import FastAPI
from fastapi_babel import Babel

app = FastAPI()
babel = Babel(app, default_timezone="UTC")
```

**20. Get Current Timezone**

```python
from fastapi import FastAPI, Request
from fastapi_babel import Babel

app = FastAPI()
babel = Babel(app)

@app.get("/timezone")
async def get_timezone(request: Request):
    return babel.get_current_timezone()
```

**21. Set Date Format**

```python
from fastapi import FastAPI
from fastapi_babel import Babel

app = FastAPI()
babel = Babel(app, date_formats={"en": "%m/%d/%Y"})
```

**22. Get Current Date Format**

```python
from fastapi import FastAPI, Request
from fastapi_babel import Babel

app = FastAPI()
babel = Babel(app)

@app.get("/date-format")
async def get_date_format(request: Request):
    return babel.get_current_date_format()
```

**23. Set Number Format**

```python
from fastapi import FastAPI
from fastapi_babel import Babel

app = FastAPI()
babel = Babel(app, num_formats={"en": {"grouping": 3, "decimal": ","}})
```

**24. Get Current Number Format**

```python
from fastapi import FastAPI, Request
from fastapi_babel import Babel

app = FastAPI()
babel = Babel(app)

@app.get("/number-format")
async def get_number_format(request: Request):
    return babel.get_current_num_format()
```

**25. Set Currency Format**

```python
from fastapi import FastAPI
from fastapi_babel import Babel

app = FastAPI()
babel = Babel(app, currency_formats={"en": {"symbol": "$", "decimal": ","}})
```

**26. Get Current Currency Format**

```python
from fastapi import FastAPI, Request
from fastapi_babel import Babel

app = FastAPI()
babel = Babel(app)

@app.get("/currency-format")
async def get_currency_format(request: Request):
    return babel.get_current_currency_format()
```

**27. Set Terrirtory**

```python
from fastapi import FastAPI
from fastapi_babel import Babel

app = FastAPI()
babel = Babel(app, territory="US")
```

**28. Get Current Terrirtory**

```python
from fastapi import FastAPI, Request
from fastapi_babel import Babel

app = FastAPI()
babel = Babel(app)

@app.get("/territory")
async def get_territory(request: Request):
    return babel.get_current_territory()
```

**29. Test Internationalization**

```python
from fastapi.testclient import TestClient
from fastapi_babel import Babel

app = FastAPI()
babel = Babel(app, default_locale="en")

client = TestClient(app)

def test_translate():
    response = client.get("/")
    assert response.status_code == 200
    assert response.content == "Welcome to the API!".encode("utf-8")
```

**30. Set Gettext Domain**

```python
from fastapi import FastAPI
from fastapi_babel import Babel, T

app = FastAPI()
babel = Babel(app)

@app.get("/")
async def home():
    return T("Welcome to the API!", domain="messages")
```

**31. Get List of Supported Timezones**

```python
from fastapi import FastAPI, Request
from fastapi_babel import Babel

app = FastAPI()
babel = Babel(app)

@app.get("/timezones")
async def get_timezones(request: Request):
    return babel.get_supported_timezones()
```

**32. Use Lazy Translation**

```python
from fastapi import FastAPI, Request
from fastapi_babel import Babel, lazy_gettext

app = FastAPI()
babel = Babel(app)

@app.get("/")
async def home(request: Request):
    message = lazy_gettext("Welcome to the API!")
    return HTMLResponse(message)
```

**33. Use Relaxed Translation Validation**

```python
from fastapi import FastAPI
from fastapi_babel import Babel, gettext

app = FastAPI()
babel = Babel(app, relaxed_translation_validation=True)

@app.get("/")
async def home():
    message = gettext("This message is not in the translation files")
    return HTMLResponse(message)
```

**34. Add Custom Extractor**

```python
from babel.messages.frontend import extract_messages
from fastapi import FastAPI
from fastapi_babel import Babel

app = FastAPI()
babel = Babel(app)

def custom_extractor(app, paths, **kwargs):
    # Custom extraction logic here
    return []

babel.register_extractor(app, extract_messages, custom_extractor)
```

**35. Use Babel's Integration for SQLAlchemy**

```python
from babel.messages import Catalog
from fastapi import FastAPI
from fastapi_babel import Babel

app = FastAPI()
babel = Babel(app)

@babel.localeselector
def get_locale():
    # Get locale from database or other source here
    return "en"

def gettext_no_locale(message):
    catalog = Catalog()
    catalog.load_messages("")
    return catalog.gettext(message)

@app.get("/")
async def home():
    message = gettext_no_locale("Hello world!")
    return HTMLResponse(message)
```

**36. Use Babel's Integration for Pyramid**

```python
from pyramid.config import Configurator
from pyramid.settings import asbool
from fastapi_babel import Babel

def myapp(global_config, **settings):
    config = Configurator(settings=settings)
    babel = Babel(config)
    config.include("pyramid_babel")
    config.add_babel_domain("mydomain")
    config.add_route("home", "/")

    @config.route_factory("GET", "/")
    def home(request):
        return babel.translate("Hello world!", request=request)

    return config.make_wsgi_app()
```