scrollscout 0.1.0__py3-none-any.whl

scrollscout/__init__.py

@@ -0,0 +1,81 @@
+"""scrollscout -- scout Vesuvius Challenge scrolls before you commit disk.
+
+Stream and preview Herculaneum scroll CT volumes from a laptop, without
+downloading terabytes and without tripping the server's rate limiter.
+
+Quick start:
+
+    import scrollscout as ss
+    vol = ss.open_scroll(1)                 # streams a few KB of metadata
+    img = ss.thumbnail(1, z_frac=0.5, width=1000, out="scroll1.png")
+"""
+from __future__ import annotations
+
+from typing import Optional
+
+from .catalog import Level, ScrollVolume, open_scroll, volume_url
+from .reader import RateLimited, read_slice, read_window
+from .render import autocontrast, to_png
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "open_scroll",
+    "volume_url",
+    "ScrollVolume",
+    "Level",
+    "read_slice",
+    "read_window",
+    "RateLimited",
+    "autocontrast",
+    "to_png",
+    "thumbnail",
+]
+
+
+def thumbnail(
+    scroll_id: int,
+    *,
+    z_frac: float = 0.5,
+    z: Optional[int] = None,
+    width: int = 1000,
+    out: Optional[str] = None,
+    tile: int = 512,
+    inter_tile_pause: float = 0.15,
+    verbose: bool = False,
+):
+    """Stream one cross-section of a scroll and return it (optionally save a PNG).
+
+    Parameters
+    ----------
+    scroll_id : which scroll (1-5).
+    z_frac    : depth as a fraction 0..1 of the volume height (ignored if ``z`` given).
+    z         : explicit slice index at the *chosen pyramid level*.
+    width     : desired output width in pixels; picks the coarsest pyramid level
+                that still meets it, keeping the read small and rate-limit-safe.
+    out       : if given, save a contrast-stretched PNG here.
+    """
+    vol = open_scroll(scroll_id)
+    level = vol.level_for_width(width)
+    zi = z if z is not None else int(round(z_frac * (level.shape[0] - 1)))
+
+    def _prog(done, total):
+        if verbose:
+            print(f"  tile {done}/{total}", end="\r", flush=True)
+
+    def _back(delay, attempt):
+        if verbose:
+            print(f"\n  429 backoff {delay:.1f}s (attempt {attempt})", flush=True)
+
+    arr = read_slice(
+        vol, level, zi,
+        tile=tile, inter_tile_pause=inter_tile_pause,
+        on_progress=_prog, on_backoff=_back,
+    )
+    if verbose:
+        print()
+    if out:
+        w, h = to_png(arr, out)
+        if verbose:
+            print(f"saved {out} ({w}x{h}) from scroll {scroll_id} level {level.path} z={zi}")
+    return arr

scrollscout/catalog.py

