import os

import re

import shutil

from http.server import HTTPServer, SimpleHTTPRequestHandler

from multiprocessing import Pool

from pathlib import Path

from typing import Dict, List, Optional, Tuple

import mkdocs.commands.build

import mkdocs.commands.serve

import mkdocs.config

import mkdocs.utils

import typer

import yaml

from jinja2 import Template

app = typer.Typer()

mkdocs_name = "mkdocs.yml"

missing_translation_snippet = """

{!../../../docs/missing-translation.md!}

"""

docs_path = Path("docs")

en_docs_path = Path("docs/en")

en_config_path: Path = en_docs_path / mkdocs_name

def get_en_config() -> dict:

return mkdocs.utils.yaml_load(en_config_path.read_text(encoding="utf-8"))

def get_lang_paths():

return sorted(docs_path.iterdir())

def lang_callback(lang: Optional[str]):

if lang is None:

return

if not lang.isalpha() or len(lang) != 2:

typer.echo("Use a 2 letter language code, like: es")

raise typer.Abort()

lang = lang.lower()

return lang

def complete_existing_lang(incomplete: str):

lang_path: Path

for lang_path in get_lang_paths():

if lang_path.is_dir() and lang_path.name.startswith(incomplete):

yield lang_path.name

def get_base_lang_config(lang: str):

en_config = get_en_config()

fastapi_url_base = "https://fastapi.tiangolo.com/"

new_config = en_config.copy()

new_config["site_url"] = en_config["site_url"] + f"{lang}/"

new_config["theme"]["logo"] = fastapi_url_base + en_config["theme"]["logo"]

new_config["theme"]["favicon"] = fastapi_url_base + en_config["theme"]["favicon"]

new_config["theme"]["language"] = lang

new_config["nav"] = en_config["nav"][:2]

extra_css = []

css: str

for css in en_config["extra_css"]:

if css.startswith("http"):

extra_css.append(css)

else:

extra_css.append(fastapi_url_base + css)

new_config["extra_css"] = extra_css

extra_js = []

js: str

for js in en_config["extra_javascript"]:

if js.startswith("http"):

extra_js.append(js)

else:

extra_js.append(fastapi_url_base + js)

new_config["extra_javascript"] = extra_js

return new_config

@app.command()

def new_lang(lang: str = typer.Argument(..., callback=lang_callback)):

"""

Generate a new docs translation directory for the language LANG.

LANG should be a 2-letter language code, like: en, es, de, pt, etc.

"""

new_path: Path = Path("docs") / lang

if new_path.exists():

typer.echo(f"The language was already created: {lang}")

raise typer.Abort()

new_path.mkdir()

new_config = get_base_lang_config(lang)

new_config_path: Path = Path(new_path) / mkdocs_name

new_config_path.write_text(

yaml.dump(new_config, sort_keys=False, width=200, allow_unicode=True),

encoding="utf-8",

)

new_config_docs_path: Path = new_path / "docs"

new_config_docs_path.mkdir()

en_index_path: Path = en_docs_path / "docs" / "index.md"

new_index_path: Path = new_config_docs_path / "index.md"

en_index_content = en_index_path.read_text(encoding="utf-8")

new_index_content = f"{missing_translation_snippet}\n\n{en_index_content}"

new_index_path.write_text(new_index_content, encoding="utf-8")

new_overrides_gitignore_path = new_path / "overrides" / ".gitignore"

new_overrides_gitignore_path.parent.mkdir(parents=True, exist_ok=True)

new_overrides_gitignore_path.write_text("")

typer.secho(f"Successfully initialized: {new_path}", color=typer.colors.GREEN)

update_languages(lang=None)

@app.command()

def build_lang(

lang: str = typer.Argument(

..., callback=lang_callback, autocompletion=complete_existing_lang

)

):

"""

Build the docs for a language, filling missing pages with translation notifications.

"""

lang_path: Path = Path("docs") / lang

if not lang_path.is_dir():

typer.echo(f"The language translation doesn't seem to exist yet: {lang}")

raise typer.Abort()

typer.echo(f"Building docs for: {lang}")

build_dir_path = Path("docs_build")

build_dir_path.mkdir(exist_ok=True)

build_lang_path = build_dir_path / lang

en_lang_path = Path("docs/en")

site_path = Path("site").absolute()

if lang == "en":

dist_path = site_path

else:

dist_path: Path = site_path / lang

shutil.rmtree(build_lang_path, ignore_errors=True)

shutil.copytree(lang_path, build_lang_path)

shutil.copytree(en_docs_path / "data", build_lang_path / "data")

overrides_src = en_docs_path / "overrides"

overrides_dest = build_lang_path / "overrides"

for path in overrides_src.iterdir():

dest_path = overrides_dest / path.name

if not dest_path.exists():

shutil.copy(path, dest_path)

en_config_path: Path = en_lang_path / mkdocs_name

