makejinja 2.2.0__tar.gz → 2.3.1__tar.gz

{makejinja-2.2.0 → makejinja-2.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: makejinja
-Version: 2.2.0
+Version: 2.3.1
 Summary: makejinja is a CLI tool and Python library to automatically generate files from Jinja2 templates. Use it to easily generate complex Home Assistant dashboards!
 Home-page: https://mirkolenz.github.io/makejinja/
 License: MIT
@@ -28,6 +28,7 @@ Classifier: Topic :: System :: Systems Administration
 Classifier: Topic :: Text Processing :: Markup
 Classifier: Topic :: Utilities
 Classifier: Typing :: Typed
+Requires-Dist: immutables (>=0.20,<0.21)
 Requires-Dist: jinja2 (>=3.1,<4.0)
 Requires-Dist: pyyaml (>=6.0,<7.0)
 Requires-Dist: rich-click (>=1.7,<2.0)
@@ -38,11 +39,12 @@ Description-Content-Type: text/markdown
 
 <!-- markdownlint-disable MD033 MD041 -->
 <p align="center">
-  <img width="256px" src="./assets/logo.png" />
+  <img width="256px" src="https://raw.githubusercontent.com/mirkolenz/makejinja/main/assets/logo.png" />
 </p>
 <p align="center">
+  <a href="https://pypi.org/project/makejinja/">PyPI</a> |
   <a href="https://mirkolenz.github.io/makejinja">Docs</a> |
-  <a href="./tests/data">Example</a> |
+  <a href="https://github.com/mirkolenz/makejinja/tree/main/tests/data">Example</a> |
   <a href="https://jinja.palletsprojects.com/en/3.1.x/templates">Templating</a>
 </p>
 <p align="center">
@@ -59,7 +61,7 @@ This allows you to load variables from external files or create repeating patter
 It is conceptually similar to [gomplate](https://github.com/hairyhenderson/gomplate), but is built on Python and Jinja instead of Go.
 A use case for this tool is generating config files for [Home Assistant](https://www.home-assistant.io/):
 Using the same language that the built-in templates use, you can greatly simplify your configuration.
-An [example for Home Assistant](./tests/data) can be found in the tests directory.
+An [example for Home Assistant](https://github.com/mirkolenz/makejinja/tree/main/tests/data) can be found in the tests directory.
 
 ## Features
 
@@ -70,7 +72,7 @@ An [example for Home Assistant](./tests/data) can be found in the tests director
 - Tailor the whitespace behavior to your needs.
 - Use custom delimiters for Jinja blocks/comments/variables.
 - Modify _all_ init options for the Jinja environment.
-- Write custom **Python loaders** that implement a subset of our fully typed [abstract loader class](./makejinja/loader.py)
+- Write custom **Python loaders** that implement a subset of our fully typed [abstract loader class](https://mirkolenz.github.io/makejinja/makejinja/loader.html#AbstractLoader)
 
 ## Installation
 
@@ -90,25 +92,25 @@ Thus, we advise leveraging [`pipx`](https://github.com/pypa/pipx) instead:
 
 You can then directly invoke the app as follows:
 
-`makejinja --input ./data/input --output ./data/output`
+`makejinja -i ./input -o ./output`
 
 ### Nix
 
 If you use the `nix` package manager, you can add this repository as an input to your flake and use `makejinja.packages.${system}.default`.
 You can also run it directly
 
-`nix run github:mirkolenz/makejinja -- --input ./data/input --output ./data/output`
+`nix run github:mirkolenz/makejinja -- -i ./input -o ./output`
 
 ### Docker
 
 We automatically publish an image at `ghcr.io/mirkolenz/makejinja`.
 To use it, mount a folder to the container and pass the options as the command.
 
-`docker run --rm -v $(pwd)/data:/data ghcr.io/mirkolenz/makejinja:latest --input /data/input --output /data/output`
+`docker run --rm -v $(pwd)/data:/data ghcr.io/mirkolenz/makejinja:latest -i /data/input -o /data/output`
 
 ## Usage in Terminal / Command Line
 
 In its default configuration, makejinja searches the input folder recursively for files ending in `.jinja`.
 It then renders these files and writes them to the output folder, preserving the directory structure.
-Our [documentation](https://mirkolenz.github.io/makejinja/cli.html) contains a detailed description of all options and can also be accessed via `makejinja --help`.
+Our [documentation](https://mirkolenz.github.io/makejinja/makejinja/cli.html) contains a detailed description of all options and can also be accessed via `makejinja --help`.
 

{makejinja-2.2.0 → makejinja-2.3.1}/README.md

@@ -1,10 +1,11 @@
 <!-- markdownlint-disable MD033 MD041 -->
 <p align="center">
-  <img width="256px" src="./assets/logo.png" />
+  <img width="256px" src="https://raw.githubusercontent.com/mirkolenz/makejinja/main/assets/logo.png" />
 </p>
 <p align="center">
+  <a href="https://pypi.org/project/makejinja/">PyPI</a> |
   <a href="https://mirkolenz.github.io/makejinja">Docs</a> |
-  <a href="./tests/data">Example</a> |
+  <a href="https://github.com/mirkolenz/makejinja/tree/main/tests/data">Example</a> |
   <a href="https://jinja.palletsprojects.com/en/3.1.x/templates">Templating</a>
 </p>
 <p align="center">
@@ -21,7 +22,7 @@ This allows you to load variables from external files or create repeating patter
 It is conceptually similar to [gomplate](https://github.com/hairyhenderson/gomplate), but is built on Python and Jinja instead of Go.
 A use case for this tool is generating config files for [Home Assistant](https://www.home-assistant.io/):
 Using the same language that the built-in templates use, you can greatly simplify your configuration.
-An [example for Home Assistant](./tests/data) can be found in the tests directory.
+An [example for Home Assistant](https://github.com/mirkolenz/makejinja/tree/main/tests/data) can be found in the tests directory.
 
 ## Features
 
@@ -32,7 +33,7 @@ An [example for Home Assistant](./tests/data) can be found in the tests director
 - Tailor the whitespace behavior to your needs.
 - Use custom delimiters for Jinja blocks/comments/variables.
 - Modify _all_ init options for the Jinja environment.
-- Write custom **Python loaders** that implement a subset of our fully typed [abstract loader class](./makejinja/loader.py)
+- Write custom **Python loaders** that implement a subset of our fully typed [abstract loader class](https://mirkolenz.github.io/makejinja/makejinja/loader.html#AbstractLoader)
 
 ## Installation
 
@@ -52,24 +53,24 @@ Thus, we advise leveraging [`pipx`](https://github.com/pypa/pipx) instead:
 
 You can then directly invoke the app as follows:
 
-`makejinja --input ./data/input --output ./data/output`
+`makejinja -i ./input -o ./output`
 
 ### Nix
 
 If you use the `nix` package manager, you can add this repository as an input to your flake and use `makejinja.packages.${system}.default`.
 You can also run it directly
 
-`nix run github:mirkolenz/makejinja -- --input ./data/input --output ./data/output`
+`nix run github:mirkolenz/makejinja -- -i ./input -o ./output`
 
 ### Docker
 
 We automatically publish an image at `ghcr.io/mirkolenz/makejinja`.
 To use it, mount a folder to the container and pass the options as the command.
 
-`docker run --rm -v $(pwd)/data:/data ghcr.io/mirkolenz/makejinja:latest --input /data/input --output /data/output`
+`docker run --rm -v $(pwd)/data:/data ghcr.io/mirkolenz/makejinja:latest -i /data/input -o /data/output`
 
 ## Usage in Terminal / Command Line
 
 In its default configuration, makejinja searches the input folder recursively for files ending in `.jinja`.
 It then renders these files and writes them to the output folder, preserving the directory structure.
-Our [documentation](https://mirkolenz.github.io/makejinja/cli.html) contains a detailed description of all options and can also be accessed via `makejinja --help`.
+Our [documentation](https://mirkolenz.github.io/makejinja/makejinja/cli.html) contains a detailed description of all options and can also be accessed via `makejinja --help`.

{makejinja-2.2.0 → makejinja-2.3.1}/makejinja/__init__.py

@@ -1,4 +1,6 @@
 """
+![Screencast demo](../assets/demo.gif)
+
 .. include:: ../README.md
 
 ## Usage as a Library

makejinja-2.3.1/makejinja/app.py

@@ -0,0 +1,360 @@
+import json
+import os
+import shutil
+import sys
+import tomllib
+from collections import abc
+from inspect import signature
+from pathlib import Path
+from typing import Any
+
+import yaml
+from jinja2 import BaseLoader, ChoiceLoader, DictLoader, Environment, FileSystemLoader
+from jinja2.environment import load_extensions
+from jinja2.utils import import_string
+from rich import print
+
+from makejinja.config import Config
+from makejinja.loader import AbstractLoader, Data, MutableData
+
+__all__ = ["makejinja"]
+
+
+def makejinja(config: Config):
+    """makejinja can be used to automatically generate files from [Jinja templates](https://jinja.palletsprojects.com/en/3.1.x/templates/)."""
+
+    for path in config.import_paths:
+        sys.path.append(str(path.resolve()))
+
+    data = load_data(config)
+
+    if config.output.is_dir() and config.clean:
+        if not config.quiet:
+            print(f"Remove output '{config.output}'")
+
+        shutil.rmtree(config.output)
+
+    if not single_input_output_file(config):
+        config.output.mkdir(exist_ok=True, parents=True)
+
+    env = init_jinja_env(config, data)
+
+    for loader in config.loaders:
+        process_loader(loader, env, data)
+
+    # Save rendered files to avoid duplicate work
+    # Even if two files are in two separate folders, they will have the same template name (i.e., relative path)
+    # and thus only the first one will be rendered every time
+    rendered_files: set[Path] = set()
+
+    # Save rendered folders to later copy metadata
+    rendered_folders: dict[Path, Path] = {}
+
+    for user_input_path in config.inputs:
+        if user_input_path.is_file():
+            handle_input_file(user_input_path, config, env, rendered_files)
+        elif user_input_path.is_dir():
+            handle_input_folder(
+                user_input_path, config, env, rendered_files, rendered_folders
+            )
+
+    # The metadata has to be copied after all files are rendered
+    # Otherwise the mtime will be updated
+    if config.copy_metadata:
+        for output_path, input_path in rendered_folders.items():
+            if not config.quiet:
+                print(f"Copy metadata '{input_path}' -> '{output_path}'")
+
+            shutil.copystat(input_path, output_path)
+
+
+def single_input_output_file(config: Config) -> bool:
+    """Check if the user provided a single input and a single output"""
+    return (
+        len(config.inputs) == 1
+        and config.inputs[0].is_file()
+        and (config.output.suffix != "" or config.output.is_file())
+        and not config.output.is_dir()
+    )
+
+
+def handle_input_file(
+    input_path: Path,
+    config: Config,
+    env: Environment,
+    rendered_files: abc.MutableSet[Path],
+) -> None:
+    relative_path = Path(input_path.name)
+    output_path = generate_output_path(config, relative_path)
+
+    if output_path not in rendered_files:
+        render_path(
+            input_path,
+            str(relative_path),
+            output_path,
+            config,
+            env,
+            enforce_jinja_suffix=False,
+        )
+
+    rendered_files.add(output_path)
+
+
+def handle_input_folder(
+    user_input_path: Path,
+    config: Config,
+    env: Environment,
+    rendered_files: abc.MutableSet[Path],
+    rendered_folders: abc.MutableMapping[Path, Path],
+) -> None:
+    input_paths = (
+        input_path
+        for include_pattern in config.include_patterns
+        for input_path in sorted(user_input_path.glob(include_pattern))
+    )
+
+    for input_path in input_paths:
+        relative_path = input_path.relative_to(user_input_path)
+        output_path = generate_output_path(config, relative_path)
+
+        if any(input_path.match(x) for x in config.exclude_patterns):
+            if not config.quiet:
+                print(f"Skip excluded '{input_path}'")
+
+        elif input_path.is_file() and output_path not in rendered_files:
+            render_path(
+                input_path,
+                str(relative_path),
+                output_path,
+                config,
+                env,
+                enforce_jinja_suffix=True,
+            )
+            rendered_files.add(output_path)
+
+        elif input_path.is_dir() and output_path not in rendered_folders:
+            if not config.quiet:
+                print(f"Create folder '{input_path}' -> '{output_path}'")
+
+            output_path.mkdir()
+            rendered_folders[output_path] = input_path
+
+
+def generate_output_path(config: Config, relative_path: Path) -> Path:
+    if single_input_output_file(config):
+        return config.output
+
+    output_file = config.output / relative_path
+
+    if relative_path.suffix == config.jinja_suffix and not config.keep_jinja_suffix:
+        output_file = output_file.with_suffix("")
+
+    return output_file
+
+
+def init_jinja_env(
+    config: Config,
+    data: Data,
+) -> Environment:
+    # If the user-provided ordering of the inputs shall be respected, use this snippet
+    # loaders: list[BaseLoader] = []
+    # for path in config.inputs:
+    #     if path.is_dir():
+    #         loaders.append(FileSystemLoader(path))
+    #     elif path.is_file():
+    #         loaders.append(DictLoader({path.name: path.read_text()}))
+
+    file_loader = DictLoader(
+        {path.name: path.read_text() for path in config.inputs if path.is_file()}
+    )
+    folder_loader = FileSystemLoader([path for path in config.inputs if path.is_dir()])
+    loaders: list[BaseLoader] = [file_loader, folder_loader]
+
+    env = Environment(
+        loader=ChoiceLoader(loaders),
+        extensions=config.extensions,
+        block_start_string=config.delimiter.block_start,
+        block_end_string=config.delimiter.block_end,
+        variable_start_string=config.delimiter.variable_start,
+        variable_end_string=config.delimiter.variable_end,
+        comment_start_string=config.delimiter.comment_start,
+        comment_end_string=config.delimiter.comment_end,
+        line_statement_prefix=config.prefix.line_statement,
+        line_comment_prefix=config.prefix.line_comment,
+        trim_blocks=config.whitespace.trim_blocks,
+        lstrip_blocks=config.whitespace.lstrip_blocks,
+        newline_sequence=config.whitespace.newline_sequence,  # type: ignore
+        keep_trailing_newline=config.whitespace.keep_trailing_newline,
+        optimized=config.internal.optimized,
+        undefined=config.undefined.value,
+        finalize=None,
+        autoescape=config.internal.autoescape,
+        cache_size=config.internal.cache_size,
+        auto_reload=config.internal.auto_reload,
+        bytecode_cache=None,
+        enable_async=config.internal.enable_async,
+    )
+
+    env.globals.update(data)
+    env.globals["env"] = os.environ
+
+    return env
+
+
+def from_yaml(path: Path) -> dict[str, Any]:
+    data = {}
+
+    with path.open("rb") as fp:
+        for doc in yaml.safe_load_all(fp):
+            data |= doc
+
+    return data
+
+
+def from_toml(path: Path) -> dict[str, Any]:
+    with path.open("rb") as fp:
+        return tomllib.load(fp)
+
+
+def from_json(path: Path) -> dict[str, Any]:
+    with path.open("rb") as fp:
+        return json.load(fp)
+
+
+DATA_LOADERS: dict[str, abc.Callable[[Path], dict[str, Any]]] = {
+    ".yaml": from_yaml,
+    ".yml": from_yaml,
+    ".toml": from_toml,
+    ".json": from_json,
+}
+
+
+def collect_files(paths: abc.Iterable[Path], pattern: str = "**/*") -> list[Path]:
+    files = []
+
+    for path in paths:
+        if path.is_dir():
+            files.extend(
+                file
+                for file in sorted(path.glob(pattern))
+                if not file.name.startswith(".") and file.is_file()
+            )
+        elif path.is_file():
+            files.append(path)
+
+    return files
+
+
+def dict_nested_set(data: MutableData, dotted_key: str, value: Any) -> None:
+    """Given `foo`, 'key1.key2.key3', 'something', set foo['key1']['key2']['key3'] = 'something'
+
+    Source: https://stackoverflow.com/a/57561744
+    """
+
+    # Start off pointing at the original dictionary that was passed in.
+    here = data
+
+    # Turn the string of key names into a list of strings.
+    keys = dotted_key.split(".")
+
+    # For every key *before* the last one, we concentrate on navigating through the dictionary.
+    for key in keys[:-1]:
+        # Try to find here[key]. If it doesn't exist, create it with an empty dictionary. Then,
+        # update our `here` pointer to refer to the thing we just found (or created).
+        here = here.setdefault(key, {})
+
+    # Finally, set the final key to the given value
+    here[keys[-1]] = value
+
+
+def load_data(config: Config) -> dict[str, Any]:
+    data: dict[str, Any] = {}
+
+    for path in collect_files(config.data):
+        if loader := DATA_LOADERS.get(path.suffix):
+            if not config.quiet:
+                print(f"Load data '{path}'")
+
+            data |= loader(path)
+        else:
+            if not config.quiet:
+                print(f"Skip unsupported data '{path}'")
+
+    for key, value in config.data_vars:
+        dict_nested_set(data, key, value)
+
+    return data
+
+
+def process_loader(loader_name: str, env: Environment, data: Data):
+    cls: type[AbstractLoader] = import_string(loader_name)
+    sig_params = signature(cls).parameters
+    params: dict[str, Any] = {}
+
+    if sig_params.get("env"):
+        params["env"] = env
+    if sig_params.get("environment"):
+        params["environment"] = env
+    if sig_params.get("data"):
+        params["data"] = data
+
+    loader = cls(**params)
+
+    if hasattr(loader, "globals"):
+        env.globals.update({func.__name__: func for func in loader.globals()})
+
+    if hasattr(loader, "functions"):
+        env.globals.update({func.__name__: func for func in loader.functions()})
+
+    if hasattr(loader, "data"):
+        env.globals.update(loader.data())
+
+    if hasattr(loader, "extensions"):
+        load_extensions(env, loader.extensions())
+
+    if hasattr(loader, "filters"):
+        env.filters.update({func.__name__: func for func in loader.filters()})
+
+    if hasattr(loader, "tests"):
+        env.tests.update({func.__name__: func for func in loader.tests()})
+
+    if hasattr(loader, "policies"):
+        env.policies.update(loader.policies())
+
+
+def render_path(
+    input: Path,
+    template_name: str,
+    output: Path,
+    config: Config,
+    env: Environment,
+    enforce_jinja_suffix: bool,
+) -> None:
+    if output.exists() and not config.force:
+        if not config.quiet:
+            print(f"Skip existing '{output}'")
+
+    elif input.suffix == config.jinja_suffix or not enforce_jinja_suffix:
+        template = env.get_template(template_name)
+        rendered = template.render()
+
+        # Write the rendered template if it has content
+        # Prevents empty macro definitions
+        if rendered.strip() == "" and not config.keep_empty:
+            if not config.quiet:
+                print(f"Skip empty '{input}'")
+        else:
+            if not config.quiet:
+                print(f"Render file '{input}' -> '{output}'")
+
+            with output.open("w") as fp:
+                fp.write(rendered)
+
+            if config.copy_metadata:
+                shutil.copystat(input, output)
+
+    else:
+        if not config.quiet:
+            print(f"Copy file '{input}' -> '{output}'")
+
+        shutil.copy2(input, output)

{makejinja-2.2.0 → makejinja-2.3.1}/makejinja/cli.py

@@ -21,8 +21,8 @@ _ts_loaders = ts.default_loaders(
 )
 
 
-@click.command("makejinja")
-@click.version_option()
+@click.command("makejinja", context_settings={"help_option_names": ("--help", "-h")})
+@click.version_option(None, "--version", "-v")
 @ts.click_options(Config, _ts_loaders)
 def makejinja_cli(config: Config):
     """makejinja can be used to automatically generate files from [Jinja templates](https://jinja.palletsprojects.com/en/3.1.x/templates/).

{makejinja-2.2.0 → makejinja-2.3.1}/makejinja/config.py

@@ -1,7 +1,8 @@
-import typing as t
+from collections import abc
 from enum import Enum
 from pathlib import Path
 
+import immutables
 import rich_click as click
 import typed_settings as ts
 from jinja2 import (
@@ -26,6 +27,7 @@ from jinja2.defaults import (
 )
 
 __all__ = ["Config", "Delimiter", "Internal", "Prefix", "Whitespace", "Undefined"]
+frozendict = immutables.Map
 
 
 class Undefined(Enum):
@@ -62,14 +64,14 @@ class Delimiter:
 
 @ts.settings(frozen=True)
 class Prefix:
-    line_statement: t.Optional[str] = ts.option(
+    line_statement: str | None = ts.option(
         default=LINE_STATEMENT_PREFIX,
         help=(
             "If given and a string, this will be used as prefix for line based"
             " statements."
         ),
     )
-    line_comment: t.Optional[str] = ts.option(
+    line_comment: str | None = ts.option(
         default=LINE_COMMENT_PREFIX,
         help=(
             "If given and a string, this will be used as prefix for line based"
@@ -164,19 +166,21 @@ class Whitespace:
 class Config:
     inputs: tuple[Path, ...] = ts.option(
         click={
-            "type": click.Path(exists=True, file_okay=False, path_type=Path),
-            "param_decls": "--input",
-            "required": True,
+            "type": click.Path(exists=True, path_type=Path),
+            "param_decls": ("--input", "-i"),
         },
         help="""
-            Path to a folder containing template files.
+            Path to a folder containing template files or a single template file.
             It is passed to Jinja's [FileSystemLoader](https://jinja.palletsprojects.com/en/3.1.x/api/#jinja2.FileSystemLoader) when creating the environment.
             **Note:** This option may be passed multiple times to pass a list of values.
             If a template exists in multiple inputs, the last value with be used.
         """,
     )
     output: Path = ts.option(
-        click={"type": click.Path(file_okay=False, writable=True, path_type=Path)},
+        click={
+            "type": click.Path(path_type=Path),
+            "param_decls": ("--output", "-o"),
+        },
         help="""
             Path to a folder where the rendered templates are stored.
             makejinja preserves the relative paths in the process, meaning that you can even use it on nested directories.
@@ -184,7 +188,7 @@ class Config:
     )
     include_patterns: tuple[str, ...] = ts.option(
         default=("**/*",),
-        click={"param_decls": "--include-pattern"},
+        click={"param_decls": ("--include-pattern", "--include", "-I")},
         help="""
             Glob patterns to search for files in `inputs`.
             Accepts all pattern supported by [`fnmatch`](https://docs.python.org/3/library/fnmatch.html#module-fnmatch).
@@ -195,7 +199,7 @@ class Config:
     )
     exclude_patterns: tuple[str, ...] = ts.option(
         default=tuple(),
-        click={"param_decls": "--exclude-pattern"},
+        click={"param_decls": ("--exclude-pattern", "--exclude", "-E")},
         help="""
             Glob patterns pattern to exclude files matched.
             Applied against files discovered through `include_patterns`.
@@ -207,6 +211,7 @@ class Config:
         help="""
             File ending of Jinja template files.
             All files with this suffix in `inputs` matched by `pattern` are passed to the Jinja renderer.
+            This suffix is not enforced for individual files passed to `inputs`.
             **Note:** Should be provided *with* the leading dot.
         """,
     )
@@ -228,7 +233,7 @@ class Config:
     )
     copy_metadata: bool = ts.option(
         default=False,
-        click={"param_decls": "--copy-metadata"},
+        click={"param_decls": ("--copy-metadata", "-m")},
         help="""
             Copy the file metadata (e.g., created/modified/permissions) from the input file using `shutil.copystat`
         """,
@@ -237,20 +242,33 @@ class Config:
         default=tuple(),
         click={
             "type": click.Path(exists=True, path_type=Path),
-            "param_decls": "--data",
+            "param_decls": ("--data", "-d"),
         },
         help="""
                 Load variables from yaml/yml/toml/json files for use in your Jinja templates.
-                The defintions are passed to Jinja's `render` function.
+                The defintions are passed to Jinja as globals.
                 Can either be a file or a folder containg files.
                 **Note:** This option may be passed multiple times to pass a list of values.
                 If multiple files are supplied, beware that previous declarations will be overwritten by newer ones.
             """,
     )
+    data_vars: abc.Mapping[str, str] = ts.option(
+        default=frozendict(),
+        click={
+            "param_decls": ("--data-var", "-D"),
+            "help": """
+                Load variables from the command line for use in your Jinja templates.
+                The definitions are applied after loading the data from files.
+                When using dotted keys (e.g., `foo.bar=42`), the value is converted to a nested dictionary.
+                Consequently, you can override values loaded from files.
+                **Note:** This option may be passed multiple times.
+            """,
+        },
+    )
     loaders: tuple[str, ...] = ts.option(
         default=tuple(),
         click={
-            "param_decls": "--loader",
+            "param_decls": ("--loader", "-l"),
         },
         help="""
             Use custom Python code to adjust the used Jinja environment to your needs.
@@ -278,7 +296,7 @@ class Config:
     )
     extensions: tuple[str, ...] = ts.option(
         default=tuple(),
-        click={"param_decls": "--extension"},
+        click={"param_decls": ("--extension", "-e")},
         help="""
             List of Jinja extensions to use as strings of import paths.
             An overview of the built-in ones can be found on the [project website](https://jinja.palletsprojects.com/en/3.1.x/extensions/).
@@ -295,6 +313,27 @@ class Config:
         """
         ),
     )
+    clean: bool = ts.option(
+        default=False,
+        click={"param_decls": ("--clean", "-c")},
+        help="""
+            Whether to remove the output folder if it exists.
+        """,
+    )
+    force: bool = ts.option(
+        default=False,
+        click={"param_decls": ("--force", "-f")},
+        help="""
+            Whether to overwrite existing files in the output folder.
+        """,
+    )
+    quiet: bool = ts.option(
+        default=False,
+        click={"param_decls": ("--quiet", "-q")},
+        help="""
+            Print no information about the rendering process.
+        """,
+    )
     delimiter: Delimiter = Delimiter()
     prefix: Prefix = Prefix()
     whitespace: Whitespace = Whitespace()
@@ -320,6 +359,7 @@ OPTION_GROUPS = {
             "name": "Jinja Environment",
             "options": [
                 "--data",
+                "--data-var",
                 "--loader",
                 "--import-path",
                 "--extension",

makejinja-2.3.1/makejinja/loader.py

@@ -0,0 +1,59 @@
+from collections import abc
+from typing import Any
+
+from jinja2 import Environment
+from jinja2.ext import Extension
+
+__all__ = (
+    "AbstractLoader",
+    "Environment",
+    "Extension",
+    "Extensions",
+    "Filter",
+    "Filters",
+    "Function",
+    "Functions",
+    "Test",
+    "Tests",
+    "Policies",
+    "MutableData",
+    "Data",
+)
+
+Extensions = abc.Sequence[type[Extension]]
+Filter = abc.Callable[[Any], Any]
+Filters = abc.Sequence[Filter]
+Function = abc.Callable[..., Any]
+Functions = abc.Sequence[Function]
+Test = abc.Callable[..., Any]
+Tests = abc.Sequence[Test]
+Policies = abc.Mapping[str, Any]
+MutableData = abc.MutableMapping[str, Any]
+Data = abc.Mapping[str, Any]
+
+
+class AbstractLoader:
+    def __init__(self, *, env: Environment, data: Data) -> None:
+        pass
+
+    def functions(self) -> Functions:
+        return []
+
+    def data(self) -> Data:
+        return {}
+
+    def filters(self) -> Filters:
+        return []
+
+    def tests(self) -> Tests:
+        return []
+
+    def policies(self) -> Policies:
+        return {}
+
+    def extensions(self) -> Extensions:
+        return []
+
+    # Deprecated: Use functions() and data() instead
+    def globals(self) -> Functions:
+        return []

{makejinja-2.2.0 → makejinja-2.3.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "makejinja"
-version = "2.2.0"
+version = "2.3.1"
 description = "makejinja is a CLI tool and Python library to automatically generate files from Jinja2 templates. Use it to easily generate complex Home Assistant dashboards!"
 authors = ["Mirko Lenz <mirko@mirkolenz.com>"]
 license = "MIT"
@@ -50,6 +50,7 @@ jinja2 = "^3.1"
 pyyaml = "^6.0"
 rich-click = "^1.7"
 typed-settings = { version = "^23.1", extras = ["attrs", "cattrs", "click"] }
+immutables = "^0.20"
 
 [tool.poetry.group.dev.dependencies]
 pytest = "^7.4"
@@ -59,11 +60,12 @@ pytest-cov = "^4.1"
 pdoc = "^14.1"
 
 [tool.pytest.ini_options]
-addopts = "--cov makejinja --cov-report term-missing -vv"
+addopts = "--cov makejinja --cov-report term-missing"
 
 [tool.ruff]
 target-version = "py311"
-select = ["B", "E", "F", "W"]
+select = ["E", "W", "F", "B", "UP"]
+ignore = ["E501"]
 
 [tool.ruff.pydocstyle]
 convention = "google"

makejinja-2.2.0/makejinja/app.py

@@ -1,224 +0,0 @@
-import itertools
-import json
-import shutil
-import sys
-import tomllib
-import typing as t
-from inspect import signature
-from pathlib import Path
-
-import yaml
-from jinja2 import Environment, FileSystemLoader
-from jinja2.environment import load_extensions
-from jinja2.utils import import_string
-from rich import print
-
-from makejinja.config import Config
-from makejinja.loader import AbstractLoader
-
-__all__ = ["makejinja"]
-
-
-def makejinja(config: Config):
-    """makejinja can be used to automatically generate files from [Jinja templates](https://jinja.palletsprojects.com/en/3.1.x/templates/)."""
-
-    for path in config.import_paths:
-        sys.path.append(str(path.resolve()))
-
-    data = load_data(config)
-
-    if config.output.is_dir():
-        print(f"Remove output '{config.output}'")
-        shutil.rmtree(config.output)
-
-    config.output.mkdir()
-
-    env = init_jinja_env(config)
-
-    for loader in config.loaders:
-        process_loader(loader, env, data)
-
-    rendered_files: set[Path] = set()
-    rendered_folders: dict[Path, Path] = {}
-
-    for input_dir, include_pattern in itertools.product(
-        config.inputs, config.include_patterns
-    ):
-        for input_path in sorted(input_dir.glob(include_pattern)):
-            relative_path = input_path.relative_to(input_dir)
-            output_path = generate_output_path(config, relative_path)
-
-            if any(input_path.match(x) for x in config.exclude_patterns):
-                print(f"Skip excluded '{input_path}'")
-
-            elif input_path.is_file() and output_path not in rendered_files:
-                render_path(input_path, relative_path, output_path, config, env, data)
-                rendered_files.add(output_path)
-
-            elif input_path.is_dir() and output_path not in rendered_folders:
-                print(f"Create folder '{input_path}' -> '{output_path}'")
-                output_path.mkdir()
-                rendered_folders[output_path] = input_path
-
-    # The metadata has to be copied after all files are rendered
-    # Otherwise the mtime will be updated
-    if config.copy_metadata:
-        for output_path, input_path in rendered_folders.items():
-            print(f"Copy metadata '{input_path}' -> '{output_path}'")
-            shutil.copystat(input_path, output_path)
-
-
-def generate_output_path(config: Config, relative_path: Path) -> Path:
-    output_file = config.output / relative_path
-
-    if relative_path.suffix == config.jinja_suffix and not config.keep_jinja_suffix:
-        output_file = output_file.with_suffix("")
-
-    return output_file
-
-
-def init_jinja_env(config: Config) -> Environment:
-    return Environment(
-        loader=FileSystemLoader(config.inputs),
-        extensions=config.extensions,
-        block_start_string=config.delimiter.block_start,
-        block_end_string=config.delimiter.block_end,
-        variable_start_string=config.delimiter.variable_start,
-        variable_end_string=config.delimiter.variable_end,
-        comment_start_string=config.delimiter.comment_start,
-        comment_end_string=config.delimiter.comment_end,
-        line_statement_prefix=config.prefix.line_statement,
-        line_comment_prefix=config.prefix.line_comment,
-        trim_blocks=config.whitespace.trim_blocks,
-        lstrip_blocks=config.whitespace.lstrip_blocks,
-        newline_sequence=config.whitespace.newline_sequence,  # type: ignore
-        keep_trailing_newline=config.whitespace.keep_trailing_newline,
-        optimized=config.internal.optimized,
-        undefined=config.undefined.value,
-        finalize=None,
-        autoescape=config.internal.autoescape,
-        cache_size=config.internal.cache_size,
-        auto_reload=config.internal.auto_reload,
-        bytecode_cache=None,
-        enable_async=config.internal.enable_async,
-    )
-
-
-def from_yaml(path: Path) -> dict[str, t.Any]:
-    data = {}
-
-    with path.open("rb") as fp:
-        for doc in yaml.safe_load_all(fp):
-            data |= doc
-
-    return data
-
-
-def from_toml(path: Path) -> dict[str, t.Any]:
-    with path.open("rb") as fp:
-        return tomllib.load(fp)
-
-
-def from_json(path: Path) -> dict[str, t.Any]:
-    with path.open("rb") as fp:
-        return json.load(fp)
-
-
-DATA_LOADERS: dict[str, t.Callable[[Path], dict[str, t.Any]]] = {
-    ".yaml": from_yaml,
-    ".yml": from_yaml,
-    ".toml": from_toml,
-    ".json": from_json,
-}
-
-
-def collect_files(paths: t.Iterable[Path], pattern: str = "**/*") -> t.List[Path]:
-    files = []
-
-    for path in paths:
-        if path.is_dir():
-            files.extend(
-                file
-                for file in sorted(path.glob(pattern))
-                if not file.name.startswith(".") and file.is_file()
-            )
-        elif path.is_file():
-            files.append(path)
-
-    return files
-
-
-def load_data(config: Config) -> dict[str, t.Any]:
-    data: dict[str, t.Any] = {}
-
-    for path in collect_files(config.data):
-        if loader := DATA_LOADERS.get(path.suffix):
-            data |= loader(path)
-        else:
-            print(f"Skip unsupported data '{path}'")
-
-    return data
-
-
-def process_loader(
-    loader_name: str, env: Environment, data: t.MutableMapping[str, t.Any]
-):
-    cls: t.Type[AbstractLoader] = import_string(loader_name)
-    sig_params = signature(cls).parameters
-    params: dict[str, t.Any] = {}
-
-    if sig_params.get("env"):
-        params["env"] = env
-    if sig_params.get("environment"):
-        params["environment"] = env
-    if sig_params.get("data"):
-        params["data"] = data
-
-    loader = cls(**params)
-
-    if hasattr(loader, "extensions"):
-        load_extensions(env, loader.extensions())
-
-    if hasattr(loader, "globals"):
-        env.globals.update({func.__name__: func for func in loader.globals()})
-
-    if hasattr(loader, "filters"):
-        env.filters.update({func.__name__: func for func in loader.filters()})
-
-    if hasattr(loader, "tests"):
-        env.tests.update({func.__name__: func for func in loader.tests()})
-
-    if hasattr(loader, "policies"):
-        env.policies.update(loader.policies())
-
-    if hasattr(loader, "data"):
-        data.update(loader.data())
-
-
-def render_path(
-    input: Path,
-    relative_path: Path,
-    output: Path,
-    config: Config,
-    env: Environment,
-    data: dict[str, t.Any],
-) -> None:
-    if input.suffix == config.jinja_suffix:
-        template = env.get_template(str(relative_path))
-        rendered = template.render(data)
-
-        # Write the rendered template if it has content
-        # Prevents empty macro definitions
-        if rendered.strip() == "" and not config.keep_empty:
-            print(f"Skip empty '{input}'")
-        else:
-            print(f"Render file '{input}' -> '{output}'")
-            with output.open("w") as fp:
-                fp.write(rendered)
-
-            if config.copy_metadata:
-                shutil.copystat(input, output)
-
-    else:
-        print(f"Copy file '{input}' -> '{output}'")
-        shutil.copy2(input, output)

makejinja-2.2.0/makejinja/loader.py

@@ -1,54 +0,0 @@
-import typing as t
-
-from jinja2 import Environment
-from jinja2.ext import Extension
-
-__all__ = [
-    "AbstractLoader",
-    "Environment",
-    "Extension",
-    "Extensions",
-    "Filter",
-    "Filters",
-    "Global",
-    "Globals",
-    "Test",
-    "Tests",
-    "Policies",
-    "MutableData",
-    "Data",
-]
-
-Extensions = t.Sequence[t.Type[Extension]]
-Filter = t.Callable[[t.Any], t.Any]
-Filters = t.Sequence[Filter]
-Global = t.Callable[..., t.Any]
-Globals = t.Sequence[Global]
-Test = t.Callable[..., t.Any]
-Tests = t.Sequence[Test]
-Policies = t.Mapping[str, t.Any]
-MutableData = t.MutableMapping[str, t.Any]
-Data = t.Mapping[str, t.Any]
-
-
-class AbstractLoader:
-    def __init__(self, *, env: Environment, data: MutableData) -> None:
-        pass
-
-    def filters(self) -> Filters:
-        return []
-
-    def globals(self) -> Globals:
-        return []
-
-    def tests(self) -> Tests:
-        return []
-
-    def policies(self) -> Policies:
-        return {}
-
-    def data(self) -> Data:
-        return {}
-
-    def extensions(self) -> Extensions:
-        return []