plot-io 0.1.0__py3-none-any.whl

plot_io/__init__.py

@@ -0,0 +1,66 @@
+"""plot_io: plots for PDF, PNG and JPEG, drawn with pdf_io.
+
+Basic usage::
+
+    import plot_io as pl
+
+    s = pl.Scatter(x, y, color="C1")
+    s.plot.x_axis(label="Time (s)")
+    s.plot.save("scatter.pdf")
+"""
+
+from pdf_io import Span
+
+from .colorbar import Colorbar
+from .density import Density
+from .facets import FacetFigure, facet
+from .enums import Align, LineStyle, Marker, Order, Orientation, Position, Scale
+from .figure import Figure
+from .maps import ColorMap, SizeMap, color_map_names, register_color_map
+from .markers import marker_area, marker_path, register_marker
+from .palettes import palette_names, register_palette
+from .plot import Plot
+from .series import Series
+from .series.area import Area
+from .series.bar import Bar
+from .series.box import Box
+from .series.ecdf import Ecdf
+from .series.errorbar import Errorbar
+from .series.catpoints import Strip, Swarm
+from .series.contour import Contour
+from .series.hexbin import Hexbin
+from .series.hist import Hist
+from .series.hist2d import Hist2d
+from .series.kde import Kde
+from .series.kde2d import Kde2d
+from .series.pie import Pie
+from .series.regression import Regression
+from .series.violin import Violin
+from .series.stem import Stem
+from .series.errors import ErrorBars
+from .series.fill import Fill
+from .series.heatmap import Heatmap
+from .series.line import Line
+from .series.scatter import Scatter
+from .defaults import DEFAULTS
+from .settings import THEME
+from .style import PALETTE
+from .tables import SeriesGroup
+from .styles import register_style, set_style, style_settings, styles, use_style
+
+__all__ = ["Figure", "Plot", "Scatter", "Line", "Fill", "Box", "Heatmap", "Series", "Colorbar",
+           "Bar", "Hist", "Ecdf", "Kde2d", "Stem", "Errorbar", "Area", "Kde", "Violin", "Strip",
+           "Swarm", "Regression", "Hist2d", "Hexbin", "Contour", "Pie",
+           "ColorMap", "SizeMap", "Density", "facet", "FacetFigure", "SeriesGroup", "ErrorBars", "Span", "register_color_map", "color_map_names",
+           "register_marker", "marker_path", "marker_area", "Marker", "LineStyle",
+           "Orientation", "Scale", "Position", "Order", "Align", "PALETTE", "THEME", "defaults",
+           "register_style", "set_style", "use_style", "styles", "style_settings",
+           "register_palette", "palette_names",
+           "__version__"]
+
+__version__ = "0.1.0"
+
+
+def defaults() -> dict:
+    """A copy of every default setting (:data:`plot_io.defaults.DEFAULTS`)."""
+    return dict(DEFAULTS)

plot_io/_backend.py

