clan_cli: flake_name -> flake_dir

pkgs/clan-cli/clan_cli/webui/api_inputs.py

@@ -1,25 +1,13 @@
 import logging
-from pathlib import Path
-from typing import Any
 
-from pydantic import AnyUrl, BaseModel, Extra, validator
+from pydantic import AnyUrl, BaseModel, Extra
 
-from ..dirs import clan_flakes_dir
 from ..flakes.create import DEFAULT_URL
-from ..types import validate_path
 
 log = logging.getLogger(__name__)
 
 
-class ClanFlakePath(BaseModel):
-    flake_name: Path
-
-    @validator("flake_name")
-    def check_flake_name(cls: Any, v: Path) -> Path:  # noqa
-        return validate_path(clan_flakes_dir(), v)
-
-
-class FlakeCreateInput(ClanFlakePath):
+class FlakeCreateInput(BaseModel):
     url: AnyUrl = DEFAULT_URL
 
 

pkgs/clan-cli/clan_cli/webui/routers/clan_modules.py

@@ -1,10 +1,10 @@
 # Logging setup
 import logging
+from pathlib import Path
 
 from fastapi import APIRouter, HTTPException
 
 from clan_cli.clan_modules import get_clan_module_names
-from clan_cli.types import FlakeName
 
 from ..api_outputs import (
     ClanModulesResponse,
@@ -15,9 +15,9 @@ log = logging.getLogger(__name__)
 router = APIRouter()
 
 
-@router.get("/api/{flake_name}/clan_modules", tags=[Tags.modules])
-async def list_clan_modules(flake_name: FlakeName) -> ClanModulesResponse:
-    module_names, error = get_clan_module_names(flake_name)
+@router.get("/api/clan_modules", tags=[Tags.modules])
+async def list_clan_modules(flake_dir: Path) -> ClanModulesResponse:
+    module_names, error = get_clan_module_names(flake_dir)
     if error is not None:
         raise HTTPException(status_code=400, detail=error)
     return ClanModulesResponse(clan_modules=module_names)

pkgs/clan-cli/clan_cli/webui/routers/flake.py

@@ -13,12 +13,11 @@ from clan_cli.webui.api_outputs import (
     FlakeAction,
     FlakeAttrResponse,
     FlakeCreateResponse,
-    FlakeListResponse,
     FlakeResponse,
 )
 
 from ...async_cmd import run
-from ...flakes import create, list_flakes
+from ...flakes import create
 from ...nix import nix_command, nix_flake_show
 from ..tags import Tags
 
@@ -78,23 +77,17 @@ async def inspect_flake(
     return FlakeResponse(content=content, actions=actions)
 
 
-@router.get("/api/flake/list", tags=[Tags.flake])
-async def list_all_flakes() -> FlakeListResponse:
-    flakes = list_flakes.list_flakes()
-    return FlakeListResponse(flakes=flakes)
-
-
 @router.post(
     "/api/flake/create", tags=[Tags.flake], status_code=status.HTTP_201_CREATED
 )
 async def create_flake(
-    args: Annotated[FlakeCreateInput, Body()],
+    flake_dir: Path, args: Annotated[FlakeCreateInput, Body()]
 ) -> FlakeCreateResponse:
-    if args.flake_name.exists():
+    if flake_dir.exists():
         raise HTTPException(
             status_code=status.HTTP_409_CONFLICT,
             detail="Flake already exists",
         )
 
-    cmd_out = await create.create_flake(args.flake_name, args.url)
+    cmd_out = await create.create_flake(flake_dir, args.url)
     return FlakeCreateResponse(cmd_out=cmd_out)

pkgs/clan-cli/clan_cli/webui/routers/machines.py

@@ -1,5 +1,6 @@
 # Logging setup
 import logging
+from pathlib import Path
 from typing import Annotated
 
 from fastapi import APIRouter, Body
@@ -15,7 +16,6 @@ from ...config.machine import (
 )
 from ...config.schema import machine_schema
 from ...machines.list import list_machines as _list_machines
-from ...types import FlakeName
 from ..api_outputs import (
     ConfigResponse,
     Machine,
@@ -31,66 +31,62 @@ log = logging.getLogger(__name__)
 router = APIRouter()
 
 
-@router.get("/api/{flake_name}/machines", tags=[Tags.machine])
-async def list_machines(flake_name: FlakeName) -> MachinesResponse:
+@router.get("/api/machines", tags=[Tags.machine])
+async def list_machines(flake_dir: Path) -> MachinesResponse:
     machines = []
-    for m in _list_machines(flake_name):
+    for m in _list_machines(flake_dir):
         machines.append(Machine(name=m, status=Status.UNKNOWN))
 
     return MachinesResponse(machines=machines)
 
 
-@router.get("/api/{flake_name}/machines/{name}", tags=[Tags.machine])
-async def get_machine(flake_name: FlakeName, name: str) -> MachineResponse:
+@router.get("/api/machines/{name}", tags=[Tags.machine])
+async def get_machine(flake_dir: Path, name: str) -> MachineResponse:
     log.error("TODO")
     return MachineResponse(machine=Machine(name=name, status=Status.UNKNOWN))
 
 
-@router.get("/api/{flake_name}/machines/{name}/config", tags=[Tags.machine])
-async def get_machine_config(flake_name: FlakeName, name: str) -> ConfigResponse:
-    config = config_for_machine(flake_name, name)
+@router.get("/api/machines/{name}/config", tags=[Tags.machine])
+async def get_machine_config(flake_dir: Path, name: str) -> ConfigResponse:
+    config = config_for_machine(flake_dir, name)
     return ConfigResponse(**config)
 
 
-@router.put("/api/{flake_name}/machines/{name}/config", tags=[Tags.machine])
-async def put_machine(
-    flake_name: FlakeName, name: str, config: Annotated[MachineConfig, Body()]
+@router.put("/api/machines/{name}/config", tags=[Tags.machine])
+async def set_machine_config(
+    flake_dir: Path, name: str, config: Annotated[MachineConfig, Body()]
 ) -> None:
-    """
-    Set the config for a machine.
-    Creates the machine if it doesn't yet exist.
-    """
     conf = jsonable_encoder(config)
-    set_config_for_machine(flake_name, name, conf)
+    set_config_for_machine(flake_dir, name, conf)
 
 
 @router.put(
-    "/api/{flake_name}/schema",
+    "/api/schema",
     tags=[Tags.machine],
     responses={400: {"model": MissingClanImports}},
 )
 async def get_machine_schema(
-    flake_name: FlakeName, config: Annotated[MachineConfig, Body()]
+    flake_dir: Path, config: Annotated[dict, Body()]
 ) -> SchemaResponse:
-    schema = machine_schema(flake_name, config=dict(config))
+    schema = machine_schema(flake_dir, config=config)
     return SchemaResponse(schema=schema)
 
 
-@router.get("/api/{flake_name}/machines/{name}/verify", tags=[Tags.machine])
+@router.get("/api/machines/{name}/verify", tags=[Tags.machine])
 async def get_verify_machine_config(
-    flake_name: FlakeName, name: str
+    flake_dir: Path, name: str
 ) -> VerifyMachineResponse:
-    error = verify_machine_config(flake_name, name)
+    error = verify_machine_config(flake_dir, name)
     success = error is None
     return VerifyMachineResponse(success=success, error=error)
 
 
-@router.put("/api/{flake_name}/machines/{name}/verify", tags=[Tags.machine])
+@router.put("/api/machines/{name}/verify", tags=[Tags.machine])
 async def put_verify_machine_config(
-    flake_name: FlakeName,
+    flake_dir: Path,
     name: str,
     config: Annotated[dict, Body()],
 ) -> VerifyMachineResponse:
-    error = verify_machine_config(flake_name, name, config)
+    error = verify_machine_config(flake_dir, name, config)
     success = error is None
     return VerifyMachineResponse(success=success, error=error)