campground 0.1.0__tar.gz

campground-0.1.0/PKG-INFO

@@ -0,0 +1,96 @@
+Metadata-Version: 2.4
+Name: campground
+Version: 0.1.0
+Summary: Download albums from your Bandcamp library
+License: MIT
+Project-URL: Homepage, https://github.com/oxfordbags/campground
+Project-URL: Repository, https://github.com/oxfordbags/campground
+Keywords: bandcamp,music,download
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Console
+Classifier: Topic :: Multimedia :: Sound/Audio
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: curl-cffi>=0.5
+
+# campground
+
+A lightweight command-line tool for downloading albums from your Bandcamp library.
+
+## Requirements
+
+- Python 3.11+
+- A Bandcamp account with purchased items
+
+## Installation
+
+```sh
+pip install git+https://github.com/oxfordbags/campground.git
+```
+
+## Setup
+
+Campground authenticates using your browser session cookies. You only need to do this once (or when your session expires).
+
+1. Log in to [bandcamp.com](https://bandcamp.com) in your browser
+2. Open Dev Tools (`Cmd+Option+I` on Mac, `F12` on Windows)
+3. Go to the **Network** tab and refresh the page
+4. Click any `bandcamp.com` request and find the **Cookie:** request header
+5. Copy the full value
+
+Then add it to `~/.config/campground/config.toml`:
+
+```toml
+[bandcamp]
+cookies = "your_cookie_string_here"
+
+[download]
+format = "flac"           # optional, default: flac
+output_dir = "~/Music"    # optional, default: current directory
+```
+
+Or pass cookies directly on the command line:
+
+```sh
+campground <url> --cookies "your_cookie_string_here"
+```
+
+## Usage
+
+```sh
+campground <bandcamp-album-url> [options]
+```
+
+**Examples:**
+
+```sh
+# Download an album in the default format (flac)
+campground https://artist.bandcamp.com/album/album-title
+
+# Choose a format
+campground https://artist.bandcamp.com/album/album-title --format mp3-320
+
+# Download to a specific directory
+campground https://artist.bandcamp.com/album/album-title --output ~/Music/Bandcamp
+
+# Re-download and replace an existing copy
+campground https://artist.bandcamp.com/album/album-title --overwrite
+```
+
+## Options
+
+| Flag | Description |
+|---|---|
+| `-f`, `--format` | Audio format (see below). Default: `flac` |
+| `-o`, `--output` | Output directory. Default: current directory |
+| `--cookies` | Cookie string from browser dev tools |
+| `--cookies-file` | Path to a file containing the cookie string |
+| `--overwrite` | Replace an existing download in the output directory |
+
+**Supported formats:** `mp3-v0`, `mp3-320`, `flac`, `aac-hi`, `vorbis`, `alac`, `wav`, `aiff-lossless`
+
+## How it works
+
+Campground uses your session cookies to access the Bandcamp collection API, locates the requested album, fetches a signed download link for your chosen format, and streams the file to a temporary directory before extracting and moving it to the output directory. If anything goes wrong the temporary files are cleaned up automatically.

campground-0.1.0/README.md

@@ -0,0 +1,79 @@
+# campground
+
+A lightweight command-line tool for downloading albums from your Bandcamp library.
+
+## Requirements
+
+- Python 3.11+
+- A Bandcamp account with purchased items
+
+## Installation
+
+```sh
+pip install git+https://github.com/oxfordbags/campground.git
+```
+
+## Setup
+
+Campground authenticates using your browser session cookies. You only need to do this once (or when your session expires).
+
+1. Log in to [bandcamp.com](https://bandcamp.com) in your browser
+2. Open Dev Tools (`Cmd+Option+I` on Mac, `F12` on Windows)
+3. Go to the **Network** tab and refresh the page
+4. Click any `bandcamp.com` request and find the **Cookie:** request header
+5. Copy the full value
+
+Then add it to `~/.config/campground/config.toml`:
+
+```toml
+[bandcamp]
+cookies = "your_cookie_string_here"
+
+[download]
+format = "flac"           # optional, default: flac
+output_dir = "~/Music"    # optional, default: current directory
+```
+
+Or pass cookies directly on the command line:
+
+```sh
+campground <url> --cookies "your_cookie_string_here"
+```
+
+## Usage
+
+```sh
+campground <bandcamp-album-url> [options]
+```
+
+**Examples:**
+
+```sh
+# Download an album in the default format (flac)
+campground https://artist.bandcamp.com/album/album-title
+
+# Choose a format
+campground https://artist.bandcamp.com/album/album-title --format mp3-320
+
+# Download to a specific directory
+campground https://artist.bandcamp.com/album/album-title --output ~/Music/Bandcamp
+
+# Re-download and replace an existing copy
+campground https://artist.bandcamp.com/album/album-title --overwrite
+```
+
+## Options
+
+| Flag | Description |
+|---|---|
+| `-f`, `--format` | Audio format (see below). Default: `flac` |
+| `-o`, `--output` | Output directory. Default: current directory |
+| `--cookies` | Cookie string from browser dev tools |
+| `--cookies-file` | Path to a file containing the cookie string |
+| `--overwrite` | Replace an existing download in the output directory |
+
+**Supported formats:** `mp3-v0`, `mp3-320`, `flac`, `aac-hi`, `vorbis`, `alac`, `wav`, `aiff-lossless`
+
+## How it works
+
+Campground uses your session cookies to access the Bandcamp collection API, locates the requested album, fetches a signed download link for your chosen format, and streams the file to a temporary directory before extracting and moving it to the output directory. If anything goes wrong the temporary files are cleaned up automatically.

campground-0.1.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "campground"
+version = "0.1.0"
+description = "Download albums from your Bandcamp library"
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.11"
+dependencies = ["curl-cffi>=0.5"]
+keywords = ["bandcamp", "music", "download"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Environment :: Console",
+    "Topic :: Multimedia :: Sound/Audio",
+]
+
+[project.urls]
+Homepage = "https://github.com/oxfordbags/campground"
+Repository = "https://github.com/oxfordbags/campground"
+
+[project.scripts]
+campground = "campground.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

campground-0.1.0/setup.cfg

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

campground-0.1.0/src/campground/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

campground-0.1.0/src/campground/__main__.py

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

campground-0.1.0/src/campground/api.py

@@ -0,0 +1,64 @@
+import html as html_module
+import json
+import re
+from urllib.parse import urlparse, urlunparse
+
+from curl_cffi import requests
+
+from .session import HEADERS
+
+COLLECTION_SUMMARY_URL  = "https://bandcamp.com/api/fan/2/collection_summary"
+COLLECTION_ITEMS_URL    = "https://bandcamp.com/api/fancollection/1/collection_items"
+
+
+def get_fan_id(session: requests.Session) -> int:
+    resp = session.get(COLLECTION_SUMMARY_URL, headers=HEADERS)
+    resp.raise_for_status()
+    return resp.json()["fan_id"]
+
+
+def iter_collection(session: requests.Session, fan_id: int, page_size: int = 50):
+    """Yield (item, redownload_url) pairs, paginating until exhausted."""
+    token = "9999999999::a::"
+    while True:
+        payload = {"fan_id": fan_id, "older_than_token": token, "count": page_size}
+        data = session.post(COLLECTION_ITEMS_URL, json=payload, headers=HEADERS).json()
+        redownload_urls = data.get("redownload_urls", {})
+        for item in data.get("items", []):
+            yield item, redownload_urls.get(f"p{item['sale_item_id']}")
+        if not data.get("more_available"):
+            break
+        token = data["last_token"]
+
+
+def find_item(session: requests.Session, fan_id: int, target_url: str):
+    """Return (item, redownload_url) for the first collection item matching target_url."""
+    target = _normalise_url(target_url)
+    checked = 0
+    for item, redownload_url in iter_collection(session, fan_id):
+        if _normalise_url(item.get("item_url", "")) == target:
+            return item, redownload_url
+        checked += 1
+        if checked % 50 == 0:
+            print(f"  ({checked} items searched...)")
+    return None, None
+
+
+def _normalise_url(url: str) -> str:
+    """Normalise to https, strip query string and fragment, lowercase."""
+    p = urlparse(url.strip())
+    return urlunparse(p._replace(scheme="https", query="", fragment="")).rstrip("/").lower()
+
+
+def get_download_urls(session: requests.Session, redownload_url: str) -> dict:
+    """Return the downloads dict from a signed redownload URL (format name → {url, size_mb, …})."""
+    resp = session.get(redownload_url, headers=HEADERS)
+    resp.raise_for_status()
+    blobs = re.findall(r'data-blob="([^"]{20,})"', resp.text)
+    if not blobs:
+        raise RuntimeError("Could not find data blob on download page")
+    blob = json.loads(html_module.unescape(blobs[0]))
+    items = blob.get("digital_items", [])
+    if not items:
+        raise RuntimeError("No downloadable items on this page")
+    return items[0].get("downloads", {})

campground-0.1.0/src/campground/cli.py

@@ -0,0 +1,194 @@
+import argparse
+import os
+import pathlib
+import shutil
+import sys
+
+from . import api, config, download
+from .session import make as make_session, parse_cookie_string
+
+VALID_FORMATS = [
+    "mp3-v0", "mp3-320", "flac", "aac-hi",
+    "vorbis", "alac", "wav", "aiff-lossless",
+]
+
+FORMAT_EXT = {
+    "mp3-v0":       ".mp3",
+    "mp3-320":      ".mp3",
+    "flac":         ".flac",
+    "aac-hi":       ".m4a",
+    "vorbis":       ".ogg",
+    "alac":         ".m4a",
+    "wav":          ".wav",
+    "aiff-lossless":".aiff",
+}
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="campground",
+        description="Download albums from your Bandcamp library",
+    )
+    p.add_argument("url", help="Bandcamp album or track URL")
+    p.add_argument(
+        "-f", "--format", choices=VALID_FORMATS, metavar="FORMAT",
+        help=f"Audio format ({', '.join(VALID_FORMATS)}). Default: flac",
+    )
+    p.add_argument("-o", "--output", metavar="DIR", help="Output directory")
+    p.add_argument("--cookies", metavar="STRING", help="Cookie string copied from browser dev tools")
+    p.add_argument(
+        "--cookies-file", dest="cookies_file", metavar="FILE",
+        help="Path to a file containing the cookie string",
+    )
+    p.add_argument(
+        "--overwrite", action="store_true",
+        help="Replace an existing download if it already exists in the output directory",
+    )
+    return p
+
+
+def resolve_cookies(cfg: config.Config) -> dict:
+    cookie_str = cfg.cookies
+    if not cookie_str and cfg.cookies_file:
+        path = pathlib.Path(cfg.cookies_file).expanduser()
+        if not path.exists():
+            sys.exit(f"Cookies file not found: {path}")
+        cookie_str = path.read_text().strip()
+    if not cookie_str:
+        sys.exit(
+            "No cookies provided. Supply them via --cookies, --cookies-file, or config file.\n\n"
+            "To get your cookie string:\n"
+            "  1. Log in to bandcamp.com in your browser\n"
+            "  2. Open Dev Tools (Cmd+Option+I on Mac) → Network tab\n"
+            "  3. Refresh the page and click any bandcamp.com request\n"
+            "  4. Copy the full value of the 'Cookie:' request header"
+        )
+    return parse_cookie_string(cookie_str)
+
+
+def safe_name(title: str) -> str:
+    return "".join(c if c.isalnum() or c in " -_." else "_" for c in title).strip()
+
+
+def safe_filename(title: str, fmt: str) -> str:
+    return f"{safe_name(title)}{FORMAT_EXT[fmt]}"
+
+
+HELP = """
+campground — download albums from your Bandcamp library
+
+Usage:
+  campground <url> [options]
+
+Options:
+  -f, --format FORMAT      Audio format (default: flac)
+                           Choices: mp3-v0, mp3-320, flac, aac-hi,
+                                    vorbis, alac, wav, aiff-lossless
+  -o, --output DIR         Output directory (default: current directory)
+  --cookies STRING         Cookie string from browser dev tools
+  --cookies-file FILE      Path to a file containing the cookie string
+  --overwrite              Replace an existing download in the output directory
+
+Examples:
+  campground https://artist.bandcamp.com/album/title
+  campground https://artist.bandcamp.com/album/title --format mp3-320
+  campground https://artist.bandcamp.com/album/title --output ~/Downloads
+
+Setup (one-time):
+  campground uses your browser session cookies to authenticate.
+
+  1. Log in to bandcamp.com in your browser
+  2. Open Dev Tools (Cmd+Option+I) → Network tab
+  3. Refresh the page and click any bandcamp.com request
+  4. Copy the full value of the Cookie: request header
+
+  Then either pass it directly:
+    campground <url> --cookies "your_cookie_string"
+
+  Or save it to ~/.config/campground/config.toml:
+    [bandcamp]
+    cookies = "your_cookie_string"
+
+    [download]
+    format = "flac"
+    output_dir = "~/Music/Bandcamp"  # optional
+"""
+
+
+def main():
+    if len(sys.argv) == 1:
+        print(HELP.strip())
+        sys.exit(0)
+
+    try:
+        _run()
+    except KeyboardInterrupt:
+        print("\nCancelled.")
+        os._exit(130)
+
+
+def _run():
+    args = build_parser().parse_args()
+    cfg = config.merge(config.load(), args)
+
+    cookies = resolve_cookies(cfg)
+    session = make_session(cookies)
+
+    print("Authenticating...")
+    try:
+        fan_id = api.get_fan_id(session)
+    except Exception as e:
+        sys.exit(f"Authentication failed — your cookies may have expired.\n{e}")
+
+    target_url = args.url.rstrip("/")
+    print(f"Searching collection for {target_url}...")
+
+    item, redownload_url = api.find_item(session, fan_id, target_url)
+    if not item:
+        sys.exit(f"Not found in your collection: {target_url}")
+
+    title = f"{item['band_name']} - {item['item_title']}"
+    print(f"Found: {title}")
+
+    if not item.get("download_available"):
+        sys.exit("This item is not available to download (may be a pre-order or stream-only).")
+
+    if not redownload_url:
+        sys.exit("This item has no download URL.")
+
+    fmt = cfg.format
+    print(f"Fetching {fmt} download link...")
+    try:
+        downloads = api.get_download_urls(session, redownload_url)
+    except Exception as e:
+        sys.exit(f"Could not fetch download page: {e}")
+
+    if fmt not in downloads:
+        available = ", ".join(downloads.keys())
+        sys.exit(f"Format '{fmt}' not available. Available formats: {available}")
+
+    entry = downloads[fmt]
+    print(f"  Size: {entry.get('size_mb', 'unknown')}")
+
+    name = safe_name(title)
+    dest = cfg.output_dir
+
+    if cfg.output_dir_explicit:
+        dest.mkdir(parents=True, exist_ok=True)
+
+    existing = dest / name
+    if existing.exists():
+        if not args.overwrite:
+            print(f"Already exists, skipping: {existing}")
+            print("Use --overwrite to replace it.")
+            sys.exit(0)
+        shutil.rmtree(existing) if existing.is_dir() else existing.unlink()
+
+    print(f"Downloading {entry.get('size_mb', '')} to {dest}...")
+
+    try:
+        path = download.fetch_and_extract(session, entry["url"], dest, safe_filename(title, fmt), name)
+    except Exception as e:
+        sys.exit(f"Download failed: {e}")
+
+    print(f"Saved: {path}")

campground-0.1.0/src/campground/config.py

@@ -0,0 +1,53 @@
+import sys
+import tomllib
+import pathlib
+from dataclasses import dataclass, field
+
+CONFIG_PATH = pathlib.Path.home() / ".config" / "campground" / "config.toml"
+DEFAULT_FORMAT = "flac"
+
+
+@dataclass
+class Config:
+    cookies: str = ""
+    cookies_file: str = ""
+    format: str = DEFAULT_FORMAT
+    output_dir: pathlib.Path | None = None  # None resolves to cwd at runtime
+    output_dir_explicit: bool = False       # True when set by config or CLI flag
+
+    def __post_init__(self):
+        if self.output_dir is None:
+            self.output_dir = pathlib.Path.cwd()
+        elif isinstance(self.output_dir, str):
+            self.output_dir = pathlib.Path(self.output_dir).expanduser()
+
+
+def load(path: pathlib.Path = CONFIG_PATH) -> Config:
+    if not path.exists():
+        return Config()
+    try:
+        with open(path, "rb") as f:
+            data = tomllib.load(f)
+    except tomllib.TOMLDecodeError as e:
+        sys.exit(f"Invalid config file ({path}):\n{e}")
+    bc = data.get("bandcamp", {})
+    dl = data.get("download", {})
+    raw_output = dl.get("output_dir")
+    return Config(
+        cookies=bc.get("cookies", ""),
+        cookies_file=bc.get("cookies_file", ""),
+        format=dl.get("format", DEFAULT_FORMAT),
+        output_dir=raw_output,
+        output_dir_explicit=raw_output is not None,
+    )
+
+
+def merge(base: Config, args) -> Config:
+    cli_output = getattr(args, "output", None)
+    return Config(
+        cookies=getattr(args, "cookies", None) or base.cookies,
+        cookies_file=getattr(args, "cookies_file", None) or base.cookies_file,
+        format=getattr(args, "format", None) or base.format,
+        output_dir=cli_output or str(base.output_dir),
+        output_dir_explicit=bool(cli_output) or base.output_dir_explicit,
+    )

campground-0.1.0/src/campground/download.py

@@ -0,0 +1,101 @@
+import pathlib
+import re
+import shutil
+import tempfile
+import zipfile
+
+from curl_cffi import requests
+
+from .session import HEADERS
+
+
+def fetch_and_extract(
+    session: requests.Session,
+    url: str,
+    dest_dir: pathlib.Path,
+    fallback_name: str,
+    subdir_name: str,
+) -> pathlib.Path:
+    """Download to a temp directory, extract if zip, move result to dest_dir."""
+    with tempfile.TemporaryDirectory(prefix="campground_") as tmp:
+        tmp_path = pathlib.Path(tmp)
+        zip_path = _fetch(session, url, tmp_path, fallback_name)
+
+        if zip_path.suffix == ".zip":
+            print("Extracting...")
+            extracted = _unzip(zip_path, tmp_path, subdir_name)
+            final = dest_dir / extracted.name
+            shutil.move(str(extracted), final)
+        else:
+            final = dest_dir / zip_path.name
+            shutil.move(str(zip_path), final)
+
+    return final
+
+
+def _fetch(session: requests.Session, url: str, dest_dir: pathlib.Path, fallback_name: str) -> pathlib.Path:
+    resp = session.get(url, headers=HEADERS, stream=True)
+    resp.raise_for_status()
+
+    filename = _filename_from_headers(resp.headers) or fallback_name
+    filepath = dest_dir / filename
+    total = int(resp.headers.get("content-length", 0))
+    received = 0
+
+    with open(filepath, "wb") as f:
+        for chunk in resp.iter_content(chunk_size=65536):
+            if chunk:
+                f.write(chunk)
+                received += len(chunk)
+                _print_progress(filename, received, total)
+
+    print()
+    return filepath
+
+
+def _unzip(zip_path: pathlib.Path, dest_dir: pathlib.Path, subdir_name: str) -> pathlib.Path:
+    try:
+        zf_handle = zipfile.ZipFile(zip_path)
+    except zipfile.BadZipFile:
+        raise RuntimeError("Downloaded file is corrupted (not a valid zip). Try again.")
+
+    with zf_handle as zf:
+        names = zf.namelist()
+
+        for name in names:
+            parts = pathlib.Path(name).parts
+            if pathlib.Path(name).is_absolute() or ".." in parts:
+                raise RuntimeError(f"Refusing to extract unsafe path in zip: {name}")
+
+        top_level = {n.split("/")[0] for n in names}
+
+        if len(top_level) == 1 and not any(n == top_level.copy().pop() for n in names):
+            # All entries share a single root folder — extract directly so that
+            # folder becomes the subdir, avoiding double-nesting.
+            extract_to = dest_dir
+            result_dir = dest_dir / top_level.pop()
+        else:
+            # Files at root — create a named subdir.
+            extract_to = dest_dir / subdir_name
+            extract_to.mkdir(parents=True, exist_ok=True)
+            result_dir = extract_to
+
+        zf.extractall(extract_to)
+
+    zip_path.unlink()
+    return result_dir
+
+
+def _filename_from_headers(headers) -> str:
+    cd = headers.get("content-disposition", "")
+    match = re.search(r'filename="([^"]+)"', cd)
+    return match.group(1) if match else ""
+
+
+def _print_progress(filename: str, received: int, total: int):
+    mb = received / 1_048_576
+    if total:
+        pct = received * 100 // total
+        print(f"\r  {filename}: {pct}% ({mb:.1f} MB)", end="", flush=True)
+    else:
+        print(f"\r  {filename}: {mb:.1f} MB", end="", flush=True)

campground-0.1.0/src/campground/session.py

@@ -0,0 +1,25 @@
+from curl_cffi import requests
+
+UA = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36"
+
+HEADERS = {
+    "User-Agent":      UA,
+    "Accept":          "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+    "Accept-Language": "en-US,en;q=0.5",
+}
+
+
+def make(cookies: dict) -> requests.Session:
+    s = requests.Session(impersonate="chrome120")
+    s.cookies.update(cookies)
+    return s
+
+
+def parse_cookie_string(cookie_str: str) -> dict:
+    cookies = {}
+    for part in cookie_str.split(";"):
+        part = part.strip()
+        if "=" in part:
+            k, _, v = part.partition("=")
+            cookies[k.strip()] = v.strip()
+    return cookies

campground-0.1.0/src/campground.egg-info/PKG-INFO

@@ -0,0 +1,96 @@
+Metadata-Version: 2.4
+Name: campground
+Version: 0.1.0
+Summary: Download albums from your Bandcamp library
+License: MIT
+Project-URL: Homepage, https://github.com/oxfordbags/campground
+Project-URL: Repository, https://github.com/oxfordbags/campground
+Keywords: bandcamp,music,download
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Console
+Classifier: Topic :: Multimedia :: Sound/Audio
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: curl-cffi>=0.5
+
+# campground
+
+A lightweight command-line tool for downloading albums from your Bandcamp library.
+
+## Requirements
+
+- Python 3.11+
+- A Bandcamp account with purchased items
+
+## Installation
+
+```sh
+pip install git+https://github.com/oxfordbags/campground.git
+```
+
+## Setup
+
+Campground authenticates using your browser session cookies. You only need to do this once (or when your session expires).
+
+1. Log in to [bandcamp.com](https://bandcamp.com) in your browser
+2. Open Dev Tools (`Cmd+Option+I` on Mac, `F12` on Windows)
+3. Go to the **Network** tab and refresh the page
+4. Click any `bandcamp.com` request and find the **Cookie:** request header
+5. Copy the full value
+
+Then add it to `~/.config/campground/config.toml`:
+
+```toml
+[bandcamp]
+cookies = "your_cookie_string_here"
+
+[download]
+format = "flac"           # optional, default: flac
+output_dir = "~/Music"    # optional, default: current directory
+```
+
+Or pass cookies directly on the command line:
+
+```sh
+campground <url> --cookies "your_cookie_string_here"
+```
+
+## Usage
+
+```sh
+campground <bandcamp-album-url> [options]
+```
+
+**Examples:**
+
+```sh
+# Download an album in the default format (flac)
+campground https://artist.bandcamp.com/album/album-title
+
+# Choose a format
+campground https://artist.bandcamp.com/album/album-title --format mp3-320
+
+# Download to a specific directory
+campground https://artist.bandcamp.com/album/album-title --output ~/Music/Bandcamp
+
+# Re-download and replace an existing copy
+campground https://artist.bandcamp.com/album/album-title --overwrite
+```
+
+## Options
+
+| Flag | Description |
+|---|---|
+| `-f`, `--format` | Audio format (see below). Default: `flac` |
+| `-o`, `--output` | Output directory. Default: current directory |
+| `--cookies` | Cookie string from browser dev tools |
+| `--cookies-file` | Path to a file containing the cookie string |
+| `--overwrite` | Replace an existing download in the output directory |
+
+**Supported formats:** `mp3-v0`, `mp3-320`, `flac`, `aac-hi`, `vorbis`, `alac`, `wav`, `aiff-lossless`
+
+## How it works
+
+Campground uses your session cookies to access the Bandcamp collection API, locates the requested album, fetches a signed download link for your chosen format, and streams the file to a temporary directory before extracting and moving it to the output directory. If anything goes wrong the temporary files are cleaned up automatically.

campground-0.1.0/src/campground.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+src/campground/__init__.py
+src/campground/__main__.py
+src/campground/api.py
+src/campground/cli.py
+src/campground/config.py
+src/campground/download.py
+src/campground/session.py
+src/campground.egg-info/PKG-INFO
+src/campground.egg-info/SOURCES.txt
+src/campground.egg-info/dependency_links.txt
+src/campground.egg-info/entry_points.txt
+src/campground.egg-info/requires.txt
+src/campground.egg-info/top_level.txt

campground-0.1.0/src/campground.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

campground-0.1.0/src/campground.egg-info/entry_points.txt

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

campground-0.1.0/src/campground.egg-info/requires.txt

@@ -0,0 +1 @@
+curl-cffi>=0.5

campground-0.1.0/src/campground.egg-info/top_level.txt

@@ -0,0 +1 @@
+campground