fastapi-rtk 0.2.27__py3-none-any.whl → 1.0.13__py3-none-any.whl

fastapi_rtk/cli/commands/translate.py

@@ -0,0 +1,299 @@
+import os
+from typing import Annotated, Union
+
+import fastapi_babel
+import typer
+
+from ...const import INTERNAL_LANG_FOLDER
+from ...lang import __all__
+from ...lang.babel import FastAPIRTKBabelCLI, FastAPIRTKBabelConfigs
+from ...setting import Setting
+from ..cli import app
+from ..decorators import check_existing_app_silent
+from ..utils import merge_pot_files
+from . import version_callback
+
+translate_app = typer.Typer(rich_markup_mode="rich")
+app.add_typer(translate_app, name="translate")
+
+DEFAULT_EXTRACT_KEYWORDS = f"{' '.join(__all__)} lazy_gettext"
+
+RootPathType = Annotated[
+    str | None,
+    typer.Option(
+        help="Path to the root directory of the Babel. If not provided, `LANG_FOLDER` setting will be used. If `BABEL_OPTIONS` contains `ROOT_DIR`, it will be used instead."
+    ),
+]
+
+BabelCfgType = Annotated[
+    str | None,
+    typer.Option(
+        help="Path to the Babel configuration file. If not provided, it will check for `babel.cfg` in the root directory first, then use the default from `fastapi_rtk` library."
+    ),
+]
+
+ExtractDirType = Annotated[
+    str,
+    typer.Option(
+        help="Directory to extract translations from. Defaults to the current directory."
+    ),
+]
+
+KeywordsType = Annotated[
+    str,
+    typer.Option(
+        help="Additional keywords to extract translations for separated by space."
+    ),
+]
+
+LocalesType = Annotated[
+    str | None,
+    typer.Option(
+        help="Locales to initialize, separated by commas. If not provided, `LANGUAGES` setting will be used."
+    ),
+]
+
+MergeWithInternalType = Annotated[
+    bool,
+    typer.Option(
+        help="Merge translations with internal translations from `fastapi_rtk` library."
+    ),
+]
+
+
+@translate_app.callback()
+@check_existing_app_silent
+def callback(
+    version: Annotated[
+        Union[bool, None],
+        typer.Option(
+            "--version", help="Show the version and exit.", callback=version_callback
+        ),
+    ] = None,
+) -> None:
+    """
+    FastAPI RTK Translate CLI - The [bold]fastapi-rtk translate[/bold] command line app. 😎
+
+    Manage your [bold]FastAPI React Toolkit[/bold] translations easily with this CLI.
+    """
+
+
+@translate_app.command()
+def extract(
+    root_path: RootPathType = None,
+    babel_cfg: BabelCfgType = None,
+    extract_dir: ExtractDirType = ".",
+    keywords: KeywordsType = DEFAULT_EXTRACT_KEYWORDS,
+):
+    """
+    Extract translations from the source code.
+    """
+    babel_cli = init_babel_cli(root_path=root_path, babel_cfg=babel_cfg)
+    typer.echo(f"Extracting translations with additional keywords: {keywords}")
+    babel_cli.extract(extract_dir, keywords)
+
+
+@translate_app.command()
+def init(
+    root_path: RootPathType = None,
+    babel_cfg: BabelCfgType = None,
+    locales: LocalesType = None,
+    merge_with_internal: MergeWithInternalType = True,
+):
+    """
+    Initialize translations for the specified locales. If the locale files do not exist, it will create them based on the domain file (messages.pot). If the domain file does not exist, it will run the `extract` command first.
+    """
+    babel_cli = init_babel_cli(root_path=root_path, babel_cfg=babel_cfg)
+
+    # Check for the domain file
+    domain_file = babel_cli.babel.config.BABEL_MESSAGE_POT_FILE
+    if not os.path.exists(domain_file):
+        typer.echo(
+            f"Domain file {domain_file} does not exist. running `extract` command"
+        )
+        extract_dir = babel_cli.babel.config.ROOT_DIR
+        # If the extract_dir does not contain any .py files, we will run the extract command on the parent directory
+        if not any(f.endswith(".py") for f in os.listdir(extract_dir)):
+            extract_dir = os.path.join(extract_dir, "..")
+
+        extract(
+            root_path=root_path,
+            babel_cfg=babel_cfg,
+            extract_dir=extract_dir,
+            merge_with_internal=merge_with_internal,
+        )
+
+    if locales is None:
+        locales = Setting.LANGUAGES
+        typer.echo(
+            f"No locales provided. Using `LANGUAGES` setting: {locales}. If you want to specify locales, use the `--locales` option."
+        )
+
+    for local in locales.split(","):
+        local = local.strip()
+        # Check whether the locale directory exists
+        locale_dir = os.path.join(
+            babel_cli.babel.config.BABEL_TRANSLATION_DIRECTORY, local
+        )
+        if os.path.exists(locale_dir):
+            typer.echo(
+                f"Locale directory {locale_dir} already exists. Skipping initialization for {local}."
+            )
+            continue
+
+        typer.echo(f"Initializing translations for locale: {local}")
+        babel_cli.init(local)
+
+
+@translate_app.command()
+def update(
+    root_path: RootPathType = None,
+    babel_cfg: BabelCfgType = None,
+    locales: LocalesType = None,
+    merge_with_internal: MergeWithInternalType = True,
+):
+    """
+    Update translations from the domain (messages.pot) file to the locale files. If the locale files do not exist, `init` command will be run for the locale.
+    """
+    babel = init_babel_cli(root_path=root_path, babel_cfg=babel_cfg)
+
+    if locales is None:
+        locales = Setting.LANGUAGES
+        typer.echo(
+            f"No locales provided. Using `LANGUAGES` setting: {locales}. If you want to specify locales, use the `--locales` option."
+        )
+
+    for local in locales.split(","):
+        local = local.strip()
+        locale_dir = os.path.join(babel.babel.config.BABEL_TRANSLATION_DIRECTORY, local)
+        if not os.path.exists(locale_dir):
+            typer.echo(
+                f"Locale directory {locale_dir} does not exist. running `init` command for {local}."
+            )
+            init(
+                root_path=root_path,
+                babel_cfg=babel_cfg,
+                locales=local,
+                merge_with_internal=merge_with_internal,
+            )
+
+    typer.echo(f"Updating translations for locales: {locales}")
+    babel.update()
+
+    if not merge_with_internal:
+        typer.echo(
+            "Skipping merging with internal translations. If you want to merge with internal translations, use the `--merge-with-internal` option."
+        )
+        return
+
+    for local in locales.split(","):
+        # Combine the locale with the internal translations
+        local = local.strip()
+        locale_dir = os.path.join(babel.babel.config.BABEL_TRANSLATION_DIRECTORY, local)
+
+        internal_locale_dir = os.path.join(INTERNAL_LANG_FOLDER, "translations", local)
+        po_file = os.path.join(
+            locale_dir,
+            "LC_MESSAGES",
+            babel.babel.config.BABEL_DOMAIN.replace(".pot", "") + ".po",
+        )
+        internal_po_file = os.path.join(
+            internal_locale_dir,
+            "LC_MESSAGES",
+            babel.babel.config.BABEL_DOMAIN.replace(".pot", "") + ".po",
+        )
+        merge_pot_files(pot_files=[po_file, internal_po_file], output_path=po_file)
+
+
+@translate_app.command()
+def compile(root_path: RootPathType = None, babel_cfg: BabelCfgType = None):
+    """
+    Compile the translations. This will create the .mo files from the .po files.
+    """
+    babel = init_babel_cli(root_path=root_path, babel_cfg=babel_cfg)
+    typer.echo("Compiling translations.")
+    babel.compile()
+
+
+@translate_app.command()
+def build(
+    root_path: RootPathType = None,
+    babel_cfg: BabelCfgType = None,
+    extract_dir: ExtractDirType = ".",
+    keywords: KeywordsType = DEFAULT_EXTRACT_KEYWORDS,
+    locales: LocalesType = None,
+    merge_with_internal: MergeWithInternalType = True,
+):
+    """
+    Build the translations by extracting, updating, and compiling them in one step. This keeps the translations up-to-date and ready for use in your FastAPI application.
+    """
+    extract(
+        root_path=root_path,
+        babel_cfg=babel_cfg,
+        extract_dir=extract_dir,
+        keywords=keywords,
+    )
+    update(
+        root_path=root_path,
+        babel_cfg=babel_cfg,
+        locales=locales,
+        merge_with_internal=merge_with_internal,
+    )
+    compile(root_path=root_path, babel_cfg=babel_cfg)
+
+
+def init_babel_cli(
+    root_path: RootPathType = None,
+    babel_cfg: BabelCfgType = None,
+    *,
+    create_root_path_if_not_exists=True,
+    log=True,
+):
+    """
+    Initialize Babel CLI with the provided root path and Babel configuration file.
+
+    Args:
+        root_path (RootPathType): Path to the root directory of the Babel. If not provided, `LANG_FOLDER` setting will be used. If `BABEL_OPTIONS` contains `ROOT_DIR`, it will be used instead.
+        babel_cfg (BabelCfgType): Path to the Babel configuration file. If not provided, it will check for `babel.cfg` in the root directory first, then use the default from `fastapi_rtk` library.
+        create_if_not_exists (bool): Whether to create the root path if it does not exist. Defaults to True.
+        log (bool): Whether to log the actions taken. Defaults to True.
+
+    Raises:
+        FileNotFoundError: If the root path does not exist and `create_root_path_if_not_exists` is False.
+
+    Returns:
+        FastAPIRTKBabelCLI: An instance of the FastAPIRTKBabelCLI class initialized with the Babel configurations.
+    """
+    if root_path is None and "ROOT_DIR" not in Setting.BABEL_OPTIONS:
+        root_path = Setting.LANG_FOLDER
+        log and typer.echo(
+            f"No root directory provided. Using `LANG_FOLDER` setting: {root_path}"
+        )
+    if babel_cfg is None and "BABEL_CONFIG_FILE" not in Setting.BABEL_OPTIONS:
+        file_exists = os.path.exists(os.path.join(root_path, "babel.cfg"))
+        if not file_exists:
+            babel_cfg = os.path.join(INTERNAL_LANG_FOLDER, "babel.cfg")
+            log and typer.echo(
+                f"No Babel configuration file provided. Using default from {babel_cfg}"
+            )
+
+    # Ensure root_path exists
+    if not os.path.exists(root_path):
+        log and typer.echo(f"Root path {root_path} does not exist.")
+        if create_root_path_if_not_exists:
+            log and typer.echo(f"Creating necessary directories at {root_path}.")
+            os.makedirs(root_path, exist_ok=True)
+        else:
+            raise FileNotFoundError(f"Root path {root_path} does not exist.")
+
+    kwargs = {
+        "ROOT_DIR": root_path,
+        "BABEL_DEFAULT_LOCALE": "en",
+        "BABEL_TRANSLATION_DIRECTORY": "translations",
+    } | Setting.BABEL_OPTIONS
+    if babel_cfg is not None:
+        kwargs["BABEL_CONFIG_FILE"] = babel_cfg
+
+    return FastAPIRTKBabelCLI(
+        fastapi_babel.Babel(configs=FastAPIRTKBabelConfigs(**kwargs))
+    )

