bunq-cli 0.2.0__py3-none-any.whl

bunq_cli/config.py

@@ -0,0 +1,180 @@
+"""Configuration management for Bunq CLI."""
+
+from __future__ import annotations
+
+import json
+import re
+import sys
+from pathlib import Path
+
+import click
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    try:
+        import tomllib
+    except ModuleNotFoundError:
+        import tomli as tomllib  # type: ignore[no-redef]
+
+
+DEFAULT_CONFIG_PATH = Path.home() / ".config" / "bunq-cli.toml"
+DEFAULT_CONTEXT_PATH = Path.home() / ".config" / "bunq-cli.conf"
+CONTEXTS_DIR = Path.home() / ".config" / "bunq-cli" / "contexts"
+PROFILE_NAME_RE = re.compile(r"^[A-Za-z0-9_-]+$")
+
+
+def _serialize_toml(data: dict, prefix: str = "") -> str:
+    """Serialize a dict to TOML format (minimal implementation)."""
+    lines: list[str] = []
+    for key, value in data.items():
+        if not isinstance(value, dict):
+            lines.append(f"{key} = {_toml_value(value)}")
+    for key, value in data.items():
+        if isinstance(value, dict):
+            full_key = f"{prefix}.{key}" if prefix else key
+            has_subtables = any(isinstance(v, dict) for v in value.values())
+            if has_subtables:
+                scalars = {k: v for k, v in value.items() if not isinstance(v, dict)}
+                if scalars:
+                    lines.append("")
+                    lines.append(f"[{full_key}]")
+                    for k, v in scalars.items():
+                        lines.append(f"{k} = {_toml_value(v)}")
+                subtables = {k: v for k, v in value.items() if isinstance(v, dict)}
+                lines.append(_serialize_toml(subtables, prefix=full_key))
+            else:
+                lines.append("")
+                lines.append(f"[{full_key}]")
+                for k, v in value.items():
+                    lines.append(f"{k} = {_toml_value(v)}")
+    return "\n".join(lines)
+
+
+def _toml_value(value: object) -> str:
+    if isinstance(value, str):
+        # JSON string escapes are valid TOML basic-string escapes.
+        return json.dumps(value)
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    if isinstance(value, int):
+        return str(value)
+    raise TypeError(f"Unsupported TOML value type: {type(value)}")
+
+
+def load_config(path: Path | None = None) -> dict:
+    """Load configuration from TOML file."""
+    config_path = path or DEFAULT_CONFIG_PATH
+    if not config_path.exists():
+        return {}
+    with open(config_path, "rb") as f:
+        return _migrate(tomllib.load(f))
+
+
+def _migrate(config: dict) -> dict:
+    """Turn the pre-profiles [credentials] section into a 'default' profile."""
+    creds = config.pop("credentials", None)
+    if creds and "profiles" not in config:
+        config["profiles"] = {
+            "default": {
+                "context_path": creds.get("context_path", str(DEFAULT_CONTEXT_PATH)),
+                "sandbox": creds.get("sandbox", False),
+            }
+        }
+        config.setdefault("default_profile", "default")
+    return config
+
+
+def restrict_permissions(path: Path) -> None:
+    """Best effort: create/chmod a credential file so only the owner can read it."""
+    try:
+        path.touch(mode=0o600, exist_ok=True)
+        path.chmod(0o600)
+    except OSError:
+        pass
+
+
+def save_config(data: dict, path: Path | None = None) -> None:
+    """Save configuration to TOML file."""
+    config_path = path or DEFAULT_CONFIG_PATH
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+    restrict_permissions(config_path)
+    config_path.write_text(_serialize_toml(data) + "\n")
+
+
+def validate_profile_name(name: str) -> str:
+    if not PROFILE_NAME_RE.match(name):
+        raise click.BadParameter(
+            f"Invalid profile name {name!r}: use letters, digits, '-' and '_'."
+        )
+    return name
+
+
+def profile_label(name: str, profile: dict) -> str:
+    display_name = profile.get("display_name")
+    return f"{display_name} ({name})" if display_name else name
+
+
+def resolve_profile(config: dict, name: str | None = None) -> tuple[str, dict]:
+    """Return (name, profile) for the requested, default or only profile."""
+    profiles = config.get("profiles", {})
+    if not profiles:
+        raise click.ClickException("Not logged in. Run 'bunq login' first.")
+    if name is None:
+        name = config.get("default_profile")
+    if name is None and len(profiles) == 1:
+        name = next(iter(profiles))
+    if name is None:
+        raise click.ClickException(
+            "Multiple profiles configured. Pass --profile NAME or run 'bunq profiles use NAME'."
+        )
+    if name not in profiles:
+        raise click.ClickException(
+            f"Unknown profile '{name}'. Run 'bunq profiles list' to see the available profiles."
+        )
+    return name, profiles[name]
+
+
+def set_profile(config: dict, name: str, **fields: object) -> dict:
+    """Create or update a profile; fields set to None are left unchanged."""
+    profile = config.setdefault("profiles", {}).setdefault(name, {})
+    profile.update({k: v for k, v in fields.items() if v is not None})
+    config.setdefault("default_profile", name)
+    return config
+
+
+def remove_profile(config: dict, name: str) -> dict:
+    config.get("profiles", {}).pop(name, None)
+    if not config.get("profiles"):
+        config.pop("profiles", None)
+    if config.get("default_profile") == name:
+        config.pop("default_profile")
+    return config
+
+
+def get_oauth_client(config: dict) -> dict:
+    """Get stored OAuth client credentials."""
+    return config.get("oauth", {})
+
+
+def set_oauth_client(
+    config: dict,
+    client_id: str,
+    client_secret: str,
+    oauth_client_id: int,
+    profile: str,
+) -> dict:
+    """Set OAuth client credentials in config."""
+    config["oauth"] = {
+        "client_id": client_id,
+        "client_secret": client_secret,
+        "oauth_client_id": oauth_client_id,
+        "profile": profile,
+    }
+    return config
+
+
+def remove_oauth_client(config: dict) -> dict:
+    """Remove stored OAuth client credentials."""
+    config.pop("oauth", None)
+    return config

