\n"
15 | "Plural-Forms: nplurals=1; plural=0;\n"
16 | "MIME-Version: 1.0\n"
17 | "Content-Type: text/plain; charset=utf-8\n"
18 | "Content-Transfer-Encoding: 8bit\n"
19 | "Generated-By: Babel 2.16.0\n"
20 |
21 | #: forms.py:9
22 | msgid "Name"
23 | msgstr "نام"
24 |
25 | #: forms.py:10
26 | msgid "Please provide your name"
27 | msgstr ""
28 |
29 | #: forms.py:12
30 | msgid "Submit"
31 | msgstr "ارسال"
32 |
33 |
--------------------------------------------------------------------------------
/examples/wtforms/main.py:
--------------------------------------------------------------------------------
1 | from app import create_app
2 |
3 | app = create_app()
4 |
--------------------------------------------------------------------------------
/examples/wtforms/routes.py:
--------------------------------------------------------------------------------
1 | from typing import Annotated
2 | from fastapi import APIRouter, Depends
3 | from fastapi import Request
4 | from app import Application as root
5 | from fastapi_babel.core import Babel
6 | from fastapi_babel.helpers import use_babel
7 | from fastapi_babel.local_context import BabelContext
8 | from forms import RegistrationForm
9 | from i18n import babel_config
10 |
11 | router: APIRouter = APIRouter(prefix="")
12 | render = root.templates.TemplateResponse
13 |
14 |
15 | @router.get("/")
16 | async def read_item(request: Request, babel: Annotated[Babel, Depends(use_babel)]):
17 | babel.locale = "fa"
18 | # with BabelContext(babel_config, babel=babel):
19 | form = RegistrationForm()
20 | return render("index.html", {"request": request, "form": form})
21 |
22 |
23 | @router.post("/")
24 | async def send_item(request: Request):
25 | form = RegistrationForm(await request.form())
26 | if form.validate():
27 | return render("index.html", {"request": request, "form": form})
28 | return form.errors
29 |
--------------------------------------------------------------------------------
/examples/wtforms/templates/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 | Document
9 |
10 |
11 |
12 |
18 |
19 |
20 |
--------------------------------------------------------------------------------
/fastapi_babel/__init__.py:
--------------------------------------------------------------------------------
1 | from .core import Babel
2 | from .helpers import _, LazyText as lazy_gettext, use_babel
3 | from .cli import BabelCli
4 | from .local_context import BabelContext
5 | from .middleware import BabelMiddleware
6 | from .properties import RootConfigs as BabelConfigs
7 |
8 | __version__ = "1.0.0"
9 | __author__ = "papuridalego@gmail.com"
10 | __all__ = [
11 | "Babel",
12 | "BabelCli",
13 | "BabelConfigs",
14 | "_",
15 | "lazy_gettext",
16 | "BabelContext",
17 | "BabelMiddleware",
18 | ]
19 |
--------------------------------------------------------------------------------
/fastapi_babel/cli.py:
--------------------------------------------------------------------------------
1 | from __future__ import annotations
2 |
3 | from subprocess import run
4 | from typing import Optional
5 | from .core import Babel
6 |
7 |
8 | class BabelCli:
9 | __module_name__ = "pybabel"
10 |
11 | def __init__(self, babel: Babel) -> None:
12 | """Babel cli manager to facilitate using pybabel commands by specified congigs
13 | fron `BabelConfigs`.
14 |
15 | Args:
16 | babel (Babel): `Babel` instance
17 | """
18 | self.babel = babel
19 |
20 | def extract(self, watch_dir: str) -> None:
21 | """extract all messages that annotated using gettext/_
22 | in the specified directory.
23 |
24 | for first time will create messages.pot file into the root
25 | directory.
26 |
27 | Args:
28 | watch_dir (str): directory to extract messages.
29 | """
30 | run(
31 | [
32 | BabelCli.__module_name__,
33 | "extract",
34 | "-F",
35 | self.babel.config.BABEL_CONFIG_FILE,
36 | "-o",
37 | self.babel.config.BABEL_MESSAGE_POT_FILE,
38 | watch_dir,
39 | ]
40 | )
41 |
42 | def init(self, lang: Optional[str] = None) -> None:
43 | """Initialized lacale directory for first time.
44 | if there is already exists the directory, notice that your
45 | all comiled and initialized messages will remove, in this
46 | condition has better to use `Babel.update` method.
47 |
48 | Args:
49 | lang (str): locale directory name and path
50 | """
51 | run(
52 | [
53 | BabelCli.__module_name__,
54 | "init",
55 | "-i",
56 | self.babel.config.BABEL_MESSAGE_POT_FILE,
57 | "-d",
58 | self.babel.config.BABEL_TRANSLATION_DIRECTORY,
59 | "-l",
60 | lang or self.babel.config.BABEL_DEFAULT_LOCALE,
61 | ]
62 | )
63 |
64 | def update(self, watch_dir: Optional[str] = None) -> None:
65 | """update the extracted messages after init command/initialized directory
66 | , Default is `./lang`"
67 |
68 | Args:
69 | watch_dir (str): locale directory name and path
70 | """
71 | run(
72 | [
73 | BabelCli.__module_name__,
74 | "update",
75 | "-i",
76 | self.babel.config.BABEL_MESSAGE_POT_FILE,
77 | "-d",
78 | watch_dir or self.babel.config.BABEL_TRANSLATION_DIRECTORY,
79 | ]
80 | )
81 |
82 | def compile(self):
83 | """
84 | compile all messages from translation directory in .PO to .MO file and is
85 | a binnary text file.
86 | """
87 | run(
88 | [
89 | BabelCli.__module_name__,
90 | "compile",
91 | "-d",
92 | self.babel.config.BABEL_TRANSLATION_DIRECTORY,
93 | ]
94 | )
95 |
96 | def run(self):
97 | try:
98 | from click import echo, group, option
99 | except ImportError:
100 | raise ImportError("click has not installed.")
101 |
102 | @group(
103 | "cmd",
104 | help="""
105 | First Step to extracting messages:\n
106 |
107 | 1- extract -d/--dir {watch_dir}\n
108 | 2- init -l/--lang {lang}\n
109 | 3- add your custome translation to your lang `.po` file for example FA dir {./lang/fa}. \n
110 | 4- compile.\n
111 |
112 | Example: \n
113 | 1- extract -d .\n
114 | 2- init -l fa\n
115 | 3- go to ./lang/Fa/.po and add your translations.\n
116 | 4- compile\n
117 |
118 | If you have already extracted messages and you have an existing `.po` and `.mo` file
119 | follow this steps:\n
120 | 1- extract -d/--dir {watch_dir} \n
121 | 2- update -d/--dir {lang_dir} defaults is ./lang \n
122 | 3- add your custome to your lang `.po` file for example FA dir {./lang/fa}. \n
123 | 4- compile.
124 |
125 | Example: \n
126 | 1- extract -d .\n
127 | 2- update -d lang\n
128 | 3- go to ./lang/Fa/.po and add your translations.\n
129 | 4- compile\n
130 | """, # noqa
131 | )
132 | def cmd():
133 | pass
134 |
135 | @cmd.command(
136 | "extract",
137 | help="""extract all messages that annotated using gettext/_
138 | in the specified directory.
139 |
140 | for first time will create messages.pot file into the root
141 | directory.""",
142 | )
143 | @option("-d", "--dir", "dir", help="watch dir")
144 | def extract(dir: str):
145 | """Extract messages
146 |
147 | Args:
148 | dir (Optional[str], optional): directory to extract messages. Defaults to None.
149 | """
150 |
151 | try:
152 | self.extract(dir)
153 | except Exception as err:
154 | echo(err)
155 |
156 | @cmd.command(
157 | "init",
158 | help="""Initialized lacale directory for first time.
159 | if there is already exists the directory, notice that your
160 | all comiled and initialized messages will remove, in this
161 | condition has better to use `update` command""",
162 | )
163 | @option(
164 | "-l",
165 | "--lang",
166 | "lang",
167 | help="locale directory name and path, default is fa",
168 | default="fa",
169 | )
170 | def init(lang: Optional[str] = None):
171 | try:
172 | self.init(lang)
173 | except Exception as err:
174 | echo(err)
175 |
176 | @cmd.command(
177 | "compile",
178 | help="""compile all messages from translation directory in .PO to .MO file and is
179 | a binnary text file.""",
180 | )
181 | def compile():
182 | try:
183 | self.compile()
184 | except Exception as err:
185 | echo(err)
186 |
187 | @cmd.command(
188 | "update",
189 | help="""update the extracted messages after init command/initialized directory
190 | , Default is `./lang`""",
191 | )
192 | @option("-d", "--dir", "dir", help="locale directory name and path")
193 | def update(dir: Optional[str] = None):
194 | try:
195 | self.update(dir)
196 | except Exception as err:
197 | echo(err)
198 |
199 | self.__all__ = [update, compile, init, extract]
200 | cmd()
201 |
--------------------------------------------------------------------------------
/fastapi_babel/core.py:
--------------------------------------------------------------------------------
1 | from __future__ import annotations
2 |
3 | from gettext import gettext, translation
4 | from typing import Any, Callable, NoReturn, Optional
5 |
6 | from fastapi.templating import Jinja2Templates
7 |
8 |
9 | from .properties import RootConfigs
10 | from .exceptions import BabelProxyError
11 | from contextvars import ContextVar, Token
12 |
13 |
14 | class Babel:
15 |
16 | def __init__(self, configs: RootConfigs) -> None:
17 | """
18 | `Babel` is manager for babel localization
19 | and i18n tools like gettext, translation, ...
20 |
21 | Args:
22 | configs (RootConfigs): Babel configs for using.
23 | """
24 | self.config: RootConfigs = configs
25 | self.__locale: str = self.config.BABEL_DEFAULT_LOCALE
26 | self.__default_locale: str = self.config.BABEL_DEFAULT_LOCALE
27 | self.__domain: str = self.config.BABEL_DOMAIN.split(".")[0]
28 |
29 | @staticmethod
30 | def raise_context_error() -> NoReturn:
31 | raise BabelProxyError(
32 | "Babel instance is not available in the current request context."
33 | )
34 |
35 | @property
36 | def domain(self) -> str:
37 | return self.__domain
38 |
39 | @property
40 | def default_locale(self) -> str:
41 | return self.__default_locale
42 |
43 | @property
44 | def locale(self) -> str:
45 | return self.__locale
46 |
47 | @locale.setter
48 | def locale(self, value: str) -> None:
49 | self.__locale = value
50 |
51 | @property
52 | def gettext(self) -> Callable[[str], str]:
53 | if self.default_locale != self.locale:
54 | gt = translation(
55 | self.domain,
56 | self.config.BABEL_TRANSLATION_DIRECTORY,
57 | [self.locale],
58 | )
59 | gt.install()
60 | return gt.gettext
61 | return gettext
62 |
63 | def install_jinja(self, templates: Jinja2Templates) -> None:
64 | """
65 | `Babel.install_jinja` install gettext to jinja2 environment
66 | to access `_` in whole
67 | the jinja templates and let it to pybabel for
68 | extracting included messages throughout the templates.
69 |
70 | Args:
71 | templates (Jinja2Templates): Starlette Jinja2Templates object.
72 | """
73 | from .helpers import _
74 |
75 | try:
76 | from jinja2 import Environment # type: ignore # noqa
77 | except ImportError:
78 | raise ImportError(
79 | """
80 | Jinja2 has not installed.
81 | """
82 | ) from ImportError
83 |
84 | self.env: Environment = getattr(templates, "env", Environment())
85 | globals: dict[str, Any] = getattr(self.env, "globals", dict())
86 | globals.update({"_": _})
87 |
88 | def run_cli(self):
89 | """installs cli's for using pybabel commands easily by specified
90 | configs from `BabelConfigs`.
91 | """
92 |
93 | from .cli import BabelCli # type: ignore # noqa
94 |
95 | babel_cli = BabelCli(self)
96 | babel_cli.run()
97 |
--------------------------------------------------------------------------------
/fastapi_babel/exceptions.py:
--------------------------------------------------------------------------------
1 | from typing import Optional
2 |
3 |
4 | class BabelProxyError(Exception):
5 | """When babel proxy object points to a None object will raise this error"""
6 |
7 | def __init__(self, message: Optional[str] = None) -> None:
8 | self.message: str = "Proxy object points to an empty lookup instance"
9 | if message:
10 | self.message = message
11 | super().__init__("Proxy object points to an empty lookup instance")
12 |
--------------------------------------------------------------------------------
/fastapi_babel/helpers.py:
--------------------------------------------------------------------------------
1 | from __future__ import annotations
2 | from typing import Any
3 |
4 |
5 | from fastapi import Request
6 |
7 | from .core import Babel
8 | from .local_context import context_var
9 |
10 |
11 | def _(message: str) -> str:
12 | gettext = context_var.get()
13 | if not gettext:
14 | Babel.raise_context_error()
15 | return gettext(message)
16 |
17 |
18 | class LaxyTextMeta(type):
19 | def __call__(cls, *args: Any, **kwds: Any) -> str:
20 | return super().__call__(*args, **kwds)
21 |
22 |
23 | class LazyText(metaclass=LaxyTextMeta):
24 | def __init__(self, message: str):
25 | self.message = message
26 |
27 | def __repr__(self) -> str:
28 | return _(self.message)
29 |
30 |
31 | def use_babel(request: Request):
32 | """translate the message and retrieve message from .PO and .MO depends on
33 | `Babel.locale` locale.
34 |
35 | Args:
36 | message (str): message content
37 |
38 | Returns:
39 | str: transalted message.
40 | """
41 | # Get Babel instance from request or fallback to the CLI instance (when defined)
42 | babel = request.state.babel
43 | return babel
44 |
--------------------------------------------------------------------------------
/fastapi_babel/local_context.py:
--------------------------------------------------------------------------------
1 | from __future__ import annotations
2 |
3 | from contextvars import ContextVar
4 | import logging
5 | from typing import Any, Callable, Type
6 | import typing
7 |
8 |
9 | from .properties import RootConfigs
10 | from .core import Babel
11 | from .properties import RootConfigs
12 |
13 |
14 | class BabelContext:
15 | def __init__(
16 | self,
17 | babel_config: RootConfigs,
18 | babel: typing.Optional[Babel] = None,
19 | logger: typing.Optional[logging.Logger] = None,
20 | do_log: bool = False,
21 | ) -> None:
22 | """Babel context to insert object into `ContextVar`.
23 |
24 | Args:
25 | babel_config (RootConfigs): Base config object
26 | logger (typing.Optional[Logger], optional): Logger object to log inside of context manager scope.
27 | Defaults to None.
28 | """
29 | self.babel_config = babel_config
30 | self.logger = logger or logging.getLogger()
31 | self.__babel = babel or Babel(self.babel_config)
32 | self.do_log = do_log
33 |
34 | def _log(self, error: Exception, *msg: typing.Tuple[Any]):
35 | """default log method
36 |
37 | Args:
38 | error (Exception): raised error inside context manager scope.
39 | """
40 | self.logger.error(error, *msg, exc_info=True)
41 |
42 | def __enter__(self):
43 | context_var.set(self.__babel.gettext)
44 |
45 | def __exit__(self, *args, **kwargs): ...
46 |
47 |
48 | context_var: ContextVar[Callable[[str], str]] = ContextVar("gettext")
49 |
--------------------------------------------------------------------------------
/fastapi_babel/middleware.py:
--------------------------------------------------------------------------------
1 | import re
2 | from fastapi import Request, Response
3 | from fastapi.templating import Jinja2Templates
4 | from starlette.middleware.base import BaseHTTPMiddleware
5 | from starlette.middleware.base import RequestResponseEndpoint
6 | from starlette.middleware.base import DispatchFunction
7 | from starlette.types import ASGIApp
8 | from typing import Optional, Callable
9 | from .core import Babel
10 | from .local_context import context_var
11 | from .properties import RootConfigs
12 | from pathlib import Path
13 |
14 |
15 | LANGUAGES_PATTERN = re.compile(r"([a-z]{2})-?([A-Z]{2})?(;q=\d.\d{1,3})?")
16 |
17 |
18 | class BabelMiddleware(BaseHTTPMiddleware):
19 | def __init__(
20 | self,
21 | app: ASGIApp,
22 | babel_configs: RootConfigs,
23 | locale_selector: Optional[Callable[[Request], Optional[str]]] = None,
24 | jinja2_templates: Optional[Jinja2Templates] = None,
25 | dispatch: Optional[DispatchFunction] = None,
26 | ) -> None:
27 | super().__init__(app, dispatch)
28 | self.babel_configs = babel_configs
29 | self.jinja2_templates = jinja2_templates
30 | self.locale_selector = locale_selector or self._default_locale_selector
31 |
32 | def _default_locale_selector(self, request: Request):
33 | return request.headers.get("Accept-Language", None)
34 |
35 | def get_language(self, babel: Babel, lang_code: Optional[str] = None):
36 | """Applies an available language.
37 |
38 | To apply an available language it will be searched in the language folder for an available one
39 | and will also priotize the one with the highest quality value. The Fallback language will be the
40 | taken from the BABEL_DEFAULT_LOCALE var.
41 |
42 | Args:
43 | babel (Babel): Request scoped Babel instance
44 | lang_code (str): The Value of the Accept-Language Header.
45 |
46 | Returns:
47 | str: The language that should be used.
48 | """
49 | if not lang_code:
50 | return babel.config.BABEL_DEFAULT_LOCALE
51 |
52 | matches = re.finditer(LANGUAGES_PATTERN, lang_code)
53 | languages = [
54 | (f"{m.group(1)}{f'_{m.group(2)}' if m.group(2) else ''}", m.group(3) or "")
55 | for m in matches
56 | ]
57 | languages = sorted(
58 | languages, key=lambda x: x[1], reverse=True
59 | ) # sort the priority, no priority comes last
60 | translation_directory = Path(babel.config.BABEL_TRANSLATION_DIRECTORY)
61 | translation_files = [i.name for i in translation_directory.iterdir()]
62 | explicit_priority = None
63 |
64 | for lang, quality in languages:
65 | if lang in translation_files:
66 | if (
67 | not quality
68 | ): # languages without quality value having the highest priority 1
69 | return lang
70 |
71 | elif (
72 | not explicit_priority
73 | ): # set language with explicit priority <= priority 1
74 | explicit_priority = lang
75 |
76 | # Return language with explicit priority or default value
77 | return (
78 | explicit_priority
79 | if explicit_priority
80 | else self.babel_configs.BABEL_DEFAULT_LOCALE
81 | )
82 |
83 | async def dispatch(
84 | self, request: Request, call_next: RequestResponseEndpoint
85 | ) -> Response:
86 | """dispatch function
87 |
88 | Args:
89 | request (Request): ...
90 | call_next (RequestResponseEndpoint): ...
91 |
92 | Returns:
93 | Response: ...
94 | """
95 | lang_code: Optional[str] = self.locale_selector(request)
96 |
97 | # Create a new Babel instance per request
98 | babel = Babel(configs=self.babel_configs)
99 | babel.locale = self.get_language(babel, lang_code)
100 | context_var.set(babel.gettext)
101 | if self.jinja2_templates:
102 | babel.install_jinja(self.jinja2_templates)
103 |
104 | request.state.babel = babel
105 |
106 | response: Response = await call_next(request)
107 | return response
108 |
--------------------------------------------------------------------------------
/fastapi_babel/properties.py:
--------------------------------------------------------------------------------
1 | import os
2 | import pathlib
3 | import typing
4 | from dataclasses import dataclass, field
5 |
6 |
7 | @dataclass
8 | class RootConfigs:
9 |
10 | ROOT_DIR: typing.Union[str, pathlib.Path]
11 | BABEL_DEFAULT_LOCALE: str
12 | BABEL_TRANSLATION_DIRECTORY: str
13 | BABEL_DOMAIN: str = "messages.pot"
14 | BABEL_CONFIG_FILE: str = "babel.cfg"
15 | BABEL_MESSAGE_POT_FILE: str = field(init=False)
16 |
17 | def __post_init__(self):
18 | setattr(
19 | self,
20 | "ROOT_DIR",
21 | pathlib.Path(self.ROOT_DIR).parent,
22 | )
23 | setattr(
24 | self,
25 | "BABEL_TRANSLATION_DIRECTORY",
26 | os.path.join(self.ROOT_DIR, self.BABEL_TRANSLATION_DIRECTORY),
27 | )
28 | setattr(
29 | self,
30 | "BABEL_CONFIG_FILE",
31 | os.path.join(self.ROOT_DIR, self.BABEL_CONFIG_FILE),
32 | )
33 | setattr(
34 | self,
35 | "BABEL_MESSAGE_POT_FILE",
36 | os.path.join(self.ROOT_DIR, self.BABEL_DOMAIN),
37 | )
38 |
--------------------------------------------------------------------------------
/pyproject.toml:
--------------------------------------------------------------------------------
1 | [build-system]
2 | requires = ["setuptools>=42"]
3 | build-backend = "setuptools.build_meta"
4 |
--------------------------------------------------------------------------------
/requirements-dev.txt:
--------------------------------------------------------------------------------
1 | -r requirements.txt
2 |
3 | pre-commit==2.19.0
4 | black==22.3.0
5 | flake8==4.0.1
6 | isort==5.10.1
7 |
--------------------------------------------------------------------------------
/requirements.txt:
--------------------------------------------------------------------------------
1 | fastapi
2 | babel
3 | uvicorn
--------------------------------------------------------------------------------
/setup.cfg:
--------------------------------------------------------------------------------
1 | [metadata]
2 | name = fastapi-babel
3 | version = attr: fastapi_babel.__version__
4 | url = https://github.com/Anbarryprojects/fastapi-babel
5 | project_urls =
6 | Documentation = https://github.com/Anbarryprojects/fastapi-babel
7 | Source Code = https://github.com/Anbarryprojects/fastapi-babel
8 | Issue Tracker = https://github.com/Anbarryprojects/fastapi-babel/issues/
9 | license = MIT
10 | author = Parsa Pourmohammad
11 | author_email = parsapourmohammad1999@gmail.com
12 | maintainer = Anbarryprojects
13 | description = FastAPI-babel is an extenstion for I18n and I10n support in FastAPI, based on babel and pytz.
14 | long_description = file: README.md
15 | long_description_content_type = text/markdown
16 | classifiers =
17 | Development Status :: 3 - Alpha
18 | Environment :: Web Environment
19 | Framework :: FastAPI
20 | Intended Audience :: Developers
21 | Topic :: Internet :: WWW/HTTP :: Dynamic Content
22 | Topic :: Software Development :: Libraries :: Application Frameworks
23 | Programming Language :: Python :: 3
24 | License :: OSI Approved :: MIT License
25 | Operating System :: OS Independent
26 |
27 | [options]
28 | packages = find:
29 | # package_dir = = fastapi_babel
30 | include_package_data = True
31 | python_requires = >= 3.7
32 | # Dependencies are in setup.py for GitHub's dependency graph.
33 |
34 | [options.packages.find]
35 | where = fastapi_babel
36 |
37 |
38 | [flake8]
39 | max-line-length = 88
40 | per-file-ignores =
41 | # __init__ exports names
42 | fastapi_babel/__init__.py: F401
43 |
44 | [mypy]
45 | files = fastapi_babel
46 | python_version = 3.7
47 | show_error_codes = True
48 | allow_redefinition = True
49 | disallow_subclassing_any = True
50 | # disallow_untyped_calls = True
51 | # disallow_untyped_defs = True
52 | # disallow_incomplete_defs = True
53 | no_implicit_optional = True
54 | local_partial_types = True
55 | # no_implicit_reexport = True
56 | strict_equality = True
57 | warn_redundant_casts = True
58 | warn_unused_configs = True
59 | warn_unused_ignores = True
60 | # warn_return_any = True
61 | # warn_unreachable = True
62 |
63 | [mypy-click.*]
64 | ignore_missing_imports = True
65 |
66 | [mypy-jinja.*]
67 | ignore_missing_imports = True
68 |
--------------------------------------------------------------------------------
/setup.py:
--------------------------------------------------------------------------------
1 | from setuptools import find_packages, setup
2 |
3 | # Metadata goes in setup.cfg. These are here for GitHub's dependency graph.
4 | setup(
5 | name="fastapi-babel",
6 | packages=find_packages(),
7 | include_package_data=True,
8 | zip_safe=False,
9 | install_requires=[
10 | "fastapi",
11 | "uvicorn",
12 | "babel",
13 | ],
14 | )
15 |
--------------------------------------------------------------------------------
/tests/test_concurrent.py:
--------------------------------------------------------------------------------
1 | import random
2 | from threading import Thread
3 | from urllib import request
4 |
5 | from requests import get
6 |
7 |
8 | def test_api(idx: int):
9 | lang = random.choice(["fa", "en"])
10 | resp = get(
11 | "http://127.0.0.1:8000", params={"idx": idx}, headers={"Accept-Language": lang}
12 | )
13 | resp.raise_for_status()
14 | print(
15 | f"Lang: {lang} ID: {resp.json()['idx']} Text: {resp.json()['text']} FOR: {idx}"
16 | )
17 |
18 |
19 | for thread in [Thread(target=test_api, args=[i]) for i in range(100)]:
20 | thread.start()
21 |
--------------------------------------------------------------------------------
3 |