cellismo-cli 0.1.0__tar.gz

cellismo_cli-0.1.0/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: cellismo-cli
+Version: 0.1.0
+Summary: Cellismo file upload CLI
+Requires-Python: >=3.12
+Requires-Dist: click>=8.1
+Requires-Dist: requests>=2.32

cellismo_cli-0.1.0/README.md

@@ -0,0 +1,105 @@
+# cellismo-cli
+
+A command-line tool for uploading files to the Cellismo platform.
+
+## Installation
+
+```bash
+pip install cellismo-cli
+```
+
+## Usage
+
+### Login
+
+Authenticate against your Cellismo server and save credentials locally:
+
+```bash
+cellismo login
+```
+
+You will be prompted for:
+- **Email**
+- **Password**
+
+Credentials are saved to `~/.cellismo/config.json`.
+
+### Upload files
+
+Upload one or more local files to a project:
+
+```bash
+cellismo upload --project <project_id> file1.fastq.gz file2.fastq.gz
+```
+
+Options:
+- `--project` (required) — the project ID to upload files into
+- `--threads` (optional) — number of parallel upload threads (default: auto, clamped to 10–30)
+
+## Local Development
+
+```bash
+cd cellismo-cli
+
+# Install in editable mode — makes the `cellismo` command available immediately
+# and reflects code changes without reinstalling
+pip install -e .
+
+# Or build a distributable wheel/sdist
+python -m build
+pip install dist/cellismo_cli-*.whl
+```
+
+## Publishing to PyPI
+
+### Prerequisites
+
+```bash
+pip install build twine
+```
+
+### 1. Update metadata
+
+Before publishing, fill in author info in `pyproject.toml`:
+
+```toml
+[project]
+authors = [{ name = "Your Name", email = "you@example.com" }]
+license = { text = "MIT" }
+```
+
+### 2. Build the distribution
+
+```bash
+cd cellismo-cli
+python -m build
+# Produces dist/cellismo_cli-0.1.0-py3-none-any.whl and dist/cellismo_cli-0.1.0.tar.gz
+```
+
+### 3. (Optional) Test on TestPyPI first
+
+```bash
+twine upload --repository testpypi dist/*
+```
+
+Install from TestPyPI to verify:
+
+```bash
+pip install --index-url https://test.pypi.org/simple/ cellismo-cli
+```
+
+### 4. Publish to PyPI
+
+```bash
+twine upload dist/*
+```
+
+You will be prompted for your PyPI username and password. Using an API token is recommended — generate one at [pypi.org](https://pypi.org) under Account Settings → API tokens.
+
+After publishing, users can install with:
+
+```bash
+pip install cellismo-cli
+```
+
+> **Note:** Check [pypi.org/project/cellismo-cli](https://pypi.org/project/cellismo-cli) to confirm the package name is available before publishing. For internal tools, consider a private PyPI registry (e.g., AWS CodeArtifact, Artifactory, or a self-hosted devpi).

cellismo_cli-0.1.0/cellismo_cli/api_client.py

@@ -0,0 +1,103 @@
+import requests
+
+
+class ApiError(Exception):
+    def __init__(self, status: int, code: str, message: str) -> None:
+        super().__init__(message)
+        self.status = status
+        self.code = code
+        self.message = message
+
+
+class ApiClient:
+    def __init__(self, base_url: str, token: str | None) -> None:
+        self._base = base_url.rstrip("/")
+        self._token = token
+
+    def _headers(self) -> dict[str, str]:
+        h: dict[str, str] = {"Content-Type": "application/json"}
+        if self._token:
+            h["Authorization"] = f"Bearer {self._token}"
+        return h
+
+    def _raise_for(self, r: requests.Response) -> None:
+        if r.ok:
+            return
+        try:
+            err = r.json().get("error", {})
+            if isinstance(err, dict):
+                code = err.get("code", "unknown")
+                message = err.get("message", r.text)
+            else:
+                code = "unknown"
+                message = r.text
+        except Exception:
+            code = "unknown"
+            message = r.text
+        raise ApiError(r.status_code, code, message)
+
+    def issue_token(self, email: str, password: str) -> str:
+        r = requests.post(f"{self._base}/api/cli/auth/token",
+                          json={"email": email, "password": password},
+                          headers=self._headers())
+        self._raise_for(r)
+        return r.json()["token"]
+
+    def register_file(self, *, project_id: str, filename: str, size_bytes: int) -> str:
+        r = requests.post(f"{self._base}/api/cli/files/register",
+                          json={"project_id": project_id, "filename": filename,
+                                "size_bytes": size_bytes},
+                          headers=self._headers())
+        self._raise_for(r)
+        return r.json()["file_id"]
+
+    def upload_start(self, file_id: str, total_parts: int) -> str:
+        r = requests.post(f"{self._base}/api/cli/files/{file_id}/upload/start",
+                          json={"total_parts": total_parts},
+                          headers=self._headers())
+        self._raise_for(r)
+        return r.json()["upload_id"]
+
+    def get_presigned_urls(self, file_id: str, parts_info: list[dict], url_expire_time: int = 600) -> tuple[dict, float]:
+        r = requests.post(f"{self._base}/api/cli/files/{file_id}/upload/presigned-urls",
+                          json={"parts_info": parts_info, "url_expire_time": url_expire_time},
+                          headers=self._headers())
+        self._raise_for(r)
+        data = r.json()
+        return data["urls"], float(data["expires_at"])
+
+    def report_progress(self, file_id: str, parts_completed: int) -> bool:
+        """Returns True if the server reports the upload was cancelled."""
+        r = requests.post(f"{self._base}/api/cli/files/{file_id}/progress",
+                          json={"parts_completed": parts_completed},
+                          headers=self._headers())
+        self._raise_for(r)
+        return bool(r.json().get("cancelled", False))
+
+    def complete_upload(self, file_id: str, parts: list[dict]) -> None:
+        r = requests.post(f"{self._base}/api/cli/files/{file_id}/upload/complete",
+                          json={"parts": parts},
+                          headers=self._headers())
+        self._raise_for(r)
+
+    def verify_upload(self, file_id: str) -> str:
+        """Returns the S3 composite SHA-256 checksum for the completed upload."""
+        r = requests.get(f"{self._base}/api/cli/files/{file_id}/upload/verify",
+                         headers=self._headers())
+        self._raise_for(r)
+        return r.json()["checksum_sha256"]
+
+    def abort_upload(self, file_id: str) -> None:
+        try:
+            r = requests.post(f"{self._base}/api/cli/files/{file_id}/upload/abort",
+                              headers=self._headers())
+            self._raise_for(r)
+        except Exception:
+            pass  # best-effort abort
+
+    def list_project_files(self, project_id: str) -> list[dict]:
+        r = requests.get(f"{self._base}/api/cli/projects/{project_id}/files",
+                         headers=self._headers())
+        self._raise_for(r)
+        return r.json()["files"]
+

cellismo_cli-0.1.0/cellismo_cli/commands/login.py

@@ -0,0 +1,29 @@
+import click
+
+from cellismo_cli import config
+from cellismo_cli.api_client import ApiClient, ApiError
+
+
+@click.command()
+@click.option("--new", "force_new", is_flag=True, default=False, help="Force re-authentication even if already logged in.")
+def login(force_new):
+    """Authenticate with a Cellismo server and save credentials locally."""
+    if not force_new:
+        cfg = config.load()
+        if cfg and cfg.get("token") and cfg.get("base_url"):
+            click.echo("Already logged in. Use --new to authenticate again.")
+            return
+
+    # TODO: should be replaced with the real backend URL
+    base_url = "http://localhost:8000"
+    email = click.prompt("Email")
+    password = click.prompt("Password", hide_input=True)
+
+    client = ApiClient(base_url=base_url, token=None)
+    try:
+        token = client.issue_token(email, password)
+    except ApiError as e:
+        raise click.ClickException(e.message)
+
+    config.save(token, base_url)
+    click.echo(f"Logged in as {email}. Credentials saved to ~/.cellismo/config.json")

cellismo_cli-0.1.0/cellismo_cli/commands/upload.py

@@ -0,0 +1,111 @@
+import os
+import signal
+
+import click
+
+from cellismo_cli import config
+from cellismo_cli.api_client import ApiClient, ApiError
+from cellismo_cli.uploader import upload_file, MAX_FILE_SIZE, UploadCancelledError
+
+MIN_THREADS = 10
+MAX_THREADS = 30
+
+
+@click.command()
+@click.option("--project", required=True, help="Project ID to upload files into.")
+@click.option("--threads", type=int, default=None, help="Number of upload threads.")
+@click.argument("files", nargs=-1, required=True)
+def upload(project, threads, files):
+    """Upload files to the given project in Cellismo."""
+    cfg = config.require()
+    client = ApiClient(base_url=cfg["base_url"], token=cfg["token"])
+
+    if threads is None:
+        threads = max((os.cpu_count() or 4) * 3, MIN_THREADS)
+        threads = min(threads, MAX_THREADS)
+
+    try:
+        existing_files = client.list_project_files(project)
+    except ApiError as e:
+        if e.status == 401:
+            raise click.ClickException(
+                "Session expired or invalid. Run `cellismo login --new` to create a new authentication."
+            )
+        raise click.ClickException(f"Failed to fetch project files: {e.message}")
+
+    existing_by_name: dict[str, str] = {f["filename"]: f["file_id"] for f in existing_files}
+
+    for file_path in files:
+        if not os.path.exists(file_path):
+            click.echo(f"✗ Skipping {file_path} — file not found locally")
+            continue
+
+        file_size = os.path.getsize(file_path)
+        if file_size > MAX_FILE_SIZE:
+            click.echo(f"✗ Skipping {file_path} — file too large (max 48.8 TB)")
+            continue
+
+        filename = os.path.basename(file_path)
+
+        if filename in existing_by_name:
+            overwrite = click.confirm(
+                f"  '{filename}' already exists in this project. Overwrite?", default=False
+            )
+            if overwrite:
+                # Delete the existing file
+                client.abort_upload(existing_by_name[filename])
+            else:
+                click.echo(f"✗ Skipping {filename} — not overwriting")
+                continue
+    
+        try:
+            # Register the file information into database
+            file_id = client.register_file(
+                project_id=project, filename=filename, size_bytes=file_size
+            )
+        except ApiError as e:
+            if e.status == 403:
+                click.echo(f"✗ Skipping {filename} — you don't have access to project {project}")
+            elif e.status == 401:
+                raise click.ClickException(
+                    "Session expired or invalid. Run `cellismo login --new` to create a new authentication."
+                )
+            else:
+                click.echo(f"✗ Skipping {filename} — {e.message}")
+            continue
+
+        click.echo(f"\nUploading {filename} (file ID: {file_id})")
+
+        def on_progress(parts_done: int, total_parts: int) -> bool:
+            try:
+                return client.report_progress(file_id, parts_done)
+            except Exception:
+                return False
+
+        try:
+            success = upload_file(
+                file_path=file_path,
+                file_id=file_id,
+                api_client=client,
+                num_threads=threads,
+                on_progress=on_progress,
+            )
+            if success:
+                click.echo(f"✓ {filename} uploaded successfully")
+            else:
+                click.echo(f"✗ {filename} upload failed")
+        except UploadCancelledError:
+            client.abort_upload(file_id)
+            click.echo(f"\n✗ {filename} upload cancelled from the web UI")
+        except KeyboardInterrupt:
+            # to make pressing any more ctrl+c do nothing
+            signal.signal(signal.SIGINT, signal.SIG_IGN)
+            click.echo(f"\n✗ Upload interrupted — aborting {filename}")
+            try:
+                client.abort_upload(file_id)
+            except Exception:
+                pass
+            raise SystemExit(1)
+        except Exception as e:
+            click.echo(f"✗ {filename} upload failed: {e}")
+            client.abort_upload(file_id)

cellismo_cli-0.1.0/cellismo_cli/config.py

@@ -0,0 +1,25 @@
+import json
+from pathlib import Path
+
+_CONFIG_PATH = Path.home() / ".cellismo" / "config.json"
+
+
+def load() -> dict | None:
+    if not _CONFIG_PATH.exists():
+        return None
+    try:
+        return json.loads(_CONFIG_PATH.read_text())
+    except (json.JSONDecodeError, OSError):
+        return None
+
+
+def save(token: str, base_url: str) -> None:
+    _CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
+    _CONFIG_PATH.write_text(json.dumps({"token": token, "base_url": base_url}))
+
+
+def require() -> dict:
+    cfg = load()
+    if cfg is None:
+        raise SystemExit("Not logged in. Run `cellismo login` first.")
+    return cfg

cellismo_cli-0.1.0/cellismo_cli/main.py

@@ -0,0 +1,13 @@
+import click
+
+from cellismo_cli.commands.login import login
+from cellismo_cli.commands.upload import upload
+
+
+@click.group()
+def cli():
+    """Cellismo CLI — upload files to your projects."""
+
+
+cli.add_command(login)
+cli.add_command(upload)

cellismo_cli-0.1.0/cellismo_cli/uploader.py

@@ -0,0 +1,227 @@
+import base64
+import hashlib
+import math
+import os
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from threading import Event, Thread
+
+import requests
+
+from cellismo_cli.api_client import ApiError
+
+class UploadCancelledError(Exception):
+    pass
+
+
+CANCEL_POLL_INTERVAL = 2  # seconds between background cancellation checks
+UPLOAD_CHUNK_SIZE = 256 * 1024  # 256 KiB — abort is checked between chunks
+
+PART_SIZE_MIN = 5 * 1024 * 1024          # 5 MiB
+PART_SIZE_MAX = 5 * 1024 * 1024 * 1024   # 5 GiB
+PART_COUNT_MAX = 10_000
+MAX_FILE_SIZE = int(48.8 * 1024**4)
+MAX_RETRY = 10
+URL_EXPIRE_TIME = 600
+URL_EXPIRE_BUFFER = 30  # seconds before expiry to refresh URLs
+
+
+def get_part_num_size(file_size: int) -> tuple[int, int]:
+    minimum = math.ceil(file_size / PART_COUNT_MAX)
+    part_size = max(minimum, PART_SIZE_MIN)
+    part_size = min(part_size, PART_SIZE_MAX)
+    number_of_parts = math.ceil(file_size / part_size)
+    return number_of_parts, part_size
+
+
+def compute_checksums(file_path: str, part_size: int, number_of_parts: int) -> dict[int, tuple[bytes, str]]:
+    checksums: dict[int, tuple[bytes, str]] = {}
+    with open(file_path, "rb") as f:
+        for pn in range(1, number_of_parts + 1):
+            f.seek((pn - 1) * part_size)
+            data = f.read(part_size)
+            raw = hashlib.sha256(data).digest()
+            checksums[pn] = (raw, base64.b64encode(raw).decode())
+    return checksums
+
+
+def _upload_part(
+    part_number: int,
+    file_path: str,
+    part_size: int,
+    presigned_url: str,
+    checksum_b64: str,
+    urls_expire_at: float,
+    abort_event: Event,
+    url_expire_event: Event,
+) -> dict:
+    if abort_event.is_set():
+        return {"PartNumber": part_number, "Failed": True}
+    if url_expire_event.is_set() or time.time() >= urls_expire_at - URL_EXPIRE_BUFFER:
+        url_expire_event.set()
+        return {"Expired": True, "PartNumber": part_number}
+    try:
+        with open(file_path, "rb") as f:
+            f.seek((part_number - 1) * part_size)
+            data = f.read(part_size)
+
+        r = requests.put(
+            presigned_url,
+            data=data,
+            headers={
+                "x-amz-checksum-sha256": checksum_b64,
+                "x-amz-sdk-checksum-algorithm": "SHA256",
+            },
+        )
+        if abort_event.is_set():
+            return {"PartNumber": part_number, "Failed": True}
+        if r.status_code == 403:
+            url_expire_event.set()
+            return {"Expired": True, "PartNumber": part_number}
+        if not r.ok:
+            r.raise_for_status()
+    except Exception as e:
+        print(f"\n  [part {part_number} error] {type(e).__name__}: {e}")
+        return {"PartNumber": part_number, "Failed": True}
+    return {"PartNumber": part_number, "ETag": r.headers["ETag"], "ChecksumSHA256": checksum_b64}
+
+
+def upload_file(
+    file_path: str,
+    file_id: str,
+    api_client,
+    num_threads: int,
+    on_progress=None,
+) -> bool:
+    """Upload a single file. Returns True on success, False on failure."""
+    file_size = os.path.getsize(file_path)
+    if file_size > MAX_FILE_SIZE:
+        print(f"  ✗ Skipping {file_path} — file too large (max 48.8 TB)")
+        return False
+
+    number_of_parts, part_size = get_part_num_size(file_size)
+    try:
+        api_client.upload_start(file_id, total_parts=number_of_parts)
+    except ApiError as e:
+        if e.code == "cancelled":
+            raise UploadCancelledError()
+        raise
+    checksums = compute_checksums(file_path, part_size, number_of_parts)
+
+    # check whether file upload is cancelled on the frontend before going into the while loop
+    try:
+        if api_client.report_progress(file_id, 0):
+            raise UploadCancelledError()
+    except ApiError as e:
+        if e.code == "cancelled":
+            raise UploadCancelledError()
+        raise
+
+    unsorted: dict[int, dict] = {}
+    remaining = set(range(1, number_of_parts + 1))
+    completed: set[int] = set()
+    failed_counts: dict[int, int] = {}
+    num_attempt = 1
+
+    print("  Preparing...", end="", flush=True)
+    abort_event = Event()
+    stop_poll = Event()
+
+    def _poll_cancel():
+        while not stop_poll.wait(CANCEL_POLL_INTERVAL):
+            try:
+                cancelled = api_client.report_progress(file_id, len(completed))
+            except Exception:
+                continue
+            if cancelled:
+                abort_event.set()
+                break
+
+    poll_thread = Thread(target=_poll_cancel, daemon=True)
+    poll_thread.start()
+
+    try:
+        while remaining:
+            url_expire_event = Event()
+
+            parts_info = [
+                {"part_number": pn, "checksum_sha256": checksums[pn][1]}
+                for pn in sorted(remaining)
+            ]
+            try:
+                urls_dict, expires_at = api_client.get_presigned_urls(
+                    file_id, parts_info, url_expire_time=URL_EXPIRE_TIME * num_attempt
+                )
+            except ApiError as e:
+                if e.code == "cancelled":
+                    raise UploadCancelledError()
+                raise
+            urls = {int(k): v for k, v in urls_dict.items()}
+
+            pool = ThreadPoolExecutor(max_workers=num_threads)
+            try:
+                futures = [
+                    pool.submit(
+                        _upload_part, pn, file_path, part_size,
+                        urls[pn], checksums[pn][1], expires_at, abort_event, url_expire_event,
+                    )
+                    for pn in sorted(remaining)
+                ]
+                for future in as_completed(futures):
+                    if abort_event.is_set():
+                        pool.shutdown(wait=False, cancel_futures=True)
+                        raise UploadCancelledError()
+
+                    result = future.result()
+                    if result.get("Failed"):
+                        pn = result["PartNumber"]
+                        failed_counts[pn] = failed_counts.get(pn, 0) + 1
+                        if max(failed_counts.values()) >= MAX_RETRY:
+                            abort_event.set()
+                            pool.shutdown(wait=False, cancel_futures=True)
+                            api_client.abort_upload(file_id)
+                            return False
+                    elif result.get("Expired"):
+                        continue
+                    else:
+                        pn = result["PartNumber"]
+                        unsorted[pn] = result
+                        remaining.discard(pn)
+                        completed.add(pn)
+                        pct = len(completed) * 100 // number_of_parts
+                        if on_progress:
+                            cancelled = on_progress(len(completed), number_of_parts)
+                            if cancelled:
+                                abort_event.set()
+                                pool.shutdown(wait=False, cancel_futures=True)
+                                raise UploadCancelledError()
+                        filled = pct * 50 // 100
+                        bar = "█" * filled + "░" * (50 - filled)
+                        print(f"\r  |{bar}| {pct}%", end="", flush=True)
+            except KeyboardInterrupt:
+                abort_event.set()
+                pool.shutdown(wait=False, cancel_futures=True)
+                raise
+            else:
+                pool.shutdown(wait=True)
+
+            if abort_event.is_set():
+                raise UploadCancelledError()
+
+            num_attempt += 1
+    finally:
+        stop_poll.set()
+        poll_thread.join()
+
+    parts = [unsorted[pn] for pn in range(1, number_of_parts + 1)]
+    api_client.complete_upload(file_id, parts)
+
+    part_raw_digests = b"".join(checksums[pn][0] for pn in range(1, number_of_parts + 1))
+    composite = base64.b64encode(hashlib.sha256(part_raw_digests).digest()).decode()
+    local_checksum = f"{composite}-{number_of_parts}"
+    s3_checksum = api_client.verify_upload(file_id)
+    if local_checksum != s3_checksum:
+        raise RuntimeError(f"Checksum mismatch: local={local_checksum} s3={s3_checksum}")
+    print(f"\n  ✓ Integrity OK: {local_checksum}")
+
+    return True

cellismo_cli-0.1.0/cellismo_cli.egg-info/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: cellismo-cli
+Version: 0.1.0
+Summary: Cellismo file upload CLI
+Requires-Python: >=3.12
+Requires-Dist: click>=8.1
+Requires-Dist: requests>=2.32

cellismo_cli-0.1.0/cellismo_cli.egg-info/SOURCES.txt

@@ -0,0 +1,21 @@
+README.md
+pyproject.toml
+cellismo_cli/__init__.py
+cellismo_cli/api_client.py
+cellismo_cli/config.py
+cellismo_cli/main.py
+cellismo_cli/uploader.py
+cellismo_cli.egg-info/PKG-INFO
+cellismo_cli.egg-info/SOURCES.txt
+cellismo_cli.egg-info/dependency_links.txt
+cellismo_cli.egg-info/entry_points.txt
+cellismo_cli.egg-info/requires.txt
+cellismo_cli.egg-info/top_level.txt
+cellismo_cli/commands/__init__.py
+cellismo_cli/commands/login.py
+cellismo_cli/commands/upload.py
+tests/test_api_client.py
+tests/test_config.py
+tests/test_login_command.py
+tests/test_upload_command.py
+tests/test_uploader.py

cellismo_cli-0.1.0/cellismo_cli.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

cellismo_cli-0.1.0/cellismo_cli.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+cellismo = cellismo_cli.main:cli

cellismo_cli-0.1.0/cellismo_cli.egg-info/requires.txt

@@ -0,0 +1,2 @@
+click>=8.1
+requests>=2.32

cellismo_cli-0.1.0/cellismo_cli.egg-info/top_level.txt

@@ -0,0 +1 @@
+cellismo_cli

cellismo_cli-0.1.0/pyproject.toml

@@ -0,0 +1,25 @@
+[project]
+name = "cellismo-cli"
+version = "0.1.0"
+description = "Cellismo file upload CLI"
+requires-python = ">=3.12"
+dependencies = [
+  "click>=8.1",
+  "requests>=2.32",
+]
+
+[project.scripts]
+cellismo = "cellismo_cli.main:cli"
+
+[build-system]
+requires = ["setuptools>=75"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["cellismo_cli*"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]
+addopts = "-ra"

cellismo_cli-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

cellismo_cli-0.1.0/tests/test_api_client.py

@@ -0,0 +1,41 @@
+import pytest
+import responses as resp_lib
+from cellismo_cli.api_client import ApiClient, ApiError
+
+
+@resp_lib.activate
+def test_issue_token_success():
+    resp_lib.add(resp_lib.POST, "http://backend/api/cli/auth/token",
+                 json={"token": "raw-tok-123"}, status=200)
+    client = ApiClient(base_url="http://backend", token=None)
+    token = client.issue_token("user@x.com", "pass")
+    assert token == "raw-tok-123"
+
+
+@resp_lib.activate
+def test_issue_token_401_raises():
+    resp_lib.add(resp_lib.POST, "http://backend/api/cli/auth/token",
+                 json={"error": {"code": "invalid_credentials", "message": "bad"}}, status=401)
+    client = ApiClient(base_url="http://backend", token=None)
+    with pytest.raises(ApiError) as exc_info:
+        client.issue_token("user@x.com", "wrong")
+    assert exc_info.value.status == 401
+
+
+@resp_lib.activate
+def test_register_file_success():
+    resp_lib.add(resp_lib.POST, "http://backend/api/cli/files/register",
+                 json={"file_id": "fid-abc"}, status=200)
+    client = ApiClient(base_url="http://backend", token="tok")
+    fid = client.register_file(project_id="proj1", filename="r.gz", size_bytes=1000)
+    assert fid == "fid-abc"
+
+
+@resp_lib.activate
+def test_register_file_403_raises():
+    resp_lib.add(resp_lib.POST, "http://backend/api/cli/files/register",
+                 json={"error": {"code": "forbidden", "message": "no access"}}, status=403)
+    client = ApiClient(base_url="http://backend", token="tok")
+    with pytest.raises(ApiError) as exc_info:
+        client.register_file(project_id="p", filename="f", size_bytes=1)
+    assert exc_info.value.status == 403

cellismo_cli-0.1.0/tests/test_config.py

@@ -0,0 +1,29 @@
+import pytest
+from unittest.mock import patch
+from cellismo_cli import config
+
+
+def test_load_returns_none_when_file_missing(tmp_path):
+    with patch.object(config, "_CONFIG_PATH", tmp_path / "config.json"):
+        assert config.load() is None
+
+
+def test_save_and_load_roundtrip(tmp_path):
+    with patch.object(config, "_CONFIG_PATH", tmp_path / ".cellismo" / "config.json"):
+        config.save("mytoken", "http://localhost:8000")
+        cfg = config.load()
+    assert cfg == {"token": "mytoken", "base_url": "http://localhost:8000"}
+
+
+def test_require_exits_when_no_config(tmp_path):
+    with patch.object(config, "_CONFIG_PATH", tmp_path / "config.json"):
+        with pytest.raises(SystemExit):
+            config.require()
+
+
+def test_require_returns_config_when_present(tmp_path):
+    p = tmp_path / ".cellismo" / "config.json"
+    with patch.object(config, "_CONFIG_PATH", p):
+        config.save("tok", "http://x")
+        cfg = config.require()
+    assert cfg["token"] == "tok"

cellismo_cli-0.1.0/tests/test_login_command.py

@@ -0,0 +1,29 @@
+import pytest
+from click.testing import CliRunner
+from unittest.mock import patch, MagicMock
+from cellismo_cli.main import cli
+
+
+def test_login_saves_config_on_success():
+    runner = CliRunner()
+    with patch("cellismo_cli.commands.login.ApiClient") as MockClient, \
+         patch("cellismo_cli.commands.login.config") as mock_cfg:
+        mock_instance = MagicMock()
+        mock_instance.issue_token.return_value = "raw-tok-abc"
+        MockClient.return_value = mock_instance
+        result = runner.invoke(cli, ["login"], input="http://localhost:8000\nuser@x.com\nmypass\n")
+    assert result.exit_code == 0
+    mock_cfg.save.assert_called_once_with("raw-tok-abc", "http://localhost:8000")
+    assert "Logged in" in result.output
+
+
+def test_login_prints_error_on_bad_credentials():
+    runner = CliRunner()
+    with patch("cellismo_cli.commands.login.ApiClient") as MockClient:
+        from cellismo_cli.api_client import ApiError
+        mock_instance = MagicMock()
+        mock_instance.issue_token.side_effect = ApiError(401, "invalid_credentials", "Invalid email or password.")
+        MockClient.return_value = mock_instance
+        result = runner.invoke(cli, ["login"], input="http://localhost:8000\nuser@x.com\nbad\n")
+    assert result.exit_code != 0
+    assert "Invalid" in result.output or "invalid" in result.output

cellismo_cli-0.1.0/tests/test_upload_command.py

@@ -0,0 +1,43 @@
+import os
+import tempfile
+import pytest
+from click.testing import CliRunner
+from unittest.mock import patch, MagicMock
+from cellismo_cli.main import cli
+
+
+def test_upload_exits_if_not_logged_in(tmp_path):
+    runner = CliRunner()
+    with patch("cellismo_cli.commands.upload.config") as mock_cfg:
+        mock_cfg.require.side_effect = SystemExit("Not logged in. Run `cellismo login` first.")
+        f = tmp_path / "file.gz"
+        f.write_bytes(b"x")
+        result = runner.invoke(cli, ["upload", "--project", "proj1", str(f)])
+    assert result.exit_code != 0
+
+
+def test_upload_skips_missing_file(tmp_path):
+    runner = CliRunner()
+    with patch("cellismo_cli.commands.upload.config") as mock_cfg, \
+         patch("cellismo_cli.commands.upload.ApiClient"):
+        mock_cfg.require.return_value = {"token": "tok", "base_url": "http://x"}
+        result = runner.invoke(cli, ["upload", "--project", "proj1",
+                                     str(tmp_path / "nonexistent.gz")])
+    assert "Skipping" in result.output
+    assert "not found" in result.output
+
+
+def test_upload_skips_on_403(tmp_path):
+    runner = CliRunner()
+    f = tmp_path / "reads.gz"
+    f.write_bytes(b"data")
+    with patch("cellismo_cli.commands.upload.config") as mock_cfg, \
+         patch("cellismo_cli.commands.upload.ApiClient") as MockClient:
+        mock_cfg.require.return_value = {"token": "tok", "base_url": "http://x"}
+        from cellismo_cli.api_client import ApiError
+        mock_instance = MagicMock()
+        mock_instance.register_file.side_effect = ApiError(403, "forbidden", "no access")
+        MockClient.return_value = mock_instance
+        result = runner.invoke(cli, ["upload", "--project", "proj1", str(f)])
+    assert "Skipping" in result.output
+    assert "access" in result.output.lower()

cellismo_cli-0.1.0/tests/test_uploader.py

@@ -0,0 +1,49 @@
+import hashlib
+import base64
+import os
+import tempfile
+from cellismo_cli.uploader import get_part_num_size, compute_checksums, PART_SIZE_MIN
+
+
+def test_get_part_num_size_small_file():
+    num, size = get_part_num_size(1024)
+    assert size == PART_SIZE_MIN
+    assert num == 1
+
+
+def test_get_part_num_size_large_file():
+    file_size = 100 * 1024 * 1024  # 100 MB
+    num, size = get_part_num_size(file_size)
+    assert num * size >= file_size
+    assert num <= 10_000
+
+
+def test_compute_checksums_single_part():
+    data = b"hello world"
+    with tempfile.NamedTemporaryFile(delete=False) as f:
+        f.write(data)
+        path = f.name
+    try:
+        checksums = compute_checksums(path, part_size=len(data) + 1, number_of_parts=1)
+        raw, b64 = checksums[1]
+        expected_raw = hashlib.sha256(data).digest()
+        assert raw == expected_raw
+        assert b64 == base64.b64encode(expected_raw).decode()
+    finally:
+        os.unlink(path)
+
+
+def test_compute_checksums_two_parts():
+    data = b"a" * 10 + b"b" * 10
+    with tempfile.NamedTemporaryFile(delete=False) as f:
+        f.write(data)
+        path = f.name
+    try:
+        checksums = compute_checksums(path, part_size=10, number_of_parts=2)
+        assert len(checksums) == 2
+        r1, _ = checksums[1]
+        r2, _ = checksums[2]
+        assert r1 == hashlib.sha256(b"a" * 10).digest()
+        assert r2 == hashlib.sha256(b"b" * 10).digest()
+    finally:
+        os.unlink(path)