bunq_cli/main.py

@@ -0,0 +1,210 @@
+"""Bunq CLI - main entry point and global options."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import click
+from click.core import ParameterSource
+
+from bunq_cli.client import BunqClient
+from bunq_cli.config import (
+    DEFAULT_CONFIG_PATH,
+    load_config,
+    profile_label,
+    resolve_profile,
+)
+from bunq_cli.output import format_output
+
+# Commands that manage profiles/credentials themselves and make no sense per profile.
+SINGLE_PROFILE_COMMANDS = {"login", "logout", "profiles", "sandbox", "oauth-client"}
+
+
+class Context:
+    """Shared context for all commands."""
+
+    def __init__(self) -> None:
+        self.verbose: bool = False
+        self.quiet: bool = False
+        self.output_format: str = "auto"
+        self.no_color: bool = False
+        self.sandbox: bool = False
+        self.config_path: Path = DEFAULT_CONFIG_PATH
+        self.token: str | None = None
+        self.profile: str | None = None
+        self.all_profiles: bool = False
+        self.profile_name: str | None = None
+        self.profile_label: str = ""
+        # Set when running one profile of an --all-profiles invocation.
+        self.loop_profile: str | None = None
+        self.collected: list[tuple[object, list[str] | None]] | None = None
+
+    def get_client(self, write: bool = False, profile: str | None = None) -> BunqClient:
+        """Build a BunqClient for the selected profile.
+
+        ``write`` marks commands that change data: they are refused for
+        read-only profiles and with --all-profiles.
+        """
+        if write and self.all_profiles:
+            raise click.UsageError("This command changes data and can't be used with --all-profiles.")
+        name, settings = resolve_profile(load_config(self.config_path), profile or self.profile)
+        if write and settings.get("read_only"):
+            raise click.ClickException(f"Profile '{name}' is read-only.")
+        self.profile_name = name
+        self.profile_label = profile_label(name, settings)
+        if self.verbose:
+            click.echo(f"Using profile {self.profile_label}", err=True)
+
+        return BunqClient(
+            context_path=Path(settings["context_path"]).expanduser(),
+            sandbox=self.sandbox or settings.get("sandbox", False),
+            verbose=self.verbose,
+        )
+
+    def confirm(self, message: str, yes: bool) -> None:
+        """Ask for confirmation, naming the profile so clients aren't mixed up."""
+        if not yes:
+            click.confirm(f"[{self.profile_label}] {message}", abort=True)
+
+
+pass_context = click.make_pass_decorator(Context, ensure=True)
+yes_option = click.option("--yes", "-y", is_flag=True, help="Don't ask for confirmation.")
+
+
+class _CliGroup(click.Group):
+    def parse_args(self, ctx: click.Context, args: list[str]) -> list[str]:
+        ctx.meta["bunq.argv"] = list(args)
+        return super().parse_args(ctx, args)
+
+
+def _run_for_all_profiles(ctx: Context) -> None:
+    """Re-run the command line once per profile and merge the output."""
+    click_ctx = click.get_current_context()
+    if click_ctx.invoked_subcommand in SINGLE_PROFILE_COMMANDS:
+        raise click.UsageError(f"'{click_ctx.invoked_subcommand}' can't be used with --all-profiles.")
+    profiles = load_config(ctx.config_path).get("profiles", {})
+    if not profiles:
+        raise click.ClickException("Not logged in. Run 'bunq login' first.")
+
+    rows: list[dict] = []
+    columns: list[str] | None = None
+    failed = False
+    for name, settings in profiles.items():
+        if not ctx.quiet:
+            click.echo(f"== {profile_label(name, settings)} ==", err=True)
+        sub = Context()
+        sub.loop_profile = name
+        sub.collected = []
+        try:
+            cli.main(
+                args=click_ctx.meta["bunq.argv"],
+                prog_name=click_ctx.info_name,
+                standalone_mode=False,
+                obj=sub,
+            )
+        except (click.UsageError, click.Abort):
+            raise
+        except Exception as exc:  # one client's failure shouldn't stop the others
+            failed = True
+            message = exc.format_message() if isinstance(exc, click.ClickException) else str(exc)
+            click.echo(f"Error ({name}): {message}", err=True)
+            continue
+        for data, cols in sub.collected:
+            records = data if isinstance(data, list) else [data]
+            rows += [{"profile": name, **record} for record in records]
+            columns = columns or cols
+
+    if rows:
+        click.echo(
+            format_output(rows, fmt=ctx.output_format, columns=["profile", *columns] if columns else None)
+        )
+    click_ctx.exit(1 if failed else 0)
+
+
+@click.group(cls=_CliGroup)
+@click.version_option(package_name="bunq-cli", prog_name="bunq")
+@click.option("-v", "--verbose", is_flag=True, help="Enable verbose output.")
+@click.option("-q", "--quiet", is_flag=True, help="Suppress all output except errors.")
+@click.option("--token", metavar="TOKEN", help="API token (overrides stored credentials).")
+@click.option(
+    "--output",
+    "output_format",
+    type=click.Choice(["auto", "json", "table"]),
+    default="auto",
+    help="Output format.",
+)
+@click.option("--no-color", is_flag=True, help="Disable colored output.")
+@click.option(
+    "--config",
+    "config_path",
+    type=click.Path(path_type=Path),
+    default=None,
+    help="Custom config file path.",
+)
+@click.option("--sandbox", is_flag=True, help="Use the sandbox environment.")
+@click.option("-p", "--profile", envvar="BUNQ_PROFILE", default=None, help="Profile (client) to use. Env: BUNQ_PROFILE.")
+@click.option("--all-profiles", is_flag=True, help="Run a read-only command for every profile.")
+@pass_context
+def cli(
+    ctx: Context,
+    verbose: bool,
+    quiet: bool,
+    token: str | None,
+    output_format: str,
+    no_color: bool,
+    config_path: Path | None,
+    sandbox: bool,
+    profile: str | None,
+    all_profiles: bool,
+) -> None:
+    """Bunq CLI - interact with the Bunq API from your terminal."""
+    ctx.verbose = verbose
+    ctx.quiet = quiet
+    ctx.output_format = output_format
+    ctx.no_color = no_color
+    ctx.sandbox = sandbox
+    ctx.token = token
+    ctx.profile = ctx.loop_profile or profile
+    ctx.all_profiles = all_profiles
+    if config_path:
+        ctx.config_path = config_path
+    if all_profiles:
+        source = click.get_current_context().get_parameter_source("profile")
+        if source == ParameterSource.COMMANDLINE:
+            raise click.UsageError("Use either --profile or --all-profiles, not both.")
+        ctx.profile = ctx.loop_profile
+    if all_profiles and ctx.loop_profile is None:
+        _run_for_all_profiles(ctx)
+
+
+# Register commands
+from bunq_cli.commands.login import login, logout  # noqa: E402
+from bunq_cli.commands.accounts import accounts  # noqa: E402
+from bunq_cli.commands.payments import payments  # noqa: E402
+from bunq_cli.commands.requests import requests  # noqa: E402
+from bunq_cli.commands.cards import cards  # noqa: E402
+from bunq_cli.commands.callbacks import callbacks  # noqa: E402
+from bunq_cli.commands.oauth_client import oauth_client  # noqa: E402
+from bunq_cli.commands.events import events  # noqa: E402
+from bunq_cli.commands.statements import statements  # noqa: E402
+from bunq_cli.commands.scheduled import scheduled  # noqa: E402
+from bunq_cli.commands.drafts import drafts  # noqa: E402
+from bunq_cli.commands.bunqme import bunqme  # noqa: E402
+from bunq_cli.commands.sandbox import sandbox  # noqa: E402
+from bunq_cli.commands.profiles import profiles  # noqa: E402
+
+cli.add_command(login)
+cli.add_command(logout)
+cli.add_command(accounts)
+cli.add_command(payments)
+cli.add_command(requests)
+cli.add_command(cards)
+cli.add_command(callbacks)
+cli.add_command(oauth_client)
+cli.add_command(events)
+cli.add_command(statements)
+cli.add_command(scheduled)
+cli.add_command(drafts)
+cli.add_command(bunqme)
+cli.add_command(sandbox)
+cli.add_command(profiles)

