plot-io 0.12.0__py3-none-win_arm64.whl

plot_io/values.py

@@ -0,0 +1,190 @@
+"""Values given to ``color``, ``size`` and ``opacity``: colors, numbers to map, or computed
+values (``"density"``).
+
+The rules: a color string or a tuple of 3 or 4 numbers is one color; a list of colors is
+one color per point; a list, array or other buffer of numbers is one value per point,
+mapped through the series' ``color_map`` (or, for ``size``, its ``size_map``);
+``"density"`` or a :class:`~plot_io.Density` is computed from the series' points.
+"""
+
+import array
+import math
+from collections.abc import Callable
+from typing import Any
+
+from vec_io.arrays import doubles
+
+from . import kernels
+from .validators import Custom, length, real, typed
+
+__all__ = ["Values", "paint", "category_paint", "size_value", "is_computed",
+           "check_size_map", "lazy"]
+
+
+class _Lazy:
+    """The function ``name`` of ``plot_io.module``, imported when first called."""
+
+    __slots__ = ("module", "__name__")
+
+    def __init__(self, module: str, name: str) -> None:
+        self.module = module
+        self.__name__ = name
+
+    def _fn(self) -> Any:
+        from importlib import import_module
+        return getattr(import_module("plot_io." + self.module), self.__name__)
+
+    def __call__(self, *args: Any, **kw: Any) -> Any:
+        return self._fn()(*args, **kw)
+
+    @property
+    def value_type(self) -> str:
+        """The type of the values the function accepts (:func:`~plot_io.validators.typed`)."""
+        return getattr(self._fn(), "value_type", "Any")
+
+
+def lazy(module: str, name: str) -> Callable[..., Any]:
+    """The function ``name`` of ``plot_io.module``, imported when first called (for
+    validators of modules that import this one)."""
+    return _Lazy(module, name)
+
+
+class Values:
+    """Numbers to map through a color or size map: an ``array('d')`` (one per point), or a
+    dict ``{category: number}``."""
+
+    __slots__ = ("data",)
+
+    def __init__(self, data: Any) -> None:
+        self.data = data
+
+    def __len__(self) -> int:
+        return len(self.data)
+
+    def __repr__(self) -> str:
+        return f"Values({len(self.data)})"
+
+
+def is_computed(v: Any) -> bool:
+    from .density import Density
+    return isinstance(v, Density)
+
+
+def _number(x: Any) -> bool:
+    return real(x) is not None
+
+
+def _is_color_tuple(v: Any) -> bool:
+    return isinstance(v, tuple) and len(v) in (3, 4) and all(_number(c) for c in v)
+
+
+def _buffer(v: Any) -> Any:
+    if isinstance(v, (str, bytes, bytearray, list, tuple, dict)):
+        return None
+    try:
+        return memoryview(v)
+    except TypeError:
+        return None
+
+
+def _rgba_rows(v: Any) -> Any:
+    """An ``(n, 3)`` or ``(n, 4)`` numeric buffer as ``(n, 4)`` doubles (alpha 1 added)."""
+    n, k, _, flat = kernels.grid(v)
+    if any(x > 1.0 for x in flat[:4096]):            # 0–255 integers
+        flat = array.array("d", (x / 255.0 for x in flat))
+    if k == 3:
+        out = array.array("d", [1.0]) * (n * 4)
+        for i in range(n):
+            out[4 * i:4 * i + 3] = flat[3 * i:3 * i + 3]
+        flat = out
+    mv: Any = memoryview(flat).cast("B")
+    return mv.cast("d", (n, 4))
+
+
+def _color_map_error(name: str) -> ValueError:
+    return ValueError(f"a ColorMap goes in color_map (alias cmap), and the values in {name}")
+
+
+def paint(v: Any, name: str = "color") -> Any:
+    """A color, colors per point, values per point (``Values``), or ``"density"``."""
+    from .density import Density
+    from .color.maps import ColorMap
+    from .color.values import color
+
+    if isinstance(v, ColorMap):
+        raise _color_map_error(name)
+    if isinstance(v, Density):
+        return v
+    if isinstance(v, str):
+        if v.strip().lower() == "density":
+            return Density()
+        return color(v)
+    if _is_color_tuple(v):
+        return color(v)
+    if isinstance(v, dict):
+        raise ValueError(f"a dict of {name}s applies to categorical series (box, bar, violin)")
+    mv = _buffer(v)
+    if mv is not None:
+        if mv.ndim == 2 and mv.shape[1] in (3, 4):
+            return _rgba_rows(v)
+        if mv.ndim == 1:
+            return Values(doubles(v))
+        raise ValueError(f"{name}: expected a 1-D buffer of values or an (n, 3|4) buffer of "
+                         f"colors, got shape {tuple(mv.shape)}")
+    if hasattr(v, "to_numpy") and not isinstance(v, (list, tuple)):
+        return paint(v.to_numpy(), name)
+    if isinstance(v, (list, tuple)):
+        items = list(v)
+        if items and all(_number(x) or x is None for x in items):
+            if isinstance(v, tuple):
+                raise ValueError(f"{name}: a tuple of numbers is one color (3 or 4 numbers "
+                                 f"in [0, 1], or 0–255); use a list for one value per point")
+            return Values(doubles(items))
+        return [color(c) if c is not None else None for c in items]
+    return color(v)
+
+
+@typed("ColorLike | Column | Density | Mapping[Any, Any]")
+def category_paint(v: Any, name: str = "color") -> Any:
+    """``paint`` for categorical series: also a dict ``{category: color or number}``."""
+    if isinstance(v, dict):
+        if v and all(_number(x) or x is None for x in v.values()):
+            return Values({k: (math.nan if x is None else float(x)) for k, x in v.items()})
+        from .color.values import color
+        return {k: (color(c) if c is not None else None) for k, c in v.items()}
+    return paint(v, name)
+
+
+@typed("SupportsFloat | str | Column | Density")
+def _size_value(v: Any) -> Any:
+    from .density import Density
+    from .sizemaps import SizeMap
+
+    if isinstance(v, SizeMap):
+        raise ValueError("a SizeMap goes in size_map (alias smap), and the values in size")
+    if isinstance(v, Density):
+        return v
+    if isinstance(v, str) and v.strip().lower() == "density":
+        return Density()
+    if _number(v) or isinstance(v, str):
+        return _SIZE(v)
+    try:
+        return doubles(v.to_numpy() if hasattr(v, "to_numpy") else v)
+    except (TypeError, ValueError):
+        raise ValueError(f"expected a size, sizes or \"density\", got {v!r}") from None
+
+
+_SIZE = length(lo=0)
+#: A size (px), sizes per point, or ``"density"`` (mapped through ``size_map``); resolved
+#: as a length (single values).
+size_value = Custom(_size_value, like=_SIZE)
+
+
+@typed("SizeMap | tuple[SupportsFloat | str, SupportsFloat | str] | list[SupportsFloat | str]")
+def check_size_map(v: Any) -> Any:
+    from .sizemaps import SizeMap
+    if isinstance(v, SizeMap):
+        return v
+    if isinstance(v, (tuple, list)) and len(v) == 2:
+        return SizeMap(tuple(v))
+    raise ValueError(f"expected a SizeMap or a pair of sizes, got {v!r}")

