haplohub-cli 2.4.0__tar.gz → 2.6.0__tar.gz

{haplohub_cli-2.4.0 → haplohub_cli-2.6.0}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: haplohub-cli
-Version: 2.4.0
+Version: 2.6.0
 Summary: HaploHub Command Line Interface
 Author-email: Mike Polcari <mike@haplotype-labs.com>, Ilya Khrustalev <ilya@haplotype-labs.com>
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 Requires-Dist: click>=8.1.8
-Requires-Dist: haplohub<3,>=2.2.0
+Requires-Dist: haplohub<3,>=2.16.0
 Requires-Dist: pendulum>=3.0.0
 Requires-Dist: requests>=2.32.0
 Requires-Dist: rich>=13.9.4

{haplohub_cli-2.4.0 → haplohub_cli-2.6.0}/haplohub_cli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '2.4.0'
-__version_tuple__ = version_tuple = (2, 4, 0)
+__version__ = version = '2.6.0'
+__version_tuple__ = version_tuple = (2, 6, 0)
 
-__commit_id__ = commit_id = 'gc36ea6d15'
+__commit_id__ = commit_id = 'gaebb47593'

{haplohub_cli-2.4.0 → haplohub_cli-2.6.0}/haplohub_cli/auth/auth.py

@@ -20,7 +20,7 @@ def token_login(api_key: str):
 
     response.raise_for_status()
 
-    oauth_client.token_storage.store_credentials({"api_key": api_key})
+    oauth_client.token_storage.store_credentials(api_url, {"api_key": api_key})
     click.echo("Successfully authenticated with HaploHub.")
 
 
@@ -47,4 +47,4 @@ def interactive_login():
     credentials = auth_request.exchange_code(auth_code)
 
     click.echo("Successfully authenticated with HaploHub.")
-    oauth_client.token_storage.store_credentials(credentials)
+    oauth_client.token_storage.store_credentials(config_manager.config.api_url, credentials)

haplohub_cli-2.6.0/haplohub_cli/auth/tests/test_token_storage.py

@@ -0,0 +1,74 @@
+import json
+
+import pytest
+from pyfakefs.fake_filesystem_unittest import TestCase
+
+from haplohub_cli.auth.token_storage import CREDENTIALS_VERSION, TokenStorage, normalize_api_url
+
+
+class TokenStorageTestCase(TestCase):
+    def setUp(self):
+        self.setUpPyfakefs()
+        self.instance = TokenStorage("/tmp/test_token_storage.json")
+
+    def test_credentials_exist_should_return_false_when_file_does_not_exist(self):
+        self.assertFalse(self.instance.credentials_exist("https://api.example.com"))
+
+    def test_store_credentials_should_save_versioned_credentials(self):
+        self.instance.store_credentials("https://api.example.com", {"access_token": "123456"})
+
+        with open(self.instance.token_file) as f:
+            self.assertEqual(
+                json.load(f),
+                {
+                    "version": CREDENTIALS_VERSION,
+                    "environments": {"https://api.example.com": {"access_token": "123456"}},
+                },
+            )
+
+    def test_credentials_are_isolated_by_environment(self):
+        self.instance.store_credentials("https://api-a.example.com", {"access_token": "token-a"})
+        self.instance.store_credentials("https://api-b.example.com", {"api_key": "key-b"})
+
+        self.assertEqual(self.instance.get_access_token("https://api-a.example.com"), "token-a")
+        self.assertEqual(self.instance.get_api_key("https://api-b.example.com"), "key-b")
+        self.assertFalse(self.instance.has_api_key("https://api-a.example.com"))
+        self.assertTrue(self.instance.has_api_key("https://api-b.example.com"))
+
+    def test_get_credentials_should_fail_for_unknown_environment(self):
+        self.instance.store_credentials("https://api-a.example.com", {"access_token": "token-a"})
+
+        with pytest.raises(KeyError):
+            self.instance.get_credentials("https://api-b.example.com")
+
+    def test_legacy_credentials_are_migrated_to_current_environment(self):
+        credentials = {"access_token": "123456", "refresh_token": "refresh-123456"}
+        with open(self.instance.token_file, "w") as f:
+            json.dump(credentials, f)
+
+        self.assertTrue(self.instance.migrate("https://api.example.com/"))
+        self.assertEqual(self.instance.get_credentials("https://api.example.com"), credentials)
+
+        with open(self.instance.token_file) as f:
+            self.assertEqual(
+                json.load(f),
+                {
+                    "version": CREDENTIALS_VERSION,
+                    "environments": {"https://api.example.com": credentials},
+                },
+            )
+
+    def test_versioned_credentials_are_not_migrated_again(self):
+        self.instance.store_credentials("https://api-a.example.com", {"access_token": "token-a"})
+
+        self.assertFalse(self.instance.migrate("https://api-b.example.com"))
+        self.assertFalse(self.instance.credentials_exist("https://api-b.example.com"))
+
+    def test_get_refresh_token_should_return_none_when_missing(self):
+        self.instance.store_credentials("https://api.example.com", {"access_token": "123456"})
+
+        self.assertIsNone(self.instance.get_refresh_token("https://api.example.com"))
+
+
+def test_normalize_api_url():
+    assert normalize_api_url(" HTTPS://API.Example.COM/base/ ") == "https://api.example.com/base"

