makejinja 2.8.2__tar.gz → 2.9.0__tar.gz

{makejinja-2.8.2 → makejinja-2.9.0}/PKG-INFO

@@ -1,23 +1,22 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: makejinja
-Version: 2.8.2
+Version: 2.9.0
 Summary: Generate entire directory structures using Jinja templates with support for external data and custom plugins
-Keywords: jinja2,home-assistant,hassio,dashboard,lovelace,template,generator,cli,tool,library
+Keywords: cli,dashboard,generator,hassio,home-assistant,jinja2,library,lovelace,template,tool
 Author: Mirko Lenz
 Author-email: Mirko Lenz <mirko@mirkolenz.com>
+License-Expression: MIT
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console
 Classifier: Framework :: Pytest
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: End Users/Desktop
 Classifier: Intended Audience :: System Administrators
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Natural Language :: English
 Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
-Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: File Formats
 Classifier: Topic :: Home Automation
 Classifier: Topic :: Software Development :: Code Generators
@@ -31,8 +30,8 @@ Requires-Dist: frozendict>=2,<3
 Requires-Dist: jinja2>=3,<4
 Requires-Dist: pyyaml>=6,<7
 Requires-Dist: rich-click>=1,<2
-Requires-Dist: typed-settings[attrs,cattrs,click]>=23,<26
-Requires-Python: >=3.12, <4
+Requires-Dist: typed-settings[attrs,cattrs,click]>=25,<27
+Requires-Python: >=3.13, <4
 Project-URL: Changelog, https://github.com/mirkolenz/makejinja/releases
 Project-URL: Documentation, https://mirkolenz.github.io/makejinja/makejinja/cli.html
 Project-URL: Homepage, https://mirkolenz.github.io/makejinja/
