neurabridge 0.1.0__tar.gz

neurabridge-0.1.0/CHANGELOG.md

@@ -0,0 +1,28 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.1.0] - 2024-06-15
+
+### Added
+- Initial public release of the Neurabridge Python SDK
+- Client authentication and API access
+- Experiment discovery and run listing
+- Run download and caching functionality
+- Signal data loading as pandas DataFrames
+- Image artifact loading with Pillow support
+- Local analysis session management with manifest support
+- Support for bulk downloading across multiple experiments
+- Channel name metadata support in dataset loading
+- Progress tracking for long-running operations
+- Comprehensive test suite with pytest
+
+### Features
+- `Client` class for API interaction
+- `Experiment`, `Run`, and `LocalRun` classes for data representation
+- `ExperimentCollection` and `LocalRunCollection` for batch operations
+- `AnalysisSession` for reproducible local analysis workflows
+- Full test coverage for core functionality

neurabridge-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Neurabridge
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

neurabridge-0.1.0/PKG-INFO

@@ -0,0 +1,263 @@
+Metadata-Version: 2.4
+Name: neurabridge
+Version: 0.1.0
+Summary: Neurabridge Python SDK for experiment access and analysis workflows
+Project-URL: Homepage, https://neurabridge.io
+Project-URL: Repository, https://github.com/neurabridge-io/neurabridge_sdk
+Project-URL: Documentation, https://neurabridge.io
+Project-URL: Bug Tracker, https://github.com/neurabridge-io/neurabridge_sdk/issues
+Author: Neurabridge
+License: MIT
+License-File: LICENSE
+Keywords: brain-computer-interface,data-analysis,eeg,neuroscience,signal-processing
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Medical Science Apps.
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27
+Requires-Dist: numpy>=1.26
+Requires-Dist: pandas>=2.0
+Requires-Dist: pillow>=10
+Requires-Dist: tqdm>=4.66
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# neurabridge
+
+Neurabridge.io is the software layer for turning brain signal data into usable models and APIs.
+
+It brings hardware-integrated research workflows, analysis pipelines, and application development into one system so teams can move from signal collection to deployable intelligence faster.
+
+`neurabridge` is the official Python SDK for accessing that workflow programmatically.
+It provides a focused interface for discovering experiments, downloading run artifacts, decoding datasets, and organizing reproducible local analysis sessions.
+
+Neurabridge is built for engineers, researchers, institutions, and hardware-adjacent product teams working with EEG and related brain signals. The platform is designed to support model development for studies, regressors, classifiers, and intent or activity segmentation systems, then expose those outputs through software interfaces that manufacturers and entrepreneurs can build on.
+
+## Installation
+
+```bash
+pip install .
+```
+
+For local development:
+
+```bash
+pip install -e .[dev]
+```
+
+## What The SDK Covers
+
+- Authenticate against a Neurabridge API environment
+- List experiments and runs visible to the current token
+- Download a single run or all runs in a collection
+- Load decoded signal datasets as pandas DataFrames
+- Load associated image artifacts with Pillow
+- Create portable local analysis sessions with a manifest
+
+## Why It Exists
+
+Brain-computer application development is fragmented across vendors, protocols, experimental setups, device integrations, raw data handling, one-off analysis scripts, and ad hoc model pipelines.
+Neurabridge consolidates those steps into a software-first foundation that makes brain signal data easier to inspect, organize, model, and expose through downstream products.
+
+For technical teams, that means less time spent stitching together infrastructure and more time spent building useful systems on top of brain data.
+
+## Quick Start
+
+```python
+import neurabridge as nb
+
+client = nb.Client(
+    base_url="https://api.neurabridge.dev",
+    token="nbk_live_xxxxx",
+)
+
+whoami = client.whoami()
+experiments = client.experiments()
+
+experiment = experiments[0]
+run = client.runs(experiment.id)[0]
+local_run = client.download(experiment.id, run.id)
+
+dataset = local_run.dataset
+metadata_named_dataset = local_run.load_dataset(use_metadata_channel_names=True)
+images = local_run.images()
+```
+
+## Standard Workflow
+
+```python
+import neurabridge as nb
+from neurabridge import session
+
+client = nb.Client(base_url="https://api.neurabridge.dev", token="nbk_live_xxxxx")
+
+experiments = client.experiments()
+selected_experiment = experiments[0]
+selected_run = client.runs(selected_experiment.id)[0]
+
+local_run = client.download(selected_experiment.id, selected_run.id, show_progress=False)
+
+analysis_session = session.AnalysisSession.create(
+    name="example-session",
+    runs=[local_run],
+    base_dir="./analysis",
+)
+
+signals = analysis_session.load_signals(
+    exp_id=local_run.experiment_id,
+    run_id=local_run.run_id,
+)
+images = analysis_session.load_images(
+    exp_id=local_run.experiment_id,
+    run_id=local_run.run_id,
+)
+```
+
+## Working Across Runs
+
+```python
+client = nb.Client(base_url="https://api.neurabridge.dev", token="nbk_live_xxxxx")
+
+experiments = client.experiments()
+all_runs = experiments.download_all(show_progress=False)
+stacked_dataset = all_runs.dataset
+```
+
+## Platform Fit
+
+Neurabridge does not build hardware devices today. It is intended to sit above hardware and unify the software layer around it: experiment data access, signal decoding, analysis workflows, model development, and API-ready outputs.
+
+That makes it useful both for internal research teams and for external partners who want a faster path from hardware-generated brain data to applications.
+
+## Public API
+
+The root package exposes the main stable entry points:
+
+- `neurabridge.Client`
+- `neurabridge.AnalysisSession`
+- `neurabridge.Experiment`
+- `neurabridge.Run`
+- `neurabridge.LocalRun`
+- `neurabridge.ExperimentCollection`
+- `neurabridge.LocalRunCollection`
+
+Segmented namespaces are also available when you want to keep imports explicit:
+
+```python
+from neurabridge import experiment, session
+```
+
+### Client
+
+Main entry point for interacting with the Neurabridge API.
+
+| Method | Parameters | Returns | Description |
+|--------|-----------|---------|-------------|
+| `whoami()` | — | `dict` | Get the authenticated user information |
+| `experiments()` | — | `ExperimentCollection` | List all experiments accessible to the token |
+| `runs(exp_id)` | `exp_id: str` | `list[Run]` | Get all runs for a specific experiment |
+| `download(exp_id, run_id, show_progress)` | `exp_id: str`, `run_id: str`, `show_progress: bool = True` | `LocalRun` | Download a single run to local cache |
+| `download_all(show_progress)` | `show_progress: bool = True` | `LocalRunCollection` | Download all runs from all experiments |
+| `delete_run(exp_id, run_id)` | `exp_id: str`, `run_id: str` | `int` | Delete a specific run from the server |
+| `delete_experiment(exp_id)` | `exp_id: str` | `int` | Delete an entire experiment from the server |
+| `close()` | — | — | Close the client and clean up resources |
+
+### Experiment
+
+Metadata and stats about a remote experiment.
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `id` | `str` | Unique experiment identifier |
+| `path` | `str` | Experiment path/location on server |
+| `run_count` | `int` | Number of runs in this experiment |
+| `updated_at` | `str \| None` | Last update timestamp |
+
+### Run
+
+Metadata about a remote run (before download).
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `id` | `str` | Unique run identifier |
+| `experiment_id` | `str` | ID of parent experiment |
+| `path` | `str` | Run path/location on server |
+| `artifact_count` | `int` | Number of artifacts (signals, images, etc.) |
+| `size_bytes` | `int` | Total size of run data in bytes |
+| `updated_at` | `str \| None` | Last update timestamp |
+
+### LocalRun
+
+A downloaded run with local file access and data loading capabilities.
+
+| Property/Method | Returns | Description |
+|---------|---------|-------------|
+| `id` | `str` | Alias for `run_id` |
+| `run_id` | `str` | The run's unique identifier |
+| `experiment_id` | `str` | Parent experiment ID |
+| `path` | `Path` | Local filesystem path to downloaded run |
+| `signal_files` | `list[Path]` | Paths to signal artifact files |
+| `image_files` | `list[Path]` | Paths to image artifact files |
+| `dataset` | `DataFrame` | Cached property: all signal data as pandas DataFrame |
+| `metadata` | `dict` | Experiment metadata (channel names, sampling rates, etc.) |
+| `image` | `Image` | First image artifact as PIL Image object |
+| `images` | `list[tuple[dict, Image]]` | All image artifacts with metadata |
+| `load_dataset(use_metadata_channel_names)` | `DataFrame` | Load signal data with optional metadata-based column names |
+
+### ExperimentCollection
+
+A list-like collection of `Experiment` objects with batch operations.
+
+| Method | Parameters | Returns | Description |
+|--------|-----------|---------|-------------|
+| `download_all(show_progress)` | `show_progress: bool = True` | `LocalRunCollection` | Download all runs from all experiments in collection |
+
+### LocalRunCollection
+
+A list-like collection of `LocalRun` objects with aggregation operations.
+
+| Property/Method | Returns | Description |
+|---------|---------|-------------|
+| `dataset` | `DataFrame` | Cached property: stacked signal data from all runs |
+| `load_dataset(use_metadata_channel_names, force_reload)` | `DataFrame` | Load and concatenate all run datasets with optional cache control |
+| `profile_dataset_load(use_metadata_channel_names, force_reload)` | `dict` | Load all datasets while measuring timing, row/column counts per run |
+
+### AnalysisSession
+
+Local writable workspace for reproducible analysis across downloaded runs.
+
+| Method | Parameters | Returns | Description |
+|--------|-----------|---------|-------------|
+| `create(name, runs, base_dir)` | `name: str`, `runs: Iterable[LocalRun]`, `base_dir: str \| Path` | `AnalysisSession` | Create a new analysis session workspace with run data |
+| `open(session_path)` | `session_path: str \| Path` | `AnalysisSession` | Open an existing session from disk |
+| `list(base_dir)` | `base_dir: str \| Path` | `list[AnalysisSession]` | List all valid sessions under a directory |
+| `load_signals(exp_id, run_id, use_metadata_channel_names)` | `exp_id: str`, `run_id: str`, `use_metadata_channel_names: bool = False` | `DataFrame` | Load signal data from session workspace |
+| `load_images(exp_id, run_id)` | `exp_id: str`, `run_id: str` | `list[tuple[dict, Image]]` | Load image artifacts from session workspace |
+| `delete()` | — | — | Delete the session directory from disk |
+
+### Session Properties
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `name` | `str` | Session name |
+| `path` | `Path` | Local filesystem path to session directory |
+| `manifest` | `dict` | Session metadata manifest (JSON-serializable dict with run info) |
+
+## Notes
+
+- Signal data is returned as pandas DataFrames
+- Image artifacts are returned as Pillow images
+- Downloads are cached locally under the SDK cache directory
+- Analysis sessions store a lightweight manifest so downloaded runs can be reopened consistently
+- The SDK is intentionally read-oriented and centered on analysis and downstream application workflows
+
+## Validation Notebook
+
+The repository includes a smoke-test notebook that exercises the main SDK flow from authentication through dataset loading, manifest decoding, image rendering, and bulk download.