@@ -0,0 +1,103 @@
+"""Scroll catalog: map a scroll id to its multiscale OME-Zarr URL and pyramid levels.
+
+We stream everything. Nothing here downloads a full volume; opening a zarr array
+only reads small metadata (`.zarray` / `.zattrs`), a few KB.
+"""
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from functools import lru_cache
+from typing import Optional
+
+import fsspec
+import zarr
+
+# Canonical scroll -> volume zarr URL. Sourced from the official `vesuvius`
+# catalogue (`vesuvius.list_files()`); hard-coded as a fallback so scrollscout
+# works even if that optional dependency / network catalogue is unavailable.
+_FALLBACK_VOLUMES = {
+    1: "https://dl.ash2txt.org/full-scrolls/Scroll1/PHercParis4.volpkg/volumes_zarr_standardized/54keV_7.91um_Scroll1A.zarr/",
+    2: "https://dl.ash2txt.org/full-scrolls/Scroll2/PHercParis3.volpkg/volumes_zarr_standardized/54keV_7.91um_Scroll2A.zarr/",
+    3: "https://dl.ash2txt.org/full-scrolls/Scroll3/PHerc332.volpkg/volumes_zarr_standardized/53keV_7.91um_Scroll3.zarr/",
+    4: "https://dl.ash2txt.org/full-scrolls/Scroll4/PHerc1667.volpkg/volumes_zarr/20231117161658.zarr/",
+    5: "https://dl.ash2txt.org/full-scrolls/Scroll5/PHerc172.volpkg/volumes_zarr/20241024131838.zarr/",
+}
+
+
+@dataclass(frozen=True)
+class Level:
+    """One resolution level of a multiscale pyramid."""
+
+    path: str          # dataset key inside the zarr group, e.g. "0", "3"
+    shape: tuple       # (z, y, x)
+    chunks: tuple
+    dtype: str
+    scale: tuple       # downsample factor vs level 0, e.g. (8, 8, 8)
+
+    @property
+    def voxels(self) -> int:
+        z, y, x = self.shape
+        return z * y * x
+
+
+@dataclass(frozen=True)
+class ScrollVolume:
+    scroll_id: int
+    url: str
+    levels: tuple  # tuple[Level], finest first
+
+    def level_for_width(self, target_px: int) -> Level:
+        """Coarsest level whose in-plane width is still >= target_px.
+
+        Picking the smallest sufficient level is what keeps us off the
+        rate limiter: a 1000px view from level 3 is ~64 chunks, not ~4000.
+        """
+        candidates = [lv for lv in self.levels if lv.shape[2] >= target_px]
+        if not candidates:
+            return self.levels[0]  # target bigger than full res; use finest
+        return min(candidates, key=lambda lv: lv.voxels)
+
+    @property
+    def finest(self) -> Level:
+        return self.levels[0]
+
+
+def volume_url(scroll_id: int) -> str:
+    """Resolve a scroll's zarr URL, preferring the live `vesuvius` catalogue."""
+    try:
+        from vesuvius import list_files  # optional dependency
+
+        files = list_files()
+        entry = files.get(scroll_id) or files.get(str(scroll_id))
+        if entry:
+            # entry: {energy: {resolution: {"volume": url, ...}}}
+            for energy in entry.values():
+                for res in energy.values():
+                    if isinstance(res, dict) and res.get("volume"):
+                        return res["volume"]
+    except Exception:
+        pass
+    if scroll_id not in _FALLBACK_VOLUMES:
+        raise KeyError(f"Unknown scroll id {scroll_id!r}; known: {sorted(_FALLBACK_VOLUMES)}")
+    return _FALLBACK_VOLUMES[scroll_id]
+
+
+@lru_cache(maxsize=16)
+def open_scroll(scroll_id: int, url: Optional[str] = None) -> ScrollVolume:
+    """Open a scroll's multiscale metadata (streams only a few KB)."""
+    url = url or volume_url(scroll_id)
+    fs = fsspec.filesystem("https")
+    attrs = json.loads(fs.open(url.rstrip("/") + "/.zattrs").read())
+    datasets = attrs["multiscales"][0]["datasets"]
+    levels = []
+    for d in datasets:
+        p = d["path"]
+        scale = tuple(d["coordinateTransformations"][0]["scale"])
+        arr = zarr.open(url.rstrip("/") + "/" + p, mode="r")
+        levels.append(
+            Level(path=p, shape=tuple(arr.shape), chunks=tuple(arr.chunks),
+                  dtype=str(arr.dtype), scale=scale)
+        )
+    levels.sort(key=lambda lv: lv.voxels, reverse=True)  # finest (biggest) first
+    return ScrollVolume(scroll_id=scroll_id, url=url.rstrip("/") + "/", levels=tuple(levels))

scrollscout/cli.py

