vars/api: rename, unregister some unused vars functions

pkgs/clan-cli/clan_cli/tests/test_vars.py

@@ -14,7 +14,7 @@ from clan_cli.vars.generate import (
     create_machine_vars_interactive,
     get_generators_closure,
 )
-from clan_cli.vars.get import get_var
+from clan_cli.vars.get import get_machine_var
 from clan_cli.vars.graph import all_missing_closure, requested_closure
 from clan_cli.vars.list import stringify_all_vars
 from clan_cli.vars.public_modules import in_repo
@@ -172,13 +172,13 @@ def test_generate_public_and_secret_vars(
         in commit_message
     )
     assert (
-        get_var(
+        get_machine_var(
             str(machine.flake.path), machine.name, "my_generator/my_value"
         ).printable_value
         == "public"
     )
     assert (
-        get_var(
+        get_machine_var(
             str(machine.flake.path), machine.name, "my_shared_generator/my_shared_value"
         ).printable_value
         == "shared"
@@ -343,9 +343,9 @@ def test_generated_shared_secret_sops(
     shared_generator["script"] = 'echo hello > "$out"/my_shared_secret'
     m2_config = flake.machines["machine2"]
     m2_config["nixpkgs"]["hostPlatform"] = "x86_64-linux"
-    m2_config["clan"]["core"]["vars"]["generators"]["my_shared_generator"] = (
-        shared_generator.copy()
-    )
+    m2_config["clan"]["core"]["vars"]["generators"][
+        "my_shared_generator"
+    ] = shared_generator.copy()
     flake.refresh()
     monkeypatch.chdir(flake.path)
     machine1 = Machine(name="machine1", flake=Flake(str(flake.path)))
@@ -803,9 +803,9 @@ def test_migration(
     my_service = config["clan"]["core"]["facts"]["services"]["my_service"]
     my_service["public"]["my_value"] = {}
     my_service["secret"]["my_secret"] = {}
-    my_service["generator"]["script"] = (
-        'echo -n hello > "$facts"/my_value && echo -n hello > "$secrets"/my_secret'
-    )
+    my_service["generator"][
+        "script"
+    ] = 'echo -n hello > "$facts"/my_value && echo -n hello > "$secrets"/my_secret'
     my_generator = config["clan"]["core"]["vars"]["generators"]["my_generator"]
     my_generator["files"]["my_value"]["secret"] = False
     my_generator["files"]["my_secret"]["secret"] = True
@@ -875,9 +875,9 @@ def test_fails_when_files_are_left_from_other_backend(
             regenerate=False,
         )
     # Will raise. It was secret before, but now it's not.
-    my_secret_generator["files"]["my_secret"]["secret"] = (
-        False  # secret -> public (NOT OK)
-    )
+    my_secret_generator["files"]["my_secret"][
+        "secret"
+    ] = False  # secret -> public (NOT OK)
     # WIll not raise. It was not secret before, and it's secret now.
     my_value_generator["files"]["my_value"]["secret"] = True  # public -> secret (OK)
     flake.refresh()
@@ -932,12 +932,12 @@ def test_invalidation(
     monkeypatch.chdir(flake.path)
     cli.run(["vars", "generate", "--flake", str(flake.path), "my_machine"])
     machine = Machine(name="my_machine", flake=Flake(str(flake.path)))
-    value1 = get_var(
+    value1 = get_machine_var(
         str(machine.flake.path), machine.name, "my_generator/my_value"
     ).printable_value
     # generate again and make sure nothing changes without the invalidation data being set
     cli.run(["vars", "generate", "--flake", str(flake.path), "my_machine"])
-    value1_new = get_var(
+    value1_new = get_machine_var(
         str(machine.flake.path), machine.name, "my_generator/my_value"
     ).printable_value
     assert value1 == value1_new
@@ -946,13 +946,13 @@ def test_invalidation(
     flake.refresh()
     # generate again and make sure the value changes
     cli.run(["vars", "generate", "--flake", str(flake.path), "my_machine"])
-    value2 = get_var(
+    value2 = get_machine_var(
         str(machine.flake.path), machine.name, "my_generator/my_value"
     ).printable_value
     assert value1 != value2
     # generate again without changing invalidation data -> value should not change
     cli.run(["vars", "generate", "--flake", str(flake.path), "my_machine"])
-    value2_new = get_var(
+    value2_new = get_machine_var(
         str(machine.flake.path), machine.name, "my_generator/my_value"
     ).printable_value
     assert value2 == value2_new

pkgs/clan-cli/clan_cli/vars/get.py

@@ -8,14 +8,13 @@ from clan_lib.errors import ClanError
 from clan_lib.flake import Flake
 
 from .generate import Var
-from .list import get_vars
+from .list import get_machine_vars
 
 log = logging.getLogger(__name__)
 
 
-@API.register
-def get_var(base_dir: str, machine_name: str, var_id: str) -> Var:
-    vars_ = get_vars(base_dir=base_dir, machine_name=machine_name)
+def get_machine_var(base_dir: str, machine_name: str, var_id: str) -> Var:
+    vars_ = get_machine_vars(base_dir=base_dir, machine_name=machine_name)
     results = []
     for var in vars_:
         if var.id == var_id:
@@ -41,7 +40,7 @@ def get_var(base_dir: str, machine_name: str, var_id: str) -> Var:
 
 
 def get_command(machine_name: str, var_id: str, flake: Flake) -> None:
-    var = get_var(str(flake.path), machine_name, var_id)
+    var = get_machine_var(str(flake.path), machine_name, var_id)
     if not var.exists:
         msg = f"Var {var.id} has not been generated yet"
         raise ClanError(msg)

pkgs/clan-cli/clan_cli/vars/list.py

@@ -13,8 +13,7 @@ from .generate import Generator, Prompt, Var, execute_generator
 log = logging.getLogger(__name__)
 
 
-@API.register
-def get_vars(base_dir: str, machine_name: str) -> list[Var]:
+def get_machine_vars(base_dir: str, machine_name: str) -> list[Var]:
     machine = Machine(name=machine_name, flake=Flake(base_dir))
     pub_store = machine.public_vars_store
     sec_store = machine.secret_vars_store
@@ -32,70 +31,12 @@ def get_vars(base_dir: str, machine_name: str) -> list[Var]:
     return all_vars
 
 
-def _get_previous_value(
-    machine: Machine,
-    generator: Generator,
-    prompt: Prompt,
-) -> str | None:
-    if not prompt.persist:
-        return None
-
-    pub_store = machine.public_vars_store
-    if pub_store.exists(generator, prompt.name):
-        return pub_store.get(generator, prompt.name).decode()
-    sec_store = machine.secret_vars_store
-    if sec_store.exists(generator, prompt.name):
-        return sec_store.get(generator, prompt.name).decode()
-    return None
-
-
-@API.register
-def get_generators(base_dir: str, machine_name: str) -> list[Generator]:
-    from clan_cli.vars.generate import Generator
-
-    machine = Machine(name=machine_name, flake=Flake(base_dir))
-    generators: list[Generator] = Generator.generators_from_flake(
-        machine_name, machine.flake
-    )
-    for generator in generators:
-        for prompt in generator.prompts:
-            prompt.previous_value = _get_previous_value(machine, generator, prompt)
-    return generators
-
-
-# TODO: Ensure generator dependencies are met (executed in correct order etc.)
-# TODO: for missing prompts, default to existing values
-# TODO: raise error if mandatory prompt not provided
-@API.register
-def set_prompts(
-    base_dir: str, machine_name: str, updates: list[GeneratorUpdate]
-) -> None:
-    from clan_cli.vars.generate import Generator
-
-    machine = Machine(name=machine_name, flake=Flake(base_dir))
-    for update in updates:
-        generators = Generator.generators_from_flake(machine_name, machine.flake)
-        for generator in generators:
-            if generator.name == update.generator:
-                break
-        else:
-            msg = f"Generator '{update.generator}' not found in machine {machine.name}"
-            raise ClanError(msg)
-        execute_generator(
-            machine,
-            generator,
-            secret_vars_store=machine.secret_vars_store,
-            public_vars_store=machine.public_vars_store,
-            prompt_values=update.prompt_values,
-        )
-
-
 def stringify_vars(_vars: list[Var]) -> str:
     return "\n".join([str(var) for var in _vars])
 
 
 def stringify_all_vars(machine: Machine) -> str:
-    return stringify_vars(get_vars(str(machine.flake), machine.name))
+    return stringify_vars(get_machine_vars(str(machine.flake), machine.name))
 
 
 def list_command(args: argparse.Namespace) -> None:

pkgs/clan-cli/clan_cli/vars/set.py

@@ -3,7 +3,7 @@ import logging
 import sys
 
 from clan_cli.completions import add_dynamic_completer, complete_machines
-from clan_cli.vars.get import get_var
+from clan_cli.vars.get import get_machine_var
 from clan_cli.vars.prompt import PromptType
 from clan_lib.flake import Flake
 from clan_lib.git import commit_files
@@ -21,7 +21,7 @@ def set_var(machine: str | Machine, var: str | Var, value: bytes, flake: Flake)
     else:
         _machine = machine
     if isinstance(var, str):
-        _var = get_var(str(flake.path), _machine.name, var)
+        _var = get_machine_var(str(flake.path), _machine.name, var)
     else:
         _var = var
     path = _var.set(value)
@@ -35,7 +35,7 @@ def set_var(machine: str | Machine, var: str | Var, value: bytes, flake: Flake)
 
 def set_via_stdin(machine_name: str, var_id: str, flake: Flake) -> None:
     machine = Machine(name=machine_name, flake=flake)
-    var = get_var(str(flake.path), machine_name, var_id)
+    var = get_machine_var(str(flake.path), machine_name, var_id)
     if sys.stdin.isatty():
         new_value = ask(
             var.id,