plot-io 0.1.0__py3-none-any.whl

plot_io/times.py

@@ -0,0 +1,199 @@
+"""Dates and times on axes.
+
+Values (``datetime``, ``date``, numpy ``datetime64`` arrays, pandas timestamps) become
+float seconds since 1970-01-01 UTC, so scales, limits and the C mapping are unchanged; the
+axis (``scale="time"``, set by date data) chooses calendar-aware ticks and concise labels.
+"""
+
+import array
+import calendar
+import datetime as dt
+import math
+from typing import Any
+
+__all__ = ["is_time_like", "to_seconds", "seconds", "time_ticks", "from_seconds"]
+
+_UTC = dt.timezone.utc
+
+
+def _first(v: Any) -> Any:
+    for x in v:
+        if x is not None and not (isinstance(x, float) and math.isnan(x)):
+            return x
+    return None
+
+
+def is_time_like(v: Any) -> bool:
+    """Whether ``v`` is a date or time value, or a sequence or array of them."""
+    if isinstance(v, (dt.date, dt.datetime)):
+        return True
+    kind = getattr(getattr(v, "dtype", None), "kind", None)
+    if kind == "M":
+        return True
+    if isinstance(v, (list, tuple)) and v:
+        return isinstance(_first(v), (dt.date, dt.datetime))
+    return False
+
+
+def seconds(x: Any) -> float:
+    """Seconds since the epoch of one value (naive datetimes are UTC)."""
+    if x is None or (isinstance(x, float) and math.isnan(x)):
+        return math.nan
+    if isinstance(x, dt.datetime):
+        if x.tzinfo is not None:
+            return x.timestamp()
+        return calendar.timegm(x.timetuple()) + x.microsecond / 1e6
+    if isinstance(x, dt.date):
+        return float(calendar.timegm(x.timetuple()))
+    if hasattr(x, "astype") and getattr(getattr(x, "dtype", None), "kind", None) == "M":
+        n = int(x.astype("datetime64[ns]").astype("int64"))
+        return math.nan if n == -(2 ** 63) else n / 1e9
+    if isinstance(x, (int, float)):
+        return float(x)
+    raise ValueError(f"not a date or time: {x!r}")
+
+
+def to_seconds(v: Any) -> tuple[array.array, Any]:
+    """Seconds since the epoch of every value, and the time zone of the first aware
+    value (``None``: naive, shown as UTC)."""
+    kind = getattr(getattr(v, "dtype", None), "kind", None)
+    if kind == "M":
+        ns = v.astype("datetime64[ns]").astype("int64").tolist()
+        nat = -(2 ** 63)
+        return array.array("d", (math.nan if n == nat else n / 1e9 for n in ns)), None
+    if isinstance(v, (dt.date, dt.datetime)):
+        v = [v]
+    first = _first(v)
+    tz = first.tzinfo if isinstance(first, dt.datetime) else None
+    return array.array("d", (seconds(x) for x in v)), tz
+
+
+def from_seconds(s: float, tz: Any) -> dt.datetime:
+    """The datetime of ``s`` seconds in zone ``tz`` (naive UTC when ``tz`` is ``None``)."""
+    d = dt.datetime.fromtimestamp(s, tz or _UTC)
+    return d if tz is not None else d.replace(tzinfo=None)
+
+
+def _epoch(d: dt.datetime, tz: Any) -> float:
+    return d.timestamp() if tz is not None else seconds(d)
+
+
+#: (unit, step, approximate seconds) candidates, finest first.
+_STEPS = ([("microsecond", s, s * 1e-6) for s in (1, 2, 5, 10, 20, 50, 100, 200, 500, 1000,
+                                                 2000, 5000, 10000, 20000, 50000, 100000,
+                                                 200000, 500000)]
+          + [("second", s, s) for s in (1, 2, 5, 10, 15, 30)]
+          + [("minute", s, 60 * s) for s in (1, 2, 5, 10, 15, 30)]
+          + [("hour", s, 3600 * s) for s in (1, 2, 3, 6, 12)]
+          + [("day", s, 86400 * s) for s in (1, 2, 7, 14)]
+          + [("month", s, 2629746 * s) for s in (1, 2, 3, 6)]
+          + [("year", s, 31556952 * s) for s in (1, 2, 5, 10, 20, 25, 50, 100, 200, 250, 500,
+                                                 1000)])
+
+
+def _floor(d: dt.datetime, unit: str, step: int) -> dt.datetime:
+    if unit == "year":
+        return d.replace(year=d.year - d.year % step, month=1, day=1, hour=0, minute=0,
+                         second=0, microsecond=0)
+    if unit == "month":
+        m = (d.month - 1) - (d.month - 1) % step + 1
+        return d.replace(month=m, day=1, hour=0, minute=0, second=0, microsecond=0)
+    if unit == "day":
+        return d.replace(day=1, hour=0, minute=0, second=0, microsecond=0)
+    if unit == "hour":
+        return d.replace(hour=d.hour - d.hour % step, minute=0, second=0, microsecond=0)
+    if unit == "minute":
+        return d.replace(minute=d.minute - d.minute % step, second=0, microsecond=0)
+    if unit == "second":
+        return d.replace(second=d.second - d.second % step, microsecond=0)
+    return d.replace(microsecond=0)
+
+
+def _add(d: dt.datetime, unit: str, step: int) -> dt.datetime:
+    if unit == "year":
+        return d.replace(year=d.year + step)
+    if unit == "month":
+        m = d.month - 1 + step
+        return d.replace(year=d.year + m // 12, month=m % 12 + 1)
+    delta = {"hour": dt.timedelta(hours=step), "minute": dt.timedelta(minutes=step),
+             "second": dt.timedelta(seconds=step),
+             "microsecond": dt.timedelta(microseconds=step),
+             "day": dt.timedelta(days=1)}[unit]
+    return d + delta
+
+
+def _candidates(lo: float, hi: float, unit: str, step: int, tz: Any) -> list[float]:
+    start = _floor(from_seconds(lo, tz), unit, step)
+    out: list[float] = []
+    d = start
+    guard = 0
+    while guard < 100000:
+        guard += 1
+        s = _epoch(d, tz)
+        if s > hi + 1e-9:
+            break
+        keep = True
+        if unit == "day":
+            keep = (d.day - 1) % step == 0 and (step < 7 or d.day <= 29 - step)
+        if keep and s >= lo - 1e-9:
+            out.append(s)
+        d = _add(d, unit, step)
+    return out
+
+
+def time_ticks(lo: float, hi: float, max_ticks: int, tz: Any,
+               fmt: Any = "auto") -> tuple[list[tuple[float, str]], str | None]:
+    """Ticks between ``lo`` and ``hi`` seconds: ``[(value, label)]`` and the offset text
+    (the larger unit common to every tick: ``"Mar 2026"``)."""
+    if hi < lo:
+        lo, hi = hi, lo
+    span = max(hi - lo, 1e-6)
+    unit = "year"
+    ticks: list[float] = []
+    for u, s, approx in _STEPS:
+        if span / approx > max_ticks * 1.5:
+            continue
+        cand = _candidates(lo, hi, u, s, tz)
+        if 2 <= len(cand) <= max_ticks or (len(cand) <= max_ticks and u == "year"):
+            unit, ticks = u, cand
+            break
+    if not ticks:
+        ticks = [lo, hi]
+        unit = "second" if span < 86400 else "day"
+    dts = [from_seconds(t, tz) for t in ticks]
+    if isinstance(fmt, str) and "%" in fmt:
+        return [(t, d.strftime(fmt)) for t, d in zip(ticks, dts)], None
+    if callable(fmt):
+        return [(t, str(fmt(d))) for t, d in zip(ticks, dts)], None
+    return _concise(ticks, dts, unit)
+
+
+def _concise(ticks: list[float], dts: list[dt.datetime], unit: str) -> tuple[
+        list[tuple[float, str]], str | None]:
+    same_year = len({d.year for d in dts}) == 1
+    same_day = len({d.date() for d in dts}) == 1
+    if unit == "year":
+        return [(t, d.strftime("%Y")) for t, d in zip(ticks, dts)], None
+    if unit == "month":
+        labels = [d.strftime("%Y") if d.month == 1 and not same_year else d.strftime("%b")
+                  for d in dts]
+        return list(zip(ticks, labels)), (dts[0].strftime("%Y") if same_year else None)
+    if unit == "day":
+        labels = [d.strftime("%b %d").replace(" 0", " ") for d in dts]
+        return list(zip(ticks, labels)), (dts[0].strftime("%Y") if same_year else None)
+    if unit in ("hour", "minute"):
+        labels = [d.strftime("%H:%M") if (d.hour, d.minute) != (0, 0) or same_day
+                  else d.strftime("%b %d").replace(" 0", " ") for d in dts]
+        off = dts[0].strftime("%b %d, %Y").replace(" 0", " ") if same_day else (
+            dts[0].strftime("%Y") if same_year else None)
+        return list(zip(ticks, labels)), off
+    if unit == "second":
+        labels = [d.strftime("%H:%M:%S") for d in dts]
+        off = dts[0].strftime("%b %d, %Y").replace(" 0", " ") if same_day else None
+        return list(zip(ticks, labels)), off
+    digits = 6
+    while digits > 0 and all(d.microsecond % (10 ** (7 - digits)) == 0 for d in dts):
+        digits -= 1
+    labels = [d.strftime("%S") + ("." + f"{d.microsecond:06d}"[:digits] if digits else "")
+              for d in dts]
+    return list(zip(ticks, labels)), dts[0].strftime("%b %d, %Y %H:%M").replace(" 0", " ", 1)

plot_io/values.py

@@ -0,0 +1,161 @@
+"""Values given to ``color``, ``size`` and ``alpha``: 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 typing import Any
+
+from . import _backend
+
+__all__ = ["Values", "paint", "category_paint", "size_value", "is_values", "is_computed",
+           "check_color_map", "check_size_map"]
+
+
+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_values(v: Any) -> bool:
+    return isinstance(v, Values)
+
+
+def is_computed(v: Any) -> bool:
+    from .density import Density
+    return isinstance(v, Density)
+
+
+def _number(x: Any) -> bool:
+    return isinstance(x, (int, float)) and not isinstance(x, bool)
+
+
+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)."""
+    from pdf_io import arrays
+    n, k, _, flat = arrays.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 .maps import ColorMap
+    from .settings 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(_backend.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(_backend.doubles(items))
+        return [color(c) if c is not None else None for c in items]
+    return color(v)
+
+
+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 .settings import color
+        return {k: (color(c) if c is not None else None) for k, c in v.items()}
+    return paint(v, name)
+
+
+def size_value(v: Any) -> Any:
+    """A size (pt), sizes per point, or ``"density"`` (mapped through ``size_map``)."""
+    from .density import Density
+    from .maps import SizeMap
+    from .settings import number
+
+    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):
+        return number(lo=0)(v)
+    try:
+        return _backend.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
+
+
+def check_color_map(v: Any) -> Any:
+    from .maps import check_cmap
+    return check_cmap(v)
+
+
+def check_size_map(v: Any) -> Any:
+    from .maps 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.1.0.dist-info/METADATA

@@ -0,0 +1,102 @@
+Metadata-Version: 2.5
+Name: plot_io
+Version: 0.1.0
+Summary: Plots for PDF, PNG and JPEG, drawn with pdf_io
+Author-email: Arthur Gouhier <ajgouhier@gmail.com>
+License-Expression: BSD-3-Clause
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: pdf-io>=0.4
+Provides-Extra: dev
+Requires-Dist: flake8; extra == 'dev'
+Requires-Dist: mypy; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# plot_io
+
+Plots for PDF, PNG and JPEG in Python, drawn with [pdf_io](https://github.com/ajgouhier/pdf_io).
+No other dependency.
+
+![box plots](examples/box_plots.png)
+
+* **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`; reference lines, spans, text and
+  annotations; `color`, `marker`, `alpha`, `limits`, `scale`, `legend`, sizes in inches.
+* **One way to set things:** keywords at creation or `set(...)` on any object; figure
+  settings (font, palette, 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.
+* **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:** a colorblind-safe palette, color maps interpolated in Oklab, colorbars;
+  marker sizes by area, equal for every shape.
+* **Styles:** `style="matplotlib"`, `"seaborn"`, `"ggplot2"`, `"altair"`, `"matlab"`,
+  `"chartjs"`, `"plotly"`, `"bokeh"`, `"observable"`, `"excel"`, `"fivethirtyeight"`,
+  `"economist"`, `"tufte"` and variants give the look of those libraries; styles are
+  presets of settings, and your own build on them.
+* **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.
+
+## Install
+
+```sh
+pip install /path/to/pdf_io      # pdf_io 0.4 or later
+pip install .
+```
+
+Python 3.11+.
+
+## Quick start
+
+```python
+import plot_io as pl
+
+s = pl.Scatter(x, y, name="data")
+s.plot.x_axis(label="Time (s)")
+s.plot.save("scatter.pdf")
+```
+
+```python
+fig = pl.Figure(grid=[[1, 1, 2], [3, 4, 2]])
+p = fig.plot(1, title="Signal")
+p.line(t, v, name="raw")
+p.fill(t, upper, lower, alpha=0.3)
+p.y_axis(scale="log10", label="Power")
+fig.plot(2).box({"a": va, "b": vb})
+h = fig.plot(3).heatmap(matrix, x=columns, y=rows, cmap="magma", colorbar=True)
+fig.plot(4).scatter(x, y, c=z, cmap="viridis")
+fig.save("figure.pdf")
+fig.save("figure.png", dpi=200)
+```
+
+```python
+fig = pl.Figure(style="ggplot2")                         # or a dict: {"base": "seaborn", "font_size": 9}
+```
+
+```python
+p = pl.Plot()
+p.scatter("umap_x", "umap_y", data=genes, c="density", order="density")   # columns of a table
+p.scatter("x", "y", data=df, group="cluster", marker="auto")              # one series per group
+fig = pl.facet(df, col="condition", row="replicate")                       # small multiples
+fig.scatter("x", "y")
+```
+
+## Documentation
+
+* [API.md](API.md): the complete reference, with every setting.
+* [EXAMPLES.md](EXAMPLES.md): worked examples.
+
+## Development
+
+```sh
+python -m unittest discover -s tests -t tests
+flake8 --select F plot_io tests && mypy
+python tools/bench.py --check       # timings against the targets
+python tools/settings_doc.py        # regenerate the settings tables of API.md
+```

plot_io-0.1.0.dist-info/RECORD

@@ -0,0 +1,65 @@
+plot_io/__init__.py,sha256=wOuiSG1_9RZK75scfMcOHX_2v14zIklkzX-eupVznTI,2479
+plot_io/_backend.py,sha256=99mKkfuoMq2HyRJurrtOko8mTjHb6xo2uF1rKhBS2xM,4489
+plot_io/axis.py,sha256=jtr90_r9aRzYx-Y038EhXWH4u0ZCdUUch_KCUWcWDFM,27710
+plot_io/colorbar.py,sha256=RjZ8nzRpa__w9M_9k9vmwgcavxDg0byCLq74TyUedTM,14647
+plot_io/decorations.py,sha256=Xru8c6IrBEhjgVVySTEOy1n4ZXYYYFjRWfCpvDs-xUE,19167
+plot_io/defaults.py,sha256=XIkStLlHH3KkZHtKetlN1sV-CwaY-6euGgCAiWvIXiU,21240
+plot_io/density.py,sha256=HdMHGO7CWKjgh3dVkSrV1uPT3RMPNwEuXkKqhYyzkmA,4243
+plot_io/enums.py,sha256=C7ToKwzFnZZvE1KgmcElowhyoeLxaFPC8pAiZ_MatiE,1275
+plot_io/facets.py,sha256=iQuERUPWMtKrBWqVAh5j7VIQjH_DRjuEnUaX_9zcXS0,8300
+plot_io/figure.py,sha256=_UhTqj2cKwUAV2VXPF8R-k-YVptu0nIq0c5y4feq9SI,15572
+plot_io/labels.py,sha256=UJZKS5PTBqhV9puNIprfqm60AWfKEYHxf4dcVuwVn9Q,2377
+plot_io/legend.py,sha256=l6ixJue42hLWKtH6Ox-vNxHV5Lm386AvrvnD_ZdgHiE,20542
+plot_io/limits.py,sha256=b6YIO29FuSPZD8-13ZukOgcaeJWeCy4AcVKm0uNyJLA,3279
+plot_io/markers.py,sha256=E44DlmGE1vhasJ58LPFnOaub3FVUJa15GM7snDQR0mQ,3815
+plot_io/numbers.py,sha256=Ys7W7fZoExDv0ayDqEFV60-1tWzdaUni14nfuliqQq0,11413
+plot_io/occupancy.py,sha256=XpsaOROBBQvdnX_Tv5A8gMogqKaOBgOJKotJLB6kVH4,8956
+plot_io/palettes.py,sha256=xJ2NQlPEehHMFm1MFNb4pcFc-XPzZpLFwBpOjhkML_4,6343
+plot_io/plot.py,sha256=TCdeeXfAnT6NlV6lrK4gyo47rZVMtQcNArXzMZO38as,19292
+plot_io/render.py,sha256=x8dEp7ELV-1X7IUoU0QKl9r3iEF-3gutd-1GQrNJ14o,47363
+plot_io/scales.py,sha256=H99IMvIPU2lmt77xrGNBBNZUASpTMzmjzC9jUFu-6IQ,3397
+plot_io/settings.py,sha256=Q23_aodNc67OpYuT0sOYcWrs7hIv2by5yeEFRHr7IzI,9900
+plot_io/shapes.py,sha256=ACXqgVcqpaP5uLLAaYFsmVJWQ1nMuT6X1pT2F6LWlAQ,2436
+plot_io/sharing.py,sha256=f7Xbv4jTU2B_d4-KYcj53DKJP2133jR4Pdk_vXcUFCE,6047
+plot_io/slots.py,sha256=XYHXNFNM5SXYV5EWQlyjkKRBmceEIZTVINZYbC2KyBY,2040
+plot_io/stacking.py,sha256=4L6hpXOghruxQbgy_wbb3vSMEA469KZ5iaHD7fH4uJo,2268
+plot_io/stats.py,sha256=p-GFhywMirU2Ltk_zNgEvQsvqSYk2CIoakNGHEfCWzo,6095
+plot_io/style.py,sha256=7i3w8SkP3PmbLSlrRnEN3hV9M78abNxZeke6TffmFao,2171
+plot_io/tables.py,sha256=VzZfvrJF_73fEFub-ge-dAArNI-lNRbhbjkFnCj-OzM,5108
+plot_io/text.py,sha256=9i3xPwZ7xtMWSJFBXfxGamJM-SkRdSgpkXWEgcDIg3k,3717
+plot_io/ticks.py,sha256=Cv7NpG7T7Ug8gqZqIXM5DC0aau2BLv9syScf2RFFbO0,11874
+plot_io/times.py,sha256=RJ6eQxh29zYayzY9TVEVzbwb6UVOHSDGIWrPqLSBqtY,8241
+plot_io/values.py,sha256=BymMVwdjZtFIue7_JEZx7ubBSb0Sr2QfoVvOvH1oSB0,5521
+plot_io/maps/__init__.py,sha256=qTsi345pplO1Krmu7kV8Set5iojW1Tb8ABJhOOPBzj0,15614
+plot_io/maps/data.py,sha256=BFdSPNo027iZhothJ4uvN75Utqant8Zs3RlRoJHeZBM,26175
+plot_io/series/__init__.py,sha256=-_23tbCFO0BRu70zb25FJElxT7Dk5TP-ELcybNyrooU,20798
+plot_io/series/area.py,sha256=jFyDKDkaeE55LF0skI2drv25j7AFc5Ij_UTJingFkxE,7106
+plot_io/series/bar.py,sha256=KCnwPo0Y1NLdeSL49xG54AZQ2-QmO-BOpFaswuAX7_I,12513
+plot_io/series/box.py,sha256=EUOKH-_ZJJkd005fD2gHsN1D_I7EmmgffnUAMQCIYd4,17736
+plot_io/series/catdata.py,sha256=m404Cn12Rw8TheDA7A2w55h_ruj1giT7SX_UJj5ze5I,965
+plot_io/series/catpoints.py,sha256=tOWUK8uGenluV1JjkJn4ipK4aGtvlV7oQWdJFucHefE,7366
+plot_io/series/contour.py,sha256=mMHxHn5RbUm4854VTwatm40RLljKNnQRgaQQoiG56q4,12655
+plot_io/series/curves.py,sha256=f0-Rm0IQljMsxn2xRn1GpxNAKKQJP_KFtTuYWa-uNM4,4414
+plot_io/series/ecdf.py,sha256=H9vXFRU6dPjrxq8tZMXBN89JmAvGAxy20V2029u-zWw,5908
+plot_io/series/errorbar.py,sha256=Pa2yaYhFRzwp9HwjMVzI7a5EY_tKjxo_2pvBu_9-WDg,4594
+plot_io/series/errors.py,sha256=oMWRUgR4aGyERYfVgs2sq1IP9tPeswcLlUeMpqOxr9E,3897
+plot_io/series/fill.py,sha256=f9EoTt3lEOiJZ-M27elbWpkioo6tnEam3dUe1vnoNtE,6930
+plot_io/series/heatmap.py,sha256=WLCX4zM70RXxnNZtGrXHgc1-kNlkz1R91mwDXmVW7VQ,12663
+plot_io/series/hexbin.py,sha256=hhTN9QrQBhN5Ga86t00MCiM1wrfPsX61b8GzGyr1Dm0,9773
+plot_io/series/hist.py,sha256=VjjoA-Z90IdkBAf5Wb06Yk2AsOo5qPDnsvyRwF5UPYM,16583
+plot_io/series/hist2d.py,sha256=5XCQtQc1Hid2f5VU4C_nlCt7LJH-VJkSeK2WW5cEMVM,5776
+plot_io/series/kde.py,sha256=DdYxbluGgSS4dDWQwTcqu6RKlYKPvq_CLknFYNvbo48,9286
+plot_io/series/kde2d.py,sha256=4ci6DCfgyIDY1lc-i8hoTGsxpIeV2HtCTyR58utXV5Q,6839
+plot_io/series/line.py,sha256=mIjyXOQ26wSIqysFJFoTzD4H3851eGgK-4ZNjgEbszc,6461
+plot_io/series/pie.py,sha256=EuL_KNjIviu4lvaByisCEJ5oZaSixKjIaf1ldW7F0eQ,13353
+plot_io/series/points.py,sha256=G-1BuOvaa6Z6Sz0iqjtZhskjjgzRoeZnhMfM0qUmwd8,15329
+plot_io/series/regression.py,sha256=xkcOF7Ekw0cx8nJJNYlV7Wz0zzUa9BvzhJrKTLYqNxw,10403
+plot_io/series/scatter.py,sha256=KnZgxlawihVygL9lWzqb2lF20BpZdrZu0gUzSQSeK8g,3728
+plot_io/series/stem.py,sha256=adtzcpl1-4jkGv3kNBAVw6axhadnSEOHDoUMA7sLb1Q,4724
+plot_io/series/violin.py,sha256=MGY5q7j3Uo1pO10ah8mDSmMq19SvcmGCbPPj-25jL_k,14369
+plot_io/styles/__init__.py,sha256=br2OOqhrUsL5CGni-Kl-1i8JkqMlwVOTUg6hhy3PfRQ,8730
+plot_io/styles/library.py,sha256=WseTAPqeP0tfCWVingbrnrPNfMDOT7l2KdldxtAd08Q,24112
+plot_io-0.1.0.dist-info/METADATA,sha256=njY8VYO1SIvo1xPyqE3b_hyPAPy5-cUrHVNkMHvR-VQ,3912
+plot_io-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+plot_io-0.1.0.dist-info/licenses/LICENSE,sha256=KD-5bsauyA0Kh68YcImL7q5yE6OCTZwHnhvybthBbNg,1501
+plot_io-0.1.0.dist-info/RECORD,,

plot_io-0.1.0.dist-info/WHEEL

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

plot_io-0.1.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.