steve-cli 0.5.5__tar.gz → 1.0.1__tar.gz

{steve_cli-0.5.5 → steve_cli-1.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: steve-cli
-Version: 0.5.5
+Version: 1.0.1
 Summary: A simple CLI tool to run jobs from jobs.yaml with proper environment setup
 Author: Frank
 License: MIT
@@ -67,6 +67,8 @@ Requires-Dist: visidata>=3.0; extra == "all"
 
 A CLI tool for the data platform. Commands are organized by concern: general workspace automation, data lakehouse operations, semantic knowledge graphs, and governance.
 
+> **Upgrading from 0.x?** See [CHANGELOG.md](./CHANGELOG.md) — v1.0.0 introduces branch-isolated storage with breaking path changes that require a one-time data migration.
+
 ## Installation
 
 ```bash

{steve_cli-0.5.5 → steve_cli-1.0.1}/README.md

@@ -2,6 +2,8 @@
 
 A CLI tool for the data platform. Commands are organized by concern: general workspace automation, data lakehouse operations, semantic knowledge graphs, and governance.
 
+> **Upgrading from 0.x?** See [CHANGELOG.md](./CHANGELOG.md) — v1.0.0 introduces branch-isolated storage with breaking path changes that require a one-time data migration.
+
 ## Installation
 
 ```bash

{steve_cli-0.5.5 → steve_cli-1.0.1}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "steve-cli"
-version = "0.5.5"
+version = "1.0.1"
 description = "A simple CLI tool to run jobs from jobs.yaml with proper environment setup"
 readme = "README.md"
 license = {text = "MIT"}

{steve_cli-0.5.5 → steve_cli-1.0.1}/steve_cli/auth.py

@@ -21,6 +21,8 @@ def save_credentials(
     token: str,
     base_url: Optional[str] = None,
     workspace_name: Optional[str] = None,
+    expires_at: Optional[str] = None,
+    s3_endpoint: Optional[str] = None,
 ) -> None:
     _CREDENTIALS_FILE.parent.mkdir(parents=True, exist_ok=True)
     creds = load_credentials()
@@ -30,6 +32,10 @@ def save_credentials(
         entry["base_url"] = base_url.rstrip("/")
     if workspace_name:
         entry["workspace_name"] = workspace_name
+    if expires_at:
+        entry["expires_at"] = expires_at
+    if s3_endpoint:
+        entry["s3_endpoint"] = s3_endpoint
     workspaces[workspace_id] = entry
     creds["workspaces"] = workspaces
     _CREDENTIALS_FILE.write_text(json.dumps(creds, indent=2))
@@ -63,6 +69,10 @@ def get_token(workspace_id: Optional[str] = None) -> Optional[str]:
     return _get_workspace_entry(workspace_id).get("token")
 
 
+def get_s3_endpoint(workspace_id: Optional[str] = None) -> Optional[str]:
+    return _get_workspace_entry(workspace_id).get("s3_endpoint")
+
+
 def get_service_url(service: str, workspace_id: Optional[str] = None) -> Optional[str]:
     entry = _get_workspace_entry(workspace_id)
     base_url = entry.get("base_url")

{steve_cli-0.5.5 → steve_cli-1.0.1}/steve_cli/cli.py

@@ -963,9 +963,10 @@ def policies_apply(file: Path | None):
 @click.option("--workspace", "workspace_id", default=None, help="Workspace ID (defaults to WORKSPACE_ID from .env)")
 @click.option("--url", "base_url", default=None, help="Platform root host, e.g. jds-dev.internal.jambit.io")
 @click.option("--workspace-name", "workspace_name_opt", default=None, help="Workspace name")
+@click.option("--expires", "expires_at", default=None, help="Token expiry date/time (e.g. 2026-12-31 or ISO 8601). Informational only.")
 @click.option('--env-file', '-e', type=click.Path(path_type=Path), multiple=True,
               help='Path to .env file(s). Defaults to .env and .workspaces.env')
-def login(token: str | None, workspace_id: str | None, base_url: str | None, workspace_name_opt: str | None, env_file: tuple):
+def login(token: str | None, workspace_id: str | None, base_url: str | None, workspace_name_opt: str | None, expires_at: str | None, env_file: tuple):
     """Print CLI access URLs or save a service principal token."""
     cwd = Path.cwd()
     env_files = [Path(f) for f in env_file] if env_file else [cwd / ".env", cwd / ".workspaces.env"]
@@ -984,9 +985,27 @@ def login(token: str | None, workspace_id: str | None, base_url: str | None, wor
             click.secho("Could not resolve workspace ID. Set WORKSPACE_ID in .env or pass --workspace.", fg="red", err=True)
             raise SystemExit(1)
         click.echo(f"\nYou are about to log in to workspace {click.style(workspace_name, fg='cyan', bold=True)} ({resolved_workspace})")
-        save_credentials(resolved_workspace, token, base_url=base_url, workspace_name=workspace_name)
+        save_credentials(resolved_workspace, token, base_url=base_url, workspace_name=workspace_name, expires_at=expires_at)
         if base_url:
             click.echo(f"Platform: {base_url}")
+
+        s3_endpoint: str | None = None
+        if base_url:
+            try:
+                import urllib.request as _urlreq
+                config_url = f"https://datameshx.{base_url}/api/v1/cli/config"
+                req = _urlreq.Request(config_url, headers={"Authorization": f"Bearer {token}"})
+                with _urlreq.urlopen(req, timeout=5) as _r:
+                    import json as _json
+                    cfg = _json.loads(_r.read().decode())
+                    s3_endpoint = cfg.get("s3Endpoint")
+            except Exception as _e:
+                click.secho(f"Could not fetch platform config (s3Endpoint will use .env fallback): {_e}", fg="yellow", err=True)
+
+        if s3_endpoint:
+            save_credentials(resolved_workspace, token, base_url=base_url, workspace_name=workspace_name, expires_at=expires_at, s3_endpoint=s3_endpoint)
+            click.echo(f"S3 endpoint: {s3_endpoint}")
+
         click.secho(f"Logged in. Credentials saved to ~/.steve/credentials.json", fg="green")
         return
 
@@ -1022,6 +1041,238 @@ def logout(workspace_id: str | None, env_file: tuple):
         click.secho("All credentials removed.", fg="green")
 
 
+@main.command("status")
+@click.option('--env-file', '-e', type=click.Path(path_type=Path), multiple=True,
+              help='Path to .env file(s). Defaults to .env and .workspaces.env')
+@click.option('--no-check', is_flag=True, default=False, help='Skip connectivity checks.')
+def status(env_file: tuple, no_check: bool):
+    """Show current steve-cli environment, storage paths, and connectivity."""
+    import importlib.metadata
+    import urllib.request
+
+    cwd = Path.cwd()
+    env_files = [Path(f) for f in env_file] if env_file else [cwd / ".env", cwd / ".workspaces.env"]
+    for ef in env_files:
+        load_dotenv(ef)
+
+    try:
+        version = importlib.metadata.version("steve-cli")
+    except Exception:
+        version = "unknown"
+
+    def _section(title: str) -> None:
+        click.echo(f"\n{click.style(f'━━ {title} ', fg='bright_black')}{'━' * max(0, 48 - len(title))}")
+
+    def _row(label: str, value: str, value_color: str = "white") -> None:
+        click.echo(f"  {click.style(label.ljust(14), fg='bright_black')}  {click.style(value, fg=value_color)}")
+
+    def _check(label: str, url: str, timeout: int = 2, token: str = "", suffix: str = "") -> None:
+        if no_check:
+            _row(label, "(skipped)", "bright_black")
+            return
+        try:
+            req = urllib.request.Request(url)
+            if token:
+                req.add_header("Authorization", f"Bearer {token}")
+            with urllib.request.urlopen(req, timeout=timeout) as r:
+                _row(label, f"✓ reachable  ({url}){suffix}", "green")
+                return r.read()
+        except urllib.error.HTTPError:
+            _row(label, f"✓ reachable  ({url}){suffix}", "green")
+        except Exception as e:
+            _row(label, f"✗ unreachable  ({url}){suffix}: {e}", "red")
+
+    click.echo(f"\n{click.style('●', fg='green')} Steve CLI {click.style('v' + version, fg='cyan', bold=True)}")
+
+    from steve_cli.storage.branch import get_branch_prefix
+    import subprocess as _sp
+
+    branch = get_branch_prefix()
+    steve_branch_env = os.getenv("STEVE_BRANCH", "").strip()
+    gh_head = os.getenv("GITHUB_HEAD_REF", "").strip() or os.getenv("GITHUB_REF_NAME", "").strip()
+    if steve_branch_env:
+        branch_source = f"STEVE_BRANCH={steve_branch_env!r}"
+    elif gh_head:
+        branch_source = f"GITHUB env ({gh_head})"
+    else:
+        try:
+            r = _sp.run(["git", "rev-parse", "--abbrev-ref", "HEAD"], capture_output=True, text=True, timeout=3)
+            branch_source = "git" if r.returncode == 0 and r.stdout.strip() else "fallback"
+        except Exception:
+            branch_source = "fallback"
+
+    workspace_id = os.getenv("WORKSPACE_ID", "")
+    workspace_name = os.getenv("WORKSPACE_NAME", "")
+    session = os.getenv("SESSION_NAME", "") or socket.gethostname()
+
+    from steve_cli.auth import _get_workspace_entry, get_service_url
+    import datetime as _dt
+    entry = _get_workspace_entry(workspace_id or None)
+    token = entry.get("token", "")
+    expires_at = entry.get("expires_at", "")
+    if token:
+        expiry_warn = False
+        expiry_str = ", expires never" if not expires_at else ""
+        if expires_at:
+            try:
+                exp = _dt.datetime.fromisoformat(expires_at.replace("Z", "+00:00"))
+                now = _dt.datetime.now(_dt.timezone.utc) if exp.tzinfo else _dt.datetime.now()
+                delta = exp - now
+                total_seconds = int(delta.total_seconds())
+                if total_seconds < 0:
+                    s = abs(total_seconds)
+                    if s < 3600:
+                        ago = f"{s // 60}m ago"
+                    elif s < 86400:
+                        ago = f"{s // 3600}h ago"
+                    else:
+                        ago = f"{s // 86400}d ago"
+                    expiry_str = f", expired {ago}"
+                    expiry_warn = True
+                elif total_seconds < 3600:
+                    expiry_str = f", expires in {total_seconds // 60}m ⚠"
+                    expiry_warn = True
+                elif total_seconds < 86400:
+                    expiry_str = f", expires in {total_seconds // 3600}h ⚠"
+                    expiry_warn = True
+                elif delta.days <= 7:
+                    expiry_str = f", expires in {delta.days}d ⚠"
+                    expiry_warn = True
+                else:
+                    expiry_str = f", expires {exp.strftime('%Y-%m-%d %H:%M')}"
+            except Exception:
+                expiry_str = f", expires {expires_at}"
+        token_display = f"✓ logged in  (stp_***{token[-4:]}{expiry_str})"
+        token_color = "yellow" if expiry_warn else "green"
+    else:
+        token_display = "✗ not logged in — run: steve login"
+        token_color = "yellow"
+
+    _section("Identity")
+    _row("Branch", f"{branch}  ({branch_source})", "cyan")
+    _row("Workspace ID", workspace_id or "(not set)", "white" if workspace_id else "yellow")
+    _row("Workspace", workspace_name or "(not set)", "white" if workspace_name else "yellow")
+    _row("Session", session, "white")
+    if token and not no_check:
+        _base_url = entry.get("base_url", "")
+        if _base_url:
+            try:
+                _req = urllib.request.Request(
+                    f"https://datameshx.{_base_url}/api/v1/cli/config",
+                    headers={"Authorization": f"Bearer {token}"},
+                )
+                with urllib.request.urlopen(_req, timeout=4) as _r:
+                    _r.read()
+                _row("Auth", f"✓ token valid  (stp_***{token[-4:]}{expiry_str})", "green" if not expiry_warn else "yellow")
+            except urllib.error.HTTPError as _e:
+                if _e.code == 401:
+                    _row("Auth", f"✗ token invalid/revoked  (stp_***{token[-4:]}{expiry_str})", "red")
+                else:
+                    _row("Auth", f"✓ token valid  (stp_***{token[-4:]}{expiry_str})", "green" if not expiry_warn else "yellow")
+            except Exception as _e:
+                _row("Auth", f"{token_display}  (validation failed: {_e})", token_color)
+        else:
+            _row("Auth", token_display, token_color)
+    else:
+        _row("Auth", token_display, token_color)
+
+    tiers = ["bronze", "silver", "gold"]
+    s3_rows = []
+    for tier in tiers:
+        tier_up = tier.upper()
+        bucket = os.getenv(f"{tier_up}_BUCKET", "")
+        if bucket:
+            s3_rows.append((f"S3 {tier}", f"s3://{bucket}/_store/{branch}/"))
+    for ws in _detect_workspaces():
+        for tier in tiers:
+            bucket = os.getenv(f"{ws}_BUCKET_{tier.upper()}", "")
+            if bucket:
+                s3_rows.append((f"S3 {ws.lower()}/{tier}", f"s3://{bucket}/_store/{branch}/"))
+
+    _section("Storage Paths")
+    if s3_rows:
+        for label, path in s3_rows:
+            _row(label, path, "cyan")
+    else:
+        _row("S3", "(no bucket env vars found)", "yellow")
+    _row("Iceberg base", f"_iceberg/{branch}/", "cyan")
+
+    trino_endpoint = get_service_url("trino", workspace_id or None)
+    resolved_workspace = workspace_name or workspace_id or ""
+    trino_catalog = os.getenv("TRINO_CATALOG", "minio")
+    trino_schema_explicit = os.getenv("TRINO_SCHEMA", "")
+
+    _section("Trino")
+    if trino_endpoint:
+        _row("Endpoint", trino_endpoint, "cyan")
+    else:
+        _row("Endpoint", "✗ not configured (login required)", "yellow")
+    _row("Catalog", trino_catalog, "white")
+    for tier in tiers:
+        if trino_schema_explicit:
+            schema = trino_schema_explicit
+        elif resolved_workspace:
+            ws_clean = resolved_workspace.lower().replace("-", "_")
+            schema = f"{ws_clean}_{tier}__{branch}"
+        else:
+            schema = f"(workspace not set — set WORKSPACE_NAME)"
+        _row(f"Schema {tier}", schema, "cyan" if resolved_workspace or trino_schema_explicit else "yellow")
+        if trino_schema_explicit:
+            break
+
+    lakekeeper = os.getenv("LAKEKEEPER_ENDPOINT", "") or get_service_url("lakekeeper", workspace_id or None)
+
+    _section("Connectivity")
+    _cred_s3 = entry.get("s3_endpoint", "")
+    _env_s3 = os.getenv("S3_ENDPOINT", "")
+    if _cred_s3:
+        s3_endpoint = _cred_s3
+        s3_source = "credentials"
+    elif _env_s3:
+        s3_endpoint = _env_s3
+        s3_source = "S3_ENDPOINT env"
+    else:
+        s3_endpoint = "http://localhost:9000"
+        s3_source = "default"
+    _check("S3 endpoint", s3_endpoint, suffix=f"  (from {s3_source})")
+    if trino_endpoint:
+        if no_check:
+            _row("Trino", "(skipped)", "bright_black")
+        else:
+            try:
+                import json as _json
+                req = urllib.request.Request(f"{trino_endpoint}/v1/info")
+                if token:
+                    req.add_header("Authorization", f"Bearer {token}")
+                req.add_header("X-Trino-User", os.getenv("TRINO_USER", "admin"))
+                with urllib.request.urlopen(req, timeout=3) as r:
+                    info = _json.loads(r.read())
+                version_str = info.get("nodeVersion", {}).get("version", "?")
+                state = info.get("state", "?")
+                uptime = info.get("uptime", "")
+                detail = f"v{version_str} {state.lower()}" + (f", up {uptime}" if uptime else "")
+                _row("Trino", f"✓ reachable  ({detail})  {trino_endpoint}", "green")
+            except Exception as e:
+                _row("Trino", f"✗ unreachable: {e}", "red")
+    else:
+        _row("Trino", "✗ not configured", "yellow")
+    if lakekeeper:
+        _check("Lakekeeper", f"{lakekeeper}/catalog/v1/config")
+    else:
+        _row("Lakekeeper", "(not configured — set LAKEKEEPER_ENDPOINT or login with --url)", "bright_black")
+
+    _section("Environment")
+    for ef in env_files:
+        state = "✓ found" if ef.exists() else "✗ missing"
+        color = "green" if ef.exists() else "bright_black"
+        _row(ef.name, state, color)
+    _row("STEVE_BRANCH", repr(steve_branch_env) if steve_branch_env else "(not set — auto-detected)", "white" if steve_branch_env else "bright_black")
+    detected_ws = _detect_workspaces()
+    if detected_ws:
+        _row("Upstream ws", ", ".join(detected_ws), "white")
+    click.echo()
+
+
 @main.command("upgrade")
 def upgrade():
     """Upgrade steve-cli to the latest version."""

{steve_cli-0.5.5 → steve_cli-1.0.1}/steve_cli/decorators/lineage_job.py

@@ -67,8 +67,12 @@ def lineage_job(
                 import click
                 from steve_cli.validation.port import DataQualityError
                 if isinstance(exc, (DataQualityError, EnvironmentError)):
-                    click.secho(f"ERROR {exc}", fg="red", bold=True, err=True)
+                    click.secho(f"ERROR [{job_name}] {exc}", fg="red", bold=True, err=True)
                     sys.exit(1)
+                click.secho(
+                    f"ERROR [{job_name}] {type(exc).__name__}: {exc}",
+                    fg="red", bold=True, err=True,
+                )
                 raise
 
             session.complete()

{steve_cli-0.5.5 → steve_cli-1.0.1}/steve_cli/storage/__init__.py

@@ -1,3 +1,4 @@
+from .branch import get_branch_prefix
 from .protocol import Storage
 from .s3 import S3Storage
 from .trino import TrinoStorage
@@ -5,6 +6,7 @@ from .parquet import ParquetMetadata, extract_parquet_metadata
 from .metadata import FileMetadata, ColumnMetadata, MetadataExtractorPort, MetadataRegistry
 
 __all__ = [
+    "get_branch_prefix",
     "Storage",
     "S3Storage",
     "TrinoStorage",

steve_cli-1.0.1/steve_cli/storage/branch.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+import logging
+import os
+import re
+import subprocess
+
+logger = logging.getLogger(__name__)
+
+_MAIN_BRANCHES = {"main", "master"}
+
+
+def _sanitize(branch: str) -> str:
+    branch = branch.lower().strip()
+    branch = re.sub(r"[^a-z0-9]+", "_", branch)
+    return branch.strip("_") or "main"
+
+
+def get_branch_prefix() -> str:
+    for env_var in ("STEVE_BRANCH", "GITHUB_HEAD_REF", "GITHUB_REF_NAME"):
+        value = os.getenv(env_var, "").strip()
+        if value:
+            return _sanitize(value)
+
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+            capture_output=True,
+            text=True,
+            timeout=3,
+        )
+        if result.returncode == 0:
+            branch = result.stdout.strip()
+            if branch and branch != "HEAD":
+                return _sanitize(branch)
+    except Exception as exc:
+        logger.debug("git branch detection failed: %s", exc)
+
+    logger.warning("Could not detect git branch; defaulting to 'main'")
+    return "main"

{steve_cli-0.5.5 → steve_cli-1.0.1}/steve_cli/storage/s3.py

@@ -3,25 +3,35 @@ from __future__ import annotations
 import logging
 import os
 from pathlib import Path, PurePosixPath
-from typing import List
 
 import boto3
 from botocore.client import Config
 from botocore.exceptions import ClientError, EndpointConnectionError
 
+from .branch import get_branch_prefix
+from steve_cli.auth import get_s3_endpoint
+
 logger = logging.getLogger(__name__)
 
 
 class S3Storage:
     def __init__(self, tier: str = "bronze", workspace: str | None = None):
         self.tier = tier.lower()
+        self._branch = get_branch_prefix()
         self.endpoint, self.bucket, access_key, secret_key, required_vars = (
             self._load_config(self.tier, workspace)
         )
 
+        cred_endpoint = get_s3_endpoint()
+        if cred_endpoint:
+            self.endpoint = cred_endpoint
+            self._endpoint_source = "credentials"
+        else:
+            self._endpoint_source = "env" if os.getenv("S3_ENDPOINT") else "default"
+
         missing = [v for v in required_vars if not os.getenv(v)]
         if missing:
-            raise EnvironmentError(
+            raise OSError(
                 f"Missing required environment variables for {self.tier} tier: "
                 f"{', '.join(missing)}"
             )
@@ -67,33 +77,48 @@ class S3Storage:
             ]
         return endpoint, bucket, access_key, secret_key, required
 
-    @staticmethod
-    def _key(path: str) -> str:
+    def _key(self, path: str) -> str:
         if not path:
-            return ""
-        return str(PurePosixPath(path).as_posix().lstrip("/"))
+            return f"_store/{self._branch}/"
+        clean = str(PurePosixPath(path).as_posix().lstrip("/"))
+        return f"_store/{self._branch}/{clean}"
 
     def _object_location(self, path: str) -> str:
         return f"{self.endpoint}/{self.bucket}/{self._key(path)}"
 
     def _handle_client_error(self, error: ClientError, path: str, operation: str) -> None:
         code = error.response["Error"]["Code"]
+        key = self._key(path)
+        tier_upper = self.tier.upper()
+        location = f"s3://{self.bucket}/{key} at {self.endpoint}"
         if code == "AccessDenied":
-            logger.error("Access denied when %s: %s (BUCKET=%s)", operation, path, self.bucket)
+            logger.error("S3Storage: Access Denied when %s [%s]", operation, location)
+            raise OSError(
+                f"S3Storage: {operation} failed — Access Denied [{location}] "
+                f"(check {tier_upper}_ACCESS_KEY / {tier_upper}_SECRET_KEY have permission)"
+            )
         elif code == "NoSuchBucket":
-            logger.error("Bucket not found: %s", self.bucket)
+            logger.error("S3Storage: bucket not found [bucket=%s, endpoint=%s]", self.bucket, self.endpoint)
+            raise OSError(
+                f"S3Storage: {operation} failed — bucket '{self.bucket}' not found at {self.endpoint}"
+            )
         elif code == "NoSuchKey":
-            logger.warning("File not found: %s while %s on BUCKET=%s", path, operation, self.bucket)
+            logger.warning("S3Storage: key not found when %s [%s]", operation, location)
+            raise OSError(
+                f"S3Storage: {operation} failed — key not found [s3://{self.bucket}/{key}]"
+            )
         else:
-            logger.error("Storage error during %s: %s (BUCKET=%s)", operation, error, self.bucket)
-        raise EnvironmentError(f"S3 {operation} failed for {path}: {error.response['Error']['Code']}")
+            logger.error("S3Storage: %s error when %s [%s]: %s", code, operation, location, error)
+            raise OSError(
+                f"S3Storage: {operation} failed — {code} [s3://{self.bucket}/{key} at {self.endpoint}]"
+            )
 
     def put_file(self, local_path: str, path: str) -> None:
         try:
             self.client.upload_file(local_path, self.bucket, self._key(path))
             logger.info("Uploaded %s", self._object_location(path))
         except EndpointConnectionError:
-            raise EnvironmentError(f"Cannot connect to storage at {self.endpoint}")
+            raise OSError(f"S3Storage: cannot connect to S3 endpoint at {self.endpoint} (uploading {path})")
         except ClientError as e:
             self._handle_client_error(e, path, "uploading")
 
@@ -103,7 +128,7 @@ class S3Storage:
             self.client.download_file(self.bucket, self._key(path), local_path)
             logger.info("Downloaded %s", self._object_location(path))
         except EndpointConnectionError:
-            raise EnvironmentError(f"Cannot connect to storage at {self.endpoint}")
+            raise OSError(f"S3Storage: cannot connect to S3 endpoint at {self.endpoint} (downloading {path})")
         except ClientError as e:
             self._handle_client_error(e, path, "downloading")
 
@@ -112,7 +137,7 @@ class S3Storage:
             self.client.put_object(Bucket=self.bucket, Key=self._key(path), Body=data)
             logger.info("Stored %s", self._object_location(path))
         except EndpointConnectionError:
-            raise EnvironmentError(f"Cannot connect to storage at {self.endpoint}")
+            raise OSError(f"S3Storage: cannot connect to S3 endpoint at {self.endpoint} (writing {path})")
         except ClientError as e:
             self._handle_client_error(e, path, "writing")
 
@@ -122,16 +147,16 @@ class S3Storage:
             logger.info("Retrieved %s", self._object_location(path))
             return obj["Body"].read()
         except EndpointConnectionError:
-            raise EnvironmentError(f"Cannot connect to storage at {self.endpoint}")
+            raise OSError(f"S3Storage: cannot connect to S3 endpoint at {self.endpoint} (reading {path})")
         except ClientError as e:
             self._handle_client_error(e, path, "reading")
 
-    def list(self, prefix: str = "") -> List[str]:
-        keys: List[str] = []
+    def list(self, prefix: str = "") -> list[str]:
+        keys: list[str] = []
         paginator = self.client.get_paginator("list_objects_v2")
         for page in paginator.paginate(Bucket=self.bucket, Prefix=self._key(prefix)):
             keys.extend(obj["Key"] for obj in page.get("Contents", []))
         return keys
 
-    def list_all(self) -> List[str]:
+    def list_all(self) -> list[str]:
         return self.list()