fastapi_rtk/cli/decorators.py

@@ -21,19 +21,24 @@ def ensure_fastapi_rtk_tables_exist(f):
     return wrapper
 
 
-def _check_existing_app(f):
+def _check_existing_app(f, *, silent=False):
     @wraps(f)
     def wrapper(*args, **kwargs):
         try:
             get_import_data(path=g.path)
-            return f(*args, **kwargs)
         except FastAPICLIException as e:
-            logger.error(str(e))
-            raise typer.Exit(code=1) from None
+            if not silent:
+                logger.error(str(e))
+                raise typer.Exit(code=1) from None
+        return f(*args, **kwargs)
 
     return wrapper
 
 
+def check_existing_app_silent(f):
+    return _check_existing_app(f, silent=True)
+
+
 def _set_migrate_mode(f):
     @wraps(f)
     def wrapper(*args, **kwargs):

fastapi_rtk/cli/utils.py

@@ -1,7 +1,9 @@
 import asyncio
+import os
 import time
 from typing import Any, Coroutine
 
+import polib
 from annotated_types import T
 
 
@@ -132,3 +134,47 @@ def json_to_markdown(
     else:
         content += f"{data}{'\n' * newline_length}"
     return content
+
+
+def merge_pot_files(pot_files: list[str], output_path: str):
+    """
+    Merges multiple .pot files into a single .pot file while preserving header information from the first file.
+
+    This function:
+    - Loads the first .pot file to use as a base, ensuring that its header is preserved.
+    - Iterates over the remaining .pot files.
+    - Adds comment for the file source for the first entry of each subsequent .pot file.
+    - Appends any translation entries not already present in the base file.
+    - Merges source references (occurrences) for entries that already exist in the base file to include unique locations.
+
+    Args:
+        pot_files (list[str]): A list of file paths pointing to .pot files that need to be merged.
+        output_path (str): The file path where the merged .pot file will be saved.
+
+    Returns:
+        None
+    """
+    base = polib.pofile(pot_files[0])  # use first file to preserve header
+
+    for pot_path in pot_files[1:]:
+        pot = polib.pofile(pot_path)
+        first_entry = True
+        for entry in pot:
+            if first_entry:
+                # Add label where the file coming from
+                relative_path = os.path.relpath(
+                    pot_path, start=os.path.dirname(output_path)
+                )
+                entry.comment = f"File: {relative_path}"
+                first_entry = False
+
+            existing = base.find(entry.msgid)
+            if not existing:
+                base.append(entry)
+            else:
+                # Optionally merge source refs
+                existing.occurrences = list(
+                    set(existing.occurrences + entry.occurrences)
+                )
+
+    base.save(output_path)

fastapi_rtk/config.py

@@ -6,11 +6,36 @@ import os
 import types
 import typing as t
 
-from .utils import import_string
+from .utils import deep_merge, import_string
 
 __all__ = ["Config"]
 
 
+class ConfigKeyword:
+    ENABLE_DEEP_MERGE = (
+        "CONFIG_ENABLE_DEEP_MERGE",
+        bool,
+        "a reserved keyword for config to enable deep merge",
+    )
+    DEEP_MERGE_WHITELIST = (
+        "CONFIG_DEEP_MERGE_WHITELIST",
+        (list, tuple),
+        "a reserved keyword for config to define a whitelist of keys to deep merge",
+    )
+
+    @classmethod
+    def check_key_value(cls, key: str, value: t.Any):
+        for item in [
+            v for k, v in cls.__dict__.items() if k.isupper() and isinstance(v, tuple)
+        ]:
+            if isinstance(item, tuple) and item[0] == key:
+                expected_type = item[1]
+                if not isinstance(value, expected_type):
+                    raise TypeError(
+                        f"Expected type {expected_type} for key '{key}', got {type(value)}, '{key}' is {item[2]}"
+                    )
+
+
 class Config(dict):
     """
     COPIED FROM FLASK
@@ -60,6 +85,21 @@ class Config(dict):
 
     __callbacks: list[t.Callable[..., None]] = None
 
+    def __setitem__(self, key, value):
+        ConfigKeyword.check_key_value(key, value)
+        if (
+            ConfigKeyword.ENABLE_DEEP_MERGE[0] in self
+            and self[ConfigKeyword.ENABLE_DEEP_MERGE[0]]
+            and key in self
+            and isinstance(value, dict)
+            and isinstance(self[key], dict)
+        ):
+            whitelist = self.get(ConfigKeyword.DEEP_MERGE_WHITELIST[0], None)
+            if whitelist is None or key in whitelist:
+                value = deep_merge(self[key], value)
+
+        return super().__setitem__(key, value)
+
     def add_callback(self, callback: t.Callable[..., None]) -> None:
         """Add a function to call after the configuration is updated.
 

fastapi_rtk/const.py

@@ -1,10 +1,13 @@
+import enum
 import inspect
 import logging
+import os
 from typing import Literal
 
 import Secweb.ContentSecurityPolicy
 import Secweb.StrictTransportSecurity
 
+from . import lang
 from .utils import deep_merge
 
 __all__ = ["logger"]
@@ -26,6 +29,7 @@ ASSOC_USER_ROLE_SEQUENCE = "ab_user_role_id_seq"
 OAUTH_TABLE = "ab_oauth_account"
 OAUTH_SEQUENCE = "ab_oauth_account_id_seq"
 ACCESSTOKEN_TABLE = "ab_accesstoken"
+DEFAULT_METADATA_KEY = "default"
 
 FASTAPI_RTK_TABLES = [
     USER_TABLE,
@@ -72,7 +76,10 @@ DEFAULT_COOKIE_NAME = "dataTactics"
 DEFAULT_BASEDIR = "app"
 DEFAULT_STATIC_FOLDER = DEFAULT_BASEDIR + "/static"
 DEFAULT_TEMPLATE_FOLDER = DEFAULT_BASEDIR + "/templates"
-DEFAULT_PROFILER_FOLDER = DEFAULT_STATIC_FOLDER + "/profiles"
+DEFAULT_PROFILER_FOLDER = DEFAULT_STATIC_FOLDER + "/profiler"
+DEFAULT_LANG_FOLDER = DEFAULT_BASEDIR + "/lang"
+DEFAULT_LANGUAGES = "en,de"
+DEFAULT_TRANSLATIONS_KEY = "translations"
 DEFAULT_SECWEB_PARAMS = {
     "Option": {
         "csp": {
@@ -93,6 +100,7 @@ DEFAULT_SECWEB_PARAMS = {
             )
         },
         "wshsts": False,
+        "cacheControl": False,
     },
     "script_nonce": True,
     "style_nonce": True,
@@ -104,6 +112,9 @@ DEFAULT_SECWEB_PARAMS["Option"]["csp"]["style-src"] = [
 ]
 del DEFAULT_SECWEB_PARAMS["Option"]["csp"]["require-trusted-types-for"]
 
+INTERNAL_LANG_FOLDER = lang.__file__.replace("__init__.py", "")
+INTERNAL_BABEL_FOLDER = os.path.join(INTERNAL_LANG_FOLDER, "babel")
+
 COOKIE_PREFIX = "COOKIE_"
 COOKIE_CONFIG = {
     f"{COOKIE_PREFIX}NAME": f"{COOKIE_PREFIX.lower()}name",
@@ -136,6 +147,23 @@ AUTH_ROLE_CONFIG = {
     f"{AUTH_ROLE_PREFIX}PUBLIC_ROLE": "public_role",
 }
 
+
+class ErrorCode(str, enum.Enum):
+    GET_USER_MISSING_TOKEN_OR_INACTIVE_USER = "GET_USER_MISSING_TOKEN_OR_INACTIVE_USER"
+    GET_USER_NO_ROLES = "GET_USER_NO_ROLES"
+    PERMISSION_DENIED = "PERMISSION_DENIED"
+    FEATURE_NOT_IMPLEMENTED = "FEATURE_NOT_IMPLEMENTED"
+    PAGE_NOT_FOUND = "PAGE_NOT_FOUND"
+    ITEM_NOT_FOUND = "ITEM_NOT_FOUND"
+    HANDLER_NOT_FOUND = "HANDLER_NOT_FOUND"
+    FILE_NOT_FOUND = "FILE_NOT_FOUND"
+    IMAGE_NOT_FOUND = "IMAGE_NOT_FOUND"
+
+
+class AuthType(str, enum.Enum):
+    LDAP = "ldap"
+
+
 logging.basicConfig(format="%(asctime)s:%(levelname)s:%(name)s:%(message)s")
 logger = logging.getLogger("DT_FASTAPI")
 logger.setLevel(logging.INFO)