haplohub_cli-2.6.0/haplohub_cli/auth/token_storage.py

@@ -0,0 +1,107 @@
+import json
+import os
+import tempfile
+from genericpath import exists
+from os import path
+from typing import Dict, Tuple
+from urllib.parse import urlsplit, urlunsplit
+
+from haplohub_cli import settings
+
+CREDENTIALS_VERSION = 2
+
+
+def normalize_api_url(api_url: str) -> str:
+    api_url = api_url.strip()
+    parsed = urlsplit(api_url)
+
+    if not parsed.scheme or not parsed.netloc:
+        return api_url.rstrip("/")
+
+    return urlunsplit(
+        (
+            parsed.scheme.lower(),
+            parsed.netloc.lower(),
+            parsed.path.rstrip("/"),
+            parsed.query,
+            parsed.fragment,
+        )
+    )
+
+
+class TokenStorage:
+    def __init__(self, token_file: str):
+        self.token_file = token_file
+
+    def migrate(self, api_url: str) -> bool:
+        _, migrated = self._load(api_url)
+        return migrated
+
+    def credentials_exist(self, api_url: str) -> bool:
+        data, _ = self._load(api_url)
+        return normalize_api_url(api_url) in data["environments"]
+
+    def store_credentials(self, api_url: str, credentials: dict):
+        data, _ = self._load(api_url)
+        data["environments"][normalize_api_url(api_url)] = credentials
+        self._save(data)
+
+    def get_credentials(self, api_url: str) -> dict:
+        data, _ = self._load(api_url)
+        return data["environments"][normalize_api_url(api_url)]
+
+    def get_access_token(self, api_url: str):
+        return self.get_credentials(api_url)["access_token"]
+
+    def get_api_key(self, api_url: str):
+        return self.get_credentials(api_url)["api_key"]
+
+    def get_refresh_token(self, api_url: str):
+        return self.get_credentials(api_url).get("refresh_token")
+
+    def has_api_key(self, api_url: str) -> bool:
+        return self.credentials_exist(api_url) and "api_key" in self.get_credentials(api_url)
+
+    def _load(self, migration_api_url: str) -> Tuple[Dict[str, object], bool]:
+        if not exists(self.token_file):
+            return self._empty_store(), False
+
+        with open(self.token_file) as f:
+            data = json.load(f)
+
+        if data.get("version") == CREDENTIALS_VERSION:
+            if not isinstance(data.get("environments"), dict):
+                raise ValueError("Invalid credentials file: 'environments' must be an object")
+            return data, False
+
+        if "version" in data:
+            raise ValueError(f"Unsupported credentials file version: {data['version']}")
+
+        migrated = self._empty_store()
+        migrated["environments"][normalize_api_url(migration_api_url)] = data
+        self._save(migrated)
+        return migrated, True
+
+    def _save(self, data: Dict[str, object]):
+        directory = path.dirname(self.token_file) or "."
+        os.makedirs(directory, exist_ok=True)
+
+        temporary_file = None
+        try:
+            with tempfile.NamedTemporaryFile("w", dir=directory, delete=False) as f:
+                temporary_file = f.name
+                json.dump(data, f, indent=4)
+                f.write("\n")
+
+            os.chmod(temporary_file, 0o600)
+            os.replace(temporary_file, self.token_file)
+        finally:
+            if temporary_file and exists(temporary_file):
+                os.unlink(temporary_file)
+
+    @staticmethod
+    def _empty_store() -> Dict[str, object]:
+        return {"version": CREDENTIALS_VERSION, "environments": {}}
+
+
+token_storage = TokenStorage(settings.CREDENTIALS_FILE)

