bfplot 1.0.0__py3-none-any.whl

bfplot/result.py

@@ -0,0 +1,231 @@
+from __future__ import annotations
+
+from collections.abc import Iterable
+from pathlib import Path
+from typing import Any
+
+import matplotlib.pyplot as plt
+from matplotlib.figure import Figure
+
+from .adapters.matplotlib import translate_figures
+from .artifact import prepare_destination, read_hash, write_result
+from .bfir import BfirDocument
+from .temporal import Animation, FigureSource
+
+
+def figures_from(figure: FigureSource) -> list[Figure]:
+    if figure is None:
+        return [plt.figure(number) for number in plt.get_fignums()]
+    if isinstance(figure, Figure):
+        return [figure]
+    figures = list(figure)
+    if not all(isinstance(item, Figure) for item in figures):
+        raise TypeError("figure must be a Matplotlib Figure or iterable of Figures")
+    return figures
+
+
+class Collection:
+    """Named figures and any number of animations, combined into one BFIR document."""
+
+    def __init__(self) -> None:
+        self._groups: list[BfirDocument | Animation] = []
+        self._names: set[str] = set()
+        self._next_figure = 0
+        self._next_artist = 0
+        self._closed = False
+
+    @property
+    def names(self) -> list[str]:
+        """Names of the figures captured so far, in result order."""
+        names: list[str] = []
+        for group in self._groups:
+            document = group.initial_bfir if isinstance(group, Animation) else group
+            names.extend(
+                figure["name"] for figure in document.document["figures"] if "name" in figure
+            )
+        return names
+
+    def add(
+        self,
+        figure: FigureSource = None,
+        *,
+        name: str | Iterable[str | None] | None = None,
+    ) -> None:
+        """Capture the current state of one or more figures.
+
+        ``name`` labels a single figure, or gives one name per figure for several. When
+        omitted, a figure's Matplotlib label (``plt.figure("spectrum")``) is used if it
+        is unique within the result.
+        """
+        self._check_open()
+        figures = figures_from(figure)
+        names = self._claim_names(figures, name)
+        document, self._next_artist = translate_figures(
+            figures,
+            names=names,
+            first_figure=self._next_figure,
+            first_artist=self._next_artist,
+        )
+        self._next_figure += len(figures)
+        self._groups.append(document)
+
+    def animation(
+        self,
+        figure: FigureSource = None,
+        *,
+        name: str | Iterable[str | None] | None = None,
+        fps: float = 30,
+        loop: bool = True,
+    ) -> Animation:
+        """Record a timeline for some figures of this result.
+
+        Each animation has its own timeline and playback controls. Its figures appear
+        where the animation started; figures added with ``add()`` stay static.
+        """
+        self._check_open()
+        figures = figures_from(figure)
+        names = self._claim_names(figures, name)
+        first_figure, first_artist = self._next_figure, self._next_artist
+        next_artist = first_artist
+
+        def translator(source: FigureSource) -> BfirDocument:
+            nonlocal next_artist
+            document, next_artist = translate_figures(
+                figures_from(source),
+                names=names,
+                first_figure=first_figure,
+                first_artist=first_artist,
+            )
+            return document
+
+        recording = Animation(figures, fps=fps, loop=loop, translator=translator)
+        self._next_figure += len(figures)
+        self._next_artist = next_artist
+        self._groups.append(recording)
+        return recording
+
+    def _check_open(self) -> None:
+        if self._closed:
+            raise RuntimeError("result is closed")
+
+    def _finish(self) -> BfirDocument:
+        for group in self._groups:
+            if isinstance(group, Animation):
+                group.close()
+        self._closed = True
+        if not self._groups:
+            raise ValueError("a result needs at least one figure")
+        return self._document()
+
+    def _claim_names(
+        self, figures: list[Figure], name: str | Iterable[str | None] | None
+    ) -> list[str | None]:
+        if isinstance(name, str):
+            if len(figures) != 1:
+                raise ValueError("a single name needs exactly one figure; pass a list of names")
+            requested: list[str | None] = [name]
+        elif name is None:
+            requested = [None] * len(figures)
+        else:
+            requested = list(name)
+            if len(requested) != len(figures):
+                raise ValueError("pass one name per figure")
+        claimed: list[str | None] = []
+        pending = set(self._names)
+        for figure, explicit in zip(figures, requested, strict=True):
+            if explicit is not None:
+                if not isinstance(explicit, str) or not explicit:
+                    raise ValueError("figure names must be non-empty strings")
+                if explicit in pending:
+                    raise ValueError(f"figure name {explicit!r} is already used in this result")
+                chosen: str | None = explicit
+            else:
+                label = figure.get_label()
+                chosen = label if label and label not in pending else None
+            if chosen is not None:
+                pending.add(chosen)
+            claimed.append(chosen)
+        self._names = pending
+        return claimed
+
+    def _document(self) -> BfirDocument:
+        figures: list[dict[str, Any]] = []
+        buffers: dict[str, Any] = {}
+        timelines: list[dict[str, Any]] = []
+        for group in self._groups:
+            document = group.finalized_bfir if isinstance(group, Animation) else group
+            renamed: dict[str, str] = {}
+            for buffer_id, buffer in document.buffers.items():
+                renamed[buffer_id] = f"buffer-{len(buffers)}"
+                buffers[renamed[buffer_id]] = buffer
+            content = _rename_buffers(document.document, renamed)
+            figures.extend(content["figures"])
+            timelines.extend(content.get("timelines", []))
+        content: dict[str, Any] = {"figures": figures}
+        if timelines:
+            content["timelines"] = timelines
+        return BfirDocument(content, buffers)
+
+
+class Result(Collection):
+    """One BFPlot output: named figures and any number of animations.
+
+    Figures are captured when they are added. Nothing is written until the result
+    closes, and a result whose ``with`` block raises writes nothing. An existing BFPlot
+    result at the same path is replaced; any other existing file or directory is
+    reported when the result is created, before the script does expensive work.
+    """
+
+    def __init__(self, path: str | Path, *, preview: bool = True, _stacklevel: int = 1):
+        super().__init__()
+        self.path = Path(path)
+        self.preview = bool(preview)
+        prepare_destination(self.path, stacklevel=_stacklevel + 1)
+        self._written: Path | None = None
+        self._hash: str | None = None
+
+    @property
+    def hash(self) -> str | None:
+        """The written result's hash (``"sha256:..."``), or ``None`` until it is closed."""
+        return self._hash
+
+    def close(self) -> Path:
+        """Write the result and return its path."""
+        if self._written is not None:
+            return self._written
+        self._check_open()
+        document = self._finish()
+        self._written = write_result(self.path, document, preview=self.preview)
+        self._hash = read_hash(self._written)
+        return self._written
+
+    def abort(self) -> None:
+        """Discard the result without writing anything."""
+        self._closed = True
+        for group in self._groups:
+            if isinstance(group, Animation) and not group.closed:
+                group.abort()
+
+    def __enter__(self) -> Result:
+        return self
+
+    def __exit__(self, exception_type: Any, *_: Any) -> None:
+        if exception_type is None:
+            self.close()
+        else:
+            self.abort()
+
+
+def _rename_buffers(value: Any, renamed: dict[str, str]) -> Any:
+    if isinstance(value, dict):
+        if set(value) == {"$buffer"}:
+            return {"$buffer": renamed[value["$buffer"]]}
+        return {key: _rename_buffers(item, renamed) for key, item in value.items()}
+    if isinstance(value, list):
+        return [_rename_buffers(item, renamed) for item in value]
+    return value
+
+
+def result(path: str | Path, *, preview: bool = True) -> Result:
+    """Collect figures and animations into one output at ``path``."""
+    return Result(path, preview=preview, _stacklevel=2)

