makejinja 2.8.1__tar.gz → 2.8.3__tar.gz

{makejinja-2.8.1/src/makejinja.egg-info → makejinja-2.8.3}/PKG-INFO

@@ -1,27 +1,22 @@
 Metadata-Version: 2.4
 Name: makejinja
-Version: 2.8.1
+Version: 2.8.3
 Summary: Generate entire directory structures using Jinja templates with support for external data and custom plugins
+Keywords: cli,dashboard,generator,hassio,home-assistant,jinja2,library,lovelace,template,tool
+Author: Mirko Lenz
 Author-email: Mirko Lenz <mirko@mirkolenz.com>
-Project-URL: Repository, https://github.com/mirkolenz/makejinja
-Project-URL: Homepage, https://mirkolenz.github.io/makejinja/
-Project-URL: Documentation, https://mirkolenz.github.io/makejinja/makejinja/cli.html
-Project-URL: Issues, https://github.com/mirkolenz/makejinja/issues
-Project-URL: Changelog, https://github.com/mirkolenz/makejinja/releases
-Keywords: jinja2,home-assistant,hassio,dashboard,lovelace,template,generator,cli,tool,library
+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.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: File Formats
 Classifier: Topic :: Home Automation
 Classifier: Topic :: Software Development :: Code Generators
@@ -31,15 +26,18 @@ Classifier: Topic :: System :: Systems Administration
 Classifier: Topic :: Text Processing :: Markup
 Classifier: Topic :: Utilities
 Classifier: Typing :: Typed
-Requires-Python: >=3.11
+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]>=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/
+Project-URL: Issues, https://github.com/mirkolenz/makejinja/issues
+Project-URL: Repository, https://github.com/mirkolenz/makejinja
 Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: jinja2<4,>=3
-Requires-Dist: pyyaml<7,>=6
-Requires-Dist: rich-click<2,>=1
-Requires-Dist: typed-settings[attrs,cattrs,click]<26,>=23
-Requires-Dist: immutables<1,>=0.20
-Dynamic: license-file
 
 <!-- markdownlint-disable MD033 MD041 -->
 <h1><p align="center">makejinja</p></h1>
@@ -82,7 +80,7 @@ Our comprehensive [Home Assistant example](https://github.com/mirkolenz/makejinj
 - **Multi-Source Data Integration**: Load variables from YAML, TOML, and Python files, with support for file-specific data sources 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.1 → makejinja-2.8.3}/README.md

@@ -39,7 +39,7 @@ Our comprehensive [Home Assistant example](https://github.com/mirkolenz/makejinj
 - **Multi-Source Data Integration**: Load variables from YAML, TOML, and Python files, with support for file-specific data sources 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.1 → makejinja-2.8.3}/pyproject.toml

@@ -1,20 +1,21 @@
 [project]
 name = "makejinja"
-version = "2.8.1"
+version = "2.8.3"
 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.11",
-    "Programming Language :: Python :: 3.12",
-    "Programming Language :: Python :: 3.13",
     "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",
@@ -40,45 +39,50 @@ classifiers = [
     "Topic :: Utilities",
     "Typing :: Typed",
 ]
-requires-python = ">=3.11"
 dependencies = [
+    "frozendict>=2,<3",
     "jinja2>=3,<4",
     "pyyaml>=6,<7",
     "rich-click>=1,<2",
-    "typed-settings[attrs,cattrs,click]>=23,<26",
-    "immutables>=0.20,<1",
+    "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>=8,<9", "pytest-cov>=6,<7"]
-docs = ["pdoc>=15,<16"]
+docs = ["pdoc>=16,<17"]
+test = [
+    "pytest>=9,<10",
+    "pytest-cov>=7,<8",
+]
 
 [build-system]
-requires = ["setuptools>=61"]
-build-backend = "setuptools.build_meta"
+requires = ["uv-build>=0.12,<1"]
+build-backend = "uv_build"
 