plot_io-0.12.0.dist-info/METADATA

@@ -0,0 +1,215 @@
+Metadata-Version: 2.5
+Name: plot_io
+Version: 0.12.0
+Summary: Plots for PDF, EPS, SVG, PNG, JPEG, JPEG XL and AVIF, drawn with vec_io
+Project-URL: Repository, https://github.com/ajgouhier/plot_io
+Author-email: Arthur Gouhier <ajgouhier@gmail.com>
+License-Expression: BSD-3-Clause
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: vec-io<0.8,>=0.7
+Provides-Extra: dev
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Requires-Dist: ziglang==0.15.1; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# plot_io
+
+Plotting library in Python. No dependency other than [vec_io](https://github.com/ajgouhier/vec_io).
+
+* **Familiar:** a figure of plots; `scatter`, `line`, `fill`, `box`, `heatmap`, `bar`,
+  `hist`, `kde` (1-D and 2-D), `ecdf`, `violin`, `strip`, `swarm`, `area`, `errorbar`, `stem`,
+  `regression`, `hist2d`, `hexbin`, `contour`, `pie`, `dots`; reference lines, spans, text and
+  annotations; `color`, `marker`, `opacity`, `limits`, `scale`, `legend`.
+* **Statistical helpers:** `qq`, `raincloud`, `volcano`, `ma`, `manhattan`, `dendrogram`
+  plot types; significance brackets; point labels placed without overlaps; hierarchical
+  clustering (`plt.linkage`, scipy's methods); `plt.joint`, `plt.pairs` and `plt.clustermap`
+  figures in one call.
+* **Units:** lengths in px, pt, in, mm, `em`, `%` of the axes or of another setting, data
+  units and durations (`width="1.5in"`, `tick_length="0.5em"`, `width="60%"`,
+  `cap_length="12h"`); `var()` and `calc()` relate settings (`"calc(var(--gap) * 2)"`).
+* **One way to set things:** keywords at creation or `set(...)` on any object; figure
+  settings (font, color maps, line width…) are inherited by plots and series.
+* **Layouts:** an explicit grid of ids with spans, or automatic rows and columns; plots
+  sized individually; axis lines (or plot borders) aligned across the figure; margins from
+  the real text metrics; shared axes; secondary axes; facets of a table.
+* **Titles, legends and colorbars on any side:** several titles per plot; titles,
+  legends and colorbar keys shared by any rectangle of plots, nested as headers;
+  `share_legend` for one legend per row, column or figure; markup (`<i>`, `<b>`,
+  `<sup>`, …) in any text.
+* **Data:** columns of any table by name (`data=`: dicts, pandas, polars, numpy), one
+  series per group (`group=`), numbers given as colors or sizes, point density (scipy's
+  `gaussian_kde`, in C) for colors, sizes, opacity and drawing order.
+* **Axes:** linear, log, log2, log10, sqrt, exp, symlog, logit, time and category scales;
+  limits such as `"0/max"` or `"q:0.01/q:0.99"`; ticks with shared decimals and ×10ᵏ
+  factors, calendar ticks for dates.
+* **Colors:** one system of color maps with kinds (qualitative, sequential, diverging,
+  cyclic; `okabe_ito` for color-vision deficiencies), a default map per kind, `center=`
+  for data about a value, interpolation in Oklab, colorbars;
+  marker sizes by area, equal for every shape.
+* **Styles:** `style="matplotlib"`, `"seaborn"`, `"ggplot2"`, `"altair"`, `"matlab"`,
+  `"tufte"` give the look of those libraries; styles are presets of settings, and your
+  own build on them (a variant: `{"base": "seaborn", …}`).
+* **Output:** PDF, EPS (transparency flattened), SVG, PNG, JPEG, JPEG XL and AVIF, by the
+  file's extension; CMYK, PDF/A and text as outlines are options of the save
+  (`color="cmyk"`, `pdf={"a": "2b"}`, `text="paths"`).
+* **Large data:** one million points mapped and drawn in C; `simplify="auto"` drops what
+  cannot be seen, `rasterize=` turns a series into an image inside the PDF.
+* **Genome tracks:** `bigwig` signals, `bed` intervals, `genes` and `gtf` gene models,
+  `hic` triangles and `links` over a region, and `site_profile` and `site_heatmap` around
+  sites, read from gwseq_io's readers (or any object with their methods) without
+  depending on gwseq_io.
+
+## Install
+
+```sh
+pip install plot_io
+```
+
+Python 3.11+. Text is shaped (kerned) and its fonts embedded by vec_io; it needs an
+installed outline font, the default family list (`Helvetica, Nimbus Sans, Nimbus Sans L,
+TeX Gyre Heros, FreeSans, Arial, Liberation Sans, Arimo`) taking its first installed family
+([docs/api.md](https://github.com/ajgouhier/plot_io/blob/main/docs/api.md#1-conventions)). JPEG XL
+and AVIF output need vec_io's optional libjxl and libavif.
+
+Wheels hold plot_io's C library prebuilt for Linux (x86_64, aarch64; glibc or musl),
+Windows (x86_64, arm64) and macOS 13+ (arm64). Elsewhere (Intel Macs, other CPUs), pip
+builds it from the sdist with the local C compiler (gcc or clang; on Windows clang or MinGW,
+not MSVC); `pip install --no-binary plot_io plot_io` does so on any platform, and
+`pip install .` from a checkout. With the pinned zig in the environment (`pip install
+--require-hashes -r tools/zig.lock`, then `--no-build-isolation`), the sdist builds the
+release binary itself.
+
+```sh
+python -m plot_io._native verify    # the library loads, is the release binary, computes as it should
+```
+
+## Quick start
+
+```python
+import math
+import random
+
+import plot_io as plt
+
+rng = random.Random(1)
+x = [rng.uniform(0, 10) for _ in range(100)]
+y = [v + rng.gauss(0, 1) for v in x]
+s = plt.Scatter(x, y, name="data")
+s.plot.x_axis(label="Time (s)")
+s.plot.save("scatter.pdf")
+```
+
+```python
+t = [i / 10 for i in range(1, 101)]
+v = [math.exp(-k / 4) * (2 + math.sin(3 * k)) for k in t]
+upper, lower = [a * 1.3 for a in v], [a * 0.7 for a in v]
+va, vb = [rng.gauss(0, 1) for _ in range(50)], [rng.gauss(1, 1) for _ in range(50)]
+matrix = [[math.sin(i / 2) * math.cos(j / 3) for j in range(6)] for i in range(4)]
+columns, rows = list("ABCDEF"), ["w", "x", "y", "z"]
+z = [a - b for a, b in zip(x, y)]
+
+fig = plt.Figure(layout=[[1, 1, 2], [3, 4, 2]])
+p = fig.plot(1, title="Signal")
+p.line(t, v, name="raw")
+p.fill(t, upper, lower, opacity=0.3)
+p.y_axis(scale="log", label="Power")
+fig.plot(2).box({"a": va, "b": vb})
+h = fig.plot(3).heatmap(matrix, x=columns, y=rows, colorbar=True)
+fig.plot(4).scatter(x, y, c=z)
+fig.save("figure.pdf")
+fig.save("figure.png", dpi="2x")                         # 192 dpi; a number is dots per inch
+fig.save("figure.eps")                                   # PostScript: transparency flattened
+fig.save("figure.svg")
+data = fig.write("pdf", compression="small")             # bytes
+```
+
+```python
+fig = plt.Figure(style="ggplot2")                         # or a dict: {"base": "seaborn", "font_size": 9}
+```
+
+```python
+categories, counts = ["a", "b", "c"], [3, 5, 2]
+p = plt.Plot(width="3in", font_size="9pt", vars={"accent": "#c00"})
+p.x_axis(tick_length="0.5em", minor_tick_length="50%")
+p.bar(categories, counts, width="60%", color="var(--accent)")  # a custom variable
+p.x_axis.explain("tick_length")                          # where a value comes from
+```
+
+```python
+genes = {"umap_x": x, "umap_y": y}
+df = {"x": x, "y": y, "cluster": [int(a) % 3 for a in x],
+      "condition": ["ctrl" if a < 5 else "drug" for a in y],
+      "replicate": [i % 2 + 1 for i in range(len(x))]}
+p = plt.Plot()
+p.scatter("umap_x", "umap_y", data=genes, c="density", draw_order="density")   # columns
+p.scatter("x", "y", data=df, group="cluster", marker="auto")              # one series per group
+fig, panels = plt.facet(df, col="condition", row="replicate")               # small multiples
+panels.scatter("x", "y")
+```
+
+## Documentation
+
+* [Tutorial](https://github.com/ajgouhier/plot_io/blob/main/docs/tutorial.md): first steps, from a figure to its file.
+* [Guide](https://github.com/ajgouhier/plot_io/blob/main/docs/api.md): the concepts by topic, with the settings tables.
+* [Examples](https://github.com/ajgouhier/plot_io/blob/main/docs/examples.md): every image of the docs, the scripts that draw them, recipes.
+* [Plot types](https://github.com/ajgouhier/plot_io/blob/main/docs/api.md#plot-types): a page per plot type and figure helper, in
+  [docs/plots/](https://github.com/ajgouhier/plot_io/tree/main/docs/plots).
+* [Reference](https://github.com/ajgouhier/plot_io/blob/main/docs/api.md#reference): a page per other class, in
+  [docs/reference/](https://github.com/ajgouhier/plot_io/tree/main/docs/reference).
+* [Coming from matplotlib](https://github.com/ajgouhier/plot_io/blob/main/docs/from_matplotlib.md): its calls and names in plot_io.
+
+## Development
+
+```sh
+python tools/check.py               # every check, one after the other (--list shows them)
+python tools/check.py --fast        # without the slow ones (~25 s)
+python tools/check.py --only suite,ruff,mypy
+python -m unittest discover -s tests -t tests
+python tools/bench.py --check       # timings: fails over 1.5 × a target
+python tools/gen_docs.py            # regenerate the generated sections and pages of docs/
+python tools/gen_docs.py --images   # ... and the images of the plot-type pages and the tutorial
+python tools/visual_check.py --save # render the examples as references
+python tools/visual_check.py        # ... and later compare with them (pixels, tolerances)
+PLOT_IO_GOLDEN=update python -m unittest discover -s tests -t tests -p test_golden.py
+python tools/record_stats.py > tests/stats_reference.json  # with numpy, scipy, statsmodels
+```
+
+The tests use only their own fonts (`tests/fonts`: VioTest, from vec_io's tests, through
+`VEC_IO_FONT_DIRS`; installed fonts are ignored), so their text is the same on every
+machine. The goldens (`tests/golden.json`) are keyed by meaning: the laid-out geometry of
+each scene (rounded to 1/64 px), its drawing calls and its 96 dpi pixels (the last two
+compared where the fonts match those recorded). Pixels are compared exactly, whatever
+vec_io's version, against `tests/golden/*.png` (in the repository, not in the sdist; else
+against a hash in `golden.json`); a changed scene writes its actual image and a diff to
+`$PLOT_IO_GOLDEN_OUT` (default `<tempdir>/plot_io-golden/`) and names them. A missing
+`golden.json`, or a recorded scene no longer drawn, fails. `PLOT_IO_GOLDEN=update` rewrites
+only the files that changed; `PLOT_IO_GOLDEN=dump:DIR` writes the geometry, the drawing
+calls and the PNG of each scene to `DIR` to see what changed.
+
+The tests that read real files with gwseq_io run when it is importable: installed, or a
+built checkout beside this one (`../gwseq_io/crates/gwseq-io-py/python`, added to the path
+by `tests/test_genome.py`; elsewhere, put that directory on `PYTHONPATH`). Otherwise they
+are skipped.
+
+`PLOT_IO_NATIVE_LIB=PATH` loads that build of plot_io's C library instead of the one in
+`plot_io/_native/bin/` (a sanitizer build, any other build; see
+`plot_io/_native/README.md`).
+
+The statistics kernels and color mapping are in plot_io's own C library, `plio`
+(`plot_io/_native`, built like vec_io's: zig, freestanding, five targets). Building and its
+checks:
+
+```sh
+pip install --require-hashes -r tools/zig.lock   # the pinned zig
+python tools/build_native.py        # bindings from src/plio_api.h, then all targets (not in git)
+python tools/build_native.py --check   # every target rebuilt byte for byte as manifest.json says
+python tools/crosscheck.py --qemu PATH/qemu-aarch64-static   # same results on aarch64
+python tools/dist.py                # the sdist and one wheel per platform built from it
+```
+
+The binaries are built, not committed: `manifest.json` records each target's hash. In a
+checkout, `pip install -e .` builds the host's binary the way pip does from the sdist.
+
+See [plot_io/_native/README.md](plot_io/_native/README.md).

plot_io-0.12.0.dist-info/RECORD

@@ -0,0 +1,130 @@
+plot_io/__init__.py,sha256=yZSU-se8vJoacjq6VLDZzxWZ28yAwlQxD12hTXDDdf0,2893
+plot_io/_methods.py,sha256=NYM_SwKqhVMyGC-PiPGh3Dzneg89NyEuiBC2K7qKV3U,98692
+plot_io/axis.py,sha256=ENIg2yMiNMY0trssq9IWuWVj3ss_55vjbDauApdCYU8,71219
+plot_io/boxes.py,sha256=QLTJ-YaN5XYV5Wgerm6rIcvOz9C9fOEZy9TSclbpq3c,52983
+plot_io/canvas.py,sha256=3mg8AEFlsk8z0YwVL5jFqoxI2QmAo7Fz-At-S3tfk8k,16775
+plot_io/colorbar.py,sha256=wTpQuHLcuLjNltjbk45sAZHtynTYNiW1WRf9LIGtNn8,68863
+plot_io/columns.py,sha256=3Z4B0oavf9I0iB8IEXr-BeyfGEtK0m7cCq5_kzX7AW8,25581
+plot_io/decorations.py,sha256=q73CA-HXiAuxfaYZcIIojzid2kAVCJ01TtksbGH5Xlw,39650
+plot_io/defaults.py,sha256=o2ZsVoDSqs_7bT1mssKBgrNIWJNfGTPqETHZPv7ueJM,24423
+plot_io/density.py,sha256=MFLybA0UPXbIoFKrD0NTZyrzV0bkQqcW3QMZ8Ip7olI,5315
+plot_io/ext.py,sha256=w_WRFQBQxhvMNlX6mlCkk0SxxeZPNejsMInRO0ikiNM,3978
+plot_io/facets.py,sha256=_XuyJtxWiy0-vw9Gtkac0CQmdRoKvAsS9lB0cMCHHjY,10524
+plot_io/figure.py,sha256=0gOB6pz2hDf-Cam_P7xSqaQhrliyWzMB_JyDctHUHrA,40382
+plot_io/formatters.py,sha256=FKtFpvhBCbH5Hc-tLy2n85o_3L9g4stCtXwsrZgUXBE,4356
+plot_io/geometry.py,sha256=AA2NOZ3oWtWyfWiB0h_5iX5jrHAx9mFOcGjaFoP03_c,11538
+plot_io/groups.py,sha256=AO1Cw25Vs7AzwEF6Tyo9D3J2kwj2_C8JffhOWaa0Z-0,12903
+plot_io/guides.py,sha256=LyZQh2LD-AcCUzw0FoJxzkTIq8NaFEPRXJxxl_AsjWY,23515
+plot_io/hints.py,sha256=T5lnEaudybVt-mDk7INE-ciy7IPHcIOsE1KFW29gXPc,4909
+plot_io/kernels.py,sha256=GkBbtTwSZO1S8aCFEn3LIKhff3ovNacJcpzUFoN7Fcw,34276
+plot_io/labels.py,sha256=wgrZrxx96WdR--Xbpywm1C9SroMSty5v4Me-LyW0B4o,24776
+plot_io/layout.py,sha256=uc0G6XIKtnv9pepygPUN8ccbZwv6sfUe8aAFtiVH2GQ,63681
+plot_io/legend.py,sha256=vr3K6Nk2o4yquPBU96CHlFwMmzFEyj8-vwYvrjxOez0,26744
+plot_io/levels.py,sha256=bztn9yDlcYZC3M3y0UPB5NZ1AZr8b_1i_sDb5X3IVtI,21752
+plot_io/limits.py,sha256=kvEjWnez_2iKgAJQc6N_z0pEl2aoX4E_lGegvwXQRWI,4568
+plot_io/lines.py,sha256=MVvO8QvsowYN7emKsAnoCymbWil_XMQQj7s78un3S7w,1224
+plot_io/mapped.py,sha256=msNWg5Tc9LLXG9uu5F-Nw-Jd5MvQXjoWmSqwbj75LJU,21950
+plot_io/markers.py,sha256=wJpv0NSeHATtfp6xCZ2Mm9AlqgY_d_Dga5KLI8nLaGA,3476
+plot_io/markup.py,sha256=gcakejPA_jvq0q6dAtb_NHxkSvCx2U0nnTNDZOMBQ0I,4547
+plot_io/numbers.py,sha256=xJJiOJKie-TCYvcC7o_S3mbscG0XddBCXLJo7pK2orE,13935
+plot_io/occupancy.py,sha256=D_Tt4ESKkd731yfen2hcmvZsTi0MpEHv4rMr_9vpFzM,12952
+plot_io/plot.py,sha256=VuflyonaRWkqWz_nekpb_uSab16PRgCkeir0WuPuTlo,31143
+plot_io/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+plot_io/registry.py,sha256=pXdydUPrk2nBVvqzsBvPEnZcRt5ZgiqmwYX1o7Omh1k,3118
+plot_io/render.py,sha256=al38zuZOSz0ukIXI5j4sFxCKQTyemKWo1Wgf2JcblHo,19254
+plot_io/rows.py,sha256=jlMi5-DwtmSpomoDyaivozct6gCc8a-JVt642jgAT08,21114
+plot_io/scales.py,sha256=DhKj7J_YmvWSOq2Xqp-SR74XbuaJUuhRu3HLvhH2wFU,3787
+plot_io/seams.py,sha256=ySOQUQl9cPovhWwkRJdj_jfc7ik3kO6UJ5MzY-ybWaU,6272
+plot_io/settings.py,sha256=6srh8yTSaVYiVYIWm2fUx7Mw6RMpFEp5_4LI5qK5P_M,34801
+plot_io/shapes.py,sha256=MXYpvfyrBTwriXrTY-AnCkp_FlGoM-4VZh5_-6bBP3E,2858
+plot_io/sharing.py,sha256=9MJSAkkmmVDQNV1g2Dsd5nte44efefXES2utwi8b1YY,9823
+plot_io/sizemaps.py,sha256=Bu70z3RGtJDUCn357-Hn4naYkg3oR71JkLieiYTgD54,4059
+plot_io/spec.py,sha256=H-RAnWrLkVbXgoDcK1sdPjcxLHii5cQ5DDKMQaaWNmk,9433
+plot_io/states.py,sha256=tZk8NqccqUrMwjmR0Td68eWiR3Qair7DiixHE4f_41o,9062
+plot_io/tables.py,sha256=FskqlobZWCThHvU_sjWUs6AMdnw1X4YHl1u0Ht0PSio,4981
+plot_io/text.py,sha256=J3okY8ayTGL6j_qE2pz_IovVEttWOTlr0A1War9yZ-8,16901
+plot_io/ticks.py,sha256=yPsAnhrP88CsQOaMuShhg1Eob9pd1rrnTTi22pvTljQ,17356
+plot_io/times.py,sha256=ZMABzNN4TThWFYSVzgm-AHmrniEM51Kb6a8dhKlVTh0,11725
+plot_io/titles.py,sha256=xW20tQcPq2wFIzZdlEMRoGrG6OdFmTU-jG_H1yXTGeE,10160
+plot_io/transform.py,sha256=AAnn1Tc9igIrkkYgo23-Iu8voY9I8_1j4AvxS-9YF-Q,4838
+plot_io/types.py,sha256=ndsfrIqSnWanTiSsdW9I0ldTpMicRI-3N0hzajpKyKw,716681
+plot_io/units.py,sha256=NI1HM3yaBUOhOy9jj8GG1GWB-BuSYmH1uzZzeLbHbNA,29698
+plot_io/validators.py,sha256=k3uPAABWi8s4E3VYSuf9TZsaQOv5Etr2fY7gnD1pRfg,36760
+plot_io/values.py,sha256=nxaQuVhDZPGnY724quUZDJiLs3XBk0a-P5tIaF-S4b8,6600
+plot_io/_native/__init__.py,sha256=25TRoB6NBAdqEunu_y1hQ_SE_zsLjuEfeIEUL2ZpeI0,7470
+plot_io/_native/__main__.py,sha256=IB7B_qfjro4xibz42ZCFoZ2Aa7FIaVPXOwy2uCIxBQ8,7222
+plot_io/_native/_api.py,sha256=liv5XzVcyUeGbuCrlGcYxtZdemdFw2SAGrKiu_9CgRQ,14193
+plot_io/_native/kernels.py,sha256=gh1u3oJ3j6ot8es5nmj0gY0PjE2c6RnTp9WhS8vDeyA,12765
+plot_io/_native/manifest.json,sha256=1S6annqCaryfVPBU7Ekmj54Z8wOe4DssWyJrMz7UKVA,1318
+plot_io/color/__init__.py,sha256=Gbboslj7958lrMCMHhjREk_k__RD2oKBKmnPvxbgiCo,260
+plot_io/color/data.py,sha256=_YXAcBxrWaId3is0ny2pCaT3IaSVzK3HZVId1_g9lX0,121856
+plot_io/color/maps.py,sha256=R8xkB-Pu5Eky73OTng8ZRcgpHdkwn6rE3fu_LqrEf1Y,45352
+plot_io/color/values.py,sha256=T4pcog0x6TeL0ieSnoIf2HYJwF0KipfmIeO5Khkf0Gc,11796
+plot_io/color/variants.py,sha256=-V0Nlb76WtbASrcjBIS6FWHA2h5zQjqEHTg9dFugZb8,73189
+plot_io/genome/__init__.py,sha256=wSAlyxn-kVQioA3HWqwvBu1WcJmmlg-1bGH8bD-4xAA,820
+plot_io/genome/adapters.py,sha256=7Zx9aAt5hcqLtA4b-eO-WQ8dnUc8WAT17hr3G0pQfbk,15392
+plot_io/genome/combine.py,sha256=ftLD8iX_wElIWENT6lasyuXvIXBVOL8ppwQeWWaFDA8,5241
+plot_io/genome/contacts.py,sha256=sNi438h2yboaIAS7D_8BhWWFr1cAa5xcQr1KttRUmJ0,24314
+plot_io/genome/intervals.py,sha256=L9RQPtCvFhYnRXrxxhx1LYMiKu9xTYXcOrsQn6X9N2g,36328
+plot_io/genome/lanes.py,sha256=JKwRBZHMUngTDabW1c5g6v342bVvMqzTkCxbo3_6Yi8,8072
+plot_io/genome/layout.py,sha256=HpuKjTLjplavmXEWWSIV1arG0AF8A3ymqqIZ50p6wK8,9679
+plot_io/genome/links.py,sha256=ODfrgLr_Q6qXlJxKtDE32tLST53AwUlPcpbAesiGt0E,17166
+plot_io/genome/pack.py,sha256=fMCNJgPs99xkHlmWQOZTIBQMf_GYiI58KSiIDB5QWmw,1000
+plot_io/genome/readers.py,sha256=Wrhkecm84I_a2lOWacHoYI2t3Fljc7gPofp3AlrqmYc,6693
+plot_io/genome/regions.py,sha256=d5SbRsu_4EIW3iCYdAREBB0TLaJ-JJgdngsLX0oeIVI,9523
+plot_io/genome/scale.py,sha256=f2af7kAO658ynu-6dd-WmZk-aTP3YP5f1DrIUeXvEcM,14165
+plot_io/genome/series.py,sha256=KEFcCAk9sewOa4fhjCjuv2jUo1UjBnZ_Yn8OrPK-Ok8,14053
+plot_io/genome/signal.py,sha256=EOhRSuVxVhiiyvkrSzDnsslqS7MaTY2mARxXXf_RCuA,29187
+plot_io/genome/sites.py,sha256=R5Q_iS-RVR0XG0jykckH7cGyYhv6CoZ64T5hcm279wY,33576
+plot_io/genome/sources.py,sha256=IjY3ayH4RHdJ2aR2ve0vTW1ij8GH1jLlhkaoRqrhh9w,21441
+plot_io/genome/testing.py,sha256=cChSDCn-CgFUJWjWboNvHviYJYuMomEU_CwIdhXBBxg,7149
+plot_io/helpers/__init__.py,sha256=vR_BhAcofFmN5wCV4wSwiZhEf0Zfn2j2jB_wXGPbdao,928
+plot_io/helpers/clustermap.py,sha256=A7YoKQQ6dgFre8IZLhIgvW7y2rjDQUCvddpPMJvEd58,9462
+plot_io/helpers/dendrogram.py,sha256=HXd5Kse6u18mIIcdf-dz2D_u81ylFUvVUWGqmg_SFM4,7089
+plot_io/helpers/grids.py,sha256=PoELr-MQgnD1p5EwnpQlbtmQTqlPjgnTyGNHVKyJEJc,12917
+plot_io/helpers/qq.py,sha256=vb-A7ejucENvpLdMMyFGcB2DUihRhfi1aS9-IXyyymQ,12824
+plot_io/helpers/raincloud.py,sha256=7H3yW-5DG33OzcugO2kHwBeVRDFfgPkGdtYf8ajHlPA,11102
+plot_io/helpers/tree.py,sha256=3FqiI_RIZz_aGf78k7gOE0S0uyATZ4-2vyIxCPYOF_0,9030
+plot_io/helpers/volcano.py,sha256=b9HV1xL0155Ja7aX8Bk8emT9HbRwmg6gLlFTB3T77Yc,21113
+plot_io/layers/__init__.py,sha256=KIazkYBMb_ziB4oIFK6JGHCnIib2HwKCIjFJUIzf7i8,4440
+plot_io/layers/base.py,sha256=pq7IMf6qzsQmfMCvno267VfJtU0vHdW4Y1yuvYtlZ5s,31238
+plot_io/layers/context.py,sha256=4IcJY61OacRLsDkn7fNhmK5dw1SjRgiDMPjSkpfwYE4,3517
+plot_io/layers/core.py,sha256=xM-kQPWlKlNZ00w9__fLxbcdy4aDJSICssAZHXYx5tI,19111
+plot_io/layers/geoms.py,sha256=P0XtBMzdJa2GP8Q-60EGktc5UnifaupqEHFlaxK8BZA,60565
+plot_io/layers/grammar.py,sha256=3o9xDZaAPan4tGAGm3zvyl_b7e0WtVWzs988JM4Or2k,25257
+plot_io/layers/paint.py,sha256=3gqWCtMZYOxkz4QjwisiaFm06VZGLcgVgK1waB98RjQ,26684
+plot_io/layers/pipeline.py,sha256=t-tw_dGplxBdJU4rqjn2nfgsQIzrF0EGtk1M3QzgsnY,6843
+plot_io/layers/positions.py,sha256=9-7px3BFFTgC5Zk7rlf9Dq8q5z5FN-7-L9zdgxm5FgQ,17604
+plot_io/layers/stats.py,sha256=-NK8V3dUloQZVwAb1ScxytZzB_ZtILmkedXBFHeDecY,46690
+plot_io/presets/__init__.py,sha256=A17hkpgLG-90sqYelcE6CFuUuJwLOWtR7wTV7QjFZ1k,2034
+plot_io/presets/_util.py,sha256=8rXoyzv4BlND5VDE-C-FMHH_LwA-PC58xyRxHPoUyss,6342
+plot_io/presets/area.py,sha256=WH1khN16_XTaMtyPEuAw0-BEm9vFcp23LZHgCWUSCjc,6408
+plot_io/presets/bar.py,sha256=cN2KJ2TulVtYNEXLwepKrhjuNiYSoltDELrVxnJVB1s,12893
+plot_io/presets/box.py,sha256=wx4qJRj8Daq3YWm6-O5oiSJjr8TYInRZy63JWPLIRZw,18104
+plot_io/presets/catpoints.py,sha256=j6ouBAhhnxgB_EJuigbtARyq-U1FLTMFIZMjlEdzIIk,7512
+plot_io/presets/contour.py,sha256=iTSID5uyTcaOeOCILtO6gvoiiUcn-WOzf3xkFx2c12k,15889
+plot_io/presets/curves.py,sha256=JBDusm6dezS60O3dB6-yH4wHIUugLSQtWlDNd0-rYag,1147
+plot_io/presets/dots.py,sha256=fc0xl294izcwIrnt_KQZWXGrx8LEpSVZX-GA5BMAe7U,15649
+plot_io/presets/ecdf.py,sha256=3L282ywuESnAr29dv1YLRQtWbQx0jtyf1tgTMEPbZUc,4252
+plot_io/presets/errorbar.py,sha256=Vd4-gkqgtglbfiA9FKwItO0TR8LW3nbxnwjjxR2s47M,4900
+plot_io/presets/errors.py,sha256=EBfuQtShRM8HwKMcKbpY6bRmTFlJZ0V6YHI6ST1wv9k,12322
+plot_io/presets/fill.py,sha256=t_Y8LAnp3R-eloap_LXRLJvKIgwjl2DD_f98rjC0xLo,3106
+plot_io/presets/heatmap.py,sha256=l3BeT37xTP1_RSHgG0Qx1v4K5C4m7fUDlOJ-DF-y6J8,14361
+plot_io/presets/hexbin.py,sha256=azmgxSLvjPxexz4nn7o-4bJx9dnQ8pSnxts0iXylq-s,8151
+plot_io/presets/hist.py,sha256=vdqQ5Axe--sZbWr7gqzthRX_RhlBxlNo71_ZQzap8-Y,18649
+plot_io/presets/hist2d.py,sha256=5S6DP9YdCVHxvFbcyB3Y8p0ncsV2_8RB5UIrrZ2Z_UU,3271
+plot_io/presets/kde.py,sha256=zdKCo_RRjSc25K1vcJeyn3K8F1AkFr5pVfImpjJqbZc,7229
+plot_io/presets/kde2d.py,sha256=lgzY_KWplYKNGOg3KxN1-uDAW41-xcIx9iJrMC0sd5U,6424
+plot_io/presets/line.py,sha256=DKOH0k6m1DkCNpfavhGcdhrsmA_GSCVFbJgXhWpSvq4,6839
+plot_io/presets/pie.py,sha256=e3dyqTAqIqCQDILrbqdm-1ORTBYfDAzYwGHr2tvqtqo,23522
+plot_io/presets/regression.py,sha256=rRehS2oGlH-TqKL0_Uo9nnM-jHCXcAEJFtUXBARcWlg,5814
+plot_io/presets/scatter.py,sha256=ZSYmqCs_LCUaQLkKI9kcCoaSval62jSgklGJUu8Bfuo,9062
+plot_io/presets/stem.py,sha256=8F0DV2grOAOpVvAItChrmrgxPFmx5axqV1DHFLR_PCQ,3994
+plot_io/presets/violin.py,sha256=WxlyEPoAcl_Mocoh1C8ILFn4CqfziCWwWCSHZUmshN8,15342
+plot_io/styles/__init__.py,sha256=HDPy1_vCIC87pRT1rimRBFGT-DLMC7hVN1eOqQeSxfM,11907
+plot_io/styles/library.py,sha256=ReOqS741mxvBDoiRmZx9WZ_ESz01jQTFhkMRfkPLRB0,15283
+plot_io/_native/bin/windows-arm64.dll,sha256=bv9wrv28sOKJv8EEAqogeFZA3u8OyEhhMZkXdqVKy8w,69632
+plot_io-0.12.0.dist-info/METADATA,sha256=93KmR66u-PpYOLKRyceh15_mXWb_s6RzBNTCKA82Dkg,11433
+plot_io-0.12.0.dist-info/WHEEL,sha256=WFezGyxI7afY59fTEbTiueKbbEV_hMxzB_HK5n-3eUY,94
+plot_io-0.12.0.dist-info/licenses/LICENSE,sha256=KD-5bsauyA0Kh68YcImL7q5yE6OCTZwHnhvybthBbNg,1501
+plot_io-0.12.0.dist-info/RECORD,,

plot_io-0.12.0.dist-info/WHEEL

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

plot_io-0.12.0.dist-info/licenses/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, Arthur Gouhier
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.