launchtape 0.1.0__py3-none-any.whl

launchtape/__init__.py

@@ -0,0 +1,18 @@
+"""Launch Tape: daily files of Solana launch data (https://launchtape.io) in Python.
+
+    import launchtape as lt
+    path = lt.sample("pregrad")              # free 2-hour sample, SHA-256 checked
+    for row in lt.load(path, types="record", limit=3):
+        print(row["sym"], row["instant"])
+"""
+
+from ._catalog import DATASETS, Dataset, datasets, schema
+from ._download import ChecksumError, LaunchTapeError, cache_dir, fetch, sample
+from ._read import frame, load
+from ._version import __version__
+
+__all__ = [
+    "DATASETS", "Dataset", "datasets", "schema",
+    "sample", "fetch", "cache_dir", "LaunchTapeError", "ChecksumError",
+    "load", "frame", "__version__",
+]

launchtape/__main__.py

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

launchtape/_catalog.py

@@ -0,0 +1,54 @@
+"""The datasets, their one-line descriptions and their bundled schema docs."""
+
+from __future__ import annotations
+
+from importlib.resources import files
+from typing import List, NamedTuple
+
+
+class Dataset(NamedTuple):
+    name: str
+    description: str
+
+
+_DATASETS = (
+    Dataset(
+        "gradtrades",
+        "Every PumpSwap buy and sell in the first 30 minutes after each pump.fun graduation "
+        "(wallet, amounts, price, pool reserves, fees)",
+    ),
+    Dataset(
+        "pregrad",
+        "Who is behind each pump.fun launch: creator and its funding, curve and graduation-slot "
+        "buyers, the cap path, and a +10 min outcome",
+    ),
+    Dataset(
+        "padfeed",
+        "Graduations on Meteora DBC and Raydium LaunchLab: migration facts, pool balances every "
+        "few seconds, top holders, US$ quote prices",
+    ),
+    Dataset(
+        "meteora-pools",
+        "Per-minute price, TVL, volume and exact fees for ~200 Meteora DLMM pools",
+    ),
+)
+
+DATASETS = tuple(d.name for d in _DATASETS)
+
+
+def check_dataset(dataset: str) -> str:
+    if dataset not in DATASETS:
+        raise ValueError(f"unknown dataset {dataset!r}; choose one of: {', '.join(DATASETS)}")
+    return dataset
+
+
+def datasets() -> List[Dataset]:
+    """The datasets as (name, description) pairs."""
+    return list(_DATASETS)
+
+
+def schema(dataset: str) -> str:
+    """The schema of a dataset as Markdown text (every row type and field)."""
+    check_dataset(dataset)
+    # one name per joinpath: Python 3.9's Traversable takes a single argument
+    return files("launchtape").joinpath("schemas").joinpath(f"{dataset}.md").read_text(encoding="utf-8")

launchtape/_download.py