neurabridge-0.1.0/README.md

@@ -0,0 +1,232 @@
+# neurabridge
+
+Neurabridge.io is the software layer for turning brain signal data into usable models and APIs.
+
+It brings hardware-integrated research workflows, analysis pipelines, and application development into one system so teams can move from signal collection to deployable intelligence faster.
+
+`neurabridge` is the official Python SDK for accessing that workflow programmatically.
+It provides a focused interface for discovering experiments, downloading run artifacts, decoding datasets, and organizing reproducible local analysis sessions.
+
+Neurabridge is built for engineers, researchers, institutions, and hardware-adjacent product teams working with EEG and related brain signals. The platform is designed to support model development for studies, regressors, classifiers, and intent or activity segmentation systems, then expose those outputs through software interfaces that manufacturers and entrepreneurs can build on.
+
+## Installation
+
+```bash
+pip install .
+```
+
+For local development:
+
+```bash
+pip install -e .[dev]
+```
+
+## What The SDK Covers
+
+- Authenticate against a Neurabridge API environment
+- List experiments and runs visible to the current token
+- Download a single run or all runs in a collection
+- Load decoded signal datasets as pandas DataFrames
+- Load associated image artifacts with Pillow
+- Create portable local analysis sessions with a manifest
+
+## Why It Exists
+
+Brain-computer application development is fragmented across vendors, protocols, experimental setups, device integrations, raw data handling, one-off analysis scripts, and ad hoc model pipelines.
+Neurabridge consolidates those steps into a software-first foundation that makes brain signal data easier to inspect, organize, model, and expose through downstream products.
+
+For technical teams, that means less time spent stitching together infrastructure and more time spent building useful systems on top of brain data.
+
+## Quick Start
+
+```python
+import neurabridge as nb
+
+client = nb.Client(
+    base_url="https://api.neurabridge.dev",
+    token="nbk_live_xxxxx",
+)
+
+whoami = client.whoami()
+experiments = client.experiments()
+
+experiment = experiments[0]
+run = client.runs(experiment.id)[0]
+local_run = client.download(experiment.id, run.id)
+
+dataset = local_run.dataset
+metadata_named_dataset = local_run.load_dataset(use_metadata_channel_names=True)
+images = local_run.images()
+```
+
+## Standard Workflow
+
+```python
+import neurabridge as nb
+from neurabridge import session
+
+client = nb.Client(base_url="https://api.neurabridge.dev", token="nbk_live_xxxxx")
+
+experiments = client.experiments()
+selected_experiment = experiments[0]
+selected_run = client.runs(selected_experiment.id)[0]
+
+local_run = client.download(selected_experiment.id, selected_run.id, show_progress=False)
+
+analysis_session = session.AnalysisSession.create(
+    name="example-session",
+    runs=[local_run],
+    base_dir="./analysis",
+)
+
+signals = analysis_session.load_signals(
+    exp_id=local_run.experiment_id,
+    run_id=local_run.run_id,
+)
+images = analysis_session.load_images(
+    exp_id=local_run.experiment_id,
+    run_id=local_run.run_id,
+)
+```
+
+## Working Across Runs
+
+```python
+client = nb.Client(base_url="https://api.neurabridge.dev", token="nbk_live_xxxxx")
+
+experiments = client.experiments()
+all_runs = experiments.download_all(show_progress=False)
+stacked_dataset = all_runs.dataset
+```
+
+## Platform Fit
+
+Neurabridge does not build hardware devices today. It is intended to sit above hardware and unify the software layer around it: experiment data access, signal decoding, analysis workflows, model development, and API-ready outputs.
+
+That makes it useful both for internal research teams and for external partners who want a faster path from hardware-generated brain data to applications.
+
+## Public API
+
+The root package exposes the main stable entry points:
+
+- `neurabridge.Client`
+- `neurabridge.AnalysisSession`
+- `neurabridge.Experiment`
+- `neurabridge.Run`
+- `neurabridge.LocalRun`
+- `neurabridge.ExperimentCollection`
+- `neurabridge.LocalRunCollection`
+
+Segmented namespaces are also available when you want to keep imports explicit:
+
+```python
+from neurabridge import experiment, session
+```
+
+### Client
+
+Main entry point for interacting with the Neurabridge API.
+
+| Method | Parameters | Returns | Description |
+|--------|-----------|---------|-------------|
+| `whoami()` | — | `dict` | Get the authenticated user information |
+| `experiments()` | — | `ExperimentCollection` | List all experiments accessible to the token |
+| `runs(exp_id)` | `exp_id: str` | `list[Run]` | Get all runs for a specific experiment |
+| `download(exp_id, run_id, show_progress)` | `exp_id: str`, `run_id: str`, `show_progress: bool = True` | `LocalRun` | Download a single run to local cache |
+| `download_all(show_progress)` | `show_progress: bool = True` | `LocalRunCollection` | Download all runs from all experiments |
+| `delete_run(exp_id, run_id)` | `exp_id: str`, `run_id: str` | `int` | Delete a specific run from the server |
+| `delete_experiment(exp_id)` | `exp_id: str` | `int` | Delete an entire experiment from the server |
+| `close()` | — | — | Close the client and clean up resources |
+
+### Experiment
+
+Metadata and stats about a remote experiment.
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `id` | `str` | Unique experiment identifier |
+| `path` | `str` | Experiment path/location on server |
+| `run_count` | `int` | Number of runs in this experiment |
+| `updated_at` | `str \| None` | Last update timestamp |
+
+### Run
+
+Metadata about a remote run (before download).
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `id` | `str` | Unique run identifier |
+| `experiment_id` | `str` | ID of parent experiment |
+| `path` | `str` | Run path/location on server |
+| `artifact_count` | `int` | Number of artifacts (signals, images, etc.) |
+| `size_bytes` | `int` | Total size of run data in bytes |
+| `updated_at` | `str \| None` | Last update timestamp |
+
+### LocalRun
+
+A downloaded run with local file access and data loading capabilities.
+
+| Property/Method | Returns | Description |
+|---------|---------|-------------|
+| `id` | `str` | Alias for `run_id` |
+| `run_id` | `str` | The run's unique identifier |
+| `experiment_id` | `str` | Parent experiment ID |
+| `path` | `Path` | Local filesystem path to downloaded run |
+| `signal_files` | `list[Path]` | Paths to signal artifact files |
+| `image_files` | `list[Path]` | Paths to image artifact files |
+| `dataset` | `DataFrame` | Cached property: all signal data as pandas DataFrame |
+| `metadata` | `dict` | Experiment metadata (channel names, sampling rates, etc.) |
+| `image` | `Image` | First image artifact as PIL Image object |
+| `images` | `list[tuple[dict, Image]]` | All image artifacts with metadata |
+| `load_dataset(use_metadata_channel_names)` | `DataFrame` | Load signal data with optional metadata-based column names |
+
+### ExperimentCollection
+
+A list-like collection of `Experiment` objects with batch operations.
+
+| Method | Parameters | Returns | Description |
+|--------|-----------|---------|-------------|
+| `download_all(show_progress)` | `show_progress: bool = True` | `LocalRunCollection` | Download all runs from all experiments in collection |
+
+### LocalRunCollection
+
+A list-like collection of `LocalRun` objects with aggregation operations.
+
+| Property/Method | Returns | Description |
+|---------|---------|-------------|
+| `dataset` | `DataFrame` | Cached property: stacked signal data from all runs |
+| `load_dataset(use_metadata_channel_names, force_reload)` | `DataFrame` | Load and concatenate all run datasets with optional cache control |
+| `profile_dataset_load(use_metadata_channel_names, force_reload)` | `dict` | Load all datasets while measuring timing, row/column counts per run |
+
+### AnalysisSession
+
+Local writable workspace for reproducible analysis across downloaded runs.
+
+| Method | Parameters | Returns | Description |
+|--------|-----------|---------|-------------|
+| `create(name, runs, base_dir)` | `name: str`, `runs: Iterable[LocalRun]`, `base_dir: str \| Path` | `AnalysisSession` | Create a new analysis session workspace with run data |
+| `open(session_path)` | `session_path: str \| Path` | `AnalysisSession` | Open an existing session from disk |
+| `list(base_dir)` | `base_dir: str \| Path` | `list[AnalysisSession]` | List all valid sessions under a directory |
+| `load_signals(exp_id, run_id, use_metadata_channel_names)` | `exp_id: str`, `run_id: str`, `use_metadata_channel_names: bool = False` | `DataFrame` | Load signal data from session workspace |
+| `load_images(exp_id, run_id)` | `exp_id: str`, `run_id: str` | `list[tuple[dict, Image]]` | Load image artifacts from session workspace |
+| `delete()` | — | — | Delete the session directory from disk |
+
+### Session Properties
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `name` | `str` | Session name |
+| `path` | `Path` | Local filesystem path to session directory |
+| `manifest` | `dict` | Session metadata manifest (JSON-serializable dict with run info) |
+
+## Notes
+
+- Signal data is returned as pandas DataFrames
+- Image artifacts are returned as Pillow images
+- Downloads are cached locally under the SDK cache directory
+- Analysis sessions store a lightweight manifest so downloaded runs can be reopened consistently
+- The SDK is intentionally read-oriented and centered on analysis and downstream application workflows
+
+## Validation Notebook
+
+The repository includes a smoke-test notebook that exercises the main SDK flow from authentication through dataset loading, manifest decoding, image rendering, and bulk download.