bunq_cli/oauth.py

@@ -0,0 +1,176 @@
+"""OAuth authorization code flow for Bunq CLI."""
+
+from __future__ import annotations
+
+import http.server
+import os
+import secrets
+import threading
+import urllib.parse
+import webbrowser
+from dataclasses import dataclass
+
+import click
+import requests
+
+AUTH_URL_PRODUCTION = "https://oauth.bunq.com/auth"
+AUTH_URL_SANDBOX = "https://oauth.sandbox.bunq.com/auth"
+TOKEN_URL_PRODUCTION = "https://api.oauth.bunq.com/v1/token"
+TOKEN_URL_SANDBOX = "https://api-oauth.sandbox.bunq.com/v1/token"
+
+REDIRECT_HOST = "127.0.0.1"
+REDIRECT_PORT = 12345
+REDIRECT_URI = f"http://{REDIRECT_HOST}:{REDIRECT_PORT}/callback"
+
+
+@dataclass
+class OAuthCredentials:
+    client_id: str
+    client_secret: str
+
+
+def get_oauth_credentials(config: dict | None = None) -> OAuthCredentials | None:
+    """Get OAuth client credentials from environment or config.
+
+    Priority: environment variables > config file.
+    """
+    client_id = os.environ.get("BUNQ_OAUTH_CLIENT_ID")
+    client_secret = os.environ.get("BUNQ_OAUTH_CLIENT_SECRET")
+    if client_id and client_secret:
+        return OAuthCredentials(client_id=client_id, client_secret=client_secret)
+
+    if config:
+        oauth = config.get("oauth", {})
+        client_id = oauth.get("client_id")
+        client_secret = oauth.get("client_secret")
+        if client_id and client_secret:
+            return OAuthCredentials(client_id=client_id, client_secret=client_secret)
+
+    return None
+
+
+def oauth_login(sandbox: bool = False, config: dict | None = None) -> str:
+    """Run the full OAuth browser flow and return an API token.
+
+    Raises click.ClickException on failure.
+    """
+    creds = get_oauth_credentials(config)
+    if creds is None:
+        raise click.ClickException(
+            "OAuth client not configured.\n"
+            "Run 'bunq oauth-client register' first,\n"
+            "or use 'bunq login --token YOUR_API_KEY' for direct API key authentication."
+        )
+
+    state = secrets.token_urlsafe(32)
+    auth_code: str | None = None
+    error: str | None = None
+    server_ready = threading.Event()
+
+    class CallbackHandler(http.server.BaseHTTPRequestHandler):
+        def do_GET(self) -> None:
+            nonlocal auth_code, error
+            parsed = urllib.parse.urlparse(self.path)
+            params = urllib.parse.parse_qs(parsed.query)
+
+            if parsed.path != "/callback":
+                self.send_response(404)
+                self.end_headers()
+                return
+
+            received_state = params.get("state", [None])[0]
+            if received_state != state:
+                error = "State mismatch -- possible CSRF attack."
+                self._respond("Authorization failed: state mismatch.")
+                return
+
+            if "error" in params:
+                error = params["error"][0]
+                desc = params.get("error_description", [""])[0]
+                self._respond(f"Authorization failed: {error}. {desc}")
+                return
+
+            code = params.get("code", [None])[0]
+            if code is None:
+                error = "No authorization code received."
+                self._respond("Authorization failed: no code received.")
+                return
+
+            auth_code = code
+            self._respond(
+                "Authorization successful! You can close this tab and return to your terminal."
+            )
+
+        def _respond(self, message: str) -> None:
+            self.send_response(200)
+            self.send_header("Content-Type", "text/html; charset=utf-8")
+            self.end_headers()
+            body = (
+                "<!DOCTYPE html><html><head>"
+                "<meta charset='utf-8'>"
+                "<style>body{font-family:system-ui;max-width:480px;margin:80px auto;text-align:center}</style>"
+                "</head><body>"
+                f"<h2>{message}</h2>"
+                "</body></html>"
+            )
+            self.wfile.write(body.encode())
+
+        def log_message(self, format: str, *args: object) -> None:
+            pass  # suppress request logs
+
+    server = http.server.HTTPServer((REDIRECT_HOST, REDIRECT_PORT), CallbackHandler)
+
+    def run_server() -> None:
+        server_ready.set()
+        server.handle_request()  # handle exactly one request
+
+    thread = threading.Thread(target=run_server, daemon=True)
+    thread.start()
+    server_ready.wait()
+
+    # Build authorization URL
+    auth_base = AUTH_URL_SANDBOX if sandbox else AUTH_URL_PRODUCTION
+    auth_params = urllib.parse.urlencode({
+        "response_type": "code",
+        "client_id": creds.client_id,
+        "redirect_uri": REDIRECT_URI,
+        "state": state,
+    })
+    auth_url = f"{auth_base}?{auth_params}"
+
+    click.echo(f"Opening browser for authorization...")
+    click.echo(f"If the browser doesn't open, visit: {auth_url}")
+    webbrowser.open(auth_url)
+
+    # Wait for the callback
+    thread.join(timeout=300)  # 5 minute timeout
+    server.server_close()
+
+    if auth_code is None:
+        raise click.ClickException(error or "Authorization timed out.")
+
+    # Exchange authorization code for access token
+    token_url = TOKEN_URL_SANDBOX if sandbox else TOKEN_URL_PRODUCTION
+    token_params = {
+        "grant_type": "authorization_code",
+        "code": auth_code,
+        "redirect_uri": REDIRECT_URI,
+        "client_id": creds.client_id,
+        "client_secret": creds.client_secret,
+    }
+
+    # bunq only accepts these as query parameters, not as a form body.
+    response = requests.post(token_url, params=token_params, timeout=30)
+    if response.status_code != 200:
+        try:
+            detail = response.json()
+        except ValueError:
+            detail = response.text
+        raise click.ClickException(f"Token exchange failed ({response.status_code}): {detail}")
+
+    data = response.json()
+    access_token = data.get("access_token")
+    if not access_token:
+        raise click.ClickException(f"No access token in response: {data}")
+
+    return access_token