@@ -0,0 +1,216 @@
+"""Downloads: the free samples and paid day files. A file is kept only after its SHA-256 matches the published one."""
+
+from __future__ import annotations
+
+import datetime as _dt
+import hashlib
+import json
+import os
+import re
+import sys
+import warnings
+from pathlib import Path
+from typing import Dict, Optional, Union
+from urllib.parse import urlsplit
+
+import requests
+
+from ._catalog import check_dataset
+from ._version import __version__
+
+DEFAULT_URL = "https://launchtape.io"
+CHUNK = 1 << 20
+TIMEOUT = (15, 120)  # connect, read (seconds)
+
+PathLike = Union[str, "os.PathLike[str]"]
+
+_HEX64 = re.compile(r"[0-9a-fA-F]{64}")
+_TOKEN = re.compile(r"[0-9a-f]{32}")
+_NAME = re.compile(r"[a-z][a-z0-9-]*")
+_DAY = re.compile(r"\d{4}-\d{2}-\d{2}")
+
+
+class LaunchTapeError(Exception):
+    """A download could not be completed or checked."""
+
+
+class ChecksumError(LaunchTapeError):
+    """A downloaded file's SHA-256 does not match the published one (the file is not kept)."""
+
+
+def base_url() -> str:
+    """The site to download from: $LAUNCHTAPE_URL, else https://launchtape.io."""
+    return os.environ.get("LAUNCHTAPE_URL", DEFAULT_URL).rstrip("/")
+
+
+def cache_dir() -> Path:
+    """Where samples are kept: $LAUNCHTAPE_CACHE, else ~/.cache/launchtape."""
+    env = os.environ.get("LAUNCHTAPE_CACHE")
+    return Path(env).expanduser() if env else Path.home() / ".cache" / "launchtape"
+
+
+def sha256_file(path: PathLike) -> str:
+    h = hashlib.sha256()
+    with open(path, "rb") as f:
+        for block in iter(lambda: f.read(CHUNK), b""):
+            h.update(block)
+    return h.hexdigest()
+
+
+def _get(url: str, stream: bool = False) -> requests.Response:
+    try:
+        r = requests.get(url, stream=stream, timeout=TIMEOUT,
+                         headers={"User-Agent": f"launchtape-python/{__version__}"})
+    except requests.RequestException as e:
+        raise LaunchTapeError(f"could not reach {url}: {e}") from e
+    if r.status_code != 200:
+        r.close()
+        hint = ""
+        if r.status_code == 404 and "/dl/" in url:
+            hint = " (download links last 7 days and list only the files you bought; write to us through launchtape.io)"
+        raise LaunchTapeError(f"{url}: HTTP {r.status_code}{hint}")
+    return r
+
+
+def _progress(name: str, done: int, total: Optional[int]) -> None:
+    size = f"{done / 1e6:,.1f} / {total / 1e6:,.1f} MB" if total else f"{done / 1e6:,.1f} MB"
+    sys.stderr.write(f"\r{name}: {size}")
+    sys.stderr.flush()
+
+
+def _download(url: str, target: Path, sha256: str, total: Optional[int] = None, progress: bool = False) -> Path:
+    """Stream url to target, hashing on the way; the file appears under its name only if the hash matches."""
+    target.parent.mkdir(parents=True, exist_ok=True)
+    part = target.with_name(f"{target.name}.{os.getpid()}.part")
+    h = hashlib.sha256()
+    done = 0
+    try:
+        with _get(url, stream=True) as r, open(part, "wb") as out:
+            total = total or int(r.headers.get("content-length") or 0) or None
+            for chunk in r.iter_content(CHUNK):
+                out.write(chunk)
+                h.update(chunk)
+                done += len(chunk)
+                if progress:
+                    _progress(target.name, done, total)
+        if progress:
+            sys.stderr.write("\n")
+        got = h.hexdigest()
+        if got != sha256.lower():
+            raise ChecksumError(f"{target.name}: SHA-256 {got} does not match the published {sha256.lower()}; "
+                                "the download was discarded, please try again")
+        os.replace(part, target)
+    except BaseException:
+        try:
+            part.unlink()
+        except FileNotFoundError:
+            pass
+        raise
+    return target
+
+
+def _parse_sums(text: str) -> Dict[str, str]:
+    """`sha256sum` output -> {file name: hex digest}."""
+    sums = {}
+    for line in text.splitlines():
+        parts = line.strip().split(None, 1)
+        if len(parts) == 2 and _HEX64.fullmatch(parts[0]):
+            sums[parts[1].lstrip("*")] = parts[0].lower()
+    return sums
+
+
+def sample(dataset: str, *, cache: Optional[PathLike] = None, progress: bool = False) -> Path:
+    """Download the free 2-hour sample of a dataset (checked against the site's SHA256SUMS) and return its path.
+
+    A sample already in the cache is reused when its hash still matches. If the site cannot be reached, a sample
+    already in the cache (checked when it was downloaded) is returned with a warning.
+    """
+    check_dataset(dataset)
+    folder = Path(cache).expanduser() if cache is not None else cache_dir()
+    pattern = re.compile(rf"{re.escape(dataset)}-\d{{4}}-\d{{2}}-\d{{2}}-\d{{4}}-\d{{4}}utc\.jsonl\.gz")
+    kept = sorted(p for p in folder.glob(f"{dataset}-*utc.jsonl.gz") if pattern.fullmatch(p.name))
+    base = base_url()
+    try:
+        with _get(f"{base}/sample/SHA256SUMS") as r:
+            sums = _parse_sums(r.text)
+    except LaunchTapeError as e:
+        if kept:
+            warnings.warn(f"{e}; using the {dataset} sample already in {folder}", stacklevel=2)
+            return kept[-1]
+        raise
+    names = sorted(n for n in sums if pattern.fullmatch(n))
+    if not names:
+        raise LaunchTapeError(f"no {dataset} sample is listed in {base}/sample/SHA256SUMS")
+    name = names[-1]
+    target = folder / name
+    if not (target.is_file() and sha256_file(target) == sums[name]):
+        _download(f"{base}/sample/{name}", target, sums[name], progress=progress)
+    for old in kept:  # an older sample window of the same dataset
+        if old != target:
+            old.unlink()
+    return target
+
+
+def _delivery_base(url_or_token: str) -> str:
+    s = str(url_or_token).strip()
+    if _TOKEN.fullmatch(s):
+        return f"{base_url()}/dl/{s}"
+    parts = urlsplit(s)
+    m = re.match(r"/dl/([0-9a-f]{32})(?:/|$)", parts.path)
+    if parts.scheme not in ("http", "https") or not parts.netloc or not m:
+        raise ValueError(f"not a Launch Tape delivery link or token: {url_or_token!r} "
+                         "(expected https://launchtape.io/dl/<token> or the 32-character token)")
+    return f"{parts.scheme}://{parts.netloc}/dl/{m.group(1)}"
+
+
+def _day(day: Union[str, _dt.date]) -> str:
+    if isinstance(day, _dt.datetime):
+        day = day.date()
+    if isinstance(day, _dt.date):
+        return day.isoformat()
+    s = str(day).strip()
+    if _DAY.fullmatch(s):
+        try:
+            _dt.date.fromisoformat(s)
+            return s
+        except ValueError:
+            pass
+    raise ValueError(f"day must be a UTC date like 2026-10-11, got {day!r}")
+
+
+def fetch(url_or_token: str, dataset: str, day: Union[str, _dt.date], dest: Optional[PathLike] = None,
+          *, progress: bool = False) -> Path:
+    """Download one paid day file from a delivery link and return its path.
+
+    url_or_token: the link from your delivery mail (https://launchtape.io/dl/<token>) or just its token.
+    day: the UTC day, "YYYY-MM-DD" or a date. dest: a folder (default: the current folder) or a file path ending
+    in .gz. The file is checked against the SHA-256 in <dataset>-<day>.manifest.json, which is saved next to it.
+    A file already at the destination with the right hash is not downloaded again.
+    """
+    if not _NAME.fullmatch(str(dataset)):
+        raise ValueError(f"not a dataset name: {dataset!r}")
+    stem = f"{dataset}-{_day(day)}"
+    fname = f"{stem}.jsonl.gz"
+    base = _delivery_base(url_or_token)
+    with _get(f"{base}/{stem}.manifest.json") as r:
+        raw = r.content
+    try:
+        manifest = json.loads(raw)
+    except ValueError as e:
+        raise LaunchTapeError(f"{stem}.manifest.json is not valid JSON: {e}") from None
+    files = manifest.get("files") if isinstance(manifest, dict) else None
+    entry = next((f for f in files or [] if isinstance(f, dict) and f.get("file") == fname), None)
+    sha = entry.get("sha256") if entry else None
+    if not isinstance(sha, str) or not _HEX64.fullmatch(sha):
+        raise LaunchTapeError(f"{stem}.manifest.json has no SHA-256 for {fname}")
+    size = entry.get("bytes")
+    if dest is None:
+        target = Path.cwd() / fname
+    else:
+        target = Path(dest).expanduser()
+        if target.is_dir() or not target.name.endswith(".gz"):
+            target = target / fname
+    if not (target.is_file() and sha256_file(target) == sha.lower()):
+        _download(f"{base}/{fname}", target, sha, total=size if isinstance(size, int) else None, progress=progress)
+    (target.parent / f"{stem}.manifest.json").write_bytes(raw)
+    return target