@@ -0,0 +1,95 @@
+"""Command-line interface for scrollscout."""
+from __future__ import annotations
+
+import argparse
+import sys
+
+from . import __version__
+from .catalog import open_scroll
+from .reader import read_slice
+from .render import to_png
+
+
+def _cmd_info(args) -> int:
+    vol = open_scroll(args.scroll)
+    print(f"Scroll {vol.scroll_id}")
+    print(f"  url: {vol.url}")
+    print(f"  pyramid levels ({len(vol.levels)}):")
+    print(f"    {'level':>5}  {'shape (z,y,x)':>24}  {'chunks':>14}  {'scale':>12}  approx full size")
+    for lv in vol.levels:
+        gb = lv.voxels / 1e9  # uint8 => 1 byte/voxel
+        print(f"    {lv.path:>5}  {str(lv.shape):>24}  {str(lv.chunks):>14}  "
+              f"{str(lv.scale):>12}  {gb:8.2f} GB")
+    return 0
+
+
+def _cmd_thumb(args) -> int:
+    vol = open_scroll(args.scroll)
+    level = vol.level_for_width(args.width)
+    zi = args.z if args.z is not None else int(round(args.z_frac * (level.shape[0] - 1)))
+    print(f"scroll {vol.scroll_id}: level {level.path} {level.shape}, slice z={zi}, "
+          f"target width {args.width}px")
+
+    def prog(done, total):
+        print(f"  streaming tile {done}/{total}", end="\r", flush=True)
+
+    def back(delay, attempt):
+        print(f"\n  rate-limited; backing off {delay:.1f}s (attempt {attempt})", flush=True)
+
+    arr = read_slice(vol, level, zi, tile=args.tile,
+                     inter_tile_pause=args.pause, on_progress=prog, on_backoff=back)
+    print()
+    w, h = to_png(arr, args.out, max_px=args.max_px)
+    print(f"saved {args.out} ({w}x{h})")
+    return 0
+
+
+def _cmd_scrolls(_args) -> int:
+    from .catalog import _FALLBACK_VOLUMES
+    print("Known scrolls:", ", ".join(str(k) for k in sorted(_FALLBACK_VOLUMES)))
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="scrollscout",
+        description="Scout Vesuvius Challenge scrolls -- stream and preview CT "
+                    "volumes without downloading terabytes.",
+    )
+    p.add_argument("--version", action="version", version=f"scrollscout {__version__}")
+    sub = p.add_subparsers(dest="cmd", required=True)
+
+    ps = sub.add_parser("scrolls", help="list known scroll ids")
+    ps.set_defaults(func=_cmd_scrolls)
+
+    pi = sub.add_parser("info", help="show a scroll's multiscale pyramid")
+    pi.add_argument("scroll", type=int)
+    pi.set_defaults(func=_cmd_info)
+
+    pt = sub.add_parser("thumb", help="stream a cross-section to a PNG")
+    pt.add_argument("scroll", type=int)
+    pt.add_argument("-o", "--out", default="scroll.png", help="output PNG path")
+    pt.add_argument("-w", "--width", type=int, default=1000,
+                    help="target width px (selects pyramid level)")
+    pt.add_argument("--z", type=int, default=None, help="explicit slice index at chosen level")
+    pt.add_argument("--z-frac", type=float, default=0.5, dest="z_frac",
+                    help="depth as fraction 0..1 (default middle)")
+    pt.add_argument("--tile", type=int, default=512, help="tile size in px")
+    pt.add_argument("--pause", type=float, default=0.15, help="seconds between tiles")
+    pt.add_argument("--max-px", type=int, default=1600, dest="max_px",
+                    help="cap output dimension")
+    pt.set_defaults(func=_cmd_thumb)
+    return p
+
+
+def main(argv=None) -> int:
+    args = build_parser().parse_args(argv)
+    try:
+        return args.func(args)
+    except KeyboardInterrupt:
+        print("\ninterrupted", file=sys.stderr)
+        return 130
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scrollscout/reader.py