bunq_cli/output.py

@@ -0,0 +1,65 @@
+"""Output formatting for Bunq CLI."""
+
+from __future__ import annotations
+
+import json
+import sys
+from typing import Any
+
+import click
+from tabulate import tabulate
+
+
+def format_output(
+    data: Any,
+    fmt: str = "auto",
+    columns: list[str] | None = None,
+) -> str:
+    """Format data for output.
+
+    Args:
+        data: The data to format (dict or list of dicts).
+        fmt: Output format - "json", "table", or "auto".
+        columns: Column names to include in table output. If None, uses all keys.
+    """
+    if fmt == "auto":
+        fmt = "table" if sys.stdout.isatty() else "json"
+
+    if fmt == "json":
+        return json.dumps(data, indent=2, default=str)
+
+    if isinstance(data, dict):
+        rows = [[k, v] for k, v in data.items() if columns is None or k in columns]
+        return tabulate(rows, headers=["Field", "Value"], tablefmt="simple")
+
+    if isinstance(data, list) and data:
+        if columns is None:
+            columns = list(data[0].keys())
+        rows = [[record.get(col, "") for col in columns] for record in data]
+        return tabulate(rows, headers=columns, tablefmt="simple")
+
+    return str(data)
+
+
+def echo_output(
+    data: Any,
+    fmt: str = "auto",
+    columns: list[str] | None = None,
+) -> None:
+    """Format and print data (or hand it to --all-profiles for merging)."""
+    if data is None:
+        return
+    collected = _collected()
+    if collected is not None:
+        collected.append((data, columns))
+        return
+    output = format_output(data, fmt=fmt, columns=columns)
+    click.echo(output)
+
+
+def _collected() -> list | None:
+    from bunq_cli.main import Context
+
+    click_ctx = click.get_current_context(silent=True)
+    obj = click_ctx.find_object(Context) if click_ctx else None
+    return getattr(obj, "collected", None)