launchtape/_read.py

@@ -0,0 +1,98 @@
+"""Reading the files: one JSON object per line, gzipped (plain .jsonl works too)."""
+
+from __future__ import annotations
+
+import gzip
+import json
+import os
+from pathlib import Path
+from typing import IO, Any, Dict, FrozenSet, Iterable, Iterator, Optional, Union
+
+from ._catalog import DATASETS
+from ._download import sample
+
+Source = Union[str, "os.PathLike[str]"]
+Types = Union[str, Iterable[str], None]
+
+# Every row is written as {"type":"<type>",...}: when filtering, a row of another type is skipped without parsing it.
+_PREFIX = '{"type":"'
+
+
+def _resolve(src: Source) -> Path:
+    if isinstance(src, os.PathLike):
+        return Path(src)
+    if not isinstance(src, str):
+        raise TypeError(f"expected a path or a dataset name, got {type(src).__name__}")
+    path = Path(src).expanduser()
+    if path.is_file():
+        return path
+    if src in DATASETS:
+        return sample(src)
+    raise FileNotFoundError(f"{src!r} is neither a file nor a dataset name ({', '.join(DATASETS)})")
+
+
+def _types(types: Types) -> Optional[FrozenSet[str]]:
+    if types is None:
+        return None
+    wanted = frozenset([types] if isinstance(types, str) else types)
+    if not all(isinstance(t, str) for t in wanted):
+        raise TypeError("types must be a string or a list of strings")
+    return wanted
+
+
+def _open(path: Path) -> IO[str]:
+    with open(path, "rb") as f:
+        gz = f.read(2) == b"\x1f\x8b"
+    return gzip.open(path, "rt", encoding="utf-8") if gz else open(path, "rt", encoding="utf-8")
+
+
+def load(path_or_dataset: Source, types: Types = None, limit: Optional[int] = None) -> Iterator[Dict[str, Any]]:
+    """Stream the rows of a file as dicts.
+
+    path_or_dataset: a .jsonl.gz path, or a dataset name to read its free sample (downloaded on first use).
+    types: keep only rows whose `type` is this string or one of these strings, e.g. types=["record", "outcome"].
+    limit: stop after this many rows (counted after the type filter).
+    """
+    wanted = _types(types)
+    if limit is not None and (not isinstance(limit, int) or limit < 0):
+        raise ValueError(f"limit must be a whole number >= 0, got {limit!r}")
+    path = _resolve(path_or_dataset)
+    return _rows(path, wanted, limit)
+
+
+def _rows(path: Path, wanted: Optional[FrozenSet[str]], limit: Optional[int]) -> Iterator[Dict[str, Any]]:
+    if limit == 0:
+        return
+    n = 0
+    with _open(path) as f:
+        for lineno, line in enumerate(f, 1):
+            if wanted is not None and line.startswith(_PREFIX):
+                end = line.find('"', len(_PREFIX))
+                ty = line[len(_PREFIX):end]
+                if end > 0 and "\\" not in ty and ty not in wanted:
+                    continue
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                row = json.loads(line)
+            except ValueError as e:
+                raise ValueError(f"{path}: line {lineno} is not valid JSON ({e})") from None
+            if wanted is not None and (not isinstance(row, dict) or row.get("type") not in wanted):
+                continue
+            yield row
+            n += 1
+            if limit is not None and n >= limit:
+                return
+
+
+def frame(path_or_dataset: Source, types: Types = None, limit: Optional[int] = None):
+    """The rows as a pandas DataFrame (same arguments as load). Nested fields stay as dicts/lists in their column.
+
+    A full gradtrades day is millions of rows: pass types= and/or limit= to keep it to what you need.
+    """
+    try:
+        import pandas as pd
+    except ImportError as e:
+        raise ImportError("launchtape.frame() needs pandas: pip install 'launchtape[pandas]'") from e
+    return pd.DataFrame(list(load(path_or_dataset, types=types, limit=limit)))