{haplohub_cli-2.4.0 → haplohub_cli-2.6.0}/haplohub_cli/commands/algorithm/result/__init__.py

@@ -17,10 +17,24 @@ def result():
 
 
 @result.command()
-def list(algorithm_version_id: Optional[str] = None, cohort_id: Optional[str] = None):
+@click.option("--algorithm", "-a", type=str, required=False, help="Filter by algorithm name (e.g. pgsc_calc)")
+@click.option("--version", "-v", type=str, required=False, help="Filter by algorithm version")
+@click.option("--cohort", "-c", type=types.HAPLOHUB_ID, required=False, help="Filter by cohort")
+@click.option("--member", "-m", type=types.HAPLOHUB_ID, required=False, help="Filter by member")
+@click.option("--sample", "-s", type=types.HAPLOHUB_ID, required=False, help="Filter by sample")
+def list(
+    algorithm: Optional[str] = None,
+    version: Optional[str] = None,
+    cohort: Optional[str] = None,
+    member: Optional[str] = None,
+    sample: Optional[str] = None,
+):
     return client.algorithm_result.list_algorithm_results(
-        algorithm_version_id=algorithm_version_id,
-        cohort_id=cohort_id,
+        algorithm=algorithm,
+        version=version,
+        cohort_id=cohort,
+        member_id=member,
+        sample_id=sample,
     )
 
 

{haplohub_cli-2.4.0 → haplohub_cli-2.6.0}/haplohub_cli/commands/cohort/__init__.py

@@ -36,7 +36,7 @@ def delete(id):
 
 @cohort.command()
 def accession():
-    return client.metadata.list_accession()
+    return client.accession.list_accession()
 
 
 cohort.add_command(biomarker.biomarker)

{haplohub_cli-2.4.0 → haplohub_cli-2.6.0}/haplohub_cli/commands/cohort/member/__init__.py

@@ -1,8 +1,9 @@
 import click
-from haplohub import CreateMemberRequest, UpdateMemberRequest
+from haplohub import CreateMemberRequest, DeleteMode, UpdateMemberRequest
 
 from haplohub_cli.core import types
 from haplohub_cli.core.api.client import client
+from haplohub_cli.core.deletion import DELETE_MODE_CHOICES, DELETE_MODE_HELP, confirm_hard_delete
 
 from . import report
 
@@ -23,14 +24,14 @@ def list(cohort: str):
 
 @member.command()
 @click.option("--cohort", "-c", type=types.HAPLOHUB_ID, required=True)
-@click.option("--patient-id", "-p", type=str, required=False)
+@click.option("--external-id", "-x", type=str, required=False)
 @click.option("--first-name", "-fn", type=str, required=False)
 @click.option("--last-name", "-ln", type=str, required=False)
 @click.option("--gender", "-g", type=str, required=False)
 @click.option("--birth-date", "-bd", type=str, required=False)
