makejinja 2.8.3__tar.gz → 2.9.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: makejinja
-Version: 2.8.3
+Version: 2.9.0
 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
@@ -77,7 +77,7 @@ 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, data, tests, policies, extensions, and path filtering logic for specialized requirements.

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

@@ -36,7 +36,7 @@ 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, data, tests, policies, extensions, and path filtering logic for specialized requirements.

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

@@ -1,6 +1,6 @@
 [project]
 name = "makejinja"
-version = "2.8.3"
+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"

{makejinja-2.8.3 → makejinja-2.9.0}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "makejinja"
-version = "2.8.3"
+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"

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

@@ -14,8 +14,9 @@ import rich_click as click
 import yaml
 from jinja2 import BaseLoader, ChoiceLoader, DictLoader, Environment, FileSystemLoader
 from jinja2.utils import import_string
+from typed_settings.dict_utils import set_path
 
-from makejinja.config import Config
+from makejinja.config import Config, DataNamespace
 from makejinja.plugin import Data, Functions, MutableData, PathFilter, Plugin
 
 __all__ = ["makejinja"]
@@ -288,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 ()
+
+        case DataNamespace.stem:
+            parts = (relative_path.stem,)
+
+        case DataNamespace.path:
+            parts = relative_path.with_suffix("").parts
 
-    # Turn the string of key names into a list of strings.
-    keys = dotted_key.split(".")
+    return tuple(to_identifier(part) for part in parts)
 
-    # 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 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
 

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

@@ -23,7 +23,10 @@ _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)
+# 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/).
 

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

@@ -1,5 +1,5 @@
 from collections import abc
-from enum import Enum
+from enum import Enum, auto
 from pathlib import Path
 from typing import Literal
 
@@ -25,7 +25,15 @@ from jinja2.defaults import (
 )
 from rich_click.utils import OptionGroupDict
 
-__all__ = ["Config", "Delimiter", "Internal", "Prefix", "Undefined", "Whitespace"]
+__all__ = [
+    "Config",
+    "DataNamespace",
+    "Delimiter",
+    "Internal",
+    "Prefix",
+    "Undefined",
+    "Whitespace",
+]
 
 
 class Undefined(Enum):
@@ -37,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
@@ -264,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={
@@ -405,6 +434,7 @@ OPTION_GROUPS: dict[str, list[OptionGroupDict]] = {
             "name": "Jinja Environment",
             "options": [
                 "--data",
+                "--data-namespace",
                 "--data-var",
                 "--file-data",
                 "--plugin",