@@ -78,10 +77,10 @@ Our comprehensive [Home Assistant example](https://github.com/mirkolenz/makejinj
 
 ## Key Features
 
-- **Multi-Source Data Integration**: Load variables from YAML, TOML, and Python files, with support for file-specific data sources and runtime variable injection.
+- **Multi-Source Data Integration**: Load variables from YAML, TOML, and Python files, with support for file-specific data sources, per-file namespacing, and runtime variable injection.
 - **Custom Template Delimiters**: Configure Jinja delimiters (e.g., `<% %>` instead of `{{ }}`) to avoid conflicts with target file formats like Home Assistant, Kubernetes, or Terraform.
 - **Flexible Directory Processing**: Process multiple input directories with complex nested structures, preserving hierarchy while applying powerful template transformations.
-- **Extensible Plugin System**: Create custom [plugins](https://mirkolenz.github.io/makejinja/makejinja/plugin.html#Plugin) with filters, functions, and path filtering logic for specialized requirements.
+- **Extensible Plugin System**: Create custom [plugins](https://mirkolenz.github.io/makejinja/makejinja/plugin.html#Plugin) with filters, functions, data, tests, policies, extensions, and path filtering logic for specialized requirements.
 - **Production-Ready**: Comprehensive CLI interface, configuration file support, and Python library API for seamless workflow integration.
 
 ## Use Cases

{makejinja-2.8.2 → makejinja-2.9.0}/README.md

@@ -36,10 +36,10 @@ Our comprehensive [Home Assistant example](https://github.com/mirkolenz/makejinj
 
 ## Key Features
 
-- **Multi-Source Data Integration**: Load variables from YAML, TOML, and Python files, with support for file-specific data sources and runtime variable injection.
+- **Multi-Source Data Integration**: Load variables from YAML, TOML, and Python files, with support for file-specific data sources, per-file namespacing, and runtime variable injection.
 - **Custom Template Delimiters**: Configure Jinja delimiters (e.g., `<% %>` instead of `{{ }}`) to avoid conflicts with target file formats like Home Assistant, Kubernetes, or Terraform.
 - **Flexible Directory Processing**: Process multiple input directories with complex nested structures, preserving hierarchy while applying powerful template transformations.
-- **Extensible Plugin System**: Create custom [plugins](https://mirkolenz.github.io/makejinja/makejinja/plugin.html#Plugin) with filters, functions, and path filtering logic for specialized requirements.
+- **Extensible Plugin System**: Create custom [plugins](https://mirkolenz.github.io/makejinja/makejinja/plugin.html#Plugin) with filters, functions, data, tests, policies, extensions, and path filtering logic for specialized requirements.
 - **Production-Ready**: Comprehensive CLI interface, configuration file support, and Python library API for seamless workflow integration.
 
 ## Use Cases

{makejinja-2.8.2 → makejinja-2.9.0}/pyproject.toml

@@ -1,20 +1,21 @@
 [project]
 name = "makejinja"
-version = "2.8.2"
+version = "2.9.0"
 description = "Generate entire directory structures using Jinja templates with support for external data and custom plugins"
-authors = [{ name = "Mirko Lenz", email = "mirko@mirkolenz.com" }]
 readme = "README.md"
+requires-python = ">=3.13,<4"
+license = "MIT"
 keywords = [
-    "jinja2",
-    "home-assistant",
-    "hassio",
+    "cli",
     "dashboard",
+    "generator",
+    "hassio",
+    "home-assistant",
+    "jinja2",
+    "library",
     "lovelace",
     "template",
-    "generator",
-    "cli",
     "tool",
-    "library",
 ]
 classifiers = [
     "Development Status :: 5 - Production/Stable",
@@ -23,13 +24,11 @@ classifiers = [
     "Intended Audience :: Developers",
     "Intended Audience :: End Users/Desktop",
     "Intended Audience :: System Administrators",
-    "License :: OSI Approved :: MIT License",
     "Natural Language :: English",
     "Operating System :: OS Independent",
-    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3.13",
     "Programming Language :: Python :: 3.14",
-    "Programming Language :: Python :: 3",
     "Topic :: File Formats",
     "Topic :: Home Automation",
     "Topic :: Software Development :: Code Generators",
@@ -40,38 +39,50 @@ classifiers = [
     "Topic :: Utilities",
     "Typing :: Typed",
 ]
-requires-python = ">=3.12,<4"
 dependencies = [
     "frozendict>=2,<3",
     "jinja2>=3,<4",
     "pyyaml>=6,<7",
     "rich-click>=1,<2",
-    "typed-settings[attrs,cattrs,click]>=23,<26",
+    "typed-settings[attrs,cattrs,click]>=25,<27",
 ]
 
+[[project.authors]]
+name = "Mirko Lenz"
+email = "mirko@mirkolenz.com"
+
 [project.urls]
-Repository = "https://github.com/mirkolenz/makejinja"
-Homepage = "https://mirkolenz.github.io/makejinja/"
+Changelog = "https://github.com/mirkolenz/makejinja/releases"
 Documentation = "https://mirkolenz.github.io/makejinja/makejinja/cli.html"
+Homepage = "https://mirkolenz.github.io/makejinja/"
 Issues = "https://github.com/mirkolenz/makejinja/issues"
-Changelog = "https://github.com/mirkolenz/makejinja/releases"
+Repository = "https://github.com/mirkolenz/makejinja"
 
 [project.scripts]
 makejinja = "makejinja.cli:makejinja_cli"
 
 [dependency-groups]
-test = ["pytest>=9,<10", "pytest-cov>=7,<8"]
 docs = ["pdoc>=16,<17"]
+test = [
+    "pytest>=9,<10",
+    "pytest-cov>=7,<8",
+]
 
 [build-system]
-requires = ["uv-build>=0.9,<1"]
+requires = ["uv-build>=0.12,<1"]
 build-backend = "uv_build"
 
-[tool.uv]
-default-groups = ["test", "docs"]
-
 [tool.pytest]
-addopts = ["--cov=makejinja", "--cov-report=term-missing"]
+addopts = [
+    "--cov=makejinja",
+    "--cov-report=term-missing",
+]
 
 [tool.ruff.lint.pydocstyle]
 convention = "google"
+
+[tool.uv]
+default-groups = [
+    "test",
+    "docs",
+]

makejinja-2.9.0/pyproject.toml.orig

@@ -0,0 +1,76 @@
+[project]
+name = "makejinja"
+version = "2.9.0"
+description = "Generate entire directory structures using Jinja templates with support for external data and custom plugins"
+readme = "README.md"
+requires-python = ">=3.13,<4"
+license = "MIT"
+authors = [{ name = "Mirko Lenz", email = "mirko@mirkolenz.com" }]
+keywords = [
+  "cli",
+  "dashboard",
+  "generator",
+  "hassio",
+  "home-assistant",
+  "jinja2",
+  "library",
+  "lovelace",
+  "template",
+  "tool",
+]
+classifiers = [
+  "Development Status :: 5 - Production/Stable",
+  "Environment :: Console",
+  "Framework :: Pytest",
+  "Intended Audience :: Developers",
+  "Intended Audience :: End Users/Desktop",
+  "Intended Audience :: System Administrators",
+  "Natural Language :: English",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+  "Topic :: File Formats",
+  "Topic :: Home Automation",
+  "Topic :: Software Development :: Code Generators",
+  "Topic :: Software Development :: Libraries :: Python Modules",
+  "Topic :: System :: Software Distribution",
+  "Topic :: System :: Systems Administration",
+  "Topic :: Text Processing :: Markup",
+  "Topic :: Utilities",
+  "Typing :: Typed",
+]
+dependencies = [
+  "frozendict>=2,<3",
+  "jinja2>=3,<4",
+  "pyyaml>=6,<7",
+  "rich-click>=1,<2",
+  "typed-settings[attrs,cattrs,click]>=25,<27",
+]
+
+[project.urls]
+Changelog = "https://github.com/mirkolenz/makejinja/releases"
+Documentation = "https://mirkolenz.github.io/makejinja/makejinja/cli.html"
+Homepage = "https://mirkolenz.github.io/makejinja/"
+Issues = "https://github.com/mirkolenz/makejinja/issues"
+Repository = "https://github.com/mirkolenz/makejinja"
+
+[project.scripts]
+makejinja = "makejinja.cli:makejinja_cli"
+
+[dependency-groups]
+docs = ["pdoc>=16,<17"]
+test = ["pytest>=9,<10", "pytest-cov>=7,<8"]
+
+[build-system]
+requires = ["uv-build>=0.12,<1"]
+build-backend = "uv_build"
+
+[tool.pytest]
+addopts = ["--cov=makejinja", "--cov-report=term-missing"]
+
+[tool.ruff.lint.pydocstyle]
+convention = "google"
+
+[tool.uv]
+default-groups = ["test", "docs"]

{makejinja-2.8.2 → makejinja-2.9.0}/src/makejinja/__init__.py

@@ -16,4 +16,4 @@ from .app import makejinja
 
 loader = plugin
 
-__all__ = ["makejinja", "config", "plugin", "loader", "cli"]
+__all__ = ["cli", "config", "loader", "makejinja", "plugin"]

{makejinja-2.8.2 → makejinja-2.9.0}/src/makejinja/app.py

@@ -8,16 +8,16 @@ import tomllib
 from collections import abc
 from inspect import signature
 from pathlib import Path
-from typing import Any
+from typing import Any, cast
 
 import rich_click as click
 import yaml
 from jinja2 import BaseLoader, ChoiceLoader, DictLoader, Environment, FileSystemLoader
-from jinja2.environment import load_extensions
 from jinja2.utils import import_string
+from typed_settings.dict_utils import set_path
 
-from makejinja.config import Config
-from makejinja.plugin import Data, MutableData, PathFilter, Plugin
+from makejinja.config import Config, DataNamespace
+from makejinja.plugin import Data, Functions, MutableData, PathFilter, Plugin
 
 __all__ = ["makejinja"]
 
@@ -244,7 +244,7 @@ def init_jinja_env(
     )
 
     env.globals.update(data)
-    env.globals["env"] = os.environ
+    cast(dict[str, Any], env.globals)["env"] = os.environ
 
     return env
 
@@ -266,14 +266,7 @@ def from_yaml(path: Path) -> dict[str, Any]:
 
 def from_toml(path: Path) -> dict[str, Any]:
     with path.open("rb") as fp:
-        data = tomllib.load(fp)
-
-    if isinstance(data, abc.Mapping):
-        return dict(data)
-
-    raise TypeError(
-        f"Expected TOML documents in '{path}' to be mappings but found {type(data).__name__}"
-    )
+        return tomllib.load(fp)
 
 
 def from_json(path: Path) -> dict[str, Any]:
@@ -281,7 +274,7 @@ def from_json(path: Path) -> dict[str, Any]:
         data = json.load(fp)
 
     if isinstance(data, abc.Mapping):
-        return data
+        return dict(data)
 
     raise TypeError(
         f"Expected JSON documents in '{path}' to be mappings but found {type(data).__name__}"
@@ -296,57 +289,89 @@ DATA_LOADERS: dict[str, abc.Callable[[Path], dict[str, Any]]] = {
 }
 
 
-def collect_files(paths: abc.Iterable[Path], pattern: str = "**/*") -> list[Path]:
-    files = []
+def collect_files(paths: abc.Iterable[Path]) -> abc.Iterator[tuple[Path, Path]]:
+    """Find all files in the given paths, yielding them together with their relative path."""
 
     for path in paths:
         if path.is_dir():
-            files.extend(
-                file
-                for file in sorted(path.glob(pattern))
+            yield from (
+                (file, file.relative_to(path))
+                for file in sorted(path.glob("**/*"))
                 if not file.name.startswith(".") and file.is_file()
             )
+
         elif path.is_file():
-            files.append(path)
+            yield path, Path(path.name)
 
-    return files
 
+def to_identifier(name: str) -> str:
+    """Replace all characters that are invalid in a Python identifier with underscores.
 
-def dict_nested_set(data: MutableData, dotted_key: str, value: Any) -> None:
-    """Given `foo`, 'key1.key2.key3', 'something', set foo['key1']['key2']['key3'] = 'something'
+    Jinja looks up globals by name, so only identifiers are reachable from templates.
 
-    Source: https://stackoverflow.com/a/57561744
+    >>> to_identifier("my-hosting")
+    'my_hosting'
+    >>> to_identifier("2nd")
+    '_2nd'
     """
 
-    # Start off pointing at the original dictionary that was passed in.
-    here = data
+    # The `_` prefix isolates the rules for the first character, leaving a continuation check
+    identifier = "".join(char if f"_{char}".isidentifier() else "_" for char in name)
+
+    return identifier if identifier.isidentifier() else f"_{identifier}"
+
+
+def namespace_keys(
+    relative_path: Path, data_namespace: DataNamespace
+) -> tuple[str, ...]:
+    """Determine the nested keys under which the contents of a data file are stored."""
+
+    match data_namespace:
+        case DataNamespace.flat:
+            return ()
 
-    # Turn the string of key names into a list of strings.
-    keys = dotted_key.split(".")
+        case DataNamespace.stem:
+            parts = (relative_path.stem,)
 
-    # 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, {})
+        case DataNamespace.path:
+            parts = relative_path.with_suffix("").parts
 
-    # Finally, set the final key to the given value
-    here[keys[-1]] = value
+    return tuple(to_identifier(part) for part in parts)
+
+
+def dict_nested_setdefault(data: MutableData, keys: abc.Iterable[str]) -> MutableData:
+    """Traverse nested dicts along `keys`, inserting empty dicts for missing entries.
+
+    >>> data = {}
+    >>> dict_nested_setdefault(data, ["key1", "key2"])["key3"] = "value"
+    >>> data
+    {'key1': {'key2': {'key3': 'value'}}}
+    """
+
+    for key in keys:
+        data = data.setdefault(key, {})
+
+    return data
 
 
 def load_data(config: Config) -> dict[str, Any]:
     data: dict[str, Any] = {}
 
-    for path in collect_files(config.data):
+    for path, relative_path in collect_files(config.data):
         if loader := DATA_LOADERS.get(path.suffix):
-            log(f"Load data '{path}'", config)
+            keys = namespace_keys(relative_path, config.data_namespace)
+            dotted_keys = ".".join(keys)
+            suffix = f" as '{dotted_keys}'" if keys else ""
+
+            log(f"Load data '{path}'{suffix}", config)
+
+            dict_nested_setdefault(data, keys).update(loader(path))
 
-            data |= loader(path)
         else:
             log(f"Skip unsupported data '{path}'", config)
 
     for key, value in config.data_vars.items():
-        dict_nested_set(data, key, value)
+        set_path(data, key, value)
 
     return data
 
@@ -371,6 +396,10 @@ def load_file_data(template_name: str, config: Config) -> dict[str, Any]:
     return file_data
 
 
+def _named_functions(functions: Functions) -> dict[str, Any]:
+    return {cast(Any, func).__name__: func for func in functions}
+
+
 def load_plugin(
     plugin_name: str, env: Environment, data: Data, config: Config
 ) -> Plugin:
@@ -390,22 +419,23 @@ def load_plugin(
     plugin = cls(**params)
 
     if hasattr(plugin, "globals"):
-        env.globals.update({func.__name__: func for func in plugin.globals()})
+        env.globals.update(_named_functions(plugin.globals()))
 
     if hasattr(plugin, "functions"):
-        env.globals.update({func.__name__: func for func in plugin.functions()})
+        env.globals.update(_named_functions(plugin.functions()))
 
     if hasattr(plugin, "data"):
         env.globals.update(plugin.data())
 
     if hasattr(plugin, "extensions"):
-        load_extensions(env, plugin.extensions())
+        for extension in plugin.extensions():
+            env.add_extension(extension)
 
     if hasattr(plugin, "filters"):
-        env.filters.update({func.__name__: func for func in plugin.filters()})
+        env.filters.update(_named_functions(plugin.filters()))
 
     if hasattr(plugin, "tests"):
-        env.tests.update({func.__name__: func for func in plugin.tests()})
+        env.tests.update(_named_functions(plugin.tests()))
 
     if hasattr(plugin, "policies"):
         env.policies.update(plugin.policies())

{makejinja-2.8.2 → makejinja-2.9.0}/src/makejinja/cli.py

@@ -13,7 +13,7 @@ from .app import makejinja
 
 __all__: list[str] = []
 
-click.rich_click.USE_MARKDOWN = True
+click.rich_click.TEXT_MARKUP = "markdown"
 click.rich_click.OPTION_GROUPS = OPTION_GROUPS
 
 _ts_loaders = ts.default_loaders(
@@ -23,8 +23,11 @@ _ts_loaders = ts.default_loaders(
 
 @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):
+# Without reloading, `makejinja.toml` is resolved against the working directory at import
+# time. Collection options stay bound to it either way, as typed-settings injects their
+# import-time defaults as if they were passed on the command line.
+@ts.click_options(Config, _ts_loaders, reload_settings_on_invoke=True)
+def makejinja_cli(config: Config) -> None:
     """makejinja can be used to automatically generate files from [Jinja templates](https://jinja.palletsprojects.com/en/3.1.x/templates/).
 
     Instead of passing CLI options, you can also write them to a file called `makejinja.toml` in your working directory.

{makejinja-2.8.2 → makejinja-2.9.0}/src/makejinja/config.py

@@ -1,6 +1,7 @@
 from collections import abc
-from enum import Enum
+from enum import Enum, auto
 from pathlib import Path
+from typing import Literal
 
 import rich_click as click
 import typed_settings as ts
@@ -24,7 +25,15 @@ from jinja2.defaults import (
 )
 from rich_click.utils import OptionGroupDict
 
-__all__ = ["Config", "Delimiter", "Internal", "Prefix", "Whitespace", "Undefined"]
+__all__ = [
+    "Config",
+    "DataNamespace",
+    "Delimiter",
+    "Internal",
+    "Prefix",
+    "Undefined",
+    "Whitespace",
+]
 
 
 class Undefined(Enum):
@@ -36,6 +45,14 @@ class Undefined(Enum):
     strict = StrictUndefined
 
 
+class DataNamespace(Enum):
+    """Where the contents of a data file are placed in the global namespace."""
+
+    flat = auto()
+    stem = auto()
+    path = auto()
+
+
 def _exclude_patterns_validator(instance, attribute, value) -> None:
     if any("**" in pattern for pattern in value):
         # todo: for next major release, raise ValueError instead of printing a warning
@@ -152,7 +169,7 @@ class Whitespace:
             If this is set to `True`, leading spaces and tabs are stripped from the start of a line to a block.
         """,
     )
-    newline_sequence: str = ts.option(
+    newline_sequence: Literal["\n", "\r\n", "\r"] = ts.option(
         default=NEWLINE_SEQUENCE,
         click={"param_decls": "--newline-sequence"},
         help="""
@@ -206,7 +223,7 @@ class Config:
         """,
     )
     exclude_patterns: tuple[str, ...] = ts.option(
-        default=tuple(),
+        default=(),
         click={"param_decls": ("--exclude-pattern", "--exclude", "-E")},
         validator=_exclude_patterns_validator,
         help="""
@@ -250,7 +267,7 @@ class Config:
         """,
     )
     data: tuple[Path, ...] = ts.option(
-        default=tuple(),
+        default=(),
         click={
             "type": click.Path(exists=True, path_type=Path),
             "param_decls": ("--data", "-d"),
@@ -263,6 +280,19 @@ class Config:
                 If multiple files are supplied, beware that previous declarations will be overwritten by newer ones.
             """,
     )
+    data_namespace: DataNamespace = ts.option(
+        default=DataNamespace.flat,
+        help="""
+                Determine where the contents of each `data` file are placed in the Jinja globals.
+                With `flat`, all files are merged into a single namespace, so identical keys are overwritten by files loaded later.
+                With `stem`, each file is nested under its name without the suffix, making `data/hosting.toml` available as `{{ hosting.provider }}`.
+                With `path`, each file is nested under its path relative to the `data` entry it was found in,
+                making `data/catalogs/hosting.toml` available as `{{ catalogs.hosting.provider }}` when passing `-d data`.
+                A `data` entry pointing to a file instead of a directory always uses its stem.
+                **Note:** Characters that are invalid in a Python identifier are replaced with `_` to keep the keys reachable in templates,
+                so `my-hosting.toml` is available as `{{ my_hosting.provider }}`.
+            """,
+    )
     data_vars: abc.Mapping[str, str] = ts.option(
         default=frozendict(),
         click={
@@ -290,7 +320,7 @@ class Config:
         },
     )
     loaders: tuple[str, ...] = ts.option(
-        default=tuple(),
+        default=(),
         click={
             "param_decls": ("--loader", "-l"),
             "hidden": True,
@@ -298,17 +328,18 @@ class Config:
         help="Deprecated, use `--plugin` instead.",
     )
     plugins: tuple[str, ...] = ts.option(
-        default=tuple(),
+        default=(),
         click={
             "param_decls": ("--plugin", "-p"),
         },
         help="""
             Use custom Python code to adjust the used Jinja environment to your needs.
             The specified Python file should export a **class** containing a subset of the following functions:
-            `filters`, `globals`, `data`, and `extensions`.
-            In addition, you may add an `__init__` function that receives two positional arguments:
-            the created Jinja environment and the data parsed from the files supplied to makejinja's `data` option.
-            This allows you to apply arbitrary logic to makejinja.
+            `filters`, `functions`, `data`, `tests`, `policies`, `extensions`, and `path_filters`.
+            The `globals` method is deprecated, use `functions` and `data` instead.
+            An optional `__init__` method can receive any subset of the keyword arguments `env` (or `environment`), `data`, and `config`.
+            These provide the Jinja environment, loaded global data, and makejinja configuration.
+            Before templates are loaded, the constructor can configure environment features such as `finalize`, custom loaders, and bytecode caching.
             An import path can be specified either in dotted notation (`your.custom.Plugin`)
             or with a colon as object delimiter (`your.custom:Plugin`).
             **Note:** This option may be passed multiple times to pass a list of values.
@@ -327,7 +358,7 @@ class Config:
         """,
     )
     extensions: tuple[str, ...] = ts.option(
-        default=tuple(),
+        default=(),
         click={"param_decls": ("--extension", "-e")},
         help="""
             List of Jinja extensions to use as strings of import paths.
@@ -346,13 +377,13 @@ class Config:
         ),
     )
     exec_pre: tuple[str, ...] = ts.option(
-        default=tuple(),
+        default=(),
         help="""
             Shell commands to execute before rendering.
         """,
     )
     exec_post: tuple[str, ...] = ts.option(
-        default=tuple(),
+        default=(),
         help="""
             Shell commands to execute after rendering.
         """,
@@ -403,6 +434,7 @@ OPTION_GROUPS: dict[str, list[OptionGroupDict]] = {
             "name": "Jinja Environment",
             "options": [
                 "--data",
+                "--data-namespace",
                 "--data-var",
                 "--file-data",
                 "--plugin",

makejinja-2.9.0/src/makejinja/plugin.py

@@ -0,0 +1,76 @@
+from collections import abc
+from pathlib import Path
+from typing import Any, Protocol
+
+from jinja2 import Environment
+from jinja2.ext import Extension
+
+from makejinja.config import Config
+
+__all__ = ["Plugin"]
+
+
+type Extensions = abc.Sequence[type[Extension]]
+type Filter = abc.Callable[..., Any]
+type Filters = abc.Sequence[Filter]
+type Function = abc.Callable[..., Any]
+type Functions = abc.Sequence[Function]
+type Test = abc.Callable[..., Any]
+type Tests = abc.Sequence[Test]
+type Policies = abc.Mapping[str, Any]
+type MutableData = abc.MutableMapping[str, Any]
+type Data = abc.Mapping[str, Any]
+type PathFilter = abc.Callable[[Path], bool]
+type PathFilters = abc.Sequence[PathFilter]
+
+
+class Plugin(Protocol):
+    """Extend makejinja by implementing any subset of the plugin methods.
+
+    The optional constructor receives supported parameters by keyword.
+    It may request `env` (or `environment`), `data`, and `config`.
+    Configure the environment before loading any templates, including changes to
+    `finalize`, custom loaders, or bytecode caching.
+    """
+
+    def __init__(self, *, env: Environment, data: Data, config: Config) -> None:
+        pass
+
+    def functions(self) -> Functions:
+        """Return global template callables registered by their function names."""
+        return []
+
+    def data(self) -> Data:
+        """Return global template values that override existing values."""
+        return {}
+
+    def filters(self) -> Filters:
+        """Return template filters registered by their function names."""
+        return []
+
+    def tests(self) -> Tests:
+        """Return template tests registered by their function names."""
+        return []
+
+    def policies(self) -> Policies:
+        """Return overrides for Jinja environment policies."""
+        return {}
+
+    def extensions(self) -> Extensions:
+        """Return Jinja extension classes to register on the environment."""
+        return []
+
+    def path_filters(self) -> PathFilters:
+        """Return predicates that exclude discovered paths when they return false."""
+        return []
+
+    def globals(self) -> Functions:
+        """Return global callables.
+
+        Deprecated:
+            Use `functions()` and `data()` instead.
+        """
+        return []
+
+
+AbstractLoader = Plugin

makejinja-2.8.2/src/makejinja/plugin.py

@@ -1,58 +0,0 @@
-from collections import abc
-from pathlib import Path
-from typing import Any, Protocol
-
-from jinja2 import Environment
-from jinja2.ext import Extension
-
-from makejinja.config import Config
-
-__all__ = ["Plugin"]
-
-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]
-PathFilter = abc.Callable[[Path], bool]
-PathFilters = abc.Sequence[PathFilter]
-
-
-class Plugin(Protocol):
-    """Extend the functionality of makejinja with a plugin implementing a subset of this protocol."""
-
-    def __init__(self, *, env: Environment, data: Data, config: Config) -> 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 []
-
-    def path_filters(self) -> PathFilters:
-        return []
-
-    # Deprecated: Use functions() and data() instead
-    def globals(self) -> Functions:
-        return []
-
-
-AbstractLoader = Plugin