@@ -0,0 +1,112 @@
+"""Throttle-safe streaming reads from the Vesuvius data server.
+
+The scroll volumes live on dl.ash2txt.org as chunked OME-Zarr. A naive
+`array[z, y0:y1, x0:x1]` over a large region makes zarr fire one HTTP request
+per chunk, all at once -- which trips the server's HTTP 429 rate limiter and
+kills the read. Every laptop contributor hits this.
+
+This module reads a 2D slice in small, chunk-aligned tiles with a bounded
+number of tiles in flight and exponential backoff on 429, so a read *slows
+down* under pressure instead of failing.
+"""
+from __future__ import annotations
+
+import time
+from typing import Callable, Optional
+
+import numpy as np
+import zarr
+
+from .catalog import Level, ScrollVolume
+
+
+class RateLimited(RuntimeError):
+    pass
+
+
+def _is_429(exc: Exception) -> bool:
+    s = str(exc)
+    return "429" in s or "Too Many Requests" in s
+
+
+def _fetch_tile(arr, z: int, y0: int, y1: int, x0: int, x1: int,
+                tries: int, base_delay: float,
+                on_backoff: Optional[Callable[[float, int], None]]) -> np.ndarray:
+    """Fetch one 2D tile with retry+backoff on rate limiting."""
+    for attempt in range(tries):
+        try:
+            return np.asarray(arr[z, y0:y1, x0:x1])
+        except Exception as exc:  # noqa: BLE001 - zarr wraps the HTTP error deeply
+            if _is_429(exc) and attempt < tries - 1:
+                delay = base_delay * (2 ** attempt)
+                if on_backoff:
+                    on_backoff(delay, attempt + 1)
+                time.sleep(delay)
+                continue
+            if _is_429(exc):
+                raise RateLimited(
+                    f"Rate limited after {tries} attempts on tile "
+                    f"z={z} y[{y0}:{y1}] x[{x0}:{x1}]"
+                ) from exc
+            raise
+    raise RateLimited("unreachable")
+
+
+def read_slice(
+    scroll: ScrollVolume,
+    level: Level,
+    z: int,
+    *,
+    tile: int = 512,
+    inter_tile_pause: float = 0.15,
+    tries: int = 6,
+    base_delay: float = 1.0,
+    on_progress: Optional[Callable[[int, int], None]] = None,
+    on_backoff: Optional[Callable[[float, int], None]] = None,
+) -> np.ndarray:
+    """Read a full 2D (y, x) cross-section at index ``z`` of ``level``.
+
+    Reads tile-by-tile with a short pause between tiles so we stay polite to
+    the server. Returns a 2D numpy array of the level's native dtype.
+    """
+    arr = zarr.open(scroll.url + level.path, mode="r")
+    _, ny, nx = level.shape
+    if not (0 <= z < level.shape[0]):
+        raise IndexError(f"z={z} out of range 0..{level.shape[0]-1} for level {level.path}")
+
+    out = np.empty((ny, nx), dtype=level.dtype)
+    y_tiles = list(range(0, ny, tile))
+    x_tiles = list(range(0, nx, tile))
+    total = len(y_tiles) * len(x_tiles)
+    done = 0
+    for y0 in y_tiles:
+        y1 = min(y0 + tile, ny)
+        for x0 in x_tiles:
+            x1 = min(x0 + tile, nx)
+            out[y0:y1, x0:x1] = _fetch_tile(
+                arr, z, y0, y1, x0, x1, tries, base_delay, on_backoff
+            )
+            done += 1
+            if on_progress:
+                on_progress(done, total)
+            if inter_tile_pause and done < total:
+                time.sleep(inter_tile_pause)
+    return out
+
+
+def read_window(
+    scroll: ScrollVolume,
+    level: Level,
+    z: int,
+    y0: int,
+    y1: int,
+    x0: int,
+    x1: int,
+    *,
+    tries: int = 6,
+    base_delay: float = 1.0,
+    on_backoff: Optional[Callable[[float, int], None]] = None,
+) -> np.ndarray:
+    """Read a single small (y, x) window -- one throttle-safe request."""
+    arr = zarr.open(scroll.url + level.path, mode="r")
+    return _fetch_tile(arr, z, y0, y1, x0, x1, tries, base_delay, on_backoff)

scrollscout/render.py

@@ -0,0 +1,42 @@
+"""Turn a streamed cross-section into a viewable, contrast-stretched image."""
+from __future__ import annotations
+
+from typing import Optional, Tuple
+
+import numpy as np
+
+
+def autocontrast(a: np.ndarray, low_pct: float = 1.0, high_pct: float = 99.5) -> np.ndarray:
+    """Percentile contrast stretch to uint8.
+
+    Scroll CT data is low-contrast (papyrus vs air vs resin sit close together);
+    a percentile stretch makes the wound sheets legible without clipping detail.
+    """
+    a = a.astype(np.float32)
+    lo, hi = np.percentile(a, [low_pct, high_pct])
+    if hi <= lo:
+        hi = lo + 1.0
+    out = np.clip((a - lo) / (hi - lo) * 255.0, 0, 255)
+    return out.astype(np.uint8)
+
+
+def to_png(
+    a: np.ndarray,
+    path: str,
+    *,
+    max_px: Optional[int] = 1600,
+    stretch: bool = True,
+) -> Tuple[int, int]:
+    """Save a 2D array as a PNG, optionally auto-contrasted and downscaled.
+
+    Returns the saved (width, height).
+    """
+    from PIL import Image
+
+    img8 = autocontrast(a) if stretch else a.astype(np.uint8)
+    im = Image.fromarray(img8)
+    if max_px and max(im.size) > max_px:
+        r = max_px / max(im.size)
+        im = im.resize((max(1, int(im.size[0] * r)), max(1, int(im.size[1] * r))), Image.LANCZOS)
+    im.save(path)
+    return im.size