launchtape/_version.py

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

launchtape/cli.py

@@ -0,0 +1,80 @@
+"""Command line: launchtape datasets | sample | head | schema | fetch."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from typing import List, Optional
+
+from ._catalog import DATASETS, datasets, schema
+from ._download import LaunchTapeError, fetch, sample
+from ._read import load
+from ._version import __version__
+
+
+def _parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(prog="launchtape", description="Launch Tape: daily files of Solana launch data "
+                                "(https://launchtape.io).")
+    p.add_argument("--version", action="version", version=f"launchtape {__version__}")
+    sub = p.add_subparsers(dest="cmd", metavar="command", required=True)
+
+    sub.add_parser("datasets", help="list the datasets")
+
+    s = sub.add_parser("sample", help="download a free 2-hour sample (SHA-256 checked) and print its path")
+    s.add_argument("dataset", nargs="+", choices=DATASETS)
+
+    s = sub.add_parser("head", help="print the first rows of a dataset's sample, or of a file, as JSON lines")
+    s.add_argument("source", help="a dataset name (reads its free sample) or a .jsonl.gz path")
+    s.add_argument("-n", type=int, default=10, help="number of rows (default 10)")
+    s.add_argument("-t", "--type", dest="types", action="append", metavar="TYPE",
+                   help="only rows of this type (repeat for several)")
+
+    s = sub.add_parser("schema", help="print a dataset's schema (Markdown)")
+    s.add_argument("dataset", choices=DATASETS)
+
+    s = sub.add_parser("fetch", help="download a paid day file from your delivery link and print its path")
+    s.add_argument("link", help="https://launchtape.io/dl/<token> from your delivery mail, or the token")
+    s.add_argument("dataset")
+    s.add_argument("day", help="UTC day, YYYY-MM-DD")
+    s.add_argument("-o", "--dest", help="folder or .gz file path (default: current folder)")
+    return p
+
+
+def _run(a: argparse.Namespace) -> int:
+    progress = sys.stderr.isatty()
+    if a.cmd == "datasets":
+        width = max(len(d.name) for d in datasets())
+        for d in datasets():
+            print(f"{d.name:<{width}}  {d.description}")
+    elif a.cmd == "sample":
+        for ds in a.dataset:
+            print(sample(ds, progress=progress))
+    elif a.cmd == "head":
+        if a.n < 0:
+            raise ValueError("-n must be 0 or more")
+        src = a.source
+        if src in DATASETS and not os.path.isfile(src):
+            src = sample(src, progress=progress)  # the free sample, with download progress on a terminal
+        for row in load(src, types=a.types, limit=a.n):
+            print(json.dumps(row, separators=(",", ":")))
+    elif a.cmd == "schema":
+        sys.stdout.write(schema(a.dataset))
+    elif a.cmd == "fetch":
+        print(fetch(a.link, a.dataset, a.day, a.dest, progress=progress))
+    return 0
+
+
+def main(argv: Optional[List[str]] = None) -> int:
+    args = _parser().parse_args(argv)
+    try:
+        return _run(args)
+    except BrokenPipeError:  # e.g. `launchtape head gradtrades | head -1`
+        os.dup2(os.open(os.devnull, os.O_WRONLY), sys.stdout.fileno())
+        return 0
+    except KeyboardInterrupt:
+        return 130
+    except (LaunchTapeError, ValueError, OSError, EOFError) as e:
+        print(f"launchtape: error: {e}", file=sys.stderr)
+        return 1

launchtape/schemas/gradtrades.md

@@ -0,0 +1,40 @@
+# gradtrades schema
+
+One JSON object per line. Every row has `type` and `t` (ms since 1970 UTC, when our recorder received it). SOL amounts in SOL, token amounts in whole tokens (6 decimals). Source: Solana public RPC (PumpSwap program logs), first 30 minutes after each pump.fun graduation.
+
+| type | field | type | meaning |
+|---|---|---|---|
+| grad | t | number | graduation time (ms; chain block time for late pick-ups) |
+| grad | bt | number | block time (s) |
+| grad | slot / sig | number / string | slot and signature of the graduation (migration) transaction |
+| grad | mint | string | the coin's token mint |
+| grad | pool | string | its PumpSwap pool |
+| grad | coinCreator | string | wallet that receives the coin's creator fees |
+| grad | poolBase / poolQuote | number | starting tokens / SOL in the pool |
+| grad | virtualQuote | number | PumpSwap's extra virtual SOL in the price math (~17.6 SOL, Oct 2026) |
+| grad | price | number | SOL per token at graduation |
+| grad | capSol | number | price x 1e9 (market cap in SOL, ~496 for a normal graduate) |
+| grad | curveSol | number | SOL raised by the bonding curve |
+| grad | late | bool | picked up late; trades before `followFrom` are missing |
+| grad | followFrom | number | ms; trades are complete from here on |
+| grad | follow | bool | false = coin not followed (cap outside 300-600 SOL, or found too late) |
+| trade | bt, slot, sig, i | number, number, string, number | block time (s), slot, signature, index of the PumpSwap trade inside the transaction. A `sig` of 64 `1`s means the RPC did not report the signature (rare: a few rows per million) |
+| trade | mint | string | coin |
+| trade | side | "buy" / "sell" | direction |
+| trade | user | string | wallet that traded |
+| trade | baseAmount | number | tokens bought or sold |
+| trade | quoteAmount | number | SOL paid (buy, fees included) or received (sell, after fees) |
+| trade | price | number | quoteAmount / baseAmount (effective price, fees included) |
+| trade | poolBase / poolQuote | number | pool tokens / real SOL after the trade |
+| trade | priceAfter | number | pool price after the trade: (poolQuote + virtualQuote) / poolBase |
+| trade | virtualQuote | number | only when the pool's virtual SOL changes (rare) |
+| trade | userTokensBefore | number | the wallet's balance of this coin just before the trade |
+| trade | lpFee / protocolFee / creatorFee | number | fees in SOL |
+| trade | creator | bool | true when the trader is the coin's creator |
+| trade | ix | string | instruction variant, e.g. `buy_exact_quote_in`; absent for a normal buy |
+| trade | recovered | bool | the log was truncated; trade read from the full transaction |
+| end | mint, why, buys, sells | string, string, number, number | coin no longer followed: `window` (30 min done), `evicted` (cap of 30 coins), `budget` (data budget); counts recorded |
+| down / up | t | number | a feed connection dropped / came back: trades in between may be missing |
+| resume | mint | string | coin picked up again after a restart; the gap before `t` is missing |
+
+Failed transactions are not included. Coverage gaps are marked, never filled in.

launchtape/schemas/meteora-pools.md

@@ -0,0 +1,17 @@
+# meteora-pools schema
+
+One row per pool per minute, Meteora DLMM pools with TVL >= US$50k, top 200 by 24h fee/TVL. Source: Meteora's public DLMM API (dlmm.datapi.meteora.ag). No RPC, no wallets.
+
+| field | type | meaning |
+|---|---|---|
+| type | "pool" | row type |
+| t | number | ms when fetched |
+| pool | string | DLMM pool address |
+| price | number | pool's current price (quote per base token, as Meteora reports it) |
+| tvlUsd | number | total value locked, US$ |
+| vol24hUsd | number | rolling 24 h volume, US$ |
+| fees24hUsd | number | rolling 24 h fees, US$ |
+| vol24hDeltaUsd | number/null | change in the rolling 24 h volume since the pool's previous row |
+| feesMinUsd | number/null | exact fees earned since the previous row (diff of Meteora's all-time cumulative fees); null on a pool's first row or a reset |
+
+Token mints and names are not in the row; look them up from the pool address (Meteora API or chain).

launchtape/schemas/padfeed.md

@@ -0,0 +1,19 @@
+# padfeed schema
+
+Graduations on two non-pump.fun Solana launchpads: `dbc` = Meteora Dynamic Bonding Curve (Bags, Jupiter Studio, ...) -> DAMM v2 pool, `ray` = Raydium LaunchLab (bonk.fun etc.) -> Raydium CPMM pool. Each coin followed 20 min (dbc) / 30 min (ray). Source: Solana RPC; US$ quote prices from Jupiter's free price API.
+
+| type | field | type | meaning |
+|---|---|---|---|
+| all | t | number | ms when recorded |
+| grad | pad | "dbc"/"ray" | launchpad |
+| grad | platform | string | platform config / name |
+| grad | mint, quote | string | coin mint; quote mint (SOL, or a token such as USD1/a tokenized stock) |
+| grad | pool, curveAuth, baseVault, quoteVault | string/null | pool and vault accounts; `pool` is null on every dbc row (the DAMM v2 pool is not known when the migration is heard; the vaults identify it) and set on ray rows |
+| grad | b, q | number | vault balances (tokens, quote units) at migration |
+| grad | px | number | price in quote = q / b |
+| grad | supply, decimals, tokenProgram | number, number, string | mint facts (Token or Token-2022) |
+| grad | feeBps, freeze, mintAuth | | Token-2022 transfer fee, freeze / mint authorities (null = none) |
+| grad | sig, blockTime, lagMs | string, number, number | migration signature, its block time (ms, not seconds like `bt` elsewhere) and how long after the block we heard of it (ms) |
+| px | pad, mint, b, q | | vault balances when they changed (every ~6 s, ~2 s for fast-moving coins); price = q / b |
+| holders | pad, mint, top10, top20[] | | +60 s and +5 min: 20 largest token accounts (`acct`, `owner`, `amt`); `top10` = share held by top 10 excluding pool vaults and curve |
+| qpx | usd | object | every 30 s: US$ price of SOL and of every non-SOL quote mint seen in the last 2 h, keyed by mint |

launchtape/schemas/pregrad.md

@@ -0,0 +1,39 @@
+# pregrad schema
+
+Who is behind each pump.fun launch, as raw facts (addresses, amounts, times). No wallet labels, no risk flags, no images. Sources: PumpPortal free websocket (creations, migrations), Solana public RPC (bonding curves, transactions). Amounts in SOL; `pct` = % of the 1,000,000,000 supply; times in ms unless the name ends in `S` (seconds).
+
+| type | field | type | meaning |
+|---|---|---|---|
+| create | t, mint, sig | number, string, string | coin creation |
+| create | creator | string | creator wallet |
+| create | name, sym | string | coin name / ticker |
+| create | devTokens, devSol | number | creator's own buy at creation |
+| create | capSol | number | curve market cap right after creation |
+| create | curve | string | bonding-curve account |
+| create | mayhem | bool | pump.fun "mayhem mode" launch |
+| curvex | slot, curve, mint | number, string, string/null | bonding-curve cap crossing (mint null when not yet mapped) |
+| curvex | cap, cross, sol, sinceFirstS | number | cap now (SOL), line crossed (100/200/300/400 SOL), SOL in curve, seconds since first seen |
+| ctrade | bt, slot, sig, i, mint, side, user | | bonding-curve trade on a coin near graduation (read from cap 200 SOL up); `i` counts this coin's trades inside the transaction, so (`sig`, `mint`, `i`) is the unique key (one transaction can trade two coins) |
+| ctrade | sol, tokens, capAfter, curveSol | number | SOL and tokens of the trade, cap and curve SOL after it. Note: pump.fun also runs curves priced in another token instead of SOL (the PUMP coin and a few others). In files up to 2026-10-12 17:47 UTC those coins' rows carry `sol` 0, `capAfter` null, `curveSol` 0 (the amount really is zero SOL; the trade was in the other token): treat `capAfter` null as "not a SOL curve". From 2026-10-12 17:47 UTC the recorder no longer follows non-SOL curves, so new files hold SOL curves only |
+| migrate | mint, sig, pool | string | migration seen by PumpPortal (`pool` = destination AMM) |
+| grad | mint, slot, capSol, creator | | graduation as seen on chain |
+| record | mint, sym, name, pool, slot0, sig0, t0, bt0 | | one per graduate, written 10-40 s after graduation (t0 = graduation) |
+| record | src | object | `first` = which feed saw it first, `gradRow` = a `grad` row exists, `migrate` = ms of the PumpPortal migration (or null), `curveCompleteS` = curve completed how long before t0 |
+| record | creator, create | string, object | creator wallet; creation tx (`t`, `sig`, `src`, `slot`, `mayhem`, `capSol`), null when the creation was not seen |
+| record | ageS | number | creation to graduation, seconds |
+| record | instant | bool | graduated within 5 s of creation |
+| record | cap0, curveSol | number | PumpSwap cap at graduation; SOL raised |
+| record | devBuyTokens, devBuyPct, devBuySol | number | creator's buy at creation |
+| record | creatorPctAtGrad | number/null | creator's holding at graduation |
+| record | creatorInfo | object | `txs50` (tx count, capped 50), `capped`, `oldestS`, `nBefore10m`, `funder`, `fundSol`, `fundedBeforeS`, `fundMemo`, `priorCoins24h`, `priorCoins72h` |
+| record | gradSlot | object/null | PumpSwap buys in the graduation slot: `pct`, `sol`, `nWallets`, `nTx`, `buys[]` (`w`, `tokens`, `pct`, `sol`, `sig`, `bundleSize`, `payer`, `signers`, `slotOffset`, `creatorInTx`), `whale` = the largest of those buys with its wallet facts (`txs25`, `oldestS`, `lastTxKind`, `funder`, `fundSol`, `fundedBeforeS`, `fundSig`, `fundMemo`, `gainers[]`) |
+| record | curve | object | `coverage` (full/partial/none), `holders[]` (top 10: `w`, `pct`, `sol`, `creator`), `creationSlot` (`ok`, `failed`, `curveTxs`, `capped`: transactions in the creation slot), `bundleEst` (`buyers`, `avgPct`, `top5Pct`), `estimated`, `top1NcPct`, `top5NcPct`, `nOver3Pct`, `bundleWallets`, `bundlePct`, `creatorPct`, `path` (`firstCap`, `firstS`, `t100S`..`t400S`, `maxCap`, `updates`, `completeS`: the cap over time), `trades` (`fromCap`, `fromT`, `n`, `buys`, `sells`, `wallets`, `maxCap`, `lastCap`, `completeT`, `topBuyers[]` with `w`, `tokens`, `pct`, `sol`, `creator`: our own count of its curve trades) |
+| outcome | mint, sym, t0, recT | | +10 min after graduation |
+| outcome | capAt | object | PumpSwap cap (SOL) at +10/45/60/120/180/300/600 s |
+| outcome | maxGain, minDrop | number | best / worst move in %, first 10 min |
+| outcome | crashed | bool | fell by 80%+ |
+| outcome | trades | number | PumpSwap trades counted |
+| outcome | dump, firstBigSell, bigSells[] | object | the first sale breaking a fixed size rule and the large sales: `tS`, `w`, `frac` (share of pool sold), `sol`, `capAfter`, `rule`, `tokensFrom` (where the sold tokens came from: `kind`, `from`, `for`, `tokens`, `pct`, `sig`, `bt`, `account`, `accountTxs`, `beforeDumpS`, `afterGradS`) |
+| outcome | src | string | where trades were read from |
+
+Removed before sale: our internal "rogue" wallet list and every field derived from it, `flags`, `priorRugged`, the dumper `role`, picture fingerprints and metadata URIs, heartbeat/stats rows.

launchtape-0.1.0.dist-info/METADATA

@@ -0,0 +1,125 @@
+Metadata-Version: 2.5
+Name: launchtape
+Version: 0.1.0
+Summary: Load Launch Tape's daily Solana launch data (pump.fun graduations and launches, other launchpads, Meteora pools) in Python
+Project-URL: Homepage, https://launchtape.io
+Project-URL: Datasets, https://launchtape.io/#datasets
+Project-URL: Pricing, https://launchtape.io/#buy
+Project-URL: Data licence, https://launchtape.io/#licence
+Project-URL: Source, https://github.com/launchtape-io/launchtape
+Author-email: Launch Tape <launchio48@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: crypto,dataset,market data,meteora,pump.fun,pumpswap,raydium,solana
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Office/Business :: Financial :: Investment
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Requires-Dist: requests>=2.20
+Provides-Extra: pandas
+Requires-Dist: pandas>=1.3; extra == 'pandas'
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == 'test'
+Description-Content-Type: text/markdown
+
+# launchtape
+
+Python access to [Launch Tape](https://launchtape.io): daily files of Solana launch data, one gzipped JSON-lines
+file per dataset per UTC day.
+
+| Dataset | What it is |
+|---|---|
+| `gradtrades` | Every PumpSwap buy and sell in the first 30 minutes after each pump.fun graduation (wallet, amounts, price, pool reserves, fees) |
+| `pregrad` | Who is behind each pump.fun launch: creator and its funding, curve and graduation-slot buyers, the cap path, and a +10 min outcome |
+| `padfeed` | Graduations on Meteora DBC and Raydium LaunchLab: migration facts, pool balances every few seconds, top holders, US$ quote prices |
+| `meteora-pools` | Per-minute price, TVL, volume and exact fees for ~200 Meteora DLMM pools |
+
+A free 2-hour sample of every dataset is on the site; `launchtape` downloads it, checks its SHA-256 and reads it.
+
+## Install
+
+```sh
+pip install launchtape              # needs only requests
+pip install "launchtape[pandas]"    # adds pandas for launchtape.frame()
+```
+
+Python 3.9 or newer.
+
+## Quickstart
+
+Crash rate of pump.fun graduates, split by "instant" launches (graduated within 5 s of creation):
+
+```python
+import launchtape as lt
+
+path = lt.sample("pregrad")                                    # free sample, SHA-256 checked, cached
+rec = lt.frame(path, types="record")[["mint", "sym", "instant", "ageS"]]
+out = lt.frame(path, types="outcome")[["mint", "crashed", "maxGain"]]
+df = rec.merge(out, on="mint")                                 # one row per graduate seen in both
+print(df.groupby("instant")["crashed"].agg(["mean", "count"]))
+print(lt.schema("pregrad"))                                    # every row type and field
+```
+
+The sample is two hours, so the counts are small: it shows the shape of the data, not a result.
+
+## API
+
+| Call | Does |
+|---|---|
+| `lt.datasets()` | the datasets as `(name, description)` pairs |
+| `lt.schema(dataset)` | the schema as Markdown text (bundled, works offline) |
+| `lt.sample(dataset)` | downloads the free sample into `~/.cache/launchtape`, checks it against the site's `SHA256SUMS`, returns its path; a good cached copy is reused |
+| `lt.load(path_or_dataset, types=None, limit=None)` | streams the rows as dicts; `types` keeps only rows whose `type` is one of them, `limit` stops after that many rows; a dataset name reads its sample |
+| `lt.frame(path_or_dataset, types=None, limit=None)` | the same rows as a pandas DataFrame (nested fields stay dicts/lists) |
+| `lt.fetch(link_or_token, dataset, day, dest=None)` | downloads a paid day file from your delivery link, checks it against its `.manifest.json`, returns its path |
+
+```python
+for row in lt.load("gradtrades", types="grad", limit=5):      # streams, so a 5-million-row day is fine
+    print(row["mint"], row["capSol"])
+
+path = lt.fetch("https://launchtape.io/dl/<token>", "pregrad", "2026-10-11", dest="data/")
+```
+
+Times: `t` is milliseconds since 1970 UTC (`pd.to_datetime(df["t"], unit="ms", utc=True)`). Coverage gaps are rows
+in the files (`down`, `up`, `resume`, `end`), never filled in: see each schema.
+
+A full `gradtrades` day is about 5 million rows; for a DataFrame, pass `types=` and/or `limit=`, or stream with
+`load()`. A download that does not match its SHA-256 raises `launchtape.ChecksumError` and is not kept.
+Environment: `LAUNCHTAPE_CACHE` changes the cache folder.
+
+## Command line
+
+```sh
+launchtape datasets
+launchtape sample gradtrades                  # prints the cached path
+launchtape head gradtrades -n 5               # first rows of the sample, as JSON lines
+launchtape head pregrad -t record -n 2        # only rows of one type
+launchtape schema pregrad
+launchtape fetch https://launchtape.io/dl/<token> pregrad 2026-10-11 -o data/
+```
+
+`python -m launchtape ...` works too.
+
+## Full days: prices and how to buy
+
+Day file (one dataset, one UTC day): 0.05 SOL or 6 USDC. Month of history (one dataset, 30 days): 0.5 SOL or
+60 USDC. Daily feed (every dataset, each new day as it closes): 1 SOL or 120 USDC a month. Send SOL or USDC on
+Solana to `5vf1PzK8LrF9D5bemYJYPsFYp4nHULSTA1biBampgU58` with a memo giving your email address or Telegram handle
+and the datasets and days you want; within 24 hours you get a private download link
+(`https://launchtape.io/dl/<token>`, valid 7 days) that `launchtape fetch` reads. Or buy through
+[launchtape.io](https://launchtape.io/#buy), which has a Solana Pay QR code and a contact form.
+
+## Licences
+
+- **This package** (the code): MIT, see [LICENSE](LICENSE).
+- **The data** it downloads, the free samples included, has its own licence: personal and research use inside
+  your own team. No resale, republishing or redistribution of the files, in whole or in part. Results you derive
+  from it (charts, papers, models, strategies) are yours. Full text: [launchtape.io](https://launchtape.io/#licence).
+
+The data is market data recorded from public sources, provided as is. It is not financial advice.

launchtape-0.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+launchtape/__init__.py,sha256=icTOueqqQdGT169cdX3E8H2KgQReAyYOFdGtHbBZVm8,674
+launchtape/__main__.py,sha256=k1ocEWawweo1qCJWNFAAvyxz3tcY13dzvCenHszij30,48
+launchtape/_catalog.py,sha256=A3ej6lgEafgVa1wGS9kTBIu2WtFzb0EFI-Zuu0NgshU,1649
+launchtape/_download.py,sha256=pNR3ZK97483Bld84q4Fu5T_pAB8sSTkBHn8TU8q8LcY,8536
+launchtape/_read.py,sha256=nBTIpwvHARrtesudJwCA4TZ3f436SSgo3RNNtlWva94,3763
+launchtape/_version.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+launchtape/cli.py,sha256=RRh7q2uO8KhqlWuJvowvjIM6nBJ8o7sjqvKc0j4qcxw,3347
+launchtape/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+launchtape/schemas/gradtrades.md,sha256=wDOsIQwSaoVR21ImppsKe4MU3GJd4i4Z5HJ3j5i03HM,3144
+launchtape/schemas/meteora-pools.md,sha256=670__xb3Nx23Lxm_q5qrIoVxmZnt_7lQ3tyjA7eqQLM,928
+launchtape/schemas/padfeed.md,sha256=Pg0uWJYvvH-oipVYAb5rzb2-3O8ELeG9w2eiDTLStVg,1784
+launchtape/schemas/pregrad.md,sha256=VqjNFqtZrlG3D_FXlCKF2SMeNoSLOHe6mTxovIwByH0,5038
+launchtape-0.1.0.dist-info/METADATA,sha256=Uug1GFjoYD4_YRTzcOyGNCfwi1t24HuVic67fRLRCDk,6247
+launchtape-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+launchtape-0.1.0.dist-info/entry_points.txt,sha256=qZr6NbuN6w0KGM0PrGFUYNLaZ4qssiqK7_4BxRwpTik,51
+launchtape-0.1.0.dist-info/licenses/LICENSE,sha256=7-f_I6mVMjcLHcyA1uXpYcSmpuqTXJYyuQ5YDLUFO3E,1068
+launchtape-0.1.0.dist-info/RECORD,,

launchtape-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

launchtape-0.1.0.dist-info/entry_points.txt

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

launchtape-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Launch Tape
+
+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.