kapitan 0.36.1.dev3__tar.gz → 0.36.2.dev2__tar.gz

{kapitan-0.36.1.dev3 → kapitan-0.36.2.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kapitan
-Version: 0.36.1.dev3
+Version: 0.36.2.dev2
 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.1.dev3 → kapitan-0.36.2.dev2}/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.1.dev3 → kapitan-0.36.2.dev2}/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.1.dev3 → kapitan-0.36.2.dev2}/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.1.dev3 → kapitan-0.36.2.dev2}/kapitan/inputs/kadet.py

@@ -135,12 +135,11 @@ class Kadet(InputType):
         inputs_hash = None
         output_obj = None
 
-        # set compile_path allowing kadet functions to have context on where files
-        # are being compiled on the current kapitan run
-        # we only do this if user didn't pass its own value
-        input_params.setdefault("compile_path", compile_path)
-
         if cache_obj := self.cacheable():
+            # Hash input_params before setdefault injects compile_path below, so the
+            # volatile per-run tempdir never appears in the key. Any compile_path the
+            # user explicitly included in input_params is still hashed, preserving the
+            # collision safety added by PR #1520.
             inputs_hash = self.inputs_hash(
                 inventory_digest(current_target.get()),
                 target_name,
@@ -151,6 +150,10 @@ class Kadet(InputType):
             output_obj = cache_obj.get(inputs_hash)
 
         if output_obj is None:
+            # set compile_path after the cache key is computed so the volatile tempdir
+            # path does not get baked into the hash; only inject if user didn't supply one
+            input_params.setdefault("compile_path", compile_path)
+
             kadet_module, spec = module_from_path(input_path)
             sys.modules[spec.name] = kadet_module
             spec.loader.exec_module(kadet_module)
@@ -277,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.1.dev3 → kapitan-0.36.2.dev2}/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.dev2/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.1.dev3 → kapitan-0.36.2.dev2}/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.1.dev3 → kapitan-0.36.2.dev2}/tests/test_kadet.py

@@ -9,7 +9,6 @@
 
 import tempfile
 import unittest
-from argparse import Namespace
 from pathlib import Path
 from unittest import mock
 
@@ -174,41 +173,115 @@ class KadetTest(unittest.TestCase):
         self.assertEqual(output, desired_output)
 
 
-class KadetCompileCacheTest(unittest.TestCase):
-    def test_compile_cache_key_includes_input_params(self):
-        input_params = {"value": "second"}
+class KadetCacheKeyTest(unittest.TestCase):
+    """
+    Regression tests for PR-1520: compile_path must not be included in the
+    cache key because it is a per-run temporary directory that changes on every
+    invocation, which would cause every cache lookup to miss.
+    """
+
+    def _make_compiler(self):
+        compiler = Kadet.__new__(Kadet)
+        compiler.target_name = "test-target"
+        compiler.search_paths = []
+        return compiler
+
+    def test_compile_path_excluded_from_cache_key(self):
+        """inputs_hash must be called without compile_path so that volatile
+        tempdir paths do not prevent cache hits across runs."""
+        compiler = self._make_compiler()
+
         config = KapitanInputTypeKadetConfig(
             input_paths=["component"],
             output_path=".",
-            input_params=input_params,
-        )
-        compiler = Kadet(
-            "compiled",
-            ["."],
-            None,
-            "test-target",
-            Namespace(cache=True),
+            input_params={"value": "first"},
         )
 
-        cache = mock.Mock()
-        cache.get.return_value = {}
+        cache_obj = mock.Mock()
+        cache_obj.get.return_value = {"output.yml": {"key": "val"}}
 
         with (
-            mock.patch.object(compiler, "cacheable", return_value=cache),
+            mock.patch.object(compiler, "cacheable", return_value=cache_obj),
             mock.patch.object(
-                compiler, "inputs_hash", return_value="cache-key"
-            ) as inputs_hash,
+                compiler, "inputs_hash", return_value="fixed-hash"
+            ) as mock_hash,
             mock.patch(
                 "kapitan.inputs.kadet.inventory_digest", return_value=b"inventory"
             ),
+            mock.patch.object(compiler, "to_file"),
         ):
-            compiler.compile_file(config, "component", "compiled/test-target")
+            compiler.compile_file(
+                config, "component", "/tmp/run1-abc/compiled/test-target"
+            )
 
-        inputs_hash.assert_called_once_with(
+        mock_hash.assert_called_once_with(
             b"inventory",
             "test-target",
             Path("component"),
-            {"value": "second", "compile_path": "compiled/test-target"},
+            {"value": "first"},  # compile_path must NOT be present in the hash
+        )
+
+    def test_different_compile_paths_yield_same_hash_args(self):
+        """Two invocations with different compile_path values must produce
+        identical inputs_hash arguments so the second call gets a cache hit."""
+        compiler = self._make_compiler()
+
+        config = KapitanInputTypeKadetConfig(
+            input_paths=["component"],
+            output_path=".",
+            input_params={"value": "second"},
         )
-        cache.get.assert_called_once_with("cache-key")
-        self.assertEqual(config.input_params, input_params)
+
+        cache_obj = mock.Mock()
+        cache_obj.get.return_value = {"output.yml": {"k": "v"}}
+
+        calls = []
+
+        def capture_hash(*args):
+            calls.append(args)
+            return "stable-hash"
+
+        with (
+            mock.patch.object(compiler, "cacheable", return_value=cache_obj),
+            mock.patch.object(compiler, "inputs_hash", side_effect=capture_hash),
+            mock.patch("kapitan.inputs.kadet.inventory_digest", return_value=b"inv"),
+            mock.patch.object(compiler, "to_file"),
+        ):
+            compiler.compile_file(
+                config, "component", "/tmp/run1-xyz/compiled/test-target"
+            )
+            compiler.compile_file(
+                config, "component", "/tmp/run2-qrs/compiled/test-target"
+            )
+
+        self.assertEqual(len(calls), 2)
+        self.assertEqual(
+            calls[0],
+            calls[1],
+            "Cache key must be stable across different compile_paths",
+        )
+
+    def test_config_input_params_not_mutated(self):
+        """compile_file must not mutate config.input_params (compile_path is injected
+        into a local copy only)."""
+        compiler = self._make_compiler()
+
+        original_params = {"value": "third"}
+        config = KapitanInputTypeKadetConfig(
+            input_paths=["component"],
+            output_path=".",
+            input_params=dict(original_params),
+        )
+
+        cache_obj = mock.Mock()
+        cache_obj.get.return_value = {"output.yml": {"k": "v"}}
+
+        with (
+            mock.patch.object(compiler, "cacheable", return_value=cache_obj),
+            mock.patch.object(compiler, "inputs_hash", return_value="hash"),
+            mock.patch("kapitan.inputs.kadet.inventory_digest", return_value=b"inv"),
+            mock.patch.object(compiler, "to_file"),
+        ):
+            compiler.compile_file(config, "component", "compiled/test-target")
+
+        self.assertEqual(dict(config.input_params), original_params)

kapitan-0.36.1.dev3/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"}