scrollscout-0.1.0.dist-info/METADATA

@@ -0,0 +1,125 @@
+Metadata-Version: 2.4
+Name: scrollscout
+Version: 0.1.0
+Summary: Scout Vesuvius Challenge scrolls: stream and preview Herculaneum CT volumes from a laptop without downloading terabytes or tripping rate limits.
+Author: Alexandre Dufour-Richard
+License: MIT
+Project-URL: Homepage, https://github.com/vonduffen/scrollscout
+Project-URL: Repository, https://github.com/vonduffen/scrollscout
+Project-URL: Issues, https://github.com/vonduffen/scrollscout/issues
+Project-URL: Vesuvius Challenge, https://scrollprize.org
+Keywords: vesuvius-challenge,herculaneum,ome-zarr,ct,papyrology
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: zarr<3,>=2.14
+Requires-Dist: numpy>=1.23
+Requires-Dist: fsspec>=2023.1
+Requires-Dist: aiohttp>=3.8
+Requires-Dist: requests>=2.28
+Requires-Dist: Pillow>=9.0
+Provides-Extra: catalog
+Requires-Dist: vesuvius>=0.1.9; extra == "catalog"
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Dynamic: license-file
+
+# scrollscout
+
+**Scout [Vesuvius Challenge](https://scrollprize.org) scrolls from a laptop — stream and preview the Herculaneum CT volumes without downloading terabytes or tripping the data server's rate limiter.**
+
+The scroll volumes are enormous. Scroll 1 alone is **14376 × 7888 × 8096 voxels ≈ 918 GB** at full resolution. If you're on a laptop with limited disk, you can't (and shouldn't) download them to take a look. The data *is* streamable as multiscale OME-Zarr — but two things bite newcomers immediately:
+
+1. **You don't know which resolution level to read.** Ask for a full-res cross-section and you'll try to pull hundreds of GB.
+2. **Naive reads get rate-limited.** A large `array[z, y0:y1, x0:x1]` makes zarr fire one HTTP request per chunk, all at once. The server replies `429 Too Many Requests` and your read dies:
+
+   ```
+   aiohttp.client_exceptions.ClientResponseError: 429, message='Too Many Requests',
+   url='https://dl.ash2txt.org/.../54keV_7.91um_Scroll1A.zarr/0/56/19/26'
+   ```
+
+`scrollscout` handles both for you: it **auto-selects the coarsest pyramid level** that satisfies your requested pixel width, and reads it in **small, chunk-aligned tiles with exponential backoff on 429**, so a read *slows down* under pressure instead of failing.
+
+![Scroll 1 mid cross-section](https://raw.githubusercontent.com/vonduffen/scrollscout/main/examples/scroll1_mid.png)
+
+*Scroll 1 (PHerc. Paris 4), middle cross-section — streamed with `scrollscout thumb 1 -w 1000`. Total transfer: a few MB, not 918 GB.*
+
+## Install
+
+```bash
+pip install scrollscout
+# optional: use the live scroll catalogue from the official `vesuvius` package
+pip install "scrollscout[catalog]"
+```
+
+You must accept the Vesuvius Challenge [data license](https://scrollprize.org/data) before accessing scroll data. scrollscout does not redistribute any scroll data; it streams the public server on your behalf.
+
+## Command line
+
+```bash
+# list a scroll's multiscale pyramid — see the sizes before you read anything
+scrollscout info 1
+
+# stream a middle cross-section to a PNG (auto-picks the pyramid level)
+scrollscout thumb 1 --width 1000 -o scroll1.png
+
+# a shallower slice of scroll 2, larger
+scrollscout thumb 2 --z-frac 0.25 --width 1200 -o scroll2_quarter.png
+```
+
+`scrollscout info 1` prints:
+
+```
+Scroll 1
+  pyramid levels (6):
+    level             shape (z,y,x)          chunks         scale  approx full size
+        0       (14376, 7888, 8096)  (128, 128, 128)  (1.0, 1.0, 1.0)    918.07 GB
+        1        (7188, 3944, 4048)  (128, 128, 128)  (2.0, 2.0, 2.0)    114.76 GB
+        2        (3594, 1972, 2024)  (128, 128, 128)  (4.0, 4.0, 4.0)     14.34 GB
+        3         (1797, 986, 1012)  (128, 128, 128)  (8.0, 8.0, 8.0)      1.79 GB
+        4           (899, 493, 506)  (128, 128, 128)  (16.0,16.0,16.0)     0.22 GB
+        5           (450, 247, 253)  (128, 128, 128)  (32.0,32.0,32.0)     0.03 GB
+```
+
+## Python API
+
+```python
+import scrollscout as ss
+
+vol = ss.open_scroll(1)            # streams only ~KB of metadata
+print(vol.level_for_width(1000))   # -> Level(path='3', ...)
+
+# get the cross-section as a numpy array (throttle-safe under the hood)
+arr = ss.thumbnail(1, z_frac=0.5, width=1000, out="scroll1.png", verbose=True)
+print(arr.shape, arr.dtype)        # (986, 1012) uint8
+```
+
+## How the throttle-safe read works
+
+- `level_for_width(target_px)` picks the **coarsest** pyramid level whose in-plane
+  width still meets your target. A 1000 px view comes from level 3 (~64 chunks),
+  never level 0 (~4000 chunks). Under-fetching is the first line of defense.
+- `read_slice()` walks the chosen slice in `tile`-sized blocks with a short pause
+  between tiles, and retries each tile with exponential backoff (`base_delay * 2**n`)
+  when the server returns 429. Non-rate-limit errors propagate immediately.
+
+## Scope & limitations
+
+- Reads scroll **volumes** (the `volumes_zarr*` OME-Zarr). Segment/surface
+  meshes and ink predictions are out of scope for v0.1.
+- Preview/QA tool, not an analysis pipeline — it gets you *looking* at the data
+  fast so you can decide where to work.
+- Cross-sections are on the `z` axis (the scan slice axis) for now.
+
+## License
+
+MIT (see `LICENSE`). Scroll data itself is governed by the Vesuvius Challenge /
+EduceLab-Scrolls terms and is **not** included or redistributed here.
+
+If you use scroll data in published work, cite EduceLab-Scrolls: Parsons, S.,
+Parker, C. S., Chapman, C., Hayashida, M., & Seales, W. B. (2023).
+*EduceLab-Scrolls: Verifiable Recovery of Text from Herculaneum Papyri using
+X-ray CT.* arXiv:2304.02084.

scrollscout-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+scrollscout/__init__.py,sha256=AO2QOyBYfw-jLtxuIoNd7f-U4RzazzuwNJ_qQAHC8vQ,2385
+scrollscout/catalog.py,sha256=dGVwSirAVrtrZedp0g8fnhtmCJS1gPO-SKDJZ6hx-vI,4055
+scrollscout/cli.py,sha256=FR_d4NFJ08T2ug3Uf8-VzWAUb3ROExB305jexwL9IRg,3541
+scrollscout/reader.py,sha256=Q0VGgTZ9SpVkHnOgtxvK-8DRhR60WYvVXy37Sh1L3D8,3676
+scrollscout/render.py,sha256=7z9GoQelnYoIS-pwqC3OCwRDDZPWdF7m_7ZAyTWIBBM,1279
+scrollscout-0.1.0.dist-info/licenses/LICENSE,sha256=fqoCMbltjt0-rd4v3jQbTjAL8tT7_DaApF3-mT_yKmM,1081
+scrollscout-0.1.0.dist-info/METADATA,sha256=JPgDV3rZBvTZuAsUXo_G_GXzyOscwv__L4QQv2eL2vk,5747
+scrollscout-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+scrollscout-0.1.0.dist-info/entry_points.txt,sha256=_HPS8ClBc0s4rgwgg_0lFKXTfX4OwYPDU-AOEEQY5rg,53
+scrollscout-0.1.0.dist-info/top_level.txt,sha256=H_5S-xPMRf7KenFZ780pEhRfdEP2FGbfYl76603rwm4,12
+scrollscout-0.1.0.dist-info/RECORD,,

scrollscout-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

scrollscout-0.1.0.dist-info/entry_points.txt

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

scrollscout-0.1.0.dist-info/licenses/LICENSE

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

scrollscout-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+scrollscout