@@ -0,0 +1,114 @@
+"""The pdf_io calls plot_io relies on, in one place.
+
+Array helpers (``scaled``, ``extent``, ``quantiles``, ``box_stats``), text metrics and the
+conversion of plot_io's color maps to pdf_io's.
+"""
+
+import contextlib
+import contextvars
+from collections.abc import Iterator, Sequence
+from typing import Any
+
+import pdf_io
+from pdf_io import arrays as _arrays
+
+__all__ = ["doubles", "scaled", "extent", "quantiles", "box_stats", "text_extent",
+           "simplify_arg", "pdf_color_map", "colors_at", "path_area"]
+
+doubles = _arrays.doubles
+box_stats = _arrays.box_stats
+
+
+def scaled(values: Any, scale: float = 1.0, offset: float = 0.0, function: Any = None,
+           linthresh: float = 1.0, **kw: Any) -> Any:
+    """pdf_io's ``arrays.scaled`` (``linthresh``: the linear region of ``symlog``)."""
+    if function == "symlog":
+        kw["linthresh"] = linthresh
+    return _arrays.scaled(values, scale, offset, function, **kw)
+
+
+def extent(values: Any, function: Any = None) -> Any:
+    return _arrays.extent(values, function)
+
+
+def quantiles(values: Any, qs: Sequence[float]) -> list[float]:
+    """Quantiles by linear interpolation (numpy's default)."""
+    return list(_arrays.quantiles(values, qs))
+
+
+def text_extent(canvas: Any, content: Any) -> tuple[float, float, float]:
+    """``(width, ascent, descent)`` of one line of text with the canvas font settings."""
+    return canvas.text_extent(content)
+
+
+_IMAGE_OUTPUT = contextvars.ContextVar("plot_io_image_output", default=False)
+
+
+@contextlib.contextmanager
+def image_output() -> Iterator[None]:
+    """Drawing for PNG, JPEG or JPEG XL output (see :func:`simplify_arg`)."""
+    token = _IMAGE_OUTPUT.set(True)
+    try:
+        yield
+    finally:
+        _IMAGE_OUTPUT.reset(token)
+
+
+def simplify_arg(value: Any, lines: bool = False) -> Any:
+    """``value`` as pdf_io's ``simplify`` argument.  For image output nothing is culled:
+    rasterizing hidden content costs less than culling it and gives the same pixels.
+    Lines and areas (``lines``) are still decimated where they are dense (``"auto"``)."""
+    if value is None or value is False or not _IMAGE_OUTPUT.get():
+        return value
+    return "auto" if lines else False
+
+
+def pdf_color_map(stops: Sequence[tuple[float, tuple[float, ...]]], interpolation: str = "linear",
+                  under: Any = None, over: Any = None, bad: Any = None) -> Any:
+    """pdf_io's color map for stops ``(position, rgba)``.  Steps start at their stop;
+    pdf_io's ``nearest`` takes the nearest stop, so step maps pass their step centres."""
+    if interpolation == "nearest":
+        ends = [p for p, _ in stops[1:]] + [1.0]
+        stops = [((p + e) / 2, c) for (p, c), e in zip(stops, ends)]
+    return pdf_io.ColorMap(list(stops), interpolation=interpolation, under=under, over=over,
+                           bad=bad)
+
+
+def colors_at(pdf_map: Any, ts: Any) -> Any:
+    """Colors of a pdf_io color map at many positions, as an ``(n, 4)`` buffer."""
+    flat = pdf_map.colors_at(ts)
+    n = len(flat) // 4
+    return memoryview(flat).cast("B").cast("d", (n, 4)) if n else []
+
+
+def path_area(path: Any) -> float:
+    """Filled area of a ``pdf_io.Path`` (nonzero winding)."""
+    return float(path.area())
+
+
+# ---------------------------------------------------------------------------
+# 2-D density and argsort
+# ---------------------------------------------------------------------------
+
+def kde2d_bandwidth(xs: Any, ys: Any, rule: str = "scott") -> tuple[float, float, float]:
+    """scipy's kernel covariance ``(h11, h12, h22)`` for points ``(xs, ys)`` (NaN for fewer
+    than two distinct points)."""
+    h = _arrays.kde2d_bandwidth(xs, ys, rule)
+    return (float(h[0]), float(h[1]), float(h[2]))
+
+
+def kde2d_at(xs: Any, ys: Any, h: tuple[float, float, float], method: str = "auto",
+             grid: int = 512) -> Any:
+    """The 2-D Gaussian density (kernel covariance ``h``) at each point."""
+    return _arrays.kde2d_at(xs, ys, h, method=method, grid=grid)
+
+
+def kde2d_grid(xs: Any, ys: Any, h: tuple[float, float, float], x0: float, x1: float, nx: int,
+               y0: float, y1: float, ny: int) -> Any:
+    """The density on an ``ny × nx`` grid of nodes from ``(x0, y0)`` to ``(x1, y1)``."""
+    return _arrays.kde2d_grid(xs, ys, h, x0, x1, nx, y0, y1, ny)
+
+
+def argsort(values: Any, descending: bool = False) -> Any:
+    """Indices that sort ``values`` (stable; NaN first ascending, last descending)."""
+    return _arrays.argsort(values, descending=descending)