riffsdk 0.2.0__tar.gz → 0.3.0__tar.gz

riffsdk-0.3.0/CHANGELOG.md

@@ -0,0 +1,39 @@
+# CHANGELOG
+
+<!-- version list -->
+
+## v0.3.0 (2026-06-10)
+
+### Features
+
+- Add CLI for upload, download, and file management
+  ([#8](https://github.com/databutton/riff-sdk-python/pull/8),
+  [`dd09191`](https://github.com/databutton/riff-sdk-python/commit/dd0919119f111c6a779a6933fb16f2425c52de20))
+
+
+## v0.2.1 (2026-06-10)
+
+### Bug Fixes
+
+- Update download-url endpoint path to /v1/storage/download-url/:key
+  ([#7](https://github.com/databutton/riff-sdk-python/pull/7),
+  [`fd06ef6`](https://github.com/databutton/riff-sdk-python/commit/fd06ef62436c861d482d8ce8e530a23572d1e790))
+
+
+## v0.2.0 (2026-06-02)
+
+### Bug Fixes
+
+- Try to make release work properly ([#6](https://github.com/databutton/riff-sdk-python/pull/6),
+  [`bc68e3b`](https://github.com/databutton/riff-sdk-python/commit/bc68e3b1e7655024ef2f01254f2afd5229115410))
+
+### Features
+
+- Add text and JSON convenience methods to storage clients
+  ([#5](https://github.com/databutton/riff-sdk-python/pull/5),
+  [`b53f219`](https://github.com/databutton/riff-sdk-python/commit/b53f219857bca08e4e71ae3a65fd1a7fb0042d78))
+
+
+## v0.1.0 (2026-06-01)
+
+- Initial Release

{riffsdk-0.2.0 → riffsdk-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: riffsdk
-Version: 0.2.0
+Version: 0.3.0
 Summary: Python SDK for the Riff Storage API
 License-File: LICENCE
 Requires-Python: >=3.11

{riffsdk-0.2.0 → riffsdk-0.3.0}/pyproject.toml

@@ -4,11 +4,14 @@ build-backend = "hatchling.build"
 
 [project]
 name = "riffsdk"
-version = "0.2.0"
+version = "0.3.0"
 description = "Python SDK for the Riff Storage API"
 requires-python = ">=3.11"
 dependencies = ["httpx>=0.27", "pydantic>=2.6", "tenacity>=8.3"]
 
+[project.scripts]
+riffsdk = "riffsdk._cli:main"
+
 [dependency-groups]
 dev = [
   "pytest>=9.0",

riffsdk-0.3.0/src/riffsdk/__main__.py

@@ -0,0 +1,3 @@
+from riffsdk._cli import main
+
+main()

riffsdk-0.3.0/src/riffsdk/_cli.py

@@ -0,0 +1,323 @@
+from __future__ import annotations
+
+import argparse
+import mimetypes
+import os
+import sys
+import tempfile
+
+from riffsdk.storage._client import StorageClient
+from riffsdk.storage._models import Scope
+from riffsdk.storage.exceptions import (
+    AuthorisationError,
+    ObjectNotFoundError,
+    StorageError,
+)
+
+
+def _die(msg: str, code: int = 1) -> None:
+    sys.stderr.write(f"riffsdk: {msg}\n")
+    sys.exit(code)
+
+
+def _resolve_key(args: argparse.Namespace) -> str:
+    key = getattr(args, "key", None) or getattr(args, "key_flag", None)
+    if not key:
+        _die("storage key is required (positional or -k/--key)")
+    return key
+
+
+def _guess_content_type(path: str) -> str:
+    return mimetypes.guess_type(path)[0] or "application/octet-stream"
+
+
+def _format_size(size: int) -> str:
+    for unit in ("B", "KB", "MB", "GB", "TB"):
+        if size < 1024:
+            return f"{size:.1f} {unit}" if unit != "B" else f"{size} {unit}"
+        size /= 1024
+    return f"{size:.1f} PB"
+
+
+def _make_progress(label: str) -> callable:
+    def callback(done: int, total: int) -> None:
+        if not sys.stderr.isatty():
+            return
+        pct = done * 100 // total if total else 0
+        bar_len = 30
+        filled = bar_len * done // total if total else 0
+        bar = "#" * filled + "-" * (bar_len - filled)
+        sys.stderr.write(
+            f"\r{label}: [{bar}] {pct}% {_format_size(done)}/{_format_size(total)}"
+        )
+        if done >= total:
+            sys.stderr.write("\n")
+        sys.stderr.flush()
+
+    return callback
+
+
+# --- Subcommand handlers ---
+
+
+def cmd_download(client: StorageClient, args: argparse.Namespace) -> None:
+    key = _resolve_key(args)
+    scope: Scope = getattr(args, "scope", None)
+
+    if args.stream:
+        if args.output:
+            _die("--output and --stream are mutually exclusive")
+        for chunk in client.download_stream(key, scope=scope):
+            sys.stdout.buffer.write(chunk)
+        sys.stdout.buffer.flush()
+    else:
+        output = args.output or os.path.basename(key)
+        parent = os.path.dirname(output)
+        if parent:
+            os.makedirs(parent, exist_ok=True)
+        progress = _make_progress(os.path.basename(key))
+        result = client.download_file(key, output, on_progress=progress, scope=scope)
+        if args.verbose:
+            sys.stderr.write(
+                f"Downloaded {result.key} ({_format_size(result.size)}, "
+                f"version={result.version})\n"
+            )
+
+
+def cmd_upload(client: StorageClient, args: argparse.Namespace) -> None:
+    key = _resolve_key(args)
+    scope: Scope = getattr(args, "scope", None)
+    ct = getattr(args, "content_type", None)
+
+    if args.stream:
+        if args.input:
+            _die("--input and --stream are mutually exclusive")
+        with tempfile.SpooledTemporaryFile(max_size=10 * 1024 * 1024) as tmp:
+            while True:
+                chunk = sys.stdin.buffer.read(65536)
+                if not chunk:
+                    break
+                tmp.write(chunk)
+            total_size = tmp.tell()
+            if total_size == 0:
+                _die("no data received on stdin")
+            tmp.seek(0)
+            content_type = ct or _guess_content_type(key)
+            result = client.upload_stream(
+                key, tmp, total_size=total_size, content_type=content_type, scope=scope
+            )
+        if args.verbose:
+            sys.stderr.write(
+                f"Uploaded {result.key} ({_format_size(result.size)}, "
+                f"version={result.version})\n"
+            )
+    elif args.input:
+        if not os.path.isfile(args.input):
+            _die(f"file not found: {args.input}")
+        progress = _make_progress(os.path.basename(args.input))
+        result = client.upload_file(
+            key, args.input, content_type=ct, on_progress=progress, scope=scope
+        )
+        if args.verbose:
+            sys.stderr.write(
+                f"Uploaded {result.key} ({_format_size(result.size)}, "
+                f"version={result.version})\n"
+            )
+    else:
+        _die("specify --input/-i or --stream/-s")
+
+
+def cmd_download_dir(client: StorageClient, args: argparse.Namespace) -> None:
+    prefix = _resolve_key(args)
+    scope: Scope = getattr(args, "scope", None)
+    output_dir = args.output
+    if not output_dir:
+        _die("--output/-o is required for download-dir")
+
+    count = 0
+    for obj in client.list(prefix, scope=scope):
+        rel = obj.key[len(prefix) :]
+        if not rel:
+            continue
+        local_path = os.path.join(output_dir, rel)
+        parent = os.path.dirname(local_path)
+        if parent:
+            os.makedirs(parent, exist_ok=True)
+        progress = _make_progress(rel) if args.verbose else None
+        client.download_file(obj.key, local_path, on_progress=progress, scope=scope)
+        count += 1
+        sys.stderr.write(f"  {rel} ({_format_size(obj.size)})\n")
+
+    sys.stderr.write(f"Downloaded {count} file(s)\n")
+
+
+def cmd_upload_dir(client: StorageClient, args: argparse.Namespace) -> None:
+    local_dir = args.path
+    prefix = _resolve_key(args)
+    scope: Scope = getattr(args, "scope", None)
+
+    if not os.path.isdir(local_dir):
+        _die(f"not a directory: {local_dir}")
+
+    count = 0
+    for dirpath, _dirnames, filenames in os.walk(local_dir):
+        for filename in filenames:
+            local_path = os.path.join(dirpath, filename)
+            rel = os.path.relpath(local_path, local_dir).replace(os.sep, "/")
+            key = prefix + rel
+            progress = _make_progress(rel) if args.verbose else None
+            client.upload_file(key, local_path, on_progress=progress, scope=scope)
+            count += 1
+            sys.stderr.write(f"  {rel}\n")
+
+    sys.stderr.write(f"Uploaded {count} file(s)\n")
+
+
+def cmd_ls(client: StorageClient, args: argparse.Namespace) -> None:
+    prefix = getattr(args, "prefix", "") or ""
+    scope: Scope = getattr(args, "scope", None)
+    delimiter = getattr(args, "delimiter", None)
+    long_fmt = getattr(args, "long", False)
+
+    for obj in client.list(prefix, delimiter=delimiter, scope=scope):
+        if long_fmt:
+            updated = obj.updated_at.isoformat() if obj.updated_at else ""
+            sys.stdout.write(
+                f"{updated}\t{obj.size:>10}\t{obj.content_type}\t{obj.key}\n"
+            )
+        else:
+            sys.stdout.write(f"{obj.key}\n")
+
+
+def cmd_stat(client: StorageClient, args: argparse.Namespace) -> None:
+    key = _resolve_key(args)
+    scope: Scope = getattr(args, "scope", None)
+    obj = client.stat(key, scope=scope)
+
+    sys.stdout.write(f"Key:          {obj.key}\n")
+    sys.stdout.write(f"Size:         {obj.size} ({_format_size(obj.size)})\n")
+    sys.stdout.write(f"Content-Type: {obj.content_type}\n")
+    sys.stdout.write(f"Version:      {obj.version}\n")
+    if obj.created_at:
+        sys.stdout.write(f"Created:      {obj.created_at.isoformat()}\n")
+    if obj.updated_at:
+        sys.stdout.write(f"Updated:      {obj.updated_at.isoformat()}\n")
+
+
+def cmd_delete(client: StorageClient, args: argparse.Namespace) -> None:
+    key = _resolve_key(args)
+    scope: Scope = getattr(args, "scope", None)
+    version = getattr(args, "version", None)
+    client.delete(key, version=version, scope=scope)
+    sys.stderr.write(f"Deleted {key}\n")
+
+
+# --- Argument parser ---
+
+
+def _add_key_args(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument("key", nargs="?", default=None, help="storage key")
+    parser.add_argument(
+        "-k", "--key", dest="key_flag", default=None, help="storage key"
+    )
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="riffsdk",
+        description="Riff Storage CLI",
+    )
+    parser.add_argument(
+        "-v", "--verbose", action="store_true", help="verbose output to stderr"
+    )
+    parser.add_argument("--scope", default=None, help="storage scope")
+    parser.add_argument("--base-url", default=None, help="override API base URL")
+
+    sub = parser.add_subparsers(dest="command")
+
+    # download
+    p = sub.add_parser("download", help="download a file from storage")
+    _add_key_args(p)
+    p.add_argument("-o", "--output", default=None, help="local output path")
+    p.add_argument(
+        "-s", "--stream", action="store_true", help="write to stdout for piping"
+    )
+    p.set_defaults(func=cmd_download)
+
+    # upload
+    p = sub.add_parser("upload", help="upload a file to storage")
+    _add_key_args(p)
+    p.add_argument("-i", "--input", default=None, help="local input path")
+    p.add_argument(
+        "-s", "--stream", action="store_true", help="read from stdin for piping"
+    )
+    p.add_argument("-t", "--content-type", default=None, help="MIME content type")
+    p.set_defaults(func=cmd_upload)
+
+    # download-dir
+    p = sub.add_parser("download-dir", help="download a directory from storage")
+    _add_key_args(p)
+    p.add_argument("-o", "--output", required=True, help="local output directory")
+    p.set_defaults(func=cmd_download_dir)
+
+    # upload-dir
+    p = sub.add_parser("upload-dir", help="upload a directory to storage")
+    p.add_argument("path", help="local directory to upload")
+    p.add_argument("-k", "--key", dest="key_flag", required=True, help="storage prefix")
+    p.set_defaults(func=cmd_upload_dir)
+
+    # ls
+    p = sub.add_parser("ls", help="list objects")
+    p.add_argument("prefix", nargs="?", default="", help="key prefix filter")
+    p.add_argument("-l", "--long", action="store_true", help="detailed listing")
+    p.add_argument("-d", "--delimiter", default=None, help="delimiter for hierarchy")
+    p.set_defaults(func=cmd_ls)
+
+    # stat
+    p = sub.add_parser("stat", help="show object metadata")
+    _add_key_args(p)
+    p.set_defaults(func=cmd_stat)
+
+    # delete
+    p = sub.add_parser("delete", help="delete an object")
+    _add_key_args(p)
+    p.add_argument("--version", default=None, help="match specific version")
+    p.set_defaults(func=cmd_delete)
+
+    return parser
+
+
+def _run(argv: list[str]) -> None:
+    parser = _build_parser()
+    args = parser.parse_args(argv)
+
+    if not args.command:
+        parser.print_help(sys.stderr)
+        sys.exit(1)
+
+    kwargs: dict = {}
+    if args.base_url:
+        kwargs["base_url"] = args.base_url
+    if args.scope:
+        kwargs["scope"] = args.scope
+
+    with StorageClient(**kwargs) as client:
+        args.func(client, args)
+
+
+def main() -> None:
+    try:
+        _run(sys.argv[1:])
+    except AuthorisationError as e:
+        _die(f"authentication failed: {e.message}", code=2)
+    except ObjectNotFoundError as e:
+        _die(f"object not found: {e.key}", code=3)
+    except StorageError as e:
+        _die(str(e))
+    except KeyboardInterrupt:
+        sys.stderr.write("\nInterrupted\n")
+        sys.exit(130)
+    except BrokenPipeError:
+        devnull = os.open(os.devnull, os.O_WRONLY)
+        os.dup2(devnull, sys.stdout.fileno())
+        sys.exit(0)

{riffsdk-0.2.0 → riffsdk-0.3.0}/src/riffsdk/storage/_async_client.py

@@ -590,7 +590,7 @@ class AsyncStorageClient:
 
         resp = await self._transport.request(
             "GET",
-            f"/v1/storage/objects/{key}/download-url",
+            f"/v1/storage/download-url/{key}",
             token=token,
             params=params,
             headers=self._scope_headers(scope),

{riffsdk-0.2.0 → riffsdk-0.3.0}/src/riffsdk/storage/_client.py

@@ -619,7 +619,7 @@ class StorageClient:
 
         resp = self._transport.request(
             "GET",
-            f"/v1/storage/objects/{key}/download-url",
+            f"/v1/storage/download-url/{key}",
             token=token,
             params=params,
             headers=self._scope_headers(scope),

riffsdk-0.3.0/tests/test_cli.py

@@ -0,0 +1,423 @@
+import io
+import os
+import tempfile
+from datetime import UTC, datetime
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from riffsdk._cli import (
+    _build_parser,
+    _resolve_key,
+    cmd_delete,
+    cmd_download,
+    cmd_download_dir,
+    cmd_ls,
+    cmd_stat,
+    cmd_upload,
+    cmd_upload_dir,
+    main,
+)
+from riffsdk.storage._models import DownloadResult, ObjectMeta, UploadResult
+from riffsdk.storage.exceptions import AuthorisationError, ObjectNotFoundError
+
+
+def _ts() -> datetime:
+    return datetime(2025, 1, 1, tzinfo=UTC)
+
+
+def _meta(key: str = "test.txt", size: int = 100) -> ObjectMeta:
+    return ObjectMeta(
+        key=key,
+        size=size,
+        content_type="text/plain",
+        version="v1",
+        created_at=_ts(),
+        updated_at=_ts(),
+    )
+
+
+def _upload_result(key: str = "test.txt", size: int = 100) -> UploadResult:
+    return UploadResult(
+        key=key, version="v1", size=size, content_type="text/plain", created_at=_ts()
+    )
+
+
+def _download_result(key: str = "test.txt", size: int = 100) -> DownloadResult:
+    return DownloadResult(
+        key=key, size=size, content_type="text/plain", version="v1"
+    )
+
+
+class TestArgParsing:
+    def test_download_positional_key(self):
+        parser = _build_parser()
+        args = parser.parse_args(["download", "mykey", "-o", "out.txt"])
+        assert args.key == "mykey"
+        assert args.output == "out.txt"
+        assert args.command == "download"
+
+    def test_download_flag_key(self):
+        parser = _build_parser()
+        args = parser.parse_args(["download", "-k", "mykey", "-o", "out.txt"])
+        assert args.key_flag == "mykey"
+        assert args.output == "out.txt"
+
+    def test_upload_with_input(self):
+        parser = _build_parser()
+        args = parser.parse_args(["upload", "mykey", "-i", "in.txt"])
+        assert args.key == "mykey"
+        assert args.input == "in.txt"
+
+    def test_upload_stream(self):
+        parser = _build_parser()
+        args = parser.parse_args(["upload", "-k", "mykey", "--stream"])
+        assert args.key_flag == "mykey"
+        assert args.stream is True
+
+    def test_ls_default_prefix(self):
+        parser = _build_parser()
+        args = parser.parse_args(["ls"])
+        assert args.prefix == ""
+
+    def test_ls_with_prefix_and_long(self):
+        parser = _build_parser()
+        args = parser.parse_args(["ls", "data/", "-l"])
+        assert args.prefix == "data/"
+        assert args.long is True
+
+    def test_stat_positional(self):
+        parser = _build_parser()
+        args = parser.parse_args(["stat", "mykey"])
+        assert args.key == "mykey"
+
+    def test_delete_with_version(self):
+        parser = _build_parser()
+        args = parser.parse_args(["delete", "mykey", "--version", "v2"])
+        assert args.key == "mykey"
+        assert args.version == "v2"
+
+    def test_upload_dir(self):
+        parser = _build_parser()
+        args = parser.parse_args(["upload-dir", "/tmp/data", "-k", "prefix/"])
+        assert args.path == "/tmp/data"
+        assert args.key_flag == "prefix/"
+
+    def test_download_dir(self):
+        parser = _build_parser()
+        args = parser.parse_args(["download-dir", "prefix/", "-o", "/tmp/out"])
+        assert args.key == "prefix/"
+        assert args.output == "/tmp/out"
+
+    def test_global_verbose(self):
+        parser = _build_parser()
+        args = parser.parse_args(["-v", "ls"])
+        assert args.verbose is True
+
+    def test_resolve_key_positional(self):
+        parser = _build_parser()
+        args = parser.parse_args(["download", "mykey"])
+        assert _resolve_key(args) == "mykey"
+
+    def test_resolve_key_flag(self):
+        parser = _build_parser()
+        args = parser.parse_args(["download", "-k", "mykey"])
+        assert _resolve_key(args) == "mykey"
+
+    def test_resolve_key_missing(self):
+        parser = _build_parser()
+        args = parser.parse_args(["download"])
+        with pytest.raises(SystemExit, match="1"):
+            _resolve_key(args)
+
+
+class TestDownload:
+    def test_download_to_file(self):
+        client = MagicMock()
+        client.download_file.return_value = _download_result()
+
+        parser = _build_parser()
+        with tempfile.TemporaryDirectory() as tmpdir:
+            out = os.path.join(tmpdir, "out.txt")
+            args = parser.parse_args(["download", "test.txt", "-o", out])
+            args.verbose = False
+            cmd_download(client, args)
+
+        client.download_file.assert_called_once()
+        call_args = client.download_file.call_args
+        assert call_args[0] == ("test.txt", out)
+
+    def test_download_default_output(self):
+        client = MagicMock()
+        client.download_file.return_value = _download_result(key="path/to/file.txt")
+
+        parser = _build_parser()
+        args = parser.parse_args(["download", "path/to/file.txt"])
+        args.verbose = False
+        cmd_download(client, args)
+
+        call_args = client.download_file.call_args
+        assert call_args[0][1] == "file.txt"
+
+    def test_download_stream(self):
+        client = MagicMock()
+        client.download_stream.return_value = iter([b"hello", b" world"])
+
+        parser = _build_parser()
+        args = parser.parse_args(["download", "test.txt", "--stream"])
+        args.verbose = False
+
+        buf = io.BytesIO()
+        with patch("sys.stdout") as mock_stdout:
+            mock_stdout.buffer = buf
+            cmd_download(client, args)
+
+        assert buf.getvalue() == b"hello world"
+
+    def test_download_stream_and_output_conflict(self):
+        client = MagicMock()
+        parser = _build_parser()
+        args = parser.parse_args(["download", "test.txt", "--stream", "-o", "out.txt"])
+        args.verbose = False
+
+        with pytest.raises(SystemExit):
+            cmd_download(client, args)
+
+
+class TestUpload:
+    def test_upload_from_file(self):
+        client = MagicMock()
+        client.upload_file.return_value = _upload_result()
+
+        with tempfile.NamedTemporaryFile(suffix=".txt", delete=False) as f:
+            f.write(b"test data")
+            f.flush()
+            try:
+                parser = _build_parser()
+                args = parser.parse_args(["upload", "test.txt", "-i", f.name])
+                args.verbose = False
+                cmd_upload(client, args)
+
+                client.upload_file.assert_called_once()
+                call_args = client.upload_file.call_args
+                assert call_args[0] == ("test.txt", f.name)
+            finally:
+                os.unlink(f.name)
+
+    def test_upload_from_stdin(self):
+        client = MagicMock()
+        client.upload_stream.return_value = _upload_result()
+
+        parser = _build_parser()
+        args = parser.parse_args(["upload", "test.txt", "--stream"])
+        args.verbose = False
+
+        stdin_data = io.BytesIO(b"piped data")
+        with patch("sys.stdin") as mock_stdin:
+            mock_stdin.buffer = stdin_data
+            cmd_upload(client, args)
+
+        client.upload_stream.assert_called_once()
+        call_args = client.upload_stream.call_args
+        assert call_args[0][0] == "test.txt"
+        assert call_args[1]["total_size"] == 10
+
+    def test_upload_stdin_empty(self):
+        client = MagicMock()
+        parser = _build_parser()
+        args = parser.parse_args(["upload", "test.txt", "--stream"])
+        args.verbose = False
+
+        stdin_data = io.BytesIO(b"")
+        with patch("sys.stdin") as mock_stdin:
+            mock_stdin.buffer = stdin_data
+            with pytest.raises(SystemExit):
+                cmd_upload(client, args)
+
+    def test_upload_no_input_no_stream(self):
+        client = MagicMock()
+        parser = _build_parser()
+        args = parser.parse_args(["upload", "test.txt"])
+        args.verbose = False
+
+        with pytest.raises(SystemExit):
+            cmd_upload(client, args)
+
+    def test_upload_content_type_override(self):
+        client = MagicMock()
+        client.upload_stream.return_value = _upload_result()
+
+        parser = _build_parser()
+        args = parser.parse_args(
+            ["upload", "data", "--stream", "-t", "application/json"]
+        )
+        args.verbose = False
+
+        stdin_data = io.BytesIO(b'{"key": "value"}')
+        with patch("sys.stdin") as mock_stdin:
+            mock_stdin.buffer = stdin_data
+            cmd_upload(client, args)
+
+        call_args = client.upload_stream.call_args
+        assert call_args[1]["content_type"] == "application/json"
+
+    def test_upload_stream_and_input_conflict(self):
+        client = MagicMock()
+        parser = _build_parser()
+        args = parser.parse_args(
+            ["upload", "test.txt", "--stream", "-i", "file.txt"]
+        )
+        args.verbose = False
+
+        stdin_data = io.BytesIO(b"data")
+        with patch("sys.stdin") as mock_stdin:
+            mock_stdin.buffer = stdin_data
+            with pytest.raises(SystemExit):
+                cmd_upload(client, args)
+
+
+class TestLs:
+    def test_ls_short(self, capsys):
+        client = MagicMock()
+        client.list.return_value = iter([_meta("a.txt"), _meta("b.txt")])
+
+        parser = _build_parser()
+        args = parser.parse_args(["ls"])
+        cmd_ls(client, args)
+
+        out = capsys.readouterr().out
+        assert "a.txt\n" in out
+        assert "b.txt\n" in out
+
+    def test_ls_long(self, capsys):
+        client = MagicMock()
+        client.list.return_value = iter([_meta("a.txt", size=1024)])
+
+        parser = _build_parser()
+        args = parser.parse_args(["ls", "-l"])
+        cmd_ls(client, args)
+
+        out = capsys.readouterr().out
+        assert "1024" in out
+        assert "a.txt" in out
+        assert "text/plain" in out
+
+    def test_ls_with_prefix(self):
+        client = MagicMock()
+        client.list.return_value = iter([])
+
+        parser = _build_parser()
+        args = parser.parse_args(["ls", "data/"])
+        cmd_ls(client, args)
+
+        client.list.assert_called_once_with("data/", delimiter=None, scope=None)
+
+
+class TestStat:
+    def test_stat(self, capsys):
+        client = MagicMock()
+        client.stat.return_value = _meta("doc.pdf", size=2048)
+
+        parser = _build_parser()
+        args = parser.parse_args(["stat", "doc.pdf"])
+        cmd_stat(client, args)
+
+        out = capsys.readouterr().out
+        assert "doc.pdf" in out
+        assert "2048" in out
+        assert "text/plain" in out
+        assert "v1" in out
+
+
+class TestDelete:
+    def test_delete(self):
+        client = MagicMock()
+
+        parser = _build_parser()
+        args = parser.parse_args(["delete", "test.txt"])
+        cmd_delete(client, args)
+
+        client.delete.assert_called_once_with("test.txt", version=None, scope=None)
+
+    def test_delete_with_version(self):
+        client = MagicMock()
+
+        parser = _build_parser()
+        args = parser.parse_args(["delete", "test.txt", "--version", "v2"])
+        cmd_delete(client, args)
+
+        client.delete.assert_called_once_with("test.txt", version="v2", scope=None)
+
+
+class TestDownloadDir:
+    def test_download_dir(self):
+        client = MagicMock()
+        client.list.return_value = iter([
+            _meta("prefix/a.txt", size=10),
+            _meta("prefix/sub/b.txt", size=20),
+        ])
+        client.download_file.return_value = _download_result()
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            parser = _build_parser()
+            args = parser.parse_args(["download-dir", "prefix/", "-o", tmpdir])
+            args.verbose = False
+            cmd_download_dir(client, args)
+
+        assert client.download_file.call_count == 2
+        calls = client.download_file.call_args_list
+        assert calls[0][0][0] == "prefix/a.txt"
+        assert calls[1][0][0] == "prefix/sub/b.txt"
+
+
+class TestUploadDir:
+    def test_upload_dir(self):
+        client = MagicMock()
+        client.upload_file.return_value = _upload_result()
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            os.makedirs(os.path.join(tmpdir, "sub"))
+            with open(os.path.join(tmpdir, "a.txt"), "w") as f:
+                f.write("hello")
+            with open(os.path.join(tmpdir, "sub", "b.txt"), "w") as f:
+                f.write("world")
+
+            parser = _build_parser()
+            args = parser.parse_args(["upload-dir", tmpdir, "-k", "prefix/"])
+            args.verbose = False
+            cmd_upload_dir(client, args)
+
+        assert client.upload_file.call_count == 2
+        keys = sorted(c[0][0] for c in client.upload_file.call_args_list)
+        assert keys == ["prefix/a.txt", "prefix/sub/b.txt"]
+
+
+class TestErrorHandling:
+    def test_auth_error_exit_code(self):
+        with patch("riffsdk._cli._run") as mock_run:
+            mock_run.side_effect = AuthorisationError("bad token")
+            with pytest.raises(SystemExit) as exc_info:
+                main()
+            assert exc_info.value.code == 2
+
+    def test_not_found_exit_code(self):
+        with patch("riffsdk._cli._run") as mock_run:
+            mock_run.side_effect = ObjectNotFoundError(
+                "not found", key="missing.txt"
+            )
+            with pytest.raises(SystemExit) as exc_info:
+                main()
+            assert exc_info.value.code == 3
+
+    def test_no_command_exits(self):
+        with patch("sys.argv", ["riffsdk"]):
+            with pytest.raises(SystemExit) as exc_info:
+                main()
+            assert exc_info.value.code == 1
+
+    def test_keyboard_interrupt(self):
+        with patch("riffsdk._cli._run") as mock_run:
+            mock_run.side_effect = KeyboardInterrupt()
+            with pytest.raises(SystemExit) as exc_info:
+                main()
+            assert exc_info.value.code == 130

riffsdk-0.2.0/CHANGELOG.md

@@ -1,21 +0,0 @@
-# CHANGELOG
-
-<!-- version list -->
-
-## v0.2.0 (2026-06-01)
-
-### Bug Fixes
-
-- Try to make release work properly ([#6](https://github.com/databutton/riff-sdk-python/pull/6),
-  [`bc68e3b`](https://github.com/databutton/riff-sdk-python/commit/bc68e3b1e7655024ef2f01254f2afd5229115410))
-
-### Features
-
-- Add text and JSON convenience methods to storage clients
-  ([#5](https://github.com/databutton/riff-sdk-python/pull/5),
-  [`b53f219`](https://github.com/databutton/riff-sdk-python/commit/b53f219857bca08e4e71ae3a65fd1a7fb0042d78))
-
-
-## v0.1.0 (2026-06-01)
-
-- Initial Release