en_config: dict = mkdocs.utils.yaml_load(en_config_path.read_text(encoding="utf-8"))

nav = en_config["nav"]

lang_config_path: Path = lang_path / mkdocs_name

lang_config: dict = mkdocs.utils.yaml_load(

lang_config_path.read_text(encoding="utf-8")

)

lang_nav = lang_config["nav"]

# Exclude first 2 entries FastAPI and Languages, for custom handling

use_nav = nav[2:]

lang_use_nav = lang_nav[2:]

file_to_nav = get_file_to_nav_map(use_nav)

sections = get_sections(use_nav)

lang_file_to_nav = get_file_to_nav_map(lang_use_nav)

use_lang_file_to_nav = get_file_to_nav_map(lang_use_nav)

for file in file_to_nav:

file_path = Path(file)

lang_file_path: Path = build_lang_path / "docs" / file_path

en_file_path: Path = en_lang_path / "docs" / file_path

lang_file_path.parent.mkdir(parents=True, exist_ok=True)

if not lang_file_path.is_file():

en_text = en_file_path.read_text(encoding="utf-8")

lang_text = get_text_with_translate_missing(en_text)

lang_file_path.write_text(lang_text, encoding="utf-8")

file_key = file_to_nav[file]

use_lang_file_to_nav[file] = file_key

if file_key:

composite_key = ()

new_key = ()

for key_part in file_key:

composite_key += (key_part,)

key_first_file = sections[composite_key]

if key_first_file in lang_file_to_nav:

new_key = lang_file_to_nav[key_first_file]

else:

new_key += (key_part,)

use_lang_file_to_nav[file] = new_key

key_to_section = {(): []}

for file, orig_file_key in file_to_nav.items():

if file in use_lang_file_to_nav:

file_key = use_lang_file_to_nav[file]

else:

file_key = orig_file_key

section = get_key_section(key_to_section=key_to_section, key=file_key)

section.append(file)

new_nav = key_to_section[()]

export_lang_nav = [lang_nav[0], nav[1]] + new_nav

lang_config["nav"] = export_lang_nav

build_lang_config_path: Path = build_lang_path / mkdocs_name

build_lang_config_path.write_text(

yaml.dump(lang_config, sort_keys=False, width=200, allow_unicode=True),

encoding="utf-8",

)

current_dir = os.getcwd()

os.chdir(build_lang_path)

mkdocs.commands.build.build(mkdocs.config.load_config(site_dir=str(dist_path)))

os.chdir(current_dir)

typer.secho(f"Successfully built docs for: {lang}", color=typer.colors.GREEN)

index_sponsors_template = """

{% if sponsors %}

{% for sponsor in sponsors.gold -%}

<a href="{{ sponsor.url }}" target="_blank" title="{{ sponsor.title }}"><img src="{{ sponsor.img }}"></a>

{% endfor -%}

{%- for sponsor in sponsors.silver -%}

<a href="{{ sponsor.url }}" target="_blank" title="{{ sponsor.title }}"><img src="{{ sponsor.img }}"></a>

{% endfor %}

{% endif %}

"""

def generate_readme_content():

en_index = en_docs_path / "docs" / "index.md"

content = en_index.read_text("utf-8")

match_start = re.search(r"<!-- sponsors -->", content)

match_end = re.search(r"<!-- /sponsors -->", content)

sponsors_data_path = en_docs_path / "data" / "sponsors.yml"

sponsors = mkdocs.utils.yaml_load(sponsors_data_path.read_text(encoding="utf-8"))

if not (match_start and match_end):

raise RuntimeError("Couldn't auto-generate sponsors section")

pre_end = match_start.end()

post_start = match_end.start()

template = Template(index_sponsors_template)

message = template.render(sponsors=sponsors)

pre_content = content[:pre_end]

post_content = content[post_start:]

new_content = pre_content + message + post_content

return new_content

@app.command()

def generate_readme():

"""

Generate README.md content from main index.md

"""

typer.echo("Generating README")

readme_path = Path("README.md")

new_content = generate_readme_content()

readme_path.write_text(new_content, encoding="utf-8")

@app.command()

def verify_readme():

"""

Verify README.md content from main index.md

"""

typer.echo("Verifying README")

readme_path = Path("README.md")

generated_content = generate_readme_content()

readme_content = readme_path.read_text("utf-8")

if generated_content != readme_content:

typer.secho(

"README.md outdated from the latest index.md", color=typer.colors.RED

)

raise typer.Abort()

typer.echo("Valid README ✅")

@app.command()

def build_all():

"""

Build mkdocs site for en, and then build each language inside, end result is located

at directory ./site/ with each language inside.

"""

site_path = Path("site").absolute()

update_languages(lang=None)

current_dir = os.getcwd()

os.chdir(en_docs_path)

typer.echo("Building docs for: en")

mkdocs.commands.build.build(mkdocs.config.load_config(site_dir=str(site_path)))

