kapitan 0.36.2.dev1__tar.gz → 0.36.2.dev3__tar.gz

{kapitan-0.36.2.dev1 → kapitan-0.36.2.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kapitan
-Version: 0.36.2.dev1
+Version: 0.36.2.dev3
 Summary: Generic templated configuration management for Kubernetes, Terraform and other things
 Project-URL: Homepage, https://kapitan.dev
 Project-URL: Repository, https://github.com/kapicorp/kapitan

{kapitan-0.36.2.dev1 → kapitan-0.36.2.dev3}/docs/pages/core_concepts.md

@@ -1,5 +1,5 @@
 ---
-title: "Kapitan Core Concepts"
+title: "Kapitan Core Concepts: Inventory, Targets & Inputs"
 description: "Learn how Kapitan organizes configuration with inventory, targets, classes, and input types to generate Kubernetes, Terraform, and infrastructure manifests."
 ---
 
@@ -11,7 +11,7 @@ description: "Learn how Kapitan organizes configuration with inventory, targets,
 
 ```mermaid
     graph LR
-        TARGETS ==  **kapitan compile** ==> INPUT_TYPES
+        TARGETS == "`**kapitan compile**`" ==> INPUT_TYPES
         INPUT_TYPES --> TARGETS_OUTPUT
         TARGETS_OUTPUT --> GENERATED_FILES
 

kapitan-0.36.2.dev3/docs/pages/inventory/backends.md

@@ -0,0 +1,77 @@
+---
+title: "Kapitan Inventory Backends: reclass vs reclass-rs vs OmegaConf"
+description: "Compare Kapitan inventory backends — reclass, reclass-rs, and OmegaConf — and learn which to choose for speed, compatibility, and features."
+---
+
+# :kapitan-logo: **Alternative Inventory Backends**
+
+Kapitan's [**inventory**](introduction.md) is pluggable: you can swap the engine
+that loads and resolves it without rewriting a single `class`, `target`, or
+`parameter`. Three backends ship with Kapitan, and they differ in three things
+that matter when you choose one — **speed**, **interpolation syntax**, and **which
+features they support**.
+
+* `reclass` (**default**): the original Kapitan inventory (see [reclass](https://github.com/kapicorp/reclass)). Bundled — nothing to install.
+* `reclass-rs`: a Rust drop-in replacement, much faster (see [reclass-rs](reclass-rs.md)). Optional extra.
+* `omegaconf`: an [OmegaConf](https://github.com/omry/omegaconf)-based alternative with custom resolvers (see [omegaconf](omegaconf.md)). Optional extra, **experimental**.
+
+## Which backend should I use?
+
+- **Stay on `reclass`** unless you have a reason to switch. It is the default, the most mature, and supports every Kapitan inventory feature.
+- **Switch to `reclass-rs`** when inventory rendering is slow — large inventories with heavy parameter interpolation in class includes. It is a **drop-in**: same syntax, no inventory changes, just faster ([benchmarks](reclass-rs.md#performance-comparison)). Check the [feature gaps](#feature-support) first.
+- **Choose `omegaconf`** only if you specifically want its resolver toolkit (`${merge:}`, `${escape:}`, conditionals, custom Python resolvers). It uses **different interpolation syntax**, so it is **not** a drop-in — existing inventories need [migration](omegaconf.md#migration-from-reclass). It is **experimental**.
+
+## Comparison
+
+| | `reclass` (default) | `reclass-rs` | `omegaconf` |
+|---|---|---|---|
+| **Install** | bundled | `pip install kapitan[reclass-rs]` | `pip install kapitan[omegaconf]` |
+| **Maturity** | stable, default | stable | **experimental** (pre-release dep) |
+| **Implementation** | Python | Rust | Python |
+| **Speed** | baseline | **much faster** on large inventories ([benchmarks](reclass-rs.md#performance-comparison)) | comparable to reclass |
+| **Interpolation syntax** | colon paths `${a:b:c}` | colon paths `${a:b:c}` (same as reclass) | dotted paths `${a.b.c}` + resolvers |
+| **Drop-in for reclass?** | — | ✅ yes, same syntax | ❌ no, needs [migration](omegaconf.md#migration-from-reclass) |
+| **List merge (class include)** | extend / concatenate | extend / concatenate | extend **+ de-duplicate** (`EXTEND_UNIQUE`) |
+| **Custom resolvers** | ❌ | ❌ | ✅ `${merge:}`, `${escape:}`, `${if:}`, user-defined, … |
+| **Inventory queries** (`$[...]`, exports) | ✅ | ❌ not supported | ❌ not supported |
+
+!!! warning "List-merge semantics differ"
+    `reclass` / `reclass-rs` **concatenate** lists on class inclusion (duplicates
+    kept). `omegaconf` de-duplicates (`EXTEND_UNIQUE`) during class merge — but
+    its `${merge:...}` resolver keeps duplicates (`EXTEND`). If you switch
+    backends, a list that previously had repeated entries may change. Verify
+    list-valued parameters after migrating.
+
+## Switching backend
+
+Pick the backend by either:
+
+* (**recommended**) setting it in the [.kapitan config file](../commands/kapitan_dotfile.md):
+
+```yaml
+global:
+  inventory-backend: reclass-rs
+```
+
+* or passing `--inventory-backend=<backend>` on the `kapitan` command line.
+
+## Feature support
+
+`reclass` is the reference: it supports the full feature set.
+
+`reclass-rs` is a drop-in, but a few reclass options are **not implemented yet**
+(known gaps, sourced from the [upstream reclass-rs project](https://github.com/projectsyn/reclass-rs)
+— may change between versions):
+
+- inventory queries (`$[...]` expressions)
+- `allow_none_override: false` (effectively pinned to `true`; Kapitan's default is `true`, so the default case works)
+- storage types other than `yaml_fs` (`yaml_git`, `mixed`)
+
+It also has minor behavioral divergences in non-compatible modes (e.g. `null` in
+nested references, dots in `compose_node_name`) — see the upstream README. If a
+feature you rely on is missing,
+[open an issue upstream](https://github.com/projectsyn/reclass-rs/issues).
+
+`omegaconf` supports a different feature set — see
+[Differences from Reclass](omegaconf.md#differences-from-reclass) for what is and
+isn't supported, plus its resolver catalogue.

{kapitan-0.36.2.dev1 → kapitan-0.36.2.dev3}/docs/pages/inventory/introduction.md

@@ -1,5 +1,5 @@
 ---
-title: "Kapitan Inventory"
+title: "Kapitan Inventory: Classes, Targets & Parameters"
 description: "Learn how Kapitan inventory uses targets, classes, and parameters to model reusable infrastructure configuration across environments."
 ---
 
@@ -74,6 +74,59 @@ By combining [**target**](targets.md) and [**classes**](classes.md), the **Inven
 
 ---
 
+## How the inventory is built
+
+Before any input type runs, **Kapitan** turns a target file and its class graph
+into a single, fully-resolved set of `parameters`. Understanding the order of
+these steps explains *why* a value overrides another, and *when* a `${...}`
+reference gets its value.
+
+```mermaid
+flowchart TD
+    A["Read target<br/>targets/production.yml"] --> B{"wildcards<br/>enabled?"}
+    B -->|"--enable-class-wildcards"| C["Expand glob patterns<br/>into matching class names"]
+    B -->|default| D
+    C --> D["Resolve each class to a file<br/>classes/kapicorp/common.yml → kapicorp.common"]
+    D --> E["Load classes recursively<br/>(depth-first: a class's own<br/>classes are loaded before it)"]
+    E --> F["Deep-merge parameters in include order<br/>later entries override earlier;<br/>the target's own parameters win last"]
+    F --> G["Resolve ${...} interpolation<br/>against the fully-merged parameters"]
+    G --> H["Final resolved inventory<br/>handed to the compile phase"]
+
+    style F fill:#fff3e0
+    style G fill:#e1f5fe
+```
+
+1. **Read target** — the target file is the entry point. Its `classes:` list
+   drives everything that follows.
+2. **Expand wildcards** *(optional)* — with
+   [`--enable-class-wildcards`](classes.md#wildcard-class-patterns), glob
+   patterns in `classes:` are expanded to concrete class names *before* the
+   backend sees them. Without the flag, entries pass through unchanged.
+3. **Resolve & load classes** — each class name maps to a file under
+   `inventory/classes/`. Classes are loaded **recursively and depth-first**: a
+   class's own `classes:` are loaded before the class itself, so foundational
+   data lands first.
+4. **Merge parameters** — `parameters` blocks are **deep-merged** in the order
+   classes are encountered. **Later entries override earlier ones**, and the
+   target's own `parameters` are merged last, giving them the highest
+   precedence. This is why list position in `classes:` matters (see the
+   [override-order warning](classes.md#wildcard-class-patterns) for wildcards).
+5. **Resolve interpolation** — only **after** the full merge are `${...}`
+   references resolved, against the final merged values. A reference therefore
+   sees the *winning* value regardless of which class defined it.
+6. **Final inventory** — the resolved `parameters` are handed to the
+   [compile phase](../input_types/introduction.md#phases-of-the-compile-command),
+   which feeds each input type.
+
+!!! note "Backend differences"
+    The merge-then-resolve model above is the shared mental model. The
+    [`reclass`](backends.md) and `reclass-rs` backends follow it directly;
+    the [`omegaconf`](omegaconf.md) backend uses a **double-pass** resolution to
+    support escaped interpolations. Test inventory changes against every backend
+    you support.
+
+---
+
 ## Next steps
 
 - Learn how to define environments and deployments with [Kapitan inventory targets](targets.md).

{kapitan-0.36.2.dev1 → kapitan-0.36.2.dev3}/kapitan/cached.py

@@ -38,6 +38,12 @@ inv_sources: set[str] = set()
 # Kadet caches
 kapitan_input_kadet = None
 
+# Shared cache metrics for the compile pool, keyed by input_type_name.
+# Populated by compile_targets() only when caching is enabled, then propagated
+# to workers via the pool initializer so every InputCache(input_type_name=N)
+# bumps the same shared CacheMetrics across processes.
+input_cache_metrics: dict | None = None
+
 
 def reset_cache():
     global \

{kapitan-0.36.2.dev1 → kapitan-0.36.2.dev3}/kapitan/inputs/__init__.py

@@ -10,6 +10,13 @@ from kapitan.inventory.model.input_types import InputTypes
 from .base import InputType
 
 
+# Input types that maintain a persistent compilation cache via InputCache.
+# compile_targets() pre-allocates one CacheMetrics per entry so all workers
+# share counters across the multiprocessing pool. Add an entry here when a
+# new input type adopts InputCache.
+CACHEABLE_INPUT_TYPES: tuple[str, ...] = ("kadet",)
+
+
 @functools.cache  # Use lru_cache for caching
 def get_compiler(input_type: InputType) -> type[InputType]:
     """Dynamically imports and returns the compiler class based on input_type."""

{kapitan-0.36.2.dev1 → kapitan-0.36.2.dev3}/kapitan/inputs/cache.py

@@ -1,5 +1,6 @@
 import hashlib
 import logging
+import multiprocessing
 import os
 import pickle
 from pathlib import Path
@@ -12,8 +13,44 @@ from kapitan.errors import CompileError
 logger = logging.getLogger(__name__)
 
 
+class CacheMetrics:
+    """Process-safe counters for cache hits, misses and fills.
+
+    Backed by ``multiprocessing.Value`` so workers spawned by the compile
+    Pool can share a single tally with the parent. Pass the same instance
+    to every ``InputCache`` that should report into the same totals.
+    """
+
+    def __init__(self):
+        # 'Q' is unsigned long long (uint64); plenty of headroom for counters.
+        self.hits = multiprocessing.Value("Q", 0)
+        self.misses = multiprocessing.Value("Q", 0)
+        self.fills = multiprocessing.Value("Q", 0)
+
+    @staticmethod
+    def _bump(counter):
+        with counter.get_lock():
+            counter.value += 1
+
+    def hit(self):
+        self._bump(self.hits)
+
+    def miss(self):
+        self._bump(self.misses)
+
+    def fill(self):
+        self._bump(self.fills)
+
+    def snapshot(self) -> dict:
+        return {
+            "hits": self.hits.value,
+            "misses": self.misses.value,
+            "fills": self.fills.value,
+        }
+
+
 class InputCache:
-    def __init__(self, input_type_name: str):
+    def __init__(self, input_type_name: str, metrics: CacheMetrics | None = None):
         if cache_home := os.environ.get("XDG_CACHE_HOME"):
             self.input_cache_home = f"{cache_home}/kapitan/{input_type_name}"
         elif cache_home := os.environ.get("HOME"):
@@ -23,7 +60,9 @@ class InputCache:
                 "Could not get cache dir: $XDG_CACHE_HOME or $HOME not set."
             )
 
+        self.input_type_name = input_type_name
         self.kv_cache = {}
+        self.metrics = metrics if metrics is not None else CacheMetrics()
 
         logger.debug("Input cache home: %s", self.input_cache_home)
 
@@ -45,9 +84,18 @@ class InputCache:
                             retry,
                             lock_retries,
                         )
-                        return self.load_output(fp)
+                        output_obj = self.load_output(fp)
+                        # load_output can return None when a kadet
+                        # ModuleNotFoundError is swallowed; treat that as a
+                        # miss so the caller recomputes.
+                        if output_obj is None:
+                            self.metrics.miss()
+                        else:
+                            self.metrics.hit()
+                        return output_obj
                 except FileNotFoundError:
                     pass
+        self.metrics.miss()
         return None
 
     def set(self, inputs_hash, output_obj, lock_retries=2):
@@ -76,7 +124,7 @@ class InputCache:
                     retry,
                     lock_retries,
                 )
-
+                self.metrics.fill()
                 return inputs_hash
         return None
 

{kapitan-0.36.2.dev1 → kapitan-0.36.2.dev3}/kapitan/inputs/kadet.py

@@ -280,7 +280,8 @@ class Kadet(InputType):
     def cacheable(self):
         if cached.args.cache:
             if cached.kapitan_input_kadet is None:
-                cached.kapitan_input_kadet = InputCache("kadet")
+                metrics = (cached.input_cache_metrics or {}).get("kadet")
+                cached.kapitan_input_kadet = InputCache("kadet", metrics=metrics)
 
             return cached.kapitan_input_kadet
         return False

{kapitan-0.36.2.dev1 → kapitan-0.36.2.dev3}/kapitan/targets.py

@@ -20,7 +20,8 @@ from reclass.errors import NotFoundError, ReclassException
 from kapitan import cached
 from kapitan.dependency_manager.base import fetch_dependencies
 from kapitan.errors import CompileError, InventoryError, KapitanError
-from kapitan.inputs import get_compiler
+from kapitan.inputs import CACHEABLE_INPUT_TYPES, get_compiler
+from kapitan.inputs.cache import CacheMetrics
 from kapitan.profiling import worker_profile
 from kapitan.resources import get_inventory
 from kapitan.utils import available_cpu_count
@@ -29,7 +30,7 @@ from kapitan.utils import available_cpu_count
 logger = logging.getLogger(__name__)
 
 
-def _pool_init(globals_cached):
+def _pool_init(globals_cached, input_cache_metrics):
     """Pool initializer: seed each worker's `cached` module from the parent.
 
     Called once per worker after fork/spawn. ``initargs`` is pickled once per
@@ -41,9 +42,44 @@ def _pool_init(globals_cached):
     populated from the snapshot. When ``--inventory-pool-cache=False``
     (``globals_cached is None``), workers keep whatever state they inherited
     (the full cache on fork, an empty module on spawn).
+
+    ``input_cache_metrics`` is a dict mapping input_type_name to a
+    ``CacheMetrics`` backed by shared ``multiprocessing.Value`` counters.
+    Forwarding it explicitly keeps the spawn start method working, where
+    module globals don't cross the process boundary.
     """
     if globals_cached and not cached.inv:
         cached.from_dict(globals_cached)
+    cached.input_cache_metrics = input_cache_metrics
+
+
+def _log_cache_metrics(metrics_by_type):
+    """Emit a one-line summary of compile-cache activity per input type.
+
+    Skips entries that saw no lookups (e.g., an input type isn't used in
+    this compile run). When caching was on but nothing fired anywhere,
+    a single "no lookups" line is emitted instead.
+    """
+    if not metrics_by_type:
+        return
+    any_activity = False
+    for input_type, metrics in metrics_by_type.items():
+        snap = metrics.snapshot()
+        lookups = snap["hits"] + snap["misses"]
+        if lookups == 0:
+            continue
+        any_activity = True
+        hit_rate = 100.0 * snap["hits"] / lookups
+        logger.info(
+            "Compile cache (%s): %d hits, %d misses, %d fills (hit rate %.1f%%)",
+            input_type,
+            snap["hits"],
+            snap["misses"],
+            snap["fills"],
+            hit_rate,
+        )
+    if not any_activity:
+        logger.info("Compile cache: no lookups")
 
 
 def compile_targets(inventory_path, search_paths, ref_controller, args):
@@ -119,6 +155,14 @@ def compile_targets(inventory_path, search_paths, ref_controller, args):
     output_path = args.output_path
     compile_path = os.path.join(output_path, "compiled")
 
+    # Allocate one shared CacheMetrics per cacheable input type so workers
+    # bump the same counters as the parent. The dict is pre-populated here
+    # (eagerly, before pool spawn) because multiprocessing.Value objects
+    # have to be created in the parent to be sharable across workers.
+    cached.input_cache_metrics = (
+        {name: CacheMetrics() for name in CACHEABLE_INPUT_TYPES} if args.cache else None
+    )
+
     try:
         fetching_start = time.time()
 
@@ -152,7 +196,10 @@ def compile_targets(inventory_path, search_paths, ref_controller, args):
         # initargs so each worker is seeded a single time. Per-target
         # mutations (e.g. target_full_path) travel with the target object
         # itself via imap_unordered.
-        pool_initargs = (cached.as_dict() if args.inventory_pool_cache else None,)
+        pool_initargs = (
+            cached.as_dict() if args.inventory_pool_cache else None,
+            cached.input_cache_metrics,
+        )
 
         with multiprocessing.Pool(
             parallelism, initializer=_pool_init, initargs=pool_initargs
@@ -206,6 +253,7 @@ def compile_targets(inventory_path, search_paths, ref_controller, args):
             logger.info(
                 f"Compiled {len(targets)} targets in %.2fs", time.time() - compile_start
             )
+            _log_cache_metrics(cached.input_cache_metrics)
     except ReclassException as e:
         if isinstance(e, NotFoundError):
             logger.error("Inventory reclass error: inventory not found")

kapitan-0.36.2.dev3/mise.lock

@@ -0,0 +1,97 @@
+# @generated - this file is auto-generated by `mise lock` https://mise.en.dev/dev-tools/mise-lock.html
+
+[[tools.cue]]
+version = "0.15.4"
+backend = "aqua:cue-lang/cue"
+
+[tools.cue."platforms.linux-arm64"]
+checksum = "sha256:f5a47ef6a6566849543b0ea84a7058c690bbb1492a1c101a6d62feaf59f8112e"
+url = "https://github.com/cue-lang/cue/releases/download/v0.15.4/cue_v0.15.4_linux_arm64.tar.gz"
+
+[tools.cue."platforms.linux-x64"]
+checksum = "sha256:4709f0d3e9988b82192a205953fefdbb3637317a1cef63d84fe65b7b92ef95a3"
+url = "https://github.com/cue-lang/cue/releases/download/v0.15.4/cue_v0.15.4_linux_amd64.tar.gz"
+
+[tools.cue."platforms.macos-arm64"]
+checksum = "sha256:2d324ba027447a7dab2e980f3ccfb7e15a3dd9096258b9f69205153e4c5b46cd"
+url = "https://github.com/cue-lang/cue/releases/download/v0.15.4/cue_v0.15.4_darwin_arm64.tar.gz"
+
+[tools.cue."platforms.macos-x64"]
+checksum = "sha256:e64e6a9f30609ed619a203334a6404c46a9fb7685a86424f74c3c52a55ebfa1c"
+url = "https://github.com/cue-lang/cue/releases/download/v0.15.4/cue_v0.15.4_darwin_amd64.tar.gz"
+
+[tools.cue."platforms.windows-x64"]
+checksum = "sha256:d42e26a0fb09219fc1735326fb2188dadf7c8deab136698a55d793c0c15a6aaa"
+url = "https://github.com/cue-lang/cue/releases/download/v0.15.4/cue_v0.15.4_windows_amd64.zip"
+
+[[tools.helm]]
+version = "3.19.5"
+backend = "aqua:helm/helm"
+
+[tools.helm."platforms.linux-arm64"]
+checksum = "sha256:ce02147ffee6d993bf8ae97a44a22e9e1daf0b69d2d5b69a0c8cf6706445ccf5"
+url = "https://get.helm.sh/helm-v3.19.5-linux-arm64.tar.gz"
+
+[tools.helm."platforms.linux-x64"]
+checksum = "sha256:a0a5e8c592ed3f376ac110715eff214730c7422f9a44d96cf98117d2b8b0e6c0"
+url = "https://get.helm.sh/helm-v3.19.5-linux-amd64.tar.gz"
+
+[tools.helm."platforms.macos-arm64"]
+checksum = "sha256:195e24e587f423f15a78feebab04583ceee68323598575a0e8b3b11b43fd26fe"
+url = "https://get.helm.sh/helm-v3.19.5-darwin-arm64.tar.gz"
+
+[tools.helm."platforms.macos-x64"]
+checksum = "sha256:57f4a847c349382b7cc742a6434ef25f88f0928a113d8cf49084b464878ef0b9"
+url = "https://get.helm.sh/helm-v3.19.5-darwin-amd64.tar.gz"
+
+[tools.helm."platforms.windows-x64"]
+checksum = "sha256:fee9632f0503debf0153f99e832b4dcb7c862c78b2f809e73eea0095d91ea51c"
+url = "https://get.helm.sh/helm-v3.19.5-windows-amd64.tar.gz"
+
+[[tools.kustomize]]
+version = "5.8.1"
+backend = "aqua:kubernetes-sigs/kustomize"
+
+[tools.kustomize."platforms.linux-arm64"]
+checksum = "sha256:0953ea3e476f66d6ddfcd911d750f5167b9365aa9491b2326398e289fef2c142"
+url = "https://github.com/kubernetes-sigs/kustomize/releases/download/kustomize/v5.8.1/kustomize_v5.8.1_linux_arm64.tar.gz"
+
+[tools.kustomize."platforms.linux-x64"]
+checksum = "sha256:029a7f0f4e1932c52a0476cf02a0fd855c0bb85694b82c338fc648dcb53a819d"
+url = "https://github.com/kubernetes-sigs/kustomize/releases/download/kustomize/v5.8.1/kustomize_v5.8.1_linux_amd64.tar.gz"
+
+[tools.kustomize."platforms.macos-arm64"]
+checksum = "sha256:8886f8a78474e608cc81234f729fda188a9767da23e28925802f00ece2bab288"
+url = "https://github.com/kubernetes-sigs/kustomize/releases/download/kustomize/v5.8.1/kustomize_v5.8.1_darwin_arm64.tar.gz"
+
+[tools.kustomize."platforms.macos-x64"]
+checksum = "sha256:ee7cf0c1e3592aa7bb66ba82b359933a95e7f2e0b36e5f53ed0a4535b017f2f8"
+url = "https://github.com/kubernetes-sigs/kustomize/releases/download/kustomize/v5.8.1/kustomize_v5.8.1_darwin_amd64.tar.gz"
+
+[tools.kustomize."platforms.windows-x64"]
+checksum = "sha256:8ec7f5e815e526d4622c06df0a7793d8cfb6eb1c74f816b46166097fef8b26c6"
+url = "https://github.com/kubernetes-sigs/kustomize/releases/download/kustomize/v5.8.1/kustomize_v5.8.1_windows_amd64.zip"
+
+[[tools.uv]]
+version = "0.9.18"
+backend = "aqua:astral-sh/uv"
+
+[tools.uv."platforms.linux-arm64"]
+checksum = "sha256:b710ceb9889276cbd7ce04e2ca06b5bd3e288da465bd38f7dd17955c4e703a65"
+url = "https://github.com/astral-sh/uv/releases/download/0.9.18/uv-aarch64-unknown-linux-musl.tar.gz"
+
+[tools.uv."platforms.linux-x64"]
+checksum = "sha256:a55ae2d0d53c8f6541bb4d6afc95857ff33a97de8f1d23e9d09acdcb865c4a00"
+url = "https://github.com/astral-sh/uv/releases/download/0.9.18/uv-x86_64-unknown-linux-musl.tar.gz"
+
+[tools.uv."platforms.macos-arm64"]
+checksum = "sha256:dc3bee4abbb3bac267a3985a23ea7617d19d41ff381dbaf560ba415ad65af68f"
+url = "https://github.com/astral-sh/uv/releases/download/0.9.18/uv-aarch64-apple-darwin.tar.gz"
+
+[tools.uv."platforms.macos-x64"]
+checksum = "sha256:f86836c637333c65bbc7902acc9c49888eef9fbd15dccbc1946b10e30b041073"
+url = "https://github.com/astral-sh/uv/releases/download/0.9.18/uv-x86_64-apple-darwin.tar.gz"
+
+[tools.uv."platforms.windows-x64"]
+checksum = "sha256:28cbe5d30907a774bfe27a517a39b494ec6f7d3816bda8bbf6f9645490449182"
+url = "https://github.com/astral-sh/uv/releases/download/0.9.18/uv-x86_64-pc-windows-msvc.zip"

{kapitan-0.36.2.dev1 → kapitan-0.36.2.dev3}/tests/test_input_cache.py

@@ -5,7 +5,7 @@ from pathlib import Path
 from unittest.mock import patch
 
 from kapitan.errors import CompileError
-from kapitan.inputs.cache import InputCache
+from kapitan.inputs.cache import CacheMetrics, InputCache
 
 
 class InputCacheTest(unittest.TestCase):
@@ -166,6 +166,63 @@ class InputCacheTest(unittest.TestCase):
                 self.assertTrue("input1" in cache1.input_cache_home)
                 self.assertTrue("input2" in cache2.input_cache_home)
 
+    def test_metrics_track_hits_misses_fills(self):
+        """
+        cache.get / cache.set should bump the shared CacheMetrics counters.
+        """
+        with tempfile.TemporaryDirectory() as tmpdir:
+            with patch.dict(os.environ, {"HOME": tmpdir}, clear=True):
+                metrics = CacheMetrics()
+                cache = InputCache("test_input", metrics=metrics)
+                inputs_hash = "abcdef123456"
+                test_obj = {"a": 1}
+
+                # miss: nothing cached yet
+                self.assertIsNone(cache.get(inputs_hash))
+                self.assertEqual(
+                    metrics.snapshot(), {"hits": 0, "misses": 1, "fills": 0}
+                )
+
+                # fill: write a new entry
+                cache.set(inputs_hash, test_obj)
+                self.assertEqual(
+                    metrics.snapshot(), {"hits": 0, "misses": 1, "fills": 1}
+                )
+
+                # hit: the same key now returns
+                self.assertEqual(cache.get(inputs_hash), test_obj)
+                self.assertEqual(
+                    metrics.snapshot(), {"hits": 1, "misses": 1, "fills": 1}
+                )
+
+                # second set with the same key is a no-op and must not count as a fill
+                cache.set(inputs_hash, {"c": 3})
+                self.assertEqual(
+                    metrics.snapshot(), {"hits": 1, "misses": 1, "fills": 1}
+                )
+
+    def test_metrics_shared_across_caches(self):
+        """
+        Two InputCache instances sharing the same CacheMetrics should
+        aggregate counters together (simulating multiple worker processes).
+        """
+        with tempfile.TemporaryDirectory() as tmpdir:
+            with patch.dict(os.environ, {"HOME": tmpdir}, clear=True):
+                metrics = CacheMetrics()
+                cache_a = InputCache("input_a", metrics=metrics)
+                cache_b = InputCache("input_b", metrics=metrics)
+
+                cache_a.get("hash_a")  # miss
+                cache_b.get("hash_b")  # miss
+                cache_a.set("hash_a", {"x": 1})  # fill
+                cache_b.set("hash_b", {"y": 2})  # fill
+                cache_a.get("hash_a")  # hit
+                cache_b.get("hash_b")  # hit
+
+                self.assertEqual(
+                    metrics.snapshot(), {"hits": 2, "misses": 2, "fills": 2}
+                )
+
     def test_dump_and_load_output(self):
         """
         tests the dump_output and load_output methods

kapitan-0.36.2.dev1/docs/pages/inventory/backends.md

@@ -1,12 +0,0 @@
-# :kapitan-logo: **Alternative Inventory Backends**
-
-We provide pluggable backend alternatives for the Inventory:
-
-* `reclass`(**default**): The original kapitan inventory  (see [reclass](https://github.com/kapicorp/reclass))
-* `reclass-rs`: The Rust drop in replacement (see [reclass-rs](reclass-rs.md))
-* `omegaconf`: An alternative inventory solution based on [Omegaconf](https://github.com/omry/omegaconf) (see [omegaconf](omegaconf.md))
-
-You can switch the backend to by:
-
-* (**recommended**) Define the backend in the [.kapitan config file](../commands/kapitan_dotfile.md).
-* Passing the `--inventory-backend=backend` command line option when calling `kapitan`.

kapitan-0.36.2.dev1/mise.lock

@@ -1,35 +0,0 @@
-[[tools.cue]]
-version = "0.15.4"
-backend = "aqua:cue-lang/cue"
-"platforms.linux-arm64" = { checksum = "sha256:f5a47ef6a6566849543b0ea84a7058c690bbb1492a1c101a6d62feaf59f8112e", url = "https://github.com/cue-lang/cue/releases/download/v0.15.4/cue_v0.15.4_linux_arm64.tar.gz"}
-"platforms.linux-x64" = { checksum = "sha256:4709f0d3e9988b82192a205953fefdbb3637317a1cef63d84fe65b7b92ef95a3", url = "https://github.com/cue-lang/cue/releases/download/v0.15.4/cue_v0.15.4_linux_amd64.tar.gz"}
-"platforms.macos-arm64" = { checksum = "sha256:2d324ba027447a7dab2e980f3ccfb7e15a3dd9096258b9f69205153e4c5b46cd", url = "https://github.com/cue-lang/cue/releases/download/v0.15.4/cue_v0.15.4_darwin_arm64.tar.gz"}
-"platforms.macos-x64" = { checksum = "sha256:e64e6a9f30609ed619a203334a6404c46a9fb7685a86424f74c3c52a55ebfa1c", url = "https://github.com/cue-lang/cue/releases/download/v0.15.4/cue_v0.15.4_darwin_amd64.tar.gz"}
-"platforms.windows-x64" = { checksum = "sha256:d42e26a0fb09219fc1735326fb2188dadf7c8deab136698a55d793c0c15a6aaa", url = "https://github.com/cue-lang/cue/releases/download/v0.15.4/cue_v0.15.4_windows_amd64.zip"}
-
-[[tools.helm]]
-version = "3.19.5"
-backend = "aqua:helm/helm"
-"platforms.linux-arm64" = { checksum = "sha256:ce02147ffee6d993bf8ae97a44a22e9e1daf0b69d2d5b69a0c8cf6706445ccf5", url = "https://get.helm.sh/helm-v3.19.5-linux-arm64.tar.gz"}
-"platforms.linux-x64" = { checksum = "sha256:a0a5e8c592ed3f376ac110715eff214730c7422f9a44d96cf98117d2b8b0e6c0", url = "https://get.helm.sh/helm-v3.19.5-linux-amd64.tar.gz"}
-"platforms.macos-arm64" = { checksum = "sha256:195e24e587f423f15a78feebab04583ceee68323598575a0e8b3b11b43fd26fe", url = "https://get.helm.sh/helm-v3.19.5-darwin-arm64.tar.gz"}
-"platforms.macos-x64" = { checksum = "sha256:57f4a847c349382b7cc742a6434ef25f88f0928a113d8cf49084b464878ef0b9", url = "https://get.helm.sh/helm-v3.19.5-darwin-amd64.tar.gz"}
-"platforms.windows-x64" = { checksum = "sha256:fee9632f0503debf0153f99e832b4dcb7c862c78b2f809e73eea0095d91ea51c", url = "https://get.helm.sh/helm-v3.19.5-windows-amd64.tar.gz"}
-
-[[tools.kustomize]]
-version = "5.8.1"
-backend = "aqua:kubernetes-sigs/kustomize"
-"platforms.linux-arm64" = { checksum = "sha256:0953ea3e476f66d6ddfcd911d750f5167b9365aa9491b2326398e289fef2c142", url = "https://github.com/kubernetes-sigs/kustomize/releases/download/kustomize/v5.8.1/kustomize_v5.8.1_linux_arm64.tar.gz"}
-"platforms.linux-x64" = { checksum = "sha256:029a7f0f4e1932c52a0476cf02a0fd855c0bb85694b82c338fc648dcb53a819d", url = "https://github.com/kubernetes-sigs/kustomize/releases/download/kustomize/v5.8.1/kustomize_v5.8.1_linux_amd64.tar.gz"}
-"platforms.macos-arm64" = { checksum = "sha256:8886f8a78474e608cc81234f729fda188a9767da23e28925802f00ece2bab288", url = "https://github.com/kubernetes-sigs/kustomize/releases/download/kustomize/v5.8.1/kustomize_v5.8.1_darwin_arm64.tar.gz"}
-"platforms.macos-x64" = { checksum = "sha256:ee7cf0c1e3592aa7bb66ba82b359933a95e7f2e0b36e5f53ed0a4535b017f2f8", url = "https://github.com/kubernetes-sigs/kustomize/releases/download/kustomize/v5.8.1/kustomize_v5.8.1_darwin_amd64.tar.gz"}
-"platforms.windows-x64" = { checksum = "sha256:8ec7f5e815e526d4622c06df0a7793d8cfb6eb1c74f816b46166097fef8b26c6", url = "https://github.com/kubernetes-sigs/kustomize/releases/download/kustomize/v5.8.1/kustomize_v5.8.1_windows_amd64.zip"}
-
-[[tools.uv]]
-version = "0.9.18"
-backend = "aqua:astral-sh/uv"
-"platforms.linux-arm64" = { checksum = "sha256:b710ceb9889276cbd7ce04e2ca06b5bd3e288da465bd38f7dd17955c4e703a65", url = "https://github.com/astral-sh/uv/releases/download/0.9.18/uv-aarch64-unknown-linux-musl.tar.gz"}
-"platforms.linux-x64" = { checksum = "sha256:a55ae2d0d53c8f6541bb4d6afc95857ff33a97de8f1d23e9d09acdcb865c4a00", url = "https://github.com/astral-sh/uv/releases/download/0.9.18/uv-x86_64-unknown-linux-musl.tar.gz"}
-"platforms.macos-arm64" = { checksum = "sha256:dc3bee4abbb3bac267a3985a23ea7617d19d41ff381dbaf560ba415ad65af68f", url = "https://github.com/astral-sh/uv/releases/download/0.9.18/uv-aarch64-apple-darwin.tar.gz"}
-"platforms.macos-x64" = { checksum = "sha256:f86836c637333c65bbc7902acc9c49888eef9fbd15dccbc1946b10e30b041073", url = "https://github.com/astral-sh/uv/releases/download/0.9.18/uv-x86_64-apple-darwin.tar.gz"}
-"platforms.windows-x64" = { checksum = "sha256:28cbe5d30907a774bfe27a517a39b494ec6f7d3816bda8bbf6f9645490449182", url = "https://github.com/astral-sh/uv/releases/download/0.9.18/uv-x86_64-pc-windows-msvc.zip"}