-[tool.uv]
-default-groups = ["test", "docs"]
-
-[tool.pytest.ini_options]
-addopts = "--cov makejinja --cov-report term-missing"
-
-[tool.ruff]
-target-version = "py311"
-
-[tool.ruff.lint]
-select = ["E", "W", "F", "B", "UP"]
-ignore = ["E501"]
+[tool.pytest]
+addopts = [
+    "--cov=makejinja",
+    "--cov-report=term-missing",
+]
 
 [tool.ruff.lint.pydocstyle]
 convention = "google"
+
+[tool.uv]
+default-groups = [
+    "test",
+    "docs",
+]

makejinja-2.8.3/pyproject.toml.orig

@@ -0,0 +1,76 @@
+[project]
+name = "makejinja"
+version = "2.8.3"
+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.1 → makejinja-2.8.3}/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.1 → makejinja-2.8.3}/src/makejinja/app.py

@@ -8,16 +8,15 @@ 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 rich import print
 
 from makejinja.config import Config
-from makejinja.plugin import Data, MutableData, PathFilter, Plugin
+from makejinja.plugin import Data, Functions, MutableData, PathFilter, Plugin
 
 __all__ = ["makejinja"]
 
@@ -26,15 +25,15 @@ STDIN_PATH = Path("/dev/stdin").resolve()
 
 
 def log(message: str, config: Config) -> None:
-    if not config.quiet and config.output != STDOUT_PATH:
-        print(message)
+    if not config.quiet:
+        click.echo(message, err=True)
 
 
 def exec(cmd: str) -> None:
     subprocess.run(cmd, shell=True, check=True)
 
 
-def makejinja(config: Config):
+def makejinja(config: Config) -> None:
     """makejinja can be used to automatically generate files from [Jinja templates](https://jinja.palletsprojects.com/en/3.1.x/templates/)."""
 
     for cmd in config.exec_pre:
@@ -231,7 +230,7 @@ def init_jinja_env(
         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
+        newline_sequence=config.whitespace.newline_sequence,
         keep_trailing_newline=config.whitespace.keep_trailing_newline,
         optimized=config.internal.optimized,
         undefined=config.undefined.value,
@@ -244,7 +243,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
 
@@ -254,7 +253,12 @@ def from_yaml(path: Path) -> dict[str, Any]:
 
     with path.open("rb") as fp:
         for doc in yaml.safe_load_all(fp):
-            data |= doc
+            if isinstance(doc, abc.Mapping):
+                data |= doc
+            else:
+                raise TypeError(
+                    f"Expected YAML documents in '{path}' to be mappings but found {type(doc).__name__}"
+                )
 
     return data
 
@@ -266,7 +270,14 @@ def from_toml(path: Path) -> dict[str, Any]:
 
 def from_json(path: Path) -> dict[str, Any]:
     with path.open("rb") as fp:
-        return json.load(fp)
+        data = json.load(fp)
+
+    if isinstance(data, abc.Mapping):
+        return dict(data)
+
+    raise TypeError(
+        f"Expected JSON documents in '{path}' to be mappings but found {type(data).__name__}"
+    )
 
 
 DATA_LOADERS: dict[str, abc.Callable[[Path], dict[str, Any]]] = {
@@ -352,6 +363,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:
@@ -371,22 +386,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.1 → makejinja-2.8.3}/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(
@@ -24,12 +24,12 @@ _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):
+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.
     **Note**: In this file, options may be named differently.
-    Please refer to the file [`makejinja/config.py`](https://github.com/mirkolenz/makejinja/blob/main/makejinja/config.py) to see their actual names.
+    Please refer to the file [`makejinja/config.py`](https://github.com/mirkolenz/makejinja/blob/main/src/makejinja/config.py) to see their actual names.
     You will also find an example here: [`makejinja/tests/data/makejinja.toml`](https://github.com/mirkolenz/makejinja/blob/main/tests/data/makejinja.toml).
     To override its location, you can set the environment variable `MAKEJINJA_SETTINGS` to the path of your config file.
     """

{makejinja-2.8.1 → makejinja-2.8.3}/src/makejinja/config.py

@@ -1,18 +1,17 @@
 from collections import abc
 from enum import Enum
 from pathlib import Path
+from typing import Literal
 
-import immutables
 import rich_click as click
 import typed_settings as ts
+from frozendict import frozendict
 from jinja2 import (
     ChainableUndefined,
     DebugUndefined,
     StrictUndefined,
 )
-from jinja2 import (
-    Undefined as DefaultUndefined,
-)
+from jinja2 import Undefined as DefaultUndefined
 from jinja2.defaults import (
     BLOCK_END_STRING,
     BLOCK_START_STRING,
@@ -24,9 +23,9 @@ from jinja2.defaults import (
     VARIABLE_END_STRING,
     VARIABLE_START_STRING,
 )
+from rich_click.utils import OptionGroupDict
 
-__all__ = ["Config", "Delimiter", "Internal", "Prefix", "Whitespace", "Undefined"]
-frozendict = immutables.Map
+__all__ = ["Config", "Delimiter", "Internal", "Prefix", "Undefined", "Whitespace"]
 
 
 class Undefined(Enum):
@@ -40,9 +39,10 @@ class Undefined(Enum):
 
 def _exclude_patterns_validator(instance, attribute, value) -> None:
     if any("**" in pattern for pattern in value):
-        # raise ValueError("The recursive wildcard `**` is not supported by `exclude_patterns`.")
-        print(
+        # todo: for next major release, raise ValueError instead of printing a warning
+        click.echo(
             "The recursive wildcard `**` is not supported by `exclude_patterns` (it acts like non-recursive `*`).",
+            err=True,
         )
 
 
@@ -153,7 +153,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="""
@@ -182,7 +182,7 @@ class Config:
             Path to a directory 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.
+            If a template exists in multiple inputs, the first matching template in the provided order will be used.
         """,
     )
     output: Path = ts.option(
@@ -207,7 +207,7 @@ class Config:
         """,
     )
     exclude_patterns: tuple[str, ...] = ts.option(
-        default=tuple(),
+        default=(),
         click={"param_decls": ("--exclude-pattern", "--exclude", "-E")},
         validator=_exclude_patterns_validator,
         help="""
@@ -251,7 +251,7 @@ class Config:
         """,
     )
     data: tuple[Path, ...] = ts.option(
-        default=tuple(),
+        default=(),
         click={
             "type": click.Path(exists=True, path_type=Path),
             "param_decls": ("--data", "-d"),
@@ -291,7 +291,7 @@ class Config:
         },
     )
     loaders: tuple[str, ...] = ts.option(
-        default=tuple(),
+        default=(),
         click={
             "param_decls": ("--loader", "-l"),
             "hidden": True,
@@ -299,17 +299,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.
@@ -328,7 +329,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.
@@ -347,13 +348,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.
         """,
@@ -385,7 +386,7 @@ class Config:
     internal: Internal = Internal()
 
 
-OPTION_GROUPS = {
+OPTION_GROUPS: dict[str, list[OptionGroupDict]] = {
     "makejinja": [
         {
             "name": "Input/Output",

makejinja-2.8.3/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.1/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2022 Mirko Lenz
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

makejinja-2.8.1/PKG-INFO

@@ -1,137 +0,0 @@
-Metadata-Version: 2.4
-Name: makejinja
-Version: 2.8.1
-Summary: Generate entire directory structures using Jinja templates with support for external data and custom plugins
-Author-email: Mirko Lenz <mirko@mirkolenz.com>
-Project-URL: Repository, https://github.com/mirkolenz/makejinja
-Project-URL: Homepage, https://mirkolenz.github.io/makejinja/
-Project-URL: Documentation, https://mirkolenz.github.io/makejinja/makejinja/cli.html
-Project-URL: Issues, https://github.com/mirkolenz/makejinja/issues
-Project-URL: Changelog, https://github.com/mirkolenz/makejinja/releases
-Keywords: jinja2,home-assistant,hassio,dashboard,lovelace,template,generator,cli,tool,library
-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.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Programming Language :: Python :: 3
-Classifier: Topic :: File Formats
-Classifier: Topic :: Home Automation
-Classifier: Topic :: Software Development :: Code Generators
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Topic :: System :: Software Distribution
-Classifier: Topic :: System :: Systems Administration
-Classifier: Topic :: Text Processing :: Markup
-Classifier: Topic :: Utilities
-Classifier: Typing :: Typed
-Requires-Python: >=3.11
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: jinja2<4,>=3
-Requires-Dist: pyyaml<7,>=6
-Requires-Dist: rich-click<2,>=1
-Requires-Dist: typed-settings[attrs,cattrs,click]<26,>=23
-Requires-Dist: immutables<1,>=0.20
-Dynamic: license-file
-
-<!-- markdownlint-disable MD033 MD041 -->
-<h1><p align="center">makejinja</p></h1>
-
-<p align="center">
-  <img width="256px" alt="makejinja logo" 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://github.com/users/mirkolenz/packages/container/package/makejinja">Docker</a> |
-  <a href="https://mirkolenz.github.io/makejinja">Docs</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">Jinja reference</a>
-</p>
-
-<p align="center">
-  Generate entire directory structures using Jinja templates with support for external data and custom plugins.
-</p>
-
-<p align="center">
-  <img alt="makejinja demonstration" src="https://mirkolenz.github.io/makejinja/assets/demo.gif" />
-</p>
-
----
-
-<!-- PDOC_START -->
-
-makejinja can be used to automatically generate files from [Jinja templates](https://jinja.palletsprojects.com/en/3.1.x/templates).
-It is conceptually similar to [Ansible templates](https://docs.ansible.com/ansible/latest/collections/ansible/builtin/template_module.html) since both are built on top of Jinja.
-However, makejinja is a standalone tool that can be used without Ansible and offers some advanced features like custom plugins.
-
-A popular use case is generating config files for [Home Assistant](https://www.home-assistant.io/):
-Using the same Jinja language that Home Assistant's built-in templates use, you can greatly simplify your configuration management.
-makejinja's custom delimiter support prevents conflicts with Home Assistant's own template syntax, while file-specific data loading enables modular dashboard and automation generation.
-Our comprehensive [Home Assistant example](https://github.com/mirkolenz/makejinja/tree/main/tests/data) demonstrates dashboard generation with custom plugins, multiple data sources, and advanced template organization.
-
-## 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.
-- **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.
-- **Production-Ready**: Comprehensive CLI interface, configuration file support, and Python library API for seamless workflow integration.
-
-## Use Cases
-
-- **Configuration Management**: Generate environment-specific configs (dev/staging/prod) from shared templates with different data sources.
-- **Home Assistant Dashboards**: Create complex dashboards and automations using Jinja syntax without conflicts. See our [complete example](https://github.com/mirkolenz/makejinja/tree/main/tests/data).
-- **Infrastructure as Code**: Generate Kubernetes manifests, Terraform modules, or Docker Compose files with consistent patterns across environments.
-- **Web Development**: Generate HTML pages, CSS files, or JavaScript configs from data sources for static sites or multi-tenant applications.
-- **Database Schemas**: Create SQL migration scripts, database configurations, or ORM models based on structured schema definitions.
-- **Network Configuration**: Generate router configs, firewall rules, or network device settings from centralized network topology data.
-- **Monitoring & Alerting**: Create Grafana dashboards, Prometheus rules, or alerting configurations from service inventories.
-- **Documentation & CI/CD**: Create project docs, API specifications, or pipeline definitions from structured data sources.
-
-## Installation
-
-The tool is written in Python and can be installed via uv, nix, and docker.
-It can be used as a CLI tool or as a Python library.
-
-### UV
-
-makejinja is available on [PyPI](https://pypi.org/project/makejinja/) and can be installed via `uv`:
-
-```shell
-uv tool install makejinja
-makejinja -i ./input -o ./output
-```
-
-### Nix
-
-makejinja is packaged in nixpkgs.
-To use the most recent version, you can run it via `nix run`:
-
-```shell
-nix run github:mirkolenz/makejinja -- -i ./input -o ./output
-```
-
-Alternatively, you can add this repository as an input to your flake and use `makejinja.packages.${system}.default`.
-
-### Docker
-
-We automatically publish an image to the [GitHub Container Registry](https://ghcr.io/mirkolenz/makejinja).
-To use it, mount a directory to the container and pass the options as the command:
-
-```shell
-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 directory recursively for files ending in `.jinja`.
-It then renders these files and writes them to the output directory, preserving the directory structure.
-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.8.1/setup.cfg

@@ -1,4 +0,0 @@
-[egg_info]
-tag_build = 
-tag_date = 0
-

makejinja-2.8.1/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

makejinja-2.8.1/src/makejinja.egg-info/SOURCES.txt

@@ -1,17 +0,0 @@
-LICENSE
-README.md
-pyproject.toml
-src/makejinja/__init__.py
-src/makejinja/__main__.py
-src/makejinja/app.py
-src/makejinja/cli.py
-src/makejinja/config.py
-src/makejinja/plugin.py
-src/makejinja/py.typed
-src/makejinja.egg-info/PKG-INFO
-src/makejinja.egg-info/SOURCES.txt
-src/makejinja.egg-info/dependency_links.txt
-src/makejinja.egg-info/entry_points.txt
-src/makejinja.egg-info/requires.txt
-src/makejinja.egg-info/top_level.txt
-tests/test_makejinja.py

makejinja-2.8.1/src/makejinja.egg-info/dependency_links.txt

@@ -1 +0,0 @@
-

makejinja-2.8.1/src/makejinja.egg-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-makejinja = makejinja.cli:makejinja_cli

makejinja-2.8.1/src/makejinja.egg-info/requires.txt

@@ -1,5 +0,0 @@
-jinja2<4,>=3
-pyyaml<7,>=6
-rich-click<2,>=1
-typed-settings[attrs,cattrs,click]<26,>=23
-immutables<1,>=0.20

makejinja-2.8.1/src/makejinja.egg-info/top_level.txt

@@ -1 +0,0 @@
-makejinja

makejinja-2.8.1/tests/test_makejinja.py

@@ -1,152 +0,0 @@
-from dataclasses import dataclass
-from pathlib import Path
-
-import pytest
-from click.testing import CliRunner
-
-
-@dataclass(slots=True, frozen=True)
-class MakejinjaPaths:
-    """Paths used in makejinja test execution.
-
-    Attributes:
-        input: Path to input template directories
-        baseline: Path to expected output files
-        output: Path to actual generated output files
-    """
-
-    input: Path
-    baseline: Path
-    output: Path
-
-    def __repr__(self) -> str:
-        return "makejinja"
-
-
-@pytest.fixture(scope="session")
-def test_run(tmp_path_factory: pytest.TempPathFactory) -> MakejinjaPaths:
-    """Execute makejinja on test data and return paths to input, expected, and actual output."""
-    assert __package__ is not None
-    data_path = Path(__package__, "data")
-    input_path = data_path / "input"
-    baseline_path = data_path / "output"
-    output_path = tmp_path_factory.mktemp("data")
-
-    with pytest.MonkeyPatch.context() as m:
-        m.chdir(data_path)
-        runner = CliRunner()
-
-        # Need to import it AFTER chdir
-        from makejinja.cli import makejinja_cli
-
-        runner.invoke(
-            makejinja_cli,
-            [
-                # Override it here to use our tmp_path
-                "--output",
-                str(output_path),
-            ],
-            catch_exceptions=False,
-            color=True,
-        )
-
-    return MakejinjaPaths(input_path, baseline_path, output_path)
-
-
-def _dir_content(path: Path) -> set[Path]:
-    return {item.relative_to(path) for item in path.rglob("*")}
-
-
-def test_output_structure(test_run: MakejinjaPaths):
-    """Test that makejinja generates the expected directory structure."""
-    expected_files = _dir_content(test_run.baseline)
-    actual_files = _dir_content(test_run.output)
-
-    if expected_files != actual_files:
-        missing = sorted(expected_files - actual_files)
-        extra = sorted(actual_files - expected_files)
-        pytest.fail(f"Directory structure mismatch. Missing: {missing}, Extra: {extra}")
-
-
-def test_template_rendering(test_run: MakejinjaPaths):
-    """Test that makejinja renders all templates with correct content."""
-    paths = _dir_content(test_run.baseline)
-
-    for item in paths:
-        baseline_path = test_run.baseline / item
-        output_path = test_run.output / item
-
-        if baseline_path.is_file() and output_path.is_file():
-            expected_content = baseline_path.read_text()
-            actual_content = output_path.read_text()
-
-            if expected_content.strip() != actual_content.strip():
-                pytest.fail(
-                    f"Content mismatch in {item}: expected '{expected_content.strip()}', got '{actual_content.strip()}'"
-                )
-
-
-def test_custom_delimiters(test_run: MakejinjaPaths):
-    """Test that custom Jinja delimiters (<< >>, <% %>) work correctly."""
-    not_empty_file = test_run.output / "not-empty.yaml"
-    content = not_empty_file.read_text()
-
-    assert "NOT EMPTY" in content, (
-        f"Custom delimiters not working. Expected 'NOT EMPTY' in {not_empty_file}"
-    )
-
-
-def test_file_specific_data(test_run: MakejinjaPaths):
-    """Test that file-specific data loading works correctly."""
-    file_specific_output = test_run.output / "file-specific.yaml"
-    content = file_specific_output.read_text()
-
-    # Should contain data from data1.yaml
-    assert "Value from data1" in content, (
-        f"File-specific data not loaded. Expected 'Value from data1' in {file_specific_output}"
-    )
-    assert "item1" in content and "item2" in content, (
-        f"File-specific list data not loaded correctly in {file_specific_output}"
-    )
-
-
-def test_plugin_features(test_run: MakejinjaPaths):
-    """Test that custom plugin filters and functions work."""
-    # Test that secret files are excluded by plugin path filter
-    secret_file = test_run.output / "secret.yaml"
-    assert not secret_file.exists(), (
-        f"Secret file should be excluded by plugin but exists: {secret_file}"
-    )
-
-
-def test_partial_inclusion(test_run: MakejinjaPaths):
-    """Test that partial template inclusion works."""
-    ui_lovelace_file = test_run.output / "ui-lovelace.yaml"
-    content = ui_lovelace_file.read_text()
-
-    # Should contain content from include.yaml.partial
-    assert "icon: mdi:home" in content, (
-        f"Partial inclusion not working. Expected 'icon: mdi:home' in {ui_lovelace_file}"
-    )
-
-
-def test_empty_template_handling(test_run: MakejinjaPaths):
-    """Test that empty templates are handled correctly."""
-    # The empty.yaml.jinja should not produce output (contains only comments)
-    empty_file = test_run.output / "empty.yaml"
-    assert not empty_file.exists(), (
-        f"Empty template should not generate output file but {empty_file} exists"
-    )
-
-
-def test_nested_directory_processing(test_run: MakejinjaPaths):
-    """Test that nested directories are processed correctly."""
-    nested_file = test_run.output / "views" / "home.yaml"
-    assert nested_file.exists(), (
-        f"Nested directory processing failed. Expected {nested_file} to exist"
-    )
-
-    content = nested_file.read_text()
-    assert len(content.strip()) > 0, (
-        f"Nested template should have content but {nested_file} is empty"
-    )