os.chdir(current_dir)

langs = []

for lang in get_lang_paths():

if lang == en_docs_path or not lang.is_dir():

continue

langs.append(lang.name)

cpu_count = os.cpu_count() or 1

with Pool(cpu_count * 2) as p:

p.map(build_lang, langs)

def update_single_lang(lang: str):

lang_path = docs_path / lang

typer.echo(f"Updating {lang_path.name}")

update_config(lang_path.name)

@app.command()

def update_languages(

lang: str = typer.Argument(

None, callback=lang_callback, autocompletion=complete_existing_lang

)

):

"""

Update the mkdocs.yml file Languages section including all the available languages.

The LANG argument is a 2-letter language code. If it's not provided, update all the

mkdocs.yml files (for all the languages).

"""

if lang is None:

for lang_path in get_lang_paths():

if lang_path.is_dir():

update_single_lang(lang_path.name)

else:

update_single_lang(lang)

@app.command()

def serve():

"""

A quick server to preview a built site with translations.

For development, prefer the command live (or just mkdocs serve).

This is here only to preview a site with translations already built.

Make sure you run the build-all command first.

"""

typer.echo("Warning: this is a very simple server.")

typer.echo("For development, use the command live instead.")

typer.echo("This is here only to preview a site with translations already built.")

typer.echo("Make sure you run the build-all command first.")

os.chdir("site")

server_address = ("", 8008)

server = HTTPServer(server_address, SimpleHTTPRequestHandler)

typer.echo(f"Serving at: http://127.0.0.1:8008")

server.serve_forever()

@app.command()

def live(

lang: str = typer.Argument(

None, callback=lang_callback, autocompletion=complete_existing_lang

)

):

"""

Serve with livereload a docs site for a specific language.

This only shows the actual translated files, not the placeholders created with

build-all.

Takes an optional LANG argument with the name of the language to serve, by default

en.

"""

if lang is None:

lang = "en"

lang_path: Path = docs_path / lang

os.chdir(lang_path)

mkdocs.commands.serve.serve(dev_addr="127.0.0.1:8008")

def update_config(lang: str):

lang_path: Path = docs_path / lang

config_path = lang_path / mkdocs_name

current_config: dict = mkdocs.utils.yaml_load(

config_path.read_text(encoding="utf-8")

)

if lang == "en":

config = get_en_config()

else:

config = get_base_lang_config(lang)

config["nav"] = current_config["nav"]

config["theme"]["language"] = current_config["theme"]["language"]

languages = [{"en": "/"}]

alternate: List[Dict[str, str]] = config["extra"].get("alternate", [])

alternate_dict = {alt["link"]: alt["name"] for alt in alternate}

new_alternate: List[Dict[str, str]] = []

for lang_path in get_lang_paths():

if lang_path.name == "en" or not lang_path.is_dir():

continue

name = lang_path.name

languages.append({name: f"/{name}/"})

for lang_dict in languages:

name = list(lang_dict.keys())[0]

url = lang_dict[name]

if url not in alternate_dict:

new_alternate.append({"link": url, "name": name})

else:

use_name = alternate_dict[url]

new_alternate.append({"link": url, "name": use_name})

config["nav"][1] = {"Languages": languages}

config["extra"]["alternate"] = new_alternate

config_path.write_text(

yaml.dump(config, sort_keys=False, width=200, allow_unicode=True),

encoding="utf-8",

)

def get_key_section(

*, key_to_section: Dict[Tuple[str, ...], list], key: Tuple[str, ...]

) -> list:

if key in key_to_section:

return key_to_section[key]

super_key = key[:-1]

title = key[-1]

super_section = get_key_section(key_to_section=key_to_section, key=super_key)

new_section = []

super_section.append({title: new_section})

key_to_section[key] = new_section

return new_section

def get_text_with_translate_missing(text: str) -> str:

lines = text.splitlines()

lines.insert(1, missing_translation_snippet)

new_text = "\n".join(lines)

return new_text

def get_file_to_nav_map(nav: list) -> Dict[str, Tuple[str, ...]]:

file_to_nav = {}

for item in nav:

if type(item) is str:

file_to_nav[item] = tuple()

elif type(item) is dict:

item_key = list(item.keys())[0]

sub_nav = item[item_key]

sub_file_to_nav = get_file_to_nav_map(sub_nav)

for k, v in sub_file_to_nav.items():

file_to_nav[k] = (item_key,) + v

return file_to_nav

def get_sections(nav: list) -> Dict[Tuple[str, ...], str]:

sections = {}

for item in nav:

if type(item) is str:

continue

elif type(item) is dict:

item_key = list(item.keys())[0]

sub_nav = item[item_key]

sections[(item_key,)] = sub_nav[0]

sub_sections = get_sections(sub_nav)

for k, v in sub_sections.items():

new_key = (item_key,) + k

sections[new_key] = v

return sections

if __name__ == "__main__":

app()