thunderprint 0.1.0__py3-none-win_amd64.whl

thunderprint/__init__.py

@@ -0,0 +1,126 @@
+"""Locate where and when a recording was made from the thunder in it.
+
+    import thunderprint as tp
+    res = tp.locate("storm.opus", "2025-07-19")
+    print(res.best)          # Region(rank=1, lat=..., lon=..., start=..., reliable=True, ...)
+    env = res.envelope()     # observed vs modelled thunder over UTC time
+    res.viewer               # path to the interactive HTML map
+
+Lightning comes from MET Norway's Frost API (Nordic coverage; set FROST_CLIENT_ID or pass
+`frost_client_id`), or from your own strikes via `strikes=` (a CSV path, or rows / a DataFrame
+with time, lat, lon[, peak_ka, cloud, error_km]).
+"""
+
+from __future__ import annotations
+
+import csv
+import tempfile
+from datetime import date as _date, datetime, time as _time, timezone
+from pathlib import Path
+from typing import Iterable, Mapping
+
+from ._cli import ThunderprintError, run
+from .results import Envelope, Region, Result, Spectrogram, load
+
+__all__ = ["locate", "simulate", "fetch", "load", "Result", "Region", "Envelope", "Spectrogram", "ThunderprintError"]
+
+STRIKE_COLUMNS = ("time", "lat", "lon", "peak_ka", "cloud", "error_km")
+
+
+def locate(
+    audio: str | Path,
+    date: str | _date,
+    *,
+    start: str | _time | None = None,
+    strikes: str | Path | Iterable[Mapping] | None = None,
+    out_dir: str | Path | None = None,
+    model: str = "improved",
+    overrides: str | Path | None = None,
+    frost_client_id: str | None = None,
+    quiet: bool = True,
+) -> Result:
+    """Searches every strike on UTC `date` for where and when `audio` was recorded.
+
+    `start` (UTC time of day) narrows the search to ±0.5 s when the recording start is known.
+    Results are written to `out_dir` (a temp dir if omitted) and returned parsed. Takes minutes.
+    """
+    out = Path(out_dir) if out_dir else Path(tempfile.mkdtemp(prefix="thunderprint-"))
+    with _strike_file(strikes) as strikes_path:
+        args = ["locate", "--audio", str(audio), "--date", _iso_date(date), "--model", model, "--out", str(out)]
+        args += _opt("--start", start and _iso_time(start)) + _opt("--overrides", overrides) + _opt("--strikes", strikes_path)
+        run(args, frost_client_id, quiet)
+    return load(out)
+
+
+def simulate(
+    date: str | _date,
+    lat: float,
+    lon: float,
+    start: str | _time,
+    out_dir: str | Path,
+    *,
+    strikes: str | Path | Iterable[Mapping] | None = None,
+    frost_client_id: str | None = None,
+    **options: float,
+) -> Path:
+    """Synthesises a thunder recording at (`lat`, `lon`) from real strikes; returns the audio.wav path.
+
+    `options` map to `thunderprint sim` flags, e.g. duration=260, temp=14, wind_e=0, noise=0.02, seed=1.
+    """
+    out = Path(out_dir)
+    with _strike_file(strikes) as strikes_path:
+        args = ["sim", "--date", _iso_date(date), f"--lat={lat}", f"--lon={lon}", "--start", _iso_time(start), "--out", str(out)]
+        args += [f"--{k.replace('_', '-')}={v}" for k, v in options.items()] + _opt("--strikes", strikes_path)
+        run(args, frost_client_id)
+    return out / "audio.wav"
+
+
+def fetch(date: str | _date, *, frost_client_id: str | None = None) -> int:
+    """Downloads and caches one UTC day of Frost lightning; returns the strike count."""
+    return int(run(["fetch", "--date", _iso_date(date)], frost_client_id).split()[0])
+
+
+def _opt(flag: str, value) -> list[str]:
+    return [flag, str(value)] if value else []
+
+
+def _iso_date(d: str | _date) -> str:
+    return d.isoformat() if isinstance(d, _date) else d
+
+
+def _iso_time(t: str | _time) -> str:
+    return t.isoformat() if isinstance(t, _time) else t
+
+
+class _strike_file:
+    """Context manager: a CSV path for `strikes`, writing rows / a DataFrame to a temp file if needed."""
+
+    def __init__(self, strikes):
+        self.strikes, self.tmp = strikes, None
+
+    def __enter__(self) -> str | None:
+        s = self.strikes
+        if s is None or isinstance(s, (str, Path)):
+            return s and str(s)
+        rows = s.to_dict("records") if hasattr(s, "to_dict") else list(s)
+        self.tmp = tempfile.NamedTemporaryFile("w", suffix=".csv", delete=False, newline="")
+        cols = [c for c in STRIKE_COLUMNS if rows and c in rows[0]]
+        w = csv.writer(self.tmp)
+        w.writerow(cols)
+        for r in rows:
+            w.writerow([_csv_value(r[c]) for c in cols])
+        self.tmp.close()
+        return self.tmp.name
+
+    def __exit__(self, *exc):
+        if self.tmp:
+            Path(self.tmp.name).unlink(missing_ok=True)
+
+
+def _csv_value(v) -> str:
+    if isinstance(v, datetime):
+        # Naive datetimes are UTC here; .timestamp() alone would read them as local time.
+        return f"{(v if v.tzinfo else v.replace(tzinfo=timezone.utc)).timestamp():.6f}"
+    if isinstance(v, bool):
+        return "1" if v else "0"
+    return str(v)

thunderprint/_cli.py

@@ -0,0 +1,53 @@
+"""Locate and run the bundled `thunderprint` binary."""
+
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import sys
+import sysconfig
+from pathlib import Path
+
+EXE = "thunderprint" + (".exe" if sys.platform == "win32" else "")
+
+
+class ThunderprintError(RuntimeError):
+    """The thunderprint binary exited with an error; `stderr` holds its message."""
+
+    def __init__(self, args: list[str], stderr: str):
+        super().__init__(f"thunderprint {' '.join(args[:1])} failed:\n{stderr.strip()}")
+        self.stderr = stderr
+
+
+def binary() -> str:
+    # The wheel installs the binary into this interpreter's scripts dir, which may not be on PATH (e.g. --user installs).
+    for d in (sysconfig.get_path("scripts"), sysconfig.get_path("scripts", f"{os.name}_user")):
+        if d and (Path(d) / EXE).is_file():
+            return str(Path(d) / EXE)
+    found = shutil.which("thunderprint")
+    if not found:
+        raise FileNotFoundError("thunderprint binary not found; reinstall the package or put it on PATH")
+    return found
+
+
+def default_cache() -> Path:
+    if sys.platform == "win32":
+        base = Path(os.environ.get("LOCALAPPDATA", Path.home() / "AppData" / "Local"))
+    elif sys.platform == "darwin":
+        base = Path.home() / "Library" / "Caches"
+    else:
+        base = Path(os.environ.get("XDG_CACHE_HOME", Path.home() / ".cache"))
+    return base / "thunderprint" / "frost"
+
+
+def run(args: list[str], frost_client_id: str | None = None, quiet: bool = True) -> str:
+    """Runs the binary with `args`; returns stdout. Progress (stderr) is shown unless `quiet`."""
+    env = dict(os.environ)
+    env.setdefault("THUNDERPRINT_CACHE", str(default_cache()))
+    if frost_client_id:
+        env["FROST_CLIENT_ID"] = frost_client_id
+    proc = subprocess.run([binary(), *args], env=env, text=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE if quiet else None)
+    if proc.returncode != 0:
+        raise ThunderprintError(args, proc.stderr or "")
+    return proc.stdout

thunderprint/results.py

@@ -0,0 +1,119 @@
+"""Typed views of a `locate` output directory (candidates.json + trace.json)."""
+
+from __future__ import annotations
+
+import base64
+import json
+from dataclasses import dataclass
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+
+
+def _utc(epoch: float) -> datetime:
+    return datetime.fromtimestamp(epoch, tz=timezone.utc)
+
+
+@dataclass(frozen=True)
+class Region:
+    """One candidate recording location. `rank` is 1-based, as in the viewer."""
+
+    rank: int
+    lat: float
+    lon: float
+    start: datetime
+    probability: float
+    rho: float
+    cr90_area_km2: float
+    reliable: bool
+    audible_strikes: int
+    ellipse_km: tuple[float, float]
+    ellipse_bearing_deg: float
+    speed_of_sound_mps: float
+    wind_mps: tuple[float, float]
+
+
+@dataclass(frozen=True)
+class Spectrogram:
+    """Log-frequency power, scaled 0–255 over the top 45 dB. `power[band][frame]`."""
+
+    freqs_hz: list[float]
+    offsets_s: list[float]
+    power: list[list[int]]
+
+
+@dataclass(frozen=True)
+class Envelope:
+    """Observed and modelled thunder envelopes (each scaled to unit max) for one region, sampled at `times`."""
+
+    times: list[datetime]
+    observed: list[float]
+    modeled: list[float]
+
+
+@dataclass
+class Result:
+    out_dir: Path
+    regions: list[Region]
+    spectrogram: Spectrogram
+    _traces: dict
+
+    @property
+    def best(self) -> Region | None:
+        return self.regions[0] if self.regions else None
+
+    @property
+    def viewer(self) -> Path:
+        """Self-contained HTML map + trace panel; open it in a browser."""
+        return self.out_dir / "index.html"
+
+    @property
+    def geopackage(self) -> Path:
+        """GeoPackage (layers: cells, candidates, ellipses, onsets) for ArcGIS Pro / QGIS / geopandas."""
+        return self.out_dir / "result.gpkg"
+
+    def envelope(self, rank: int = 1) -> Envelope:
+        tr = next(r for r in self._traces["regions"] if r["rank"] == rank)
+        step = 1.0 / self._traces["rate_hz"]
+        t0 = _utc(tr["start"])
+        times = [t0 + timedelta(seconds=i * step) for i in range(len(self._traces["observed"]))]
+        return Envelope(times, self._traces["observed"], tr["model"])
+
+    def spectrogram_times(self, rank: int = 1) -> list[datetime]:
+        t0 = self.regions[rank - 1].start
+        return [t0 + timedelta(seconds=s) for s in self.spectrogram.offsets_s]
+
+
+def load(out_dir: str | Path) -> Result:
+    """Reads a finished `locate` output directory."""
+    out_dir = Path(out_dir)
+    cand = json.loads((out_dir / "candidates.json").read_text())
+    trace = json.loads((out_dir / "trace.json").read_text())
+    regions = [_region(r) for r in cand["regions"]]
+    return Result(out_dir, regions, _spectrogram(trace["spectrogram"]), trace["traces"])
+
+
+def _region(r: dict) -> Region:
+    sc, sh, atm = r["score"], r["shape"], r["atmosphere"]
+    return Region(
+        rank=r["rank"] + 1,
+        lat=r["map"]["lat"],
+        lon=r["map"]["lon"],
+        start=_utc(sc["best_start"]),
+        probability=r["region_prob"],
+        rho=sc["best_rho"],
+        cr90_area_km2=r["cr90_area_km2"],
+        reliable=r["reliable"],
+        audible_strikes=sh["audible_strikes"],
+        ellipse_km=(2 * sh["major_km"], 2 * sh["minor_km"]),
+        ellipse_bearing_deg=sh["major_bearing_deg"],
+        speed_of_sound_mps=atm["c_mps"],
+        wind_mps=(atm["wind_e_mps"], atm["wind_n_mps"]),
+    )
+
+
+def _spectrogram(s: dict) -> Spectrogram:
+    raw = base64.b64decode(s["data_b64"])
+    n = s["frames"]
+    power = [list(raw[k * n : (k + 1) * n]) for k in range(len(s["freqs_hz"]))]
+    offsets = [s["t0_s"] + i * s["hop_s"] for i in range(n)]
+    return Spectrogram(s["freqs_hz"], offsets, power)

thunderprint-0.1.0.dist-info/METADATA

@@ -0,0 +1,193 @@
+Metadata-Version: 2.4
+Name: thunderprint
+Version: 0.1.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Atmospheric Science
+Classifier: Topic :: Multimedia :: Sound/Audio :: Analysis
+License-File: LICENSE
+Summary: Locate where and when an audio recording was made from the thunder in it
+Keywords: geolocation,thunder,lightning,acoustics,osint
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Repository, https://github.com/Hexay/thunderprint
+
+# thunderprint
+
+[![CI](https://github.com/Hexay/thunderprint/actions/workflows/ci.yml/badge.svg)](https://github.com/Hexay/thunderprint/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/thunderprint.svg)](https://pypi.org/project/thunderprint/)
+[![crates.io](https://img.shields.io/crates/v/thunderprint.svg)](https://crates.io/crates/thunderprint)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+Work out where and when an audio recording was made using only the thunder in it.
+
+![thunderprint viewer: posterior heatmap and 90% ellipse on a topo map, above modeled vs observed thunder envelopes and a spectrogram](assets/screenshot.jpg)
+
+Lightning networks log every strike with millisecond timing and positions accurate to a few hundred metres.
+Each strike's thunder reaches a listener after a delay set by distance. A recording of a storm therefore
+carries the listener's position, as the delay pattern across dozens of strikes. thunderprint searches a
+day of strikes from [MET Norway's Frost API](https://frost.met.no) for the place and start time whose
+predicted thunder best matches the recording. It outputs a probability map with a 90% credible region.
+
+The output is a self-contained HTML page, shown above for a real 4-minute recording from northern Norway. The map
+shows the posterior heatmap and the best candidate with its 90% ellipse. The panel below it plots modeled (red) against
+observed (blue) thunder over UTC time, above a spectrogram of the clip.
+
+## Install
+
+Pick one:
+
+```sh
+pip install thunderprint     # CLI + Python API, prebuilt for Linux, macOS, Windows
+cargo install thunderprint   # CLI from crates.io
+```
+
+or download a prebuilt binary from [Releases](https://github.com/Hexay/thunderprint/releases).
+
+You also need:
+
+- [`ffmpeg`](https://ffmpeg.org) on `PATH` to decode audio. Any format ffmpeg reads works.
+- A free Frost client ID from [frost.met.no](https://frost.met.no/howto.html), set as `FROST_CLIENT_ID` in the
+  environment or in a `.env` file in the working directory:
+
+  ```
+  FROST_CLIENT_ID=your-client-id
+  ```
+
+To build from source (Rust stable, edition 2024): `git clone https://github.com/Hexay/thunderprint && cargo build --release`.
+
+## Quickstart
+
+You don't need a real recording to try it. `sim` synthesises thunder from real strikes at a listener you
+choose, and you can then check whether `locate` finds that listener:
+
+```sh
+thunderprint sim --date 2025-07-19 --lat 65.089 --lon 19.339 --start 14:40:30 \
+  --temp=12 --wind-e=4 --wind-n=4 --noise 0.03 --seed 25 --out data/sim/demo
+thunderprint locate --audio data/sim/demo/audio.wav --date 2025-07-19 --out out/demo
+thunderprint eval --run out/demo --truth data/sim/demo/truth.toml
+```
+
+`eval` should report an error of about 0.4 km. Open `out/demo/index.html` to see the map, with modeled and
+observed thunder and a spectrogram underneath it. Lightning for each UTC day is downloaded once and cached in `data/frost/`
+(override with `THUNDERPRINT_CACHE`).
+
+## Python
+
+```sh
+pip install thunderprint
+```
+
+The wheel bundles the compiled binary, so Rust isn't needed. ffmpeg still has to be on `PATH`.
+
+```python
+import thunderprint as tp
+
+res = tp.locate("storm.opus", "2025-07-19", frost_client_id="...")  # or set FROST_CLIENT_ID
+res.best            # Region(rank=1, lat=65.659, lon=14.117, start=datetime(...), reliable=True, ...)
+res.regions         # all candidates, best first
+env = res.envelope()        # .times (UTC datetimes), .observed, .modeled
+res.spectrogram             # .freqs_hz, .offsets_s, .power[band][frame]
+res.viewer                  # path to the interactive HTML map
+res.geopackage              # path to result.gpkg for ArcGIS / QGIS (geopandas.read_file(res.geopackage, layer="cells"))
+
+# Your own lightning data: a CSV path, a list of dicts, or a pandas DataFrame
+res = tp.locate("storm.opus", "2023-06-02", strikes=df)  # columns: time, lat, lon[, peak_ka, cloud, error_km]
+
+tp.simulate("2025-07-19", 65.089, 19.339, "14:40:30", "sim/", temp=12, seed=25)  # synthetic test clip
+tp.load("out/run")          # re-read a previous run
+```
+
+Frost downloads are cached in the user cache directory. To use a different location, set `THUNDERPRINT_CACHE`.
+
+## Usage
+
+| Command | What it does |
+|---|---|
+| `locate --audio F --date D [--start HH:MM:SS]` | Searches every strike on UTC day `D` for where and when `F` was recorded. If you know the start time, `--start` narrows the search to ±0.5 s. |
+| `eval --run DIR --truth T` | Scores a finished run against a truth file (`lat`/`lon` TOML). |
+| `sim --date D --lat .. --lon .. --start ..` | Writes a synthetic `audio.wav` and `truth.toml`. Run `--help` for noise, wind, stereo and propagation options. |
+| `fetch --date D` | Downloads and caches one day of Frost lightning ahead of time. |
+| `probe ...` | Diagnostics: scores one point at every pipeline stage. |
+
+`locate`, `sim` and `probe` take `--strikes file.csv` to use lightning data from any network instead of Frost:
+
+| Column | Required | Meaning |
+|---|---|---|
+| `time` | yes | UTC, as epoch seconds or ISO-8601 (`2025-07-19T16:00:01.25Z`) |
+| `lat`, `lon` | yes | Strike position, in degrees |
+| `peak_ka` | no | Peak current in kA. Default 10. |
+| `cloud` | no | `1`/`true` for in-cloud, otherwise cloud-to-ground |
+| `error_km` | no | Location error, as a 50% radius. Default 0.5. |
+
+Accuracy depends on the network's timing and position errors. Frost/NORDLIS reaches about 200 m; Blitzortung's
+public feed is about 3 km.
+
+`locate` writes five files to `--out` (default `out/run`):
+
+- `index.html`: the map viewer. Under the map, it plots the modeled and observed thunder envelopes over UTC time, with a 10–1000 Hz spectrogram on the same time axis. Clicking a candidate region switches the modeled curve to that region.
+- `result.gpkg`: a GeoPackage for ArcGIS Pro or QGIS (drag it in), in WGS 84. It has four layers:
+  - `cells`: posterior grid polygons
+  - `candidates`: points
+  - `ellipses`: 90% regions, linked to candidates by `rank`
+  - `onsets`: onset-solve fixes
+- `heatmap.geojson`: the same features in a single GeoJSON file
+- `candidates.json`: ranked regions, each with its start time, fitted atmosphere, 90% area and a `reliable` flag
+- `trace.json`: the envelope curves and spectrogram shown in the viewer
+
+### Models and overrides
+
+- **`--model improved`** (the default) is the model described below.
+- **`--model baseline`** reimplements the method from the video that inspired this project (see [Prior art](#prior-art)). It's there for comparison.
+- **`--overrides file.toml`** overrides search settings. The fields are declared in [`src/config.rs`](src/config.rs) and [`experiments/`](experiments) has examples.
+
+## How it works
+
+1. **Observed envelope.** The audio is band-passed to 20–250 Hz, where thunder carries far and through walls. It's then reduced to a smoothed, compressed loudness envelope.
+2. **Predicted envelope.** For a candidate listener position, every strike is rendered as a thunder pulse.
+   - Cloud-to-ground strikes are modelled as extended vertical channels, intra-cloud strikes as horizontal sources aloft.
+   - Arrival time is slant distance divided by the speed of sound, corrected for wind.
+   - Loudness scales with peak current and falls off with range.
+   - Each pulse has a rumble tail whose length grows with the channel's spread of arrival times.
+3. **Match.** The predicted envelope is correlated with the observed one at every possible start time in the day, using FFT cross-correlation.
+4. **Search, coarse to fine.** A coarse grid covers the whole strike region, then mid and fine grids refine the best peaks.
+   - The fine stage marginalises over nuisance atmospheres: temperature (speed of sound), wind, refraction lapse rate and the effective height thunder onsets are timed from.
+5. **Posterior.** Scores are tempered into a posterior, from which the tool reports ranked regions and 90% credible ellipses. A region is marked unreliable when fewer than 30 strikes would have been audible from it.
+
+Two physical findings drove the model. Both are written up in [`research/`](research):
+
+- **CG onset height.** Real thunder onsets behave as if they come from about 6 km up, not from the channel base (see [empirical_thunder_response.md](research/empirical_thunder_response.md)).
+- **Refraction shadow.** Upward refraction hides the low part of distant channels (see [thunder_physics_lit.md](research/thunder_physics_lit.md)).
+
+## Accuracy and limitations
+
+| Case | Error |
+|---|---|
+| Synthetic clips, listener near active storms | 0.4–1.0 km |
+| Synthetic twin of the real clip | 1.4 km |
+| Real 4-minute recording, northern Norway | 1.3 km, versus 2.2 km for the baseline method. Not blind: the truth was known during development. |
+
+Limitations:
+
+- **Coverage.** Frost lightning covers the Nordic detection network (Norway and neighbouring countries) and nothing else. For anywhere else, use `--strikes` with data from another network.
+- **Recording length.** You need several minutes of unedited audio recorded inside an active storm. Short or edited clips don't hear enough strikes to fix a position.
+- **Geometry.** If every strike comes from one direction, the result is a stretched ellipse. Strikes from several directions give a tight fix.
+- **Video clocks.** In a video, the visible flashes give the frame clock. The audio track can be seconds away from that, so `--start` taken from flashes needs care.
+- **Real clips fit worse than simulations.** The model is still incomplete, and the credible regions on real audio should be read as optimistic.
+
+## Prior art
+
+- The baseline method comes from colsto's videos [*Can you geolocate a video using background thunder sounds?*](https://www.youtube.com/watch?v=SnbkIm56TfI) and [*I located a fan's video using thunder sounds*](https://www.youtube.com/watch?v=6a7Z0I3LAnE). The method is a point source, 343 m/s, inverse-square attenuation and cosine similarity.
+- Related work on timing and locating recordings is surveyed in [`research/prior_art_receiver_location.md`](research/prior_art_receiver_location.md).
+
+## Data and attribution
+
+- **Lightning data:** from [MET Norway](https://www.met.no) via the [Frost API](https://frost.met.no), licensed under [NLOD 2.0 / CC BY 4.0](https://www.met.no/en/free-meteorological-data/Licensing-and-crediting). Raw strike files are not redistributed here; each user downloads them with their own client ID.
+- **Map tiles in the viewer:** © Esri, HERE, Garmin and © OpenStreetMap contributors.
+
+## License
+
+[MIT](LICENSE)
+

thunderprint-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+thunderprint/__init__.py,sha256=QTsTJcSHh4iqapQCVCx03mepoZ-Mnx-ZGCtdyVE6AUo,4915
+thunderprint/_cli.py,sha256=7fPd622rHbvS6w66CL4bcZxUPtnhbV5Q4TcjzYOnE9U,2071
+thunderprint/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+thunderprint/results.py,sha256=9mdasU8xTjpOMM2BitHRT4eTQavhKKIwulPCT6S9-wk,3819
+thunderprint-0.1.0.data/scripts/thunderprint.exe,sha256=0iKrDdIM2znfpSNCc5IHYbu_ahBnA1gf3Xchkv3Z_jw,7511040
+thunderprint-0.1.0.dist-info/METADATA,sha256=jSLPLGDc-3TjBTjFXjLbmC53do7QkzKFl8xnvIroFRs,11402
+thunderprint-0.1.0.dist-info/WHEEL,sha256=8Aej0W0a6Cz6apA3IzJrTnxLRVLAt-w0Oh8SA3Con_c,94
+thunderprint-0.1.0.dist-info/licenses/LICENSE,sha256=sGn782b_dSVFDtSU2vrc_N1aa9F4413qazbRivcG3ik,1083
+thunderprint-0.1.0.dist-info/sboms/thunderprint.cyclonedx.json,sha256=D_iJByzMK0qQ5Z1T3M8kT1eZM-jsvywovTNihUcgDSY,138185
+thunderprint-0.1.0.dist-info/RECORD,,

thunderprint-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.15.0)
+Root-Is-Purelib: false
+Tag: py3-none-win_amd64

thunderprint-0.1.0.dist-info/licenses/LICENSE

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