bunq_cli-0.2.0.dist-info/METADATA

@@ -0,0 +1,68 @@
+Metadata-Version: 2.4
+Name: bunq-cli
+Version: 0.2.0
+Summary: Command-line interface for the Bunq API
+Author-email: Koert van der Veer <koert@ondergetekende.nl>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/ondergetekende/bunq-cli
+Project-URL: Repository, https://github.com/ondergetekende/bunq-cli
+Project-URL: Issues, https://github.com/ondergetekende/bunq-cli/issues
+Keywords: bunq,banking,cli,payments,finance
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Intended Audience :: System Administrators
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Office/Business :: Financial
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.1
+Requires-Dist: bunq-sdk>=1.28
+Requires-Dist: requests>=2.24
+Requires-Dist: tabulate>=0.9
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Dynamic: license-file
+
+# Bunq CLI
+
+A command-line interface for [Bunq](https://www.bunq.com/), the online bank. Manage accounts, payments, cards, and more from your terminal.
+
+> **Disclaimer:** This project is not affiliated with, endorsed by, or in any way associated with Bunq B.V. "Bunq" is a trademark of Bunq N.V. This is an independent, open-source tool that uses the public Bunq API.
+
+## Quick start
+
+```bash
+pip install bunq-cli
+bunq login
+bunq accounts list
+bunq payments list --account "My Account"
+```
+
+See [Getting Started](docs/getting-started.md) for full setup instructions, output formats, pagination, and global options.
+
+## Documentation
+
+| Guide | What it covers |
+| --- | --- |
+| [Getting Started](docs/getting-started.md) | Installation, authentication, profiles (multiple clients), sandbox mode, output formats, pagination, global options |
+| [Accounts](docs/accounts.md) | Monetary accounts: list, get, create savings goals |
+| [Payments](docs/payments.md) | Payments, drafts, scheduled payments, batch payments, international transfers |
+| [Payment Requests](docs/payment-requests.md) | Request money from others, manage incoming requests |
+| [Cards](docs/cards.md) | Card management: list, get, update settings, freeze/unfreeze |
+| [Callbacks](docs/callbacks.md) | Notification filters and webhook management |
+
+## Tech stack
+
+- [Python](https://www.python.org/) >= 3.11
+- [Click](https://click.palletsprojects.com/) for the CLI framework
+- [bunq SDK](https://github.com/bunq/sdk_python) for the Bunq API
+- [Tabulate](https://pypi.org/project/tabulate/) for table formatting
+
+## License
+
+MIT -- see [LICENSE](LICENSE).