adding deletion and pruning

Author: ParticularlyPythonicBS

diffs/test_database.sqlite/diff-v1-to-v2.diff

@@ -496,6 +496,110 @@ def _rollback_interactive(ctx: typer.Context) -> None:
         pass
 
 
+@app.command()
+def delete(
+    ctx: typer.Context,
+    name: str = typer.Argument(..., help="The logical name of the dataset to delete."),
+) -> None:
+    """
+    Marks a dataset for permanent deletion.
+    This action is finalized via a Pull Request and CI/CD pipeline.
+    """
+    console.print(f"🗑️  Preparing deletion for [bold red]{name}[/].")
+
+    # Verify the dataset exists before proceeding
+    if not manifest.get_dataset(name):
+        console.print(f"[red]Error: Dataset '{name}' not found.[/]")
+        raise typer.Exit(1)
+
+    console.print(
+        "[bold yellow]WARNING:[/] This will propose the [underline]permanent deletion[/] of the dataset and all its version history from Cloudflare R2."
+    )
+
+    # Use a text prompt for strong confirmation
+    confirmation = questionary.text(
+        f"To confirm, please type the name of the dataset ({name}):"
+    ).ask()
+
+    if confirmation != name:
+        console.print("Confirmation failed. Deletion cancelled.")
+        return
+
+    # Mark the dataset for deletion in the manifest
+    if manifest.mark_for_deletion(name):
+        console.print(
+            f"\n[bold green]✅ Dataset '{name}' has been marked for deletion.[/]"
+        )
+        console.print(
+            "\nNext steps:\n"
+            f"  1. [cyan]git add {settings.manifest_file}[/]\n"
+            f'  2. [cyan]git commit -m "chore: Mark {name} for deletion"[/]\n'
+            "  3. [cyan]git push[/]\n"
+            "  4. Open a Pull Request to finalize the deletion."
+        )
+    else:
+        # This case should be caught by the check above, but is here for safety
+        console.print(f"[red]Error: Could not mark '{name}' for deletion.[/]")
+        raise typer.Exit(1)
+
+
+@app.command()
+def prune_versions(
+    ctx: typer.Context,
+    name: str = typer.Argument(..., help="The logical name of the dataset to prune."),
+    keep: int = typer.Option(
+        ..., "--keep", "-k", help="The number of most recent versions to keep."
+    ),
+) -> None:
+    """Marks old versions of a dataset for permanent deletion."""
+    console.print(f"🔪 Preparing to prune old versions of [cyan]{name}[/]...")
+
+    dataset = manifest.get_dataset(name)
+    if not dataset:
+        console.print(f"[red]Error: Dataset '{name}' not found.[/]")
+        raise typer.Exit(1)
+
+    history = dataset.get("history", [])
+    if len(history) <= keep:
+        console.print(
+            f"✅ No action needed. Dataset has {len(history)} version(s), which is not more than the {keep} to keep."
+        )
+        return
+
+    versions_to_keep = [entry["version"] for entry in history[:keep]]
+    versions_to_delete = [entry["version"] for entry in history[keep:]]
+
+    console.print(
+        f"You have chosen to keep the [bold green]{keep}[/] most recent version(s):"
+    )
+    for v in versions_to_keep:
+        console.print(f"  - [green]{v}[/]")
+
+    console.print(
+        f"\nThe following [bold red]{len(versions_to_delete)}[/] older version(s) will be marked for permanent deletion:"
+    )
+    for v in versions_to_delete:
+        console.print(f"  - [red]{v}[/]")
+
+    proceed = _ask_confirm(ctx, "\nDo you want to continue?", default=False)
+    if not proceed:
+        console.print("Pruning cancelled.")
+        return
+
+    # Mark the versions for deletion in the manifest
+    manifest.mark_versions_for_deletion(name, versions_to_delete)
+    console.print(
+        f"\n[bold green]✅ {len(versions_to_delete)} version(s) have been marked for deletion.[/]"
+    )
+    console.print(
+        "\nNext steps:\n"
+        f"  1. [cyan]git add {settings.manifest_file}[/]\n"
+        f'  2. [cyan]git commit -m "chore: Prune old versions of {name}, keeping {keep}"[/]\n'
+        "  3. [cyan]git push[/]\n"
+        "  4. Open a Pull Request to finalize the deletion."
+    )
+
+
 @app.callback(invoke_without_command=True)
 def main(ctx: typer.Context, no_prompt: bool = COMMON_OPTIONS["no_prompt"]) -> None:
     """
@@ -521,6 +625,8 @@ def main(ctx: typer.Context, no_prompt: bool = COMMON_OPTIONS["no_prompt"]) -> N
         "Prepare a dataset for release": _prepare_interactive,
         "Pull a dataset version": _pull_interactive,
         "Rollback a dataset to a previous version": _rollback_interactive,
+        "Delete a dataset": delete,
+        "Prune old dataset versions": prune_versions,
         "Exit": "exit",
     }
 

diffs/test_database.sqlite/diff-v2-to-v3.diff

@@ -210,3 +210,39 @@ def update_dataset(name: str, updated_dataset: dict[str, Any]) -> None:
             data[i] = updated_dataset
             break
     write_manifest(data)
+
+
+def mark_for_deletion(name: str) -> bool:
+    """
+    Finds a dataset and adds a 'status: pending-deletion' flag.
+    Returns True if the dataset was found and marked, False otherwise.
+    """
+    data = read_manifest()
+    dataset_found = False
+    for item in data:
+        if item.get("fileName") == name:
+            item["status"] = "pending-deletion"
+            dataset_found = True
+            break
+    if dataset_found:
+        write_manifest(data)
+    return dataset_found
+
+
+def mark_versions_for_deletion(name: str, versions_to_delete: list[str]) -> bool:
+    """
+    Finds a dataset and adds a 'status: pending-deletion' flag to specific
+    history entries. Returns True on success.
+    """
+    data = read_manifest()
+    dataset_found = False
+    for item in data:
+        if item.get("fileName") == name:
+            dataset_found = True
+            for entry in item.get("history", []):
+                if entry.get("version") in versions_to_delete:
+                    entry["status"] = "pending-deletion"
+            break
+    if dataset_found:
+        write_manifest(data)
+    return dataset_found

src/datamanager/__main__.py

@@ -343,3 +343,76 @@ def test_rollback_user_cancel(test_repo: Path, mocker: MockerFixture) -> None:
     # Verify the manifest file was not changed
     final_manifest = manifest.read_manifest()
     assert final_manifest == original_manifest
+
+
+def test_delete_success(test_repo: Path, mocker: MockerFixture) -> None:
+    """Test successfully marking a dataset for deletion."""
+    os.chdir(test_repo)
+    # Mock the text confirmation to succeed
+    mocker.patch(
+        "questionary.text",
+        return_value=mocker.Mock(ask=mocker.Mock(return_value="core-dataset.sqlite")),
+    )
+
+    result = runner.invoke(app, ["delete", "core-dataset.sqlite"])
+
+    assert result.exit_code == 0, result.stdout
+    assert "has been marked for deletion" in result.stdout
+
+    # Verify the manifest was updated with the status flag
+    dataset = manifest.get_dataset("core-dataset.sqlite")
+    assert dataset is not None
+    assert dataset.get("status") == "pending-deletion"
+
+
+def test_delete_confirmation_failed(test_repo: Path, mocker: MockerFixture) -> None:
+    """Test that deletion is cancelled if the typed confirmation is wrong."""
+    os.chdir(test_repo)
+    # Mock the text confirmation to fail
+    mocker.patch(
+        "questionary.text",
+        return_value=mocker.Mock(ask=mocker.Mock(return_value="wrong-name")),
+    )
+    original_manifest = manifest.read_manifest()
+
+    result = runner.invoke(app, ["delete", "core-dataset.sqlite"])
+
+    assert result.exit_code == 0, result.stdout
+    assert "Confirmation failed. Deletion cancelled." in result.stdout
+
+    # Verify the manifest was NOT changed
+    final_manifest = manifest.read_manifest()
+    assert final_manifest == original_manifest
+
+
+def test_prune_versions_success(test_repo: Path, mocker: MockerFixture) -> None:
+    """Test successfully marking old versions for deletion."""
+    os.chdir(test_repo)
+    mocker.patch("datamanager.__main__._ask_confirm", return_value=True)
+
+    # Act: Keep the latest 1 version, which should mark v1 for deletion
+    result = runner.invoke(
+        app, ["prune-versions", "core-dataset.sqlite", "--keep", "1"]
+    )
+
+    assert result.exit_code == 0, result.stdout
+    assert "1 version(s) have been marked for deletion" in result.stdout
+
+    # Assert: Check that the v1 entry in the manifest is now marked
+    dataset = manifest.get_dataset("core-dataset.sqlite")
+    assert dataset is not None
+    v2_entry = dataset["history"][0]
+    v1_entry = dataset["history"][1]
+    assert "status" not in v2_entry  # v2 is kept, should not be marked
+    assert v1_entry.get("status") == "pending-deletion"
+
+
+def test_prune_versions_no_op(test_repo: Path, mocker: MockerFixture) -> None:
+    """Test pruning when the number to keep is >= the number of versions."""
+    os.chdir(test_repo)
+    result = runner.invoke(
+        app, ["prune-versions", "core-dataset.sqlite", "--keep", "5"]
+    )
+
+    assert result.exit_code == 0, result.stdout
+    assert "No action needed" in result.stdout