-def create(cohort, patient_id=None, first_name=None, last_name=None, gender=None, birth_date=None):
+def create(cohort, external_id=None, first_name=None, last_name=None, gender=None, birth_date=None):
     request = CreateMemberRequest(
-        patient_id=patient_id,
+        external_id=external_id,
         first_name=first_name,
         last_name=last_name,
         gender=gender,
@@ -42,21 +43,31 @@ def create(cohort, patient_id=None, first_name=None, last_name=None, gender=None
 @member.command()
 @click.argument("id")
 @click.option("--cohort", "-c", type=types.HAPLOHUB_ID, required=True)
-def delete(id, cohort):
-    return client.member.delete_member(cohort, id)
+@click.option(
+    "--mode",
+    "-m",
+    type=click.Choice(DELETE_MODE_CHOICES),
+    default=DeleteMode.SOFT.value,
+    show_default=True,
+    help=DELETE_MODE_HELP,
+)
+@click.option("--yes", "-y", is_flag=True, help="Skip the confirmation prompt for --mode hard.")
+def delete(id, cohort, mode, yes):
+    confirm_hard_delete(mode, "member", id, yes)
+    return client.member.delete_member(cohort, id, mode=mode)
 
 
 @member.command()
 @click.argument("id")
 @click.option("--cohort", "-c", type=types.HAPLOHUB_ID, required=True)
-@click.option("--patient-id", "-p", type=str, required=False)
+@click.option("--external-id", "-x", type=str, required=False)
 @click.option("--first-name", "-fn", type=str, required=False)
 @click.option("--last-name", "-ln", type=str, required=False)
 @click.option("--gender", "-g", type=str, required=False)
 @click.option("--birth-date", "-bd", type=str, required=False)
-def update(id, cohort, patient_id=None, first_name=None, last_name=None, gender=None, birth_date=None):
+def update(id, cohort, external_id=None, first_name=None, last_name=None, gender=None, birth_date=None):
     request = UpdateMemberRequest(
-        patient_id=patient_id,
+        external_id=external_id,
         first_name=first_name,
         last_name=last_name,
         gender=gender,

haplohub_cli-2.6.0/haplohub_cli/commands/cohort/sample.py

@@ -0,0 +1,84 @@
+import click
+from haplohub import CreateSampleRequest, DeleteMode, UpdateSampleRequest
+
+from haplohub_cli.core import types
+from haplohub_cli.core.api.client import client
+from haplohub_cli.core.deletion import DELETE_MODE_CHOICES, DELETE_MODE_HELP, confirm_hard_delete
+
+
+@click.group()
+def sample():
+    """
+    Manage samples
+    """
+    pass
+
+
+@sample.command()
+@click.option("--cohort", "-c", type=types.HAPLOHUB_ID, required=True)
+def list(cohort: str):
+    return client.sample.list_samples(cohort)
+
+
+@sample.command()
+@click.option("--cohort", "-c", type=types.HAPLOHUB_ID, required=True)
+@click.option(
+    "--external-id",
+    "-x",
+    type=click.STRING,
+    required=False,
+    help="Sample identity, uppercase alphanumeric starting with a letter. Generated when omitted.",
+)
+@click.option("--member", "-m", type=types.HAPLOHUB_ID, required=False, help="Member to attach the sample to.")
+@click.option(
+    "--member-external-id",
+    "-xm",
+    type=click.STRING,
+    required=False,
+    help="Member to attach the sample to, by external id. The member is created when it does not exist.",
+)
+def create(cohort, external_id=None, member=None, member_external_id=None):
+    request = CreateSampleRequest(
+        external_id=external_id,
+        member_id=member,
+        member_external_id=member_external_id,
+    )
+    return client.sample.create_sample(cohort, request)
+
+
+@sample.command()
+@click.argument("id")
+@click.option("--cohort", "-c", type=types.HAPLOHUB_ID, required=True)
+@click.option(
+    "--mode",
+    "-m",
+    type=click.Choice(DELETE_MODE_CHOICES),
+    default=DeleteMode.SOFT.value,
+    show_default=True,
+    help=DELETE_MODE_HELP,
+)
+@click.option("--yes", "-y", is_flag=True, help="Skip the confirmation prompt for --mode hard.")
+def delete(id, cohort, mode, yes):
+    confirm_hard_delete(mode, "sample", id, yes)
+    return client.sample.delete_sample(cohort, id, mode=mode)
+
+
+@sample.command()
+@click.argument("id")
+@click.option("--cohort", "-c", type=types.HAPLOHUB_ID, required=True)
+@click.option("--member", "-m", type=types.HAPLOHUB_ID, required=False, help="Member to attach the sample to.")
+@click.option(
+    "--member-external-id",
+    "-xm",
+    type=click.STRING,
+    required=False,
+    help="Member to attach the sample to, by external id.",
+)
+def update(id, cohort, member=None, member_external_id=None):
+    # external_id is the sample's immutable identity, embedded in the BCFs; only the
+    # member association can be changed.
+    request = UpdateSampleRequest(
+        member_id=member,
+        member_external_id=member_external_id,
+    )
+    return client.sample.update_sample(cohort, id, request)

haplohub_cli-2.6.0/haplohub_cli/commands/cohort/tests/test_delete.py

@@ -0,0 +1,88 @@
+from unittest import TestCase
+from unittest.mock import patch
+
+from click.testing import CliRunner
+
+from haplohub_cli.commands.cohort.member import member
+from haplohub_cli.commands.cohort.sample import sample
+
+COHORT = "coh-abc123"
+MEMBER = "mbr-abc123"
+SAMPLE = "smp-abc123"
+
+
+class DeleteMemberTestCase(TestCase):
+    def setUp(self):
+        self.runner = CliRunner()
+
+    def run_delete(self, *args, input=None):
+        with patch("haplohub_cli.commands.cohort.member.client") as client:
+            result = self.runner.invoke(member, ["delete", MEMBER, "-c", COHORT, *args], input=input)
+        return result, client.member.delete_member
+
+    def test_defaults_to_soft(self):
+        result, delete_member = self.run_delete()
+
+        self.assertEqual(result.exit_code, 0, result.output)
+        delete_member.assert_called_once_with(COHORT, MEMBER, mode="soft")
+
+    def test_cascade_needs_no_confirmation(self):
+        result, delete_member = self.run_delete("--mode", "cascade")
+
+        self.assertEqual(result.exit_code, 0, result.output)
+        delete_member.assert_called_once_with(COHORT, MEMBER, mode="cascade")
+
+    def test_hard_asks_for_confirmation(self):
+        result, delete_member = self.run_delete("--mode", "hard", input="y\n")
+
+        self.assertEqual(result.exit_code, 0, result.output)
+        self.assertIn("cannot be undone", result.output)
+        delete_member.assert_called_once_with(COHORT, MEMBER, mode="hard")
+
+    def test_hard_aborts_when_declined(self):
+        result, delete_member = self.run_delete("--mode", "hard", input="n\n")
+
+        self.assertEqual(result.exit_code, 1)
+        delete_member.assert_not_called()
+
+    def test_hard_skips_confirmation_with_yes(self):
+        result, delete_member = self.run_delete("--mode", "hard", "--yes")
+
+        self.assertEqual(result.exit_code, 0, result.output)
+        self.assertNotIn("cannot be undone", result.output)
+        delete_member.assert_called_once_with(COHORT, MEMBER, mode="hard")
+
+    def test_rejects_an_unknown_mode(self):
+        result, delete_member = self.run_delete("--mode", "nuke")
+
+        self.assertEqual(result.exit_code, 2)
+        delete_member.assert_not_called()
+
+
+class DeleteSampleTestCase(TestCase):
+    def setUp(self):
+        self.runner = CliRunner()
+
+    def run_delete(self, *args, input=None):
+        with patch("haplohub_cli.commands.cohort.sample.client") as client:
+            result = self.runner.invoke(sample, ["delete", SAMPLE, "-c", COHORT, *args], input=input)
+        return result, client.sample.delete_sample
+
+    def test_defaults_to_soft(self):
+        result, delete_sample = self.run_delete()
+
+        self.assertEqual(result.exit_code, 0, result.output)
+        delete_sample.assert_called_once_with(COHORT, SAMPLE, mode="soft")
+
+    def test_hard_asks_for_confirmation(self):
+        result, delete_sample = self.run_delete("--mode", "hard", input="y\n")
+
+        self.assertEqual(result.exit_code, 0, result.output)
+        self.assertIn("cannot be undone", result.output)
+        delete_sample.assert_called_once_with(COHORT, SAMPLE, mode="hard")
+
+    def test_hard_aborts_when_declined(self):
+        result, delete_sample = self.run_delete("--mode", "hard", input="n\n")
+
+        self.assertEqual(result.exit_code, 1)
+        delete_sample.assert_not_called()

{haplohub_cli-2.4.0 → haplohub_cli-2.6.0}/haplohub_cli/commands/config.py

@@ -1,5 +1,6 @@
 import click
 
+from haplohub_cli.auth.token_storage import token_storage
 from haplohub_cli.config.config_manager import config_manager
 
 
@@ -28,6 +29,7 @@ def set(key, value):
 @config.command()
 @click.argument("api_url", type=click.STRING)
 def switch(api_url):
+    token_storage.migrate(config_manager.config.api_url)
     config_manager.switch_environment(api_url)
     return config_manager.config
 

{haplohub_cli-2.4.0 → haplohub_cli-2.6.0}/haplohub_cli/commands/file.py

@@ -63,6 +63,21 @@ def download(cohort: str, file_id: str = None, file_path: str = None, output: st
     click.echo(f"File saved to {output}")
 
 
+def _resolve_file_id(cohort: str, file_path: str) -> str:
+    """Look a file up by its location.
+
+    The API deletes by id only - unlike downloads, which have a by-path endpoint - so
+    the path is resolved here to keep --file-path working on both commands.
+    """
+    listing = client.file.list_files(cohort, recursive=True)
+    wanted = file_path.lstrip("/")
+    for entry in listing.result.files:
+        if entry.location == wanted:
+            return entry.id
+
+    raise click.ClickException(f"No file at '{file_path}' in cohort {cohort}.")
+
+
 @file.command()
 @click.option("--cohort", "-c", type=click.STRING, required=True)
 @click.option("--file-id", "-i", type=click.STRING, required=False)
@@ -74,10 +89,10 @@ def delete(cohort: str, file_id: str = None, file_path: str = None):
     if not file_id and not file_path:
         raise click.UsageError("Must specify either --file-id or --file-path")
 
-    if file_id:
-        return client.file.delete_file(cohort, file_id)
+    if not file_id:
+        file_id = _resolve_file_id(cohort, file_path)
 
-    return client.file.delete_file_by_path(cohort, file_path)
+    return client.file.delete_file(cohort, file_id)
 
 
 @file.command()

{haplohub_cli-2.4.0 → haplohub_cli-2.6.0}/haplohub_cli/commands/metadata/__init__.py

@@ -13,4 +13,4 @@ def metadata():
 
 @metadata.command()
 def accession():
-    return client.metadata.list_accession()
+    return client.accession.list_accession()

{haplohub_cli-2.4.0 → haplohub_cli-2.6.0}/haplohub_cli/config/config_manager.py

@@ -37,6 +37,7 @@ class ConfigManager:
             return self._config
 
     def switch_environment(self, api_url: str):
+        api_url = api_url.strip().rstrip("/")
         response = requests.get(f"{api_url}/api/v1/config/")
         response.raise_for_status()
         data = response.json()
@@ -44,7 +45,7 @@ class ConfigManager:
         if data["status"] != "success":
             raise Exception(data.get("error", "Unknown error"))
 
-        new_config = {"redirect_port": settings.REDIRECT_PORT, "api_url": api_url, **data["result"]["cli"]}
+        new_config = {**data["result"]["cli"], "redirect_port": settings.REDIRECT_PORT, "api_url": api_url}
 
         self._config = Config(**new_config)
 

{haplohub_cli-2.4.0 → haplohub_cli-2.6.0}/haplohub_cli/core/api/client.py

@@ -1,6 +1,8 @@
 from functools import cached_property
 
+import click
 from haplohub import (
+    AccessionApi,
     AlgorithmApi,
     AlgorithmResultApi,
     ApiClient,
@@ -25,15 +27,20 @@ class Client:
 
     @cached_property
     def client(self):
-        if self.token_storage.has_api_key:
+        api_url = config_manager.config.api_url
+
+        if not self.token_storage.credentials_exist(api_url):
+            raise click.ClickException(f"No credentials found for {api_url}. Run `haplohub login` first.")
+
+        if self.token_storage.has_api_key(api_url):
             config = Configuration(
-                host=config_manager.config.api_url,
-                api_key={"ApiKeyAuth": self.token_storage.get_api_key()},
+                host=api_url,
+                api_key={"ApiKeyAuth": self.token_storage.get_api_key(api_url)},
             )
         else:
             config = Configuration(
-                host=config_manager.config.api_url,
-                access_token=self.token_storage.get_access_token(),
+                host=api_url,
+                access_token=self.token_storage.get_access_token(api_url),
             )
         return ApiClient(config)
 
@@ -77,5 +84,9 @@ class Client:
     def algorithm_result(self):
         return AlgorithmResultApi(self.client)
 
+    @cached_property
+    def accession(self):
+        return AccessionApi(self.client)
+
 
 client = Client()

haplohub_cli-2.6.0/haplohub_cli/core/deletion.py

@@ -0,0 +1,28 @@
+import click
+from haplohub import DeleteMode
+
+# The generated client drops `mode` straight into the query string, so the commands pass
+# the plain value rather than the enum member.
+DELETE_MODE_CHOICES = [mode.value for mode in DeleteMode]
+
+DELETE_MODE_HELP = (
+    "How far the delete reaches. "
+    "soft: the record only. "
+    "cascade: the record plus everything derived from it, files included; recoverable. "
+    "hard: irreversible, erases the records permanently and removes every version of their files."
+)
+
+
+def confirm_hard_delete(mode: str, entity: str, identifier: str, assume_yes: bool) -> None:
+    """Guard `--mode hard`, which cannot be undone.
+
+    Softer modes leave the rows recoverable and the blobs restorable, so they go through
+    without a prompt.
+    """
+    if mode != DeleteMode.HARD.value or assume_yes:
+        return
+
+    click.confirm(
+        f"Permanently erase {entity} {identifier} and every version of its files? This cannot be undone.",
+        abort=True,
+    )