bfplot/temporal.py

@@ -0,0 +1,212 @@
+from __future__ import annotations
+
+import copy
+import math
+from collections.abc import Callable, Iterable
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+from matplotlib.figure import Figure
+
+from .bfir import ANIMATABLE, BfirDocument
+
+FigureSource = Figure | Iterable[Figure] | None
+Translator = Callable[[FigureSource], BfirDocument]
+
+
+class Animation:
+    """Record mutable Matplotlib figures as a timeline of semantic BFIR updates.
+
+    Each ``capture()`` translates the figures again and stores only the fields that
+    changed. Figures, axes and artists cannot be added or removed while recording.
+    """
+
+    def __init__(
+        self,
+        figure: FigureSource,
+        *,
+        fps: float = 30,
+        loop: bool = True,
+        translator: Translator,
+        finisher: Callable[[BfirDocument], Path] | None = None,
+    ):
+        if not math.isfinite(fps) or fps <= 0:
+            raise ValueError("fps must be a positive finite number")
+        self.figure = figure
+        self.fps = float(fps)
+        self.loop = bool(loop)
+        self._translator = translator
+        self._finisher = finisher
+        self._closed = False
+        self._result: Path | None = None
+        self._final: BfirDocument | None = None
+        self._initial = translator(figure)
+        self._previous = self._initial
+        self._buffers = dict(self._initial.buffers)
+        self._frames: list[dict[str, Any]] = []
+
+    @property
+    def result(self) -> Path | None:
+        """The written result, or ``None`` while recording or inside ``bfplot.result()``."""
+        return self._result
+
+    @property
+    def closed(self) -> bool:
+        return self._closed
+
+    @property
+    def frame_count(self) -> int:
+        return len(self._frames)
+
+    @property
+    def initial_bfir(self) -> BfirDocument:
+        """A copy of the scene that playback starts from."""
+        initial = self._initial
+        return BfirDocument(copy.deepcopy(initial.document), dict(initial.buffers))
+
+    @property
+    def finalized_bfir(self) -> BfirDocument:
+        """The temporal BFIR document produced by ``close()``."""
+        if self._final is None:
+            raise RuntimeError("animation has not been closed")
+        return self._final
+
+    def capture(self, *, time: float | None = None) -> None:
+        """Capture the current figure state at a strictly increasing time (default: next frame)."""
+        if self._closed:
+            raise RuntimeError("animation is closed")
+        last = self._frames[-1]["time"] if self._frames else 0.0
+        timestamp = last + 1 / self.fps if time is None else float(time)
+        if not math.isfinite(timestamp):
+            raise ValueError("frame time must be finite")
+        if timestamp <= last:
+            raise ValueError("frame times must be strictly increasing and greater than zero")
+        current = self._translator(self.figure)
+        updates = _Diff(self._previous, current, self._buffers).updates
+        self._frames.append({"time": timestamp, "updates": updates})
+        self._previous = current
+
+    def close(self) -> Path | None:
+        """Finish recording; a standalone animation is written and its path returned."""
+        if self._final is not None:
+            return self._result
+        if self._closed:
+            raise RuntimeError("animation was aborted")
+        self._closed = True
+        duration = self._frames[-1]["time"] if self._frames else 0.0
+        document = copy.deepcopy(self._initial.document)
+        figure_ids = [figure["id"] for figure in document["figures"]]
+        document["timelines"] = [
+            {
+                "figures": figure_ids,
+                "fps": self.fps,
+                "duration": duration,
+                "loop": self.loop,
+                "frames": self._frames,
+            }
+        ]
+        final = BfirDocument(document, self._buffers)
+        final.validate()
+        self._final = final
+        if self._finisher is not None:
+            self._result = self._finisher(final)
+        return self._result
+
+    def abort(self) -> None:
+        """Stop recording without writing anything."""
+        self._closed = True
+
+    def __enter__(self) -> Animation:
+        return self
+
+    def __exit__(self, exception_type: Any, *_: Any) -> None:
+        if exception_type is None:
+            self.close()
+        else:
+            self.abort()
+
+
+class _Diff:
+    """The timeline updates that turn ``old`` into ``new``.
+
+    Changed buffers are copied into ``buffers`` (the animation's buffer table) under
+    fresh IDs so that every frame's arrays remain addressable.
+    """
+
+    def __init__(self, old: BfirDocument, new: BfirDocument, buffers: dict[str, Any]):
+        self.old, self.new, self.buffers = old, new, buffers
+        self.updates: list[dict[str, Any]] = []
+        for old_figure, new_figure in self._pair(old.document, new.document, "figures"):
+            self._fields("figure", old_figure, new_figure)
+            for old_axes, new_axes in self._pair(old_figure, new_figure, "axes"):
+                self._fields("axes", old_axes, new_axes)
+                for old_artist, new_artist in self._pair(old_axes, new_axes, "artists"):
+                    if old_artist["type"] != new_artist["type"]:
+                        raise ValueError("animation cannot change an artist type")
+                    for section in sorted(ANIMATABLE["artist"]):
+                        before, after = old_artist[section], new_artist[section]
+                        if before.keys() != after.keys():
+                            raise ValueError(
+                                f"animation cannot add or remove artist {section} fields"
+                            )
+                        for key in before:
+                            self._compare("artist", old_artist["id"], [section, key], before, after)
+
+    @staticmethod
+    def _pair(old: dict[str, Any], new: dict[str, Any], key: str) -> list[tuple[Any, Any]]:
+        before = {item["id"]: item for item in old[key]}
+        after = {item["id"]: item for item in new[key]}
+        if before.keys() != after.keys():
+            hint = "; update visibility instead" if key == "artists" else ""
+            raise ValueError(f"animation cannot add or remove {key}{hint}")
+        return [(item, after[item_id]) for item_id, item in before.items()]
+
+    def _fields(self, kind: str, old: dict[str, Any], new: dict[str, Any]) -> None:
+        for field in sorted(ANIMATABLE[kind]):
+            if (field in old) != (field in new):
+                raise ValueError(f"animation cannot add or remove {kind} field {field!r}")
+            if field in old:
+                self._compare(kind, old["id"], [field], old, new)
+
+    def _compare(
+        self, kind: str, target: str, path: list[str], old: dict[str, Any], new: dict[str, Any]
+    ) -> None:
+        key = path[-1]
+        if not self._equal(old[key], new[key]):
+            value = self._import(new[key])
+            self.updates.append(
+                {"target_kind": kind, "target": target, "path": path, "value": value}
+            )
+
+    def _equal(self, left: Any, right: Any) -> bool:
+        if isinstance(left, dict) and "$buffer" in left:
+            if not (isinstance(right, dict) and "$buffer" in right):
+                return False
+            first = self.old.buffers[left["$buffer"]].array
+            second = self.new.buffers[right["$buffer"]].array
+            return (
+                first.dtype == second.dtype
+                and first.shape == second.shape
+                and np.array_equal(first, second, equal_nan=True)
+            )
+        if type(left) is not type(right):
+            return False
+        if isinstance(left, dict):
+            return left.keys() == right.keys() and all(
+                self._equal(left[key], right[key]) for key in left
+            )
+        if isinstance(left, list):
+            return len(left) == len(right) and all(map(self._equal, left, right))
+        return left == right
+
+    def _import(self, value: Any) -> Any:
+        if isinstance(value, dict):
+            if "$buffer" in value:
+                buffer_id = f"buffer-{len(self.buffers)}"
+                self.buffers[buffer_id] = self.new.buffers[value["$buffer"]]
+                return {"$buffer": buffer_id}
+            return {key: self._import(item) for key, item in value.items()}
+        if isinstance(value, list):
+            return [self._import(item) for item in value]
+        return copy.deepcopy(value)