neurabridge-0.1.0/neurabridge/__init__.py

@@ -0,0 +1,32 @@
+from . import experiment, session
+from .api import Client
+from .experiment import Experiment, ExperimentCollection, LocalRun, LocalRunCollection, Run
+from .session import AnalysisSession
+from .version import __version__
+from .errors import (
+    AuthError,
+    DownloadError,
+    NeurabridgeError,
+    NotFoundError,
+    PermissionError,
+    SessionError,
+)
+
+__all__ = [
+    "__version__",
+    "experiment",
+    "session",
+    "Client",
+    "AnalysisSession",
+    "Experiment",
+    "ExperimentCollection",
+    "Run",
+    "LocalRun",
+    "LocalRunCollection",
+    "NeurabridgeError",
+    "AuthError",
+    "PermissionError",
+    "NotFoundError",
+    "DownloadError",
+    "SessionError",
+]

neurabridge-0.1.0/neurabridge/api/__init__.py

@@ -0,0 +1,3 @@
+from .client import Client
+
+__all__ = ["Client"]

neurabridge-0.1.0/neurabridge/api/client.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import httpx
+
+from ..experiment.catalog import delete_experiment, delete_run, list_experiments, list_runs
+from ..experiment.downloads import download_run
+from ..experiment.models import ExperimentCollection, LocalRun, LocalRunCollection, Run
+from .transport import ApiTransport
+
+
+class Client:
+    def __init__(
+        self,
+        *,
+        token: str | None = None,
+        base_url: str | None = None,
+        cache_dir: str | Path | None = None,
+        timeout: float = 30.0,
+        max_retries: int = 2,
+        retry_backoff_seconds: float = 0.3,
+        transport: httpx.BaseTransport | None = None,
+        download_transport: httpx.BaseTransport | None = None,
+    ) -> None:
+        self._transport = ApiTransport(
+            token=token,
+            base_url=base_url,
+            cache_dir=cache_dir,
+            timeout=timeout,
+            max_retries=max_retries,
+            retry_backoff_seconds=retry_backoff_seconds,
+            transport=transport,
+            download_transport=download_transport,
+        )
+
+    @property
+    def base_url(self) -> str:
+        return self._transport.base_url
+
+    @property
+    def token(self) -> str:
+        return self._transport.token
+
+    @property
+    def timeout(self) -> float:
+        return self._transport.timeout
+
+    @property
+    def max_retries(self) -> int:
+        return self._transport.max_retries
+
+    @property
+    def retry_backoff_seconds(self) -> float:
+        return self._transport.retry_backoff_seconds
+
+    @property
+    def cache_dir(self) -> Path:
+        return self._transport.cache_dir
+
+    def close(self) -> None:
+        self._transport.close()
+
+    def __enter__(self) -> "Client":
+        return self
+
+    def __exit__(self, exc_type: object, exc: object, tb: object) -> None:
+        self.close()
+
+    def whoami(self) -> dict[str, object]:
+        data = self._transport.request_json("GET", "/v1/whoami")
+        user = data.get("user", data)
+        return user if isinstance(user, dict) else {"user": user}
+
+    def experiments(self) -> ExperimentCollection:
+        return list_experiments(self)
+
+    def runs(self, exp_id: str) -> list[Run]:
+        return list_runs(self, exp_id)
+
+    def download(self, exp_id: str, run_id: str, *, show_progress: bool = True) -> LocalRun:
+        return download_run(self, exp_id=exp_id, run_id=run_id, show_progress=show_progress)
+
+    def download_all(self, *, show_progress: bool = True) -> LocalRunCollection:
+        return self.experiments().download_all(show_progress=show_progress)
+
+    def delete_run(self, exp_id: str, run_id: str) -> int:
+        return delete_run(self, exp_id, run_id)
+
+    def delete_experiment(self, exp_id: str) -> int:
+        return delete_experiment(self, exp_id)