bfplot-1.0.0.dist-info/METADATA

@@ -0,0 +1,220 @@
+Metadata-Version: 2.5
+Name: bfplot
+Version: 1.0.0
+Summary: Interactive, reproducible scientific plots, with a Python implementation for Matplotlib
+Project-URL: Homepage, https://bfichera.github.io/bfplot/
+Project-URL: Documentation, https://bfichera.github.io/bfplot/
+Project-URL: Repository, https://github.com/bfichera/bfplot
+Project-URL: Issues, https://github.com/bfichera/bfplot/issues
+Project-URL: Changelog, https://github.com/bfichera/bfplot/releases
+Author: BFPlot contributors
+License-Expression: MIT
+License-File: LICENSE
+Keywords: matplotlib,plotting,reproducibility,scientific,visualization
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: Matplotlib
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: matplotlib>=3.7
+Requires-Dist: numpy>=1.24
+Requires-Dist: zstandard>=0.21
+Description-Content-Type: text/markdown
+
+# BFPlot
+
+> **[Read the documentation →](https://bfichera.github.io/bfplot/)**
+
+Basically I was tired of saving `matplotlib` outputs as non-interactive static files. I also [hate jupyter notebooks](https://www.youtube.com/watch?v=7jiPeIFXb6U)! `bfplot` lets you save `matplotlib` figures:
+
+```python
+import matplotlib.pyplot as plt
+import bfplot
+
+fig, ax = plt.subplots()
+ax.plot([1, 2, 3, 4], [1, 4, 9, 16], marker="o")
+
+bfplot.savefig("my_plot.bfplot", fig)
+```
+
+in a format that you can open up and interact with later using an integrated viewer app:
+
+```console
+$ bfplot view my_plot.bfplot
+```
+
+Here's what the viewer looks like:
+
+![The BFPlot viewer showing the example gallery: six panels of lines, bands, scatter, error bars, a histogram and bars, with animation controls in the left rail](https://raw.githubusercontent.com/bfichera/bfplot/main/docs/assets/gallery-core.png)
+
+## Installation
+
+Install the `bfplot` app, which has the viewer built in, on macOS or Linux:
+
+```console
+$ curl -LsSf https://github.com/bfichera/bfplot/releases/latest/download/install.sh | sh
+```
+
+Then install the Python interface (Python 3.10+):
+
+```console
+$ python -m pip install bfplot
+```
+
+See [Installation](https://bfichera.github.io/bfplot/getting-started/installation/) for uninstalling and other options.
+
+## Building from source
+
+On other platforms, or to build everything yourself, you need:
+
+- Python 3.10+ (pip 25.1+ if you want the development dependency groups)
+- Rust 1.88+ (install with [rustup](https://rustup.rs))
+- Node.js, only if you change the viewer
+
+Clone the repository and install both parts into a virtual environment:
+
+```console
+$ git clone https://github.com/bfichera/bfplot.git
+$ cd bfplot
+$ python -m venv .venv
+$ . .venv/bin/activate
+$ python -m pip install --upgrade pip
+$ python -m pip install ./crates/bfplot-cli -e .
+```
+
+`./crates/bfplot-cli` compiles the `bfplot` app with Cargo (through maturin) and installs it into the same environment as the Python library, where `bfplot.show()` finds it even if the environment is not activated. `-e .` installs the Python library in editable mode. Check both parts:
+
+```console
+$ python -c "import bfplot; print(bfplot.__version__)"
+$ bfplot --version
+```
+
+To build only the app, without Python:
+
+```console
+$ cargo build --release --locked -p bfplot-cli
+```
+
+The binary is written to `target/release/bfplot`; copy it anywhere on your `PATH`.
+
+For the development setup, tests and linters, see [Contributing](https://github.com/bfichera/bfplot/blob/main/CONTRIBUTING.md).
+
+## Results
+
+The code here: 
+
+```python
+with bfplot.result("results/fit.bfplot") as result:
+    result.add(fig_spectrum, name="spectrum")
+    result.add(fig_residuals, name="residuals")
+```
+produces a directory called `results/fit.bfplot` with the following structure:
+```text
+results/fit.bfplot/
+├── manifest.toml
+├── .gitignore
+└── objects/
+```
+
+The `.gitignore` file keeps the data (in `objects/`) out of version control.
+
+By default, `manifest.toml` ends with a rough ASCII/Braille drawing of each figure, written as `#` comments. It lets you see the plot in a diff or commit without opening the viewer. Pass `preview=False` to leave it out.
+
+```toml
+# Preview (approximate; regenerated on every save)
+#
+# ── calibration · Detector calibration ──────────────────────────────────
+#  1.1┌──────────────── Response ─────────────────┐
+#   s │⠐⠲⣄⡴⠒⠲⡄                         ⣠⠖⠂        │
+#   i │ ⢠⠟⣆  ⠙⣆                      ⣰⠃          │
+#   g │⢀⠏ ⠘⣆  ⠘⡆                   ⣰⠃            │
+# -1.1└───────────────────────────────────────────┘
+#     0                                         6.3
+```
+
+## Animations
+
+```python
+with bfplot.animation("wave.bfplot", fig, fps=30) as recording:
+    for phase in np.linspace(0, 2 * np.pi, 180, endpoint=False):
+        line.set_ydata(np.sin(x + phase))
+        recording.capture()
+```
+
+## Hashes
+
+Every result has one hash, recorded in its manifest. Two results have the same hash exactly when everything in them is identical.
+
+```python
+bfplot.hash("results/fit.bfplot")         # 'sha256:769fe097...'
+bfplot.hash(fig)                           # the same figure, hashed without writing
+bfplot.same("old/fit.bfplot", "new/fit.bfplot")
+bfplot.verify("results/fit.bfplot")        # check every object, return the hash
+```
+
+```console
+$ bfplot hash results/fit.bfplot
+sha256:769fe0976cfeecf73414d7b467013c6cde561405bce6c5af5828836e03016e37
+$ bfplot compare old/fit.bfplot new/fit.bfplot
+different
+  sha256:769fe097...  old/fit.bfplot
+  sha256:45a78207...  new/fit.bfplot
+figures[0].axes[0].title: "Tent" -> "Tall tent"
+```
+
+## Serving
+
+`bfplot view` serves a result and opens it in your browser. `bfplot serve` does the same without opening a browser. By default the server listens on `127.0.0.1:8080`; use `--port` to change the port.
+
+To serve remotely, bind to another address explicitly:
+
+```console
+$ bfplot serve my_plot.bfplot --bind 0.0.0.0 --port 9000
+```
+
+### Example: Using BFPlot with psana (SLAC S3DF)
+
+On S3DF (`ssh <username>@s3df.slac.stanford.edu`, then to your psana node), start the server without a browser:
+
+```console
+$ bfplot serve /path/to/my_plot.bfplot --port 9000
+```
+
+On your own machine, forward the port through S3DF to the node running the server:
+
+```console
+$ ssh -L 9000:<psana-node>:9000 <username>@s3df.slac.stanford.edu
+```
+
+Then open <http://127.0.0.1:9000> in your local browser. If you run the server on the login node itself, use `localhost` in place of `<psana-node>`.
+
+## Supported plots
+
+Lines, scatter plots, images, error bars, filled regions, histograms, contours, text, patches and common 3D plots. Anything else is shown as a visible placeholder, never silently dropped.
+
+To see them all, run the [example gallery](https://github.com/bfichera/bfplot/blob/main/examples/gallery.py): `python examples/gallery.py`, then `bfplot view gallery.bfplot`.
+
+| Images, contours and colorbars | Three-dimensional geometry |
+| --- | --- |
+| ![Raster image, contour lines, filled contours and closed paths](https://raw.githubusercontent.com/bfichera/bfplot/main/docs/assets/gallery-fields.png) | ![Helix, 3D scatter, surface and wire mesh](https://raw.githubusercontent.com/bfichera/bfplot/main/docs/assets/gallery-3d.png) |
+
+| Dense data |
+| --- |
+| ![A 220,000-point line, a 65,000-point scatter, a long random walk and a large image](https://raw.githubusercontent.com/bfichera/bfplot/main/docs/assets/gallery-dense.png) |
+
+The first two gallery figures are independent animations: each has its own play button, timeline slider and frame rate, shown in the left rail while that figure is on screen.
+
+## Security
+
+Only open bfplot results from sources you trust.
+
+## More
+
+- [Contributing](https://github.com/bfichera/bfplot/blob/main/CONTRIBUTING.md)
+
+## License
+
+MIT License: [LICENSE](https://github.com/bfichera/bfplot/blob/main/LICENSE).

bfplot-1.0.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+bfplot/__init__.py,sha256=3IjdsUrpQnPWzpPtDbmesg2mhT4XTyt-VfLftHl-XY8,630
+bfplot/api.py,sha256=h6enDQ8WJIpd3skqsctFwmkI9lydTorZ4S4-1pms1nc,6097
+bfplot/artifact.py,sha256=M6yCHVsxZWNRlsh3TM5PCHE-o88TpwzDobDmOh5gR2I,11183
+bfplot/bfir.py,sha256=7Ga518wa3lRkQ00nX1djX0wtuj6WfMAqYmVH_BJ9RTI,10923
+bfplot/bfir.schema.json,sha256=YiWOOfgmZ_TyRyep9wB9pZT7ngVILg9EYuPaAn6LIJY,3677
+bfplot/preview.py,sha256=81qm3c95hEYlzs5-f1fDYEv4dkD7HTAFj0Tr-D0gt6g,22916
+bfplot/result.py,sha256=J3O7X-_s2G1tYlrjIyTnPKJVZvubXDaYES6-o3psS3s,8615
+bfplot/temporal.py,sha256=XABRnuh8WcPVK6E3I8-7wPVKkvfzgC3kNihfFwC5dcM,8507
+bfplot/adapters/__init__.py,sha256=BGfxJ4NVAT5SSvi_cm8YmwhJjyAfRnzhoraRyx_Ep34,82
+bfplot/adapters/matplotlib.py,sha256=yXHuCgC8dNSc3NQsbuSMrZ2-7VVW92M59b53nWXybjE,21956
+bfplot/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bfplot-1.0.0.dist-info/METADATA,sha256=VeNl5wAXF73TINPip6iYTz42zZ7oWBmkW2WkmgaqR9Q,8252
+bfplot-1.0.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+bfplot-1.0.0.dist-info/licenses/LICENSE,sha256=8REjcyQ-BVwBMIhJQlfq1vUST8Z4URtceoWaTOWYBXQ,1070
+bfplot-1.0.0.dist-info/RECORD,,

bfplot-1.0.0.dist-info/WHEEL

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