plotlet 0.1.0__py3-none-any.whl

plotlet/__init__.py

@@ -0,0 +1,23 @@
+"""plotlet — pure-Python SVG renderer, matplotlib-flavored.
+
+Tabular API (recommended):
+
+    import plotlet as pt
+    c = pt.chart(df, title="...", xlabel="x", ylabel="y", legend=True, grid=True)
+    c.line(x="time", y="value", hue="series")
+    c                         # auto-renders in Jupyter
+
+Chained API (legacy, still supported):
+
+    fig = pt.figure()
+    fig.plot([1, 2, 3], [1, 4, 9], label="squares")
+    fig.title("Hello").legend().grid(True)
+    fig
+"""
+from ._spec import SPEC
+from .colors import TAB10, colors
+from .core import Figure, figure
+from .chart import Chart, chart
+
+__all__ = ["chart", "Chart", "figure", "Figure", "SPEC", "TAB10", "colors"]
+__version__ = "0.1.0"

plotlet/_spec.py

@@ -0,0 +1,21 @@
+"""Visual spec — loaded from bundled spec.json. Internal.
+
+The spec is the locked visual contract: colors, fonts, sizes, default alphas,
+legend dimensions. Submodules read from here to avoid hardcoding literals.
+"""
+import json
+from pathlib import Path
+
+_HERE = Path(__file__).parent
+SPEC = json.loads((_HERE / "spec.json").read_text())
+
+# Convenience handles to subsections — used by other modules.
+_TAB10 = SPEC["colors"]["tab10"]
+_COLOR_NAMES = SPEC["colors"]["named"]
+_DASH = SPEC["linestyles"]
+_D = SPEC["defaults"]
+_FRAME = SPEC["frame"]
+_GRIDSPEC = SPEC["grid"]
+_FONTSPEC = SPEC["font"]
+_LEGSPEC = SPEC["legend"]
+_SIZESPEC = SPEC["size"]

plotlet/artists.py

@@ -0,0 +1,154 @@
+"""Per-artist SVG-emit helpers, marker primitive, histogram binning.
+
+Each `_artist_<type>` takes the recorded artist dict, the x and y scales,
+and the resolved color, and returns an SVG fragment. They're called from
+`core._render`.
+"""
+import math
+
+from ._spec import _D, _DASH
+
+
+def _to_pylist(obj):
+    """Convert numpy / pandas / arbitrary iterables to plain Python lists."""
+    if hasattr(obj, "tolist"):
+        return obj.tolist()
+    if isinstance(obj, (list, tuple)):
+        return list(obj)
+    return list(obj)
+
+
+def _histogram(data, bins):
+    """Equal-width binning. Returns list of {'x0', 'x1', 'count'} dicts."""
+    data = [v for v in _to_pylist(data)
+            if v is not None and not (isinstance(v, float) and math.isnan(v))]
+    if not data:
+        return []
+    lo, hi = min(data), max(data)
+    if lo == hi:
+        hi = lo + 1
+    n = bins if isinstance(bins, int) else 10
+    width = (hi - lo) / n
+    counts = [0] * n
+    for v in data:
+        if v == hi:
+            counts[-1] += 1
+        else:
+            i = int((v - lo) / width)
+            if 0 <= i < n:
+                counts[i] += 1
+    return [{"x0": lo + i * width, "x1": lo + (i + 1) * width, "count": counts[i]}
+            for i in range(n)]
+
+
+# ---------------------------------------------------------------------------
+# Artist helpers
+# ---------------------------------------------------------------------------
+
+def _artist_plot(a, xs_, ys_, col):
+    out = []
+    opts = a["opts"]
+    pts = [(xs_(x), ys_(y)) for x, y in zip(a["xs"], a["ys"])]
+    pts = [(px, py) if (math.isfinite(px) and math.isfinite(py)) else None
+           for px, py in pts]
+    d_segs, started = [], False
+    for p in pts:
+        if p is None:
+            started = False
+            continue
+        d_segs.append(f'{"M" if not started else "L"}{p[0]:.2f},{p[1]:.2f}')
+        started = True
+    ls = opts.get("linestyle")
+    if ls not in ("", "none"):
+        da = f' stroke-dasharray="{_DASH[ls]}"' if ls and _DASH.get(ls) else ""
+        out.append(f'<path d="{"".join(d_segs)}" fill="none" stroke="{col}" '
+                   f'stroke-width="{opts.get("linewidth", _D["linewidth"])}"{da}/>')
+    if opts.get("marker"):
+        sz = opts.get("markersize", _D["markersize"])
+        for p in pts:
+            if p is None:
+                continue
+            out.append(_marker_at(opts["marker"], p[0], p[1], sz, col, 1))
+    return "".join(out)
+
+
+def _artist_scatter(a, xs_, ys_, col):
+    opts = a["opts"]
+    sz = math.sqrt(opts.get("s", _D["scatter_s"])) / 2
+    alpha = opts.get("alpha", _D["scatter_alpha"])
+    marker = opts.get("marker", "o")
+    out = []
+    for x, y in zip(a["xs"], a["ys"]):
+        px, py = xs_(x), ys_(y)
+        if not (math.isfinite(px) and math.isfinite(py)):
+            continue
+        out.append(_marker_at(marker, px, py, sz, col, alpha))
+    return "".join(out)
+
+
+def _artist_bar(a, xs_, ys_, col):
+    out = []
+    opts = a["opts"]
+    bw = xs_.bandwidth
+    y0 = ys_(0)
+    alpha = opts.get("alpha", _D["bar_alpha"])
+    for c, v in zip(a["cats"], a["vals"]):
+        x = xs_(c)
+        y = ys_(v)
+        out.append(f'<rect x="{x:.2f}" y="{min(y0, y):.2f}" width="{bw:.2f}" '
+                   f'height="{abs(y - y0):.2f}" fill="{col}" opacity="{alpha}"/>')
+    return "".join(out)
+
+
+def _artist_hist(a, xs_, ys_, ih, col):
+    out = []
+    alpha = a["opts"].get("alpha", _D["hist_alpha"])
+    half_gap = _D["hist_gap"] / 2
+    for b in a["_bins"]:
+        x0 = xs_(b["x0"]) + half_gap
+        x1 = xs_(b["x1"]) - half_gap
+        w = max(0, x1 - x0)
+        y = ys_(b["count"])
+        h = ih - y
+        out.append(f'<rect x="{x0:.2f}" y="{y:.2f}" width="{w:.2f}" height="{h:.2f}" '
+                   f'fill="{col}" opacity="{alpha}"/>')
+    return "".join(out)
+
+
+def _artist_fill_between(a, xs_, ys_, col):
+    upper = [(xs_(x), ys_(y)) for x, y in zip(a["xs"], a["y1"])]
+    lower = [(xs_(x), ys_(y)) for x, y in zip(a["xs"], a["y2"])]
+    pts = upper + list(reversed(lower))
+    if not pts:
+        return ""
+    d = "M" + "L".join(f"{p[0]:.2f},{p[1]:.2f}" for p in pts) + "Z"
+    alpha = a["opts"].get("alpha", _D["fill_alpha"])
+    return f'<path d="{d}" fill="{col}" opacity="{alpha}"/>'
+
+
+# ---------------------------------------------------------------------------
+# Marker primitive — used by plot/scatter and the legend
+# ---------------------------------------------------------------------------
+
+def _marker_at(marker, x, y, size, col, alpha):
+    msw = _D["marker_stroke_width"]
+    if marker == "o":
+        return f'<circle cx="{x:.2f}" cy="{y:.2f}" r="{size}" fill="{col}" opacity="{alpha}"/>'
+    if marker == "s":
+        return (f'<rect x="{x - size:.2f}" y="{y - size:.2f}" width="{2 * size}" '
+                f'height="{2 * size}" fill="{col}" opacity="{alpha}"/>')
+    if marker == "^":
+        return (f'<path d="M{x:.2f},{y - size:.2f}L{x + size:.2f},{y + size:.2f}'
+                f'L{x - size:.2f},{y + size:.2f}Z" fill="{col}" opacity="{alpha}"/>')
+    if marker == "v":
+        return (f'<path d="M{x:.2f},{y + size:.2f}L{x + size:.2f},{y - size:.2f}'
+                f'L{x - size:.2f},{y - size:.2f}Z" fill="{col}" opacity="{alpha}"/>')
+    if marker == "x":
+        return (f'<path d="M{x - size:.2f},{y - size:.2f}L{x + size:.2f},{y + size:.2f}'
+                f'M{x - size:.2f},{y + size:.2f}L{x + size:.2f},{y - size:.2f}" '
+                f'stroke="{col}" stroke-width="{msw}" opacity="{alpha}"/>')
+    if marker == "+":
+        return (f'<path d="M{x - size:.2f},{y:.2f}L{x + size:.2f},{y:.2f}'
+                f'M{x:.2f},{y - size:.2f}L{x:.2f},{y + size:.2f}" '
+                f'stroke="{col}" stroke-width="{msw}" opacity="{alpha}"/>')
+    return ""

plotlet/chart.py

@@ -0,0 +1,150 @@
+"""Tidy-table-friendly facade over Figure.
+
+    c = chart(df, title="...", xlabel="...", legend=True, grid=True)
+    c.line(x="time", y="value", hue="series")
+    c                         # auto-renders in Jupyter
+
+Each mark method (`line`, `scatter`, `bar`, `hist`, `fill_between`) accepts
+either column-name kwargs against the bound table, or the existing array form
+as positional args. `hue=<col>` splits into one call per unique value with
+auto-labels and tab10 colors.
+
+The bound table can be anything that supports `df[col_name]` returning an
+iterable: pandas / polars DataFrames, dict-of-lists, dict-of-arrays. No
+pandas dependency.
+"""
+from __future__ import annotations
+
+from .core import Figure
+from .artists import _to_pylist
+
+
+class Chart:
+    def __init__(self, data=None, *, width: int | None = None, height: int | None = None,
+                 margin: dict | None = None,
+                 title: str | None = None,
+                 xlabel: str | None = None, ylabel: str | None = None,
+                 xlim: tuple | None = None, ylim: tuple | None = None,
+                 xscale: str | None = None, yscale: str | None = None,
+                 legend: bool | None = None, grid: bool | None = None):
+        self._fig = Figure(width=width, height=height, margin=margin)
+        self._data = data
+        if title  is not None: self._fig.title(title)
+        if xlabel is not None: self._fig.xlabel(xlabel)
+        if ylabel is not None: self._fig.ylabel(ylabel)
+        if xlim   is not None: self._fig.xlim(*xlim)
+        if ylim   is not None: self._fig.ylim(*ylim)
+        if xscale is not None: self._fig.xscale(xscale)
+        if yscale is not None: self._fig.yscale(yscale)
+        if legend is not None: self._fig.legend(legend)
+        if grid   is not None: self._fig.grid(grid)
+
+    # ---------- mark methods ----------
+
+    def line(self, *args, x=None, y=None, hue=None, data=None, **opts):
+        if x is not None or y is not None:
+            self._tabular("line", "plot", data, x, y, hue, opts)
+        else:
+            self._fig.plot(*args, **opts)
+        return self
+
+    def scatter(self, *args, x=None, y=None, hue=None, data=None, **opts):
+        if x is not None or y is not None:
+            self._tabular("scatter", "scatter", data, x, y, hue, opts)
+        else:
+            self._fig.scatter(*args, **opts)
+        return self
+
+    def bar(self, *args, x=None, y=None, data=None, **opts):
+        if x is not None or y is not None:
+            df = self._resolve_data(data, "bar")
+            self._fig.bar(_to_pylist(df[x]), _to_pylist(df[y]), **opts)
+        else:
+            self._fig.bar(*args, **opts)
+        return self
+
+    def hist(self, *args, x=None, data=None, **opts):
+        if x is not None:
+            df = self._resolve_data(data, "hist")
+            self._fig.hist(_to_pylist(df[x]), **opts)
+        else:
+            self._fig.hist(*args, **opts)
+        return self
+
+    def fill_between(self, *args, x=None, y1=None, y2=None, data=None, **opts):
+        if x is not None or y1 is not None or y2 is not None:
+            df = self._resolve_data(data, "fill_between")
+            self._fig.fill_between(
+                _to_pylist(df[x]), _to_pylist(df[y1]), _to_pylist(df[y2]), **opts)
+        else:
+            self._fig.fill_between(*args, **opts)
+        return self
+
+    # ---------- helpers ----------
+
+    def _resolve_data(self, data, public_name):
+        df = data if data is not None else self._data
+        if df is None:
+            raise ValueError(
+                f"Chart.{public_name}() with column-name kwargs requires a bound table; "
+                f"pass data=<table> or use chart(<table>)."
+            )
+        return df
+
+    def _tabular(self, public_name, kind, data, x_col, y_col, hue, opts):
+        df = self._resolve_data(data, public_name)
+        method = getattr(self._fig, kind)
+        if hue is None:
+            method(_to_pylist(df[x_col]), _to_pylist(df[y_col]), **opts)
+            return
+        hue_vals = _to_pylist(df[hue])
+        xs_all = _to_pylist(df[x_col])
+        ys_all = _to_pylist(df[y_col])
+        seen: list = []
+        for v in hue_vals:
+            if v not in seen:
+                seen.append(v)
+        opts.pop("label", None)  # hue overrides any user-provided label
+        for v in seen:
+            xs_g = [xs_all[i] for i, h in enumerate(hue_vals) if h == v]
+            ys_g = [ys_all[i] for i, h in enumerate(hue_vals) if h == v]
+            method(xs_g, ys_g, label=str(v), **opts)
+
+    # ---------- frame metadata (passthrough) ----------
+
+    def title(self, s):        self._fig.title(s);   return self
+    def xlabel(self, s):       self._fig.xlabel(s);  return self
+    def ylabel(self, s):       self._fig.ylabel(s);  return self
+    def xlim(self, a, b):      self._fig.xlim(a, b); return self
+    def ylim(self, a, b):      self._fig.ylim(a, b); return self
+    def xscale(self, s):       self._fig.xscale(s);  return self
+    def yscale(self, s):       self._fig.yscale(s);  return self
+    def grid(self, on=True):   self._fig.grid(on);   return self
+    def legend(self, on=True): self._fig.legend(on); return self
+
+    # ---------- render ----------
+
+    def to_svg(self) -> str:
+        return self._fig.to_svg()
+
+    def to_html(self, full_page: bool = False) -> str:
+        return self._fig.to_html(full_page=full_page)
+
+    def _repr_html_(self) -> str:
+        return self._fig.to_svg()
+
+    def show(self):
+        self._fig.show()
+
+    def save_svg(self, path):
+        self._fig.save_svg(path)
+        return self
+
+    def write_html(self, path):
+        self._fig.write_html(path)
+        return self
+
+
+def chart(data=None, **opts) -> Chart:
+    """Construct a table-bound Chart. See `Chart` for keyword arguments."""
+    return Chart(data, **opts)

plotlet/colors.py

@@ -0,0 +1,20 @@
+"""Color resolution: tab10 shortcuts, named colors, single-letter codes."""
+from ._spec import _TAB10, _COLOR_NAMES
+
+TAB10 = list(_TAB10)
+colors = list(_TAB10)
+
+
+def _resolve_color(c):
+    """Map a color spec to a hex string. Pass-through unrecognized strings.
+
+    Accepts: 'C0'..'C9' tab10 shortcuts, named colors ('red', 'blue', …),
+    single-letter codes ('k', 'r', 'g', 'b', 'w'), or any hex / CSS color.
+    """
+    if c is None:
+        return None
+    if isinstance(c, str):
+        if len(c) == 2 and c[0] == "C" and c[1].isdigit():
+            return _TAB10[int(c[1])]
+        return _COLOR_NAMES.get(c, c)
+    return c

plotlet/core.py

@@ -0,0 +1,336 @@
+"""Figure class, the render orchestrator, and the public `figure()` factory.
+
+This is where the deferred-render pipeline lives:
+
+  1. `figure()` returns a `Figure` whose methods record into `_calls`.
+  2. `Figure.to_svg()` calls `_render(_replay(), ...)`.
+  3. `_render` does: domain compute → scales → grid → artists → spines/ticks
+     → labels/title → legend.
+"""
+from __future__ import annotations
+
+import math
+from pathlib import Path
+
+from ._spec import (
+    SPEC, _SIZESPEC, _FRAME, _GRIDSPEC, _FONTSPEC, _LEGSPEC, _D, _DASH,
+)
+from .colors import _resolve_color, TAB10
+from .scales import _LinearScale, _LogScale, _BandScale, _nice_domain, _fmt_tick
+from .font import _measure_text, _text_path
+from .artists import (
+    _to_pylist, _histogram,
+    _artist_plot, _artist_scatter, _artist_bar, _artist_hist, _artist_fill_between,
+    _marker_at,
+)
+
+_TICK_LEN = _FRAME["tick_length"]
+_TICK_PAD = _FRAME["tick_pad"]
+_SPINE = _FRAME["color"]
+_SPW = _FRAME["width"]
+_GRID = _GRIDSPEC["color"]
+_FONT = _FONTSPEC["family"]
+
+
+_RECORDABLE = {
+    "plot", "scatter", "bar", "hist", "fill_between",
+    "title", "xlabel", "ylabel", "xlim", "ylim",
+    "xscale", "yscale", "grid", "legend",
+}
+
+
+class Figure:
+    def __init__(self, width: int | None = None, height: int | None = None,
+                 margin: dict | None = None):
+        self._calls: list[tuple[str, list, dict]] = []
+        self._width = width if width is not None else _SIZESPEC["width"]
+        self._height = height if height is not None else _SIZESPEC["height"]
+        self._margin = margin if margin is not None else dict(_SIZESPEC["margin"])
+
+    def __getattr__(self, name):
+        if name in _RECORDABLE:
+            def recorder(*args, **kwargs):
+                self._calls.append((name, list(args), dict(kwargs)))
+                return self
+            return recorder
+        raise AttributeError(f"Figure has no method {name!r}")
+
+    # ------------------------------------------------------------- replay
+    def _replay(self):
+        st = {
+            "artists": [], "title": "", "xlabel": "", "ylabel": "",
+            "xlim": None, "ylim": None, "xscale": "linear", "yscale": "linear",
+            "grid": False, "legend": False,
+        }
+        for name, args, kw in self._calls:
+            if name == "plot":
+                st["artists"].append({"type": "plot", "xs": _to_pylist(args[0]),
+                                      "ys": _to_pylist(args[1]), "opts": kw})
+            elif name == "scatter":
+                st["artists"].append({"type": "scatter", "xs": _to_pylist(args[0]),
+                                      "ys": _to_pylist(args[1]), "opts": kw})
+            elif name == "bar":
+                st["artists"].append({"type": "bar", "cats": _to_pylist(args[0]),
+                                      "vals": _to_pylist(args[1]), "opts": kw})
+            elif name == "hist":
+                st["artists"].append({"type": "hist",
+                                      "data": _to_pylist(args[0]), "opts": kw})
+            elif name == "fill_between":
+                st["artists"].append({"type": "fill_between",
+                                      "xs": _to_pylist(args[0]),
+                                      "y1": _to_pylist(args[1]),
+                                      "y2": _to_pylist(args[2]), "opts": kw})
+            elif name == "title":  st["title"] = args[0]
+            elif name == "xlabel": st["xlabel"] = args[0]
+            elif name == "ylabel": st["ylabel"] = args[0]
+            elif name == "xlim":   st["xlim"] = (args[0], args[1])
+            elif name == "ylim":   st["ylim"] = (args[0], args[1])
+            elif name == "xscale": st["xscale"] = args[0]
+            elif name == "yscale": st["yscale"] = args[0]
+            elif name == "grid":   st["grid"] = (args[0] if args else True)
+            elif name == "legend": st["legend"] = (args[0] if args else True)
+        return st
+
+    # ------------------------------------------------------------- render
+    def to_svg(self) -> str:
+        return _render(self._replay(), self._width, self._height, self._margin)
+
+    def to_html(self, full_page: bool = False) -> str:
+        svg = self.to_svg()
+        if full_page:
+            return ('<!doctype html><html><head><meta charset="utf-8">'
+                    '<title>plotlet</title></head>'
+                    f'<body style="margin:24px">{svg}</body></html>')
+        return svg
+
+    def _repr_html_(self) -> str:
+        return self.to_svg()
+
+    def show(self):
+        try:
+            from IPython.display import HTML, display
+        except ImportError:
+            print(self.to_html(full_page=True))
+            return
+        display(HTML(self.to_svg()))
+
+    def write_html(self, filename):
+        Path(filename).write_text(self.to_html(full_page=True))
+        return self
+
+    def save_svg(self, filename):
+        Path(filename).write_text(self.to_svg())
+        return self
+
+
+def figure(width: int | None = None, height: int | None = None, **opts) -> Figure:
+    """Construct a new Figure. All options are passed through to `Figure(...)`."""
+    return Figure(width=width, height=height, **opts)
+
+
+# ---------------------------------------------------------------------------
+# render orchestrator
+# ---------------------------------------------------------------------------
+
+def _render(st, W, H, M):
+    iw = W - M["left"] - M["right"]
+    ih = H - M["top"] - M["bottom"]
+
+    # pre-bin histograms so they participate in y-domain
+    for a in st["artists"]:
+        if a["type"] == "hist":
+            a["_bins"] = _histogram(a["data"], a["opts"].get("bins", 10))
+
+    # ---- x scale ----
+    has_bar = any(a["type"] == "bar" for a in st["artists"])
+    if has_bar:
+        cats = []
+        for a in st["artists"]:
+            if a["type"] == "bar":
+                for c in a["cats"]:
+                    if c not in cats: cats.append(c)
+        x_scale = _BandScale(cats, 0, iw)
+        x_ticks = cats
+    else:
+        x_min, x_max = math.inf, -math.inf
+        for a in st["artists"]:
+            if a["type"] in ("plot", "scatter", "fill_between"):
+                for v in a["xs"]:
+                    if v < x_min: x_min = v
+                    if v > x_max: x_max = v
+            elif a["type"] == "hist":
+                for b in a["_bins"]:
+                    if b["x0"] < x_min: x_min = b["x0"]
+                    if b["x1"] > x_max: x_max = b["x1"]
+        if st["xlim"] is not None:
+            x_min, x_max = st["xlim"]
+        elif math.isinf(x_min):
+            x_min, x_max = 0, 1
+        elif x_min == x_max:
+            x_min -= 0.5; x_max += 0.5
+        elif st["xscale"] == "log":
+            if x_min > 0 and x_max > 0:
+                x_min = 10 ** math.floor(math.log10(x_min))
+                x_max = 10 ** math.ceil(math.log10(x_max))
+        else:
+            x_min, x_max = _nice_domain(x_min, x_max)
+        x_scale = (_LogScale if st["xscale"] == "log" else _LinearScale)(x_min, x_max, 0, iw)
+        x_ticks = x_scale.ticks(8)
+
+    # ---- y scale ----
+    y_min, y_max = math.inf, -math.inf
+    for a in st["artists"]:
+        if a["type"] in ("plot", "scatter"):
+            for v in a["ys"]:
+                if v < y_min: y_min = v
+                if v > y_max: y_max = v
+        elif a["type"] == "bar":
+            for v in a["vals"]:
+                if v < y_min: y_min = v
+                if v > y_max: y_max = v
+        elif a["type"] == "fill_between":
+            for v in a["y1"] + a["y2"]:
+                if v < y_min: y_min = v
+                if v > y_max: y_max = v
+        elif a["type"] == "hist":
+            for b in a["_bins"]:
+                if b["count"] > y_max: y_max = b["count"]
+            if y_min > 0: y_min = 0
+    if has_bar and y_min > 0: y_min = 0
+    if st["ylim"] is not None:
+        y_min, y_max = st["ylim"]
+    elif math.isinf(y_min):
+        y_min, y_max = 0, 1
+    elif y_min == y_max:
+        y_min -= 0.5; y_max += 0.5
+    elif st["yscale"] == "log":
+        if y_min > 0 and y_max > 0:
+            y_min = 10 ** math.floor(math.log10(y_min))
+            y_max = 10 ** math.ceil(math.log10(y_max))
+    else:
+        y_min, y_max = _nice_domain(y_min, y_max)
+    y_scale = (_LogScale if st["yscale"] == "log" else _LinearScale)(y_min, y_max, ih, 0)
+    y_ticks = y_scale.ticks(8)
+
+    # ---- emit SVG ----
+    parts = [
+        f'<svg xmlns="http://www.w3.org/2000/svg" width="{W}" height="{H}" '
+        f'viewBox="0 0 {W} {H}" font-family="{_FONT}" font-size="11" '
+        f'style="background:#fff">'
+    ]
+    parts.append(f'<g transform="translate({M["left"]},{M["top"]})">')
+
+    # grid
+    if st["grid"]:
+        gw = _GRIDSPEC["width"]; gd = _GRIDSPEC["dasharray"]
+        if not has_bar:
+            for t in x_ticks:
+                x = x_scale(t)
+                parts.append(f'<line x1="{x:.2f}" x2="{x:.2f}" y1="0" y2="{ih}" '
+                             f'stroke="{_GRID}" stroke-width="{gw}" stroke-dasharray="{gd}"/>')
+        for t in y_ticks:
+            y = y_scale(t)
+            parts.append(f'<line x1="0" x2="{iw}" y1="{y:.2f}" y2="{y:.2f}" '
+                         f'stroke="{_GRID}" stroke-width="{gw}" stroke-dasharray="{gd}"/>')
+
+    # artists
+    color_idx = [0]
+    def next_color():
+        c = TAB10[color_idx[0] % 10]; color_idx[0] += 1; return c
+
+    for a in st["artists"]:
+        col = _resolve_color(a["opts"].get("color")) or next_color()
+        a["_color"] = col
+        if a["type"] == "plot":
+            parts.append(_artist_plot(a, x_scale, y_scale, col))
+        elif a["type"] == "scatter":
+            parts.append(_artist_scatter(a, x_scale, y_scale, col))
+        elif a["type"] == "bar":
+            parts.append(_artist_bar(a, x_scale, y_scale, col))
+        elif a["type"] == "hist":
+            parts.append(_artist_hist(a, x_scale, y_scale, ih, col))
+        elif a["type"] == "fill_between":
+            parts.append(_artist_fill_between(a, x_scale, y_scale, col))
+
+    # spines (4 sides)
+    for x1, y1, x2, y2 in [(0, 0, iw, 0), (0, ih, iw, ih), (0, 0, 0, ih), (iw, 0, iw, ih)]:
+        parts.append(f'<line x1="{x1}" y1="{y1}" x2="{x2}" y2="{y2}" '
+                     f'stroke="{_SPINE}" stroke-width="{_SPW}"/>')
+
+    # x ticks + labels
+    tick_size = _FONTSPEC["tick_size"]
+    label_size = _FONTSPEC["label_size"]
+    title_size = _FONTSPEC["title_size"]
+
+    for t in x_ticks:
+        x = (x_scale(t) + x_scale.bandwidth / 2) if has_bar else x_scale(t)
+        parts.append(f'<line x1="{x:.2f}" x2="{x:.2f}" y1="{ih}" y2="{ih - _TICK_LEN}" '
+                     f'stroke="{_SPINE}" stroke-width="{_SPW}"/>')
+        parts.append(f'<line x1="{x:.2f}" x2="{x:.2f}" y1="0" y2="{_TICK_LEN}" '
+                     f'stroke="{_SPINE}" stroke-width="{_SPW}"/>')
+        parts.append(_text_path(_fmt_tick(t), x, ih + _TICK_LEN + _TICK_PAD + 8,
+                                tick_size, anchor="middle"))
+
+    # y ticks + labels
+    for t in y_ticks:
+        y = y_scale(t)
+        parts.append(f'<line x1="0" x2="{_TICK_LEN}" y1="{y:.2f}" y2="{y:.2f}" '
+                     f'stroke="{_SPINE}" stroke-width="{_SPW}"/>')
+        parts.append(f'<line x1="{iw}" x2="{iw - _TICK_LEN}" y1="{y:.2f}" y2="{y:.2f}" '
+                     f'stroke="{_SPINE}" stroke-width="{_SPW}"/>')
+        parts.append(_text_path(_fmt_tick(t), -_TICK_PAD, y + 4, tick_size, anchor="end"))
+
+    # axis labels + title
+    if st["xlabel"]:
+        parts.append(_text_path(st["xlabel"], iw / 2, ih + M["bottom"] - 8,
+                                label_size, anchor="middle"))
+    if st["ylabel"]:
+        ylabel_path = _text_path(st["ylabel"], 0, 0, label_size, anchor="middle")
+        parts.append(f'<g transform="translate({-(M["left"] - 12)},{ih/2}) rotate(-90)">'
+                     f'{ylabel_path}</g>')
+    if st["title"]:
+        parts.append(_text_path(st["title"], iw / 2, -10, title_size, anchor="middle"))
+
+    # legend
+    if st["legend"]:
+        labeled = [a for a in st["artists"] if a["opts"].get("label")]
+        if labeled:
+            row_h = _LEGSPEC["row_height"]
+            pad_x = _LEGSPEC["pad_x"]
+            pad_y = _LEGSPEC["pad_y"]
+            sw    = _LEGSPEC["swatch_width"]
+            max_text = max(_measure_text(a["opts"]["label"], tick_size) for a in labeled)
+            lw = sw + 6 + max_text + 2 * pad_x
+            lh = len(labeled) * row_h + 2 * pad_y
+            lx, ly = iw - lw - _LEGSPEC["border_offset"], _LEGSPEC["border_offset"]
+            parts.append(f'<g transform="translate({lx:.2f},{ly})">')
+            parts.append(f'<rect x="0" y="0" width="{lw:.2f}" height="{lh}" '
+                         f'fill="{_LEGSPEC["background"]}" stroke="{_SPINE}" '
+                         f'stroke-width="{_SPW}" opacity="{_LEGSPEC["opacity"]}"/>')
+            for i, a in enumerate(labeled):
+                ry = pad_y + i * row_h + row_h / 2
+                if a["type"] in ("plot", "fill_between"):
+                    ls = a["opts"].get("linestyle")
+                    da = f' stroke-dasharray="{_DASH[ls]}"' if ls and _DASH.get(ls) else ""
+                    parts.append(f'<line x1="{pad_x}" x2="{pad_x + sw}" y1="{ry}" y2="{ry}" '
+                                 f'stroke="{a["_color"]}" '
+                                 f'stroke-width="{a["opts"].get("linewidth", _D["linewidth"])}"{da}/>')
+                    if a["opts"].get("marker"):
+                        parts.append(_marker_at(a["opts"]["marker"], pad_x + sw / 2, ry,
+                                                a["opts"].get("markersize", _D["markersize"]),
+                                                a["_color"], 1))
+                elif a["type"] == "scatter":
+                    s_size = math.sqrt(a["opts"].get("s", _D["scatter_s"])) / 2
+                    parts.append(_marker_at(a["opts"].get("marker", "o"),
+                                            pad_x + sw / 2, ry, s_size, a["_color"],
+                                            a["opts"].get("alpha", _D["scatter_alpha"])))
+                else:
+                    parts.append(f'<rect x="{pad_x}" y="{ry - 5}" width="{sw}" height="10" '
+                                 f'fill="{a["_color"]}" '
+                                 f'opacity="{a["opts"].get("alpha", 1)}"/>')
+                parts.append(_text_path(a["opts"]["label"], pad_x + sw + 6, ry + 4,
+                                        tick_size, anchor="start"))
+            parts.append('</g>')
+
+    parts.append('</g></svg>')
+    return "".join(parts)

plotlet/font.py

@@ -0,0 +1,63 @@
+"""Font loading + text→SVG path conversion using bundled DejaVu Sans.
+
+We extract glyph outlines and emit them as <path> elements rather than
+<text>, so SVG renders identically on every machine regardless of installed
+fonts. The same loaded font also gives us exact text-width measurement —
+no `len(text) * fudge_factor` magic numbers.
+"""
+from pathlib import Path
+
+from fontTools.ttLib import TTFont
+from fontTools.pens.svgPathPen import SVGPathPen
+from fontTools.pens.transformPen import TransformPen
+from fontTools.misc.transform import Transform
+
+_HERE = Path(__file__).parent
+_FONT_PATH = _HERE / "fonts" / "DejaVuSans.ttf"
+
+_TTF = TTFont(str(_FONT_PATH))
+_UPEM = _TTF["head"].unitsPerEm
+_CMAP = _TTF.getBestCmap()
+_GS = _TTF.getGlyphSet()
+_ASCENT = _TTF["hhea"].ascent
+_DESCENT = _TTF["hhea"].descent
+
+
+def _glyph(ch):
+    return _GS[_CMAP.get(ord(ch), ".notdef")]
+
+
+def _measure_text(s: str, size: float) -> float:
+    """Exact pixel width of `s` rendered in DejaVu Sans at `size` pt."""
+    if not s:
+        return 0.0
+    scale = size / _UPEM
+    return sum(_glyph(ch).width * scale for ch in s)
+
+
+def _text_path(s: str, x: float, y: float, size: float,
+               anchor: str = "start", color: str = "#000") -> str:
+    """Render `s` as a single SVG <path> with its baseline at (x, y).
+
+    `anchor` matches SVG's text-anchor: 'start' | 'middle' | 'end'.
+    Useful for tick labels (anchor='middle'), y-tick labels (anchor='end').
+    """
+    if not s:
+        return ""
+    width = _measure_text(s, size)
+    if anchor == "middle":
+        x0 = x - width / 2
+    elif anchor == "end":
+        x0 = x - width
+    else:
+        x0 = x
+    pen = SVGPathPen(_GS)
+    scale = size / _UPEM
+    cx = x0
+    for ch in s:
+        g = _glyph(ch)
+        # SVG y points down, font y points up — flip with negative scale.
+        tpen = TransformPen(pen, Transform().translate(cx, y).scale(scale, -scale))
+        g.draw(tpen)
+        cx += g.width * scale
+    return f'<path d="{pen.getCommands()}" fill="{color}"/>'

plotlet/scales.py

@@ -0,0 +1,116 @@
+"""Coordinate scales: linear, log, band — mirroring d3's scale types.
+
+Each scale is a callable: `scale(data_value) -> pixel_position`. Each also
+exposes `.ticks(n)` for axis tick generation.
+"""
+import math
+
+
+# ---------------------------------------------------------------------------
+# Nice-numbers algorithm (1/2/5 × 10ⁿ)
+# ---------------------------------------------------------------------------
+
+def _nice_step(span, n):
+    if span <= 0:
+        return 1
+    step = span / n
+    mag = 10 ** math.floor(math.log10(step))
+    err = step / mag
+    if err < 1.5: return 1 * mag
+    if err < 3:   return 2 * mag
+    if err < 7:   return 5 * mag
+    return 10 * mag
+
+
+def _nice_ticks(lo, hi, n=8):
+    if lo == hi:
+        return [lo]
+    step = _nice_step(hi - lo, n)
+    eps = abs(step) * 1e-9
+    start = math.ceil(lo / step - 1e-9) * step
+    out, t = [], start
+    while t <= hi + eps:
+        out.append(round(t, 10))
+        t += step
+    return out
+
+
+def _nice_domain(lo, hi, n=8):
+    if lo == hi:
+        return (lo - 0.5, hi + 0.5)
+    step = _nice_step(hi - lo, n)
+    return (math.floor(lo / step) * step, math.ceil(hi / step) * step)
+
+
+# ---------------------------------------------------------------------------
+# Scale classes
+# ---------------------------------------------------------------------------
+
+class _LinearScale:
+    def __init__(self, d0, d1, r0, r1):
+        self.d0, self.d1, self.r0, self.r1 = d0, d1, r0, r1
+
+    def __call__(self, v):
+        if self.d1 == self.d0:
+            return self.r0
+        return self.r0 + (v - self.d0) * (self.r1 - self.r0) / (self.d1 - self.d0)
+
+    def ticks(self, n=8):
+        return _nice_ticks(self.d0, self.d1, n)
+
+
+class _LogScale:
+    def __init__(self, d0, d1, r0, r1):
+        if d0 <= 0 or d1 <= 0:
+            raise ValueError("log scale needs strictly positive domain")
+        self.d0, self.d1 = d0, d1
+        self.l0, self.l1 = math.log10(d0), math.log10(d1)
+        self.r0, self.r1 = r0, r1
+
+    def __call__(self, v):
+        if v <= 0:
+            return float("nan")
+        return self.r0 + (math.log10(v) - self.l0) * (self.r1 - self.r0) / (self.l1 - self.l0)
+
+    def ticks(self, n=8):
+        a, b = math.floor(self.l0), math.ceil(self.l1)
+        return [10 ** k for k in range(int(a), int(b) + 1) if self.d0 <= 10 ** k <= self.d1]
+
+
+class _BandScale:
+    """Categorical scale — mirrors d3.scaleBand().padding(p) (inner = outer = p)."""
+
+    def __init__(self, cats, r0, r1, padding=0.2):
+        self.cats = list(cats)
+        self.r0, self.r1 = r0, r1
+        n = len(self.cats) or 1
+        total = r1 - r0
+        self.step = total / (n + padding)
+        self.bandwidth = self.step * (1 - padding)
+        self._start = self.r0 + padding * self.step
+
+    def __call__(self, cat):
+        try:
+            i = self.cats.index(cat)
+        except ValueError:
+            return float("nan")
+        return self._start + i * self.step
+
+    def ticks(self, n=None):
+        return list(self.cats)
+
+
+# ---------------------------------------------------------------------------
+# Tick formatting
+# ---------------------------------------------------------------------------
+
+def _fmt_tick(t):
+    """Format a tick value: 'g' for typical values, scientific for extremes."""
+    if isinstance(t, str):
+        return t
+    if t == 0:
+        return "0"
+    a = abs(t)
+    if a >= 1e4 or a < 1e-3:
+        return f"{t:.0e}".replace("e+0", "e").replace("e-0", "e-").replace("e+", "e")
+    return f"{t:g}"

plotlet/spec.json

@@ -0,0 +1,75 @@
+{
+  "version": "0.1.0",
+  "size": {
+    "width": 600,
+    "height": 400,
+    "margin": {"top": 30, "right": 18, "bottom": 48, "left": 58}
+  },
+  "font": {
+    "family": "DejaVu Sans, Bitstream Vera Sans, Verdana, Arial, sans-serif",
+    "tick_size": 11,
+    "label_size": 12,
+    "title_size": 13
+  },
+  "frame": {
+    "color": "#000000",
+    "width": 0.8,
+    "tick_length": 3.5,
+    "tick_pad": 4
+  },
+  "grid": {
+    "color": "#b0b0b0",
+    "width": 0.5,
+    "dasharray": "2,3"
+  },
+  "colors": {
+    "tab10": [
+      "#1f77b4", "#ff7f0e", "#2ca02c", "#d62728", "#9467bd",
+      "#8c564b", "#e377c2", "#7f7f7f", "#bcbd22", "#17becf"
+    ],
+    "named": {
+      "blue":   "#1f77b4",
+      "orange": "#ff7f0e",
+      "green":  "#2ca02c",
+      "red":    "#d62728",
+      "purple": "#9467bd",
+      "brown":  "#8c564b",
+      "pink":   "#e377c2",
+      "gray":   "#7f7f7f",
+      "olive":  "#bcbd22",
+      "cyan":   "#17becf",
+      "k": "#000000",
+      "w": "#ffffff",
+      "b": "#1f77b4",
+      "g": "#2ca02c",
+      "r": "#d62728"
+    }
+  },
+  "linestyles": {
+    "-":  null,
+    "--": "6,3",
+    ":":  "1,3",
+    "-.": "6,3,1,3"
+  },
+  "defaults": {
+    "linewidth": 1.5,
+    "markersize": 4,
+    "marker_stroke_width": 1.4,
+    "scatter_s": 25,
+    "scatter_alpha": 0.85,
+    "fill_alpha": 0.3,
+    "bar_alpha": 1,
+    "hist_alpha": 1,
+    "bar_padding": 0.2,
+    "hist_gap": 1.0
+  },
+  "legend": {
+    "row_height": 16,
+    "pad_x": 8,
+    "pad_y": 6,
+    "swatch_width": 22,
+    "background": "#ffffff",
+    "opacity": 0.92,
+    "border_offset": 6
+  }
+}

plotlet-0.1.0.dist-info/METADATA

@@ -0,0 +1,131 @@
+Metadata-Version: 2.4
+Name: plotlet
+Version: 0.1.0
+Summary: Small, hackable Python library that emits matplotlib-style SVG plots.
+Author: gitbamboo42
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/gitbamboo42/plotlet
+Project-URL: Repository, https://github.com/gitbamboo42/plotlet
+Project-URL: Issues, https://github.com/gitbamboo42/plotlet/issues
+Keywords: plot,svg,matplotlib,scientific,visualization,jupyter,reproducible
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Classifier: Topic :: Multimedia :: Graphics
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fonttools>=4.0
+Provides-Extra: dev
+Requires-Dist: jupyter; extra == "dev"
+Requires-Dist: nbconvert; extra == "dev"
+Dynamic: license-file
+
+# plotlet
+
+A small, hackable Python library that emits matplotlib-style SVG plots.
+
+## Why
+
+matplotlib is the right tool when you want the kitchen sink. plotlet's niche is **custom plot types** — genome tracks, Manhattan plots, phylogenetic trees, anything matplotlib's extension API makes painful. The whole library is ~700 lines of Python with a deliberately tiny, exposed core: adding a new plot type is a 3-step recipe, not an architecture project.
+
+It's a **scaffold, not a feature catalog**: the core ships ~5 standard plots and the infrastructure for extending. Custom plot types live in your own project (or [`cookbook/`](cookbook/)), not upstream. See [docs/PHILOSOPHY.md](docs/PHILOSOPHY.md) for the full framing.
+
+```python
+import plotlet as pt
+
+data = {
+    "x":      [1, 2, 3, 4, 5, 1, 2, 3, 4, 5],
+    "y":      [1, 4, 9, 16, 25, 1, 8, 27, 64, 125],
+    "series": ["squares"] * 5 + ["cubes"] * 5,
+}
+
+c = pt.chart(data, title="Hello", xlabel="x", ylabel="y", legend=True, grid=True)
+c.line(x="x", y="y", hue="series")
+c                                        # auto-renders in Jupyter
+```
+
+## Install
+
+Not on PyPI yet — clone and install editable:
+
+```bash
+git clone <repo>
+cd plotlet
+pip install -e .
+```
+
+## Properties
+
+- **Lightweight.** `fonttools` for font handling. numpy / pandas / polars inputs work transparently if you have them.
+- **Static SVG output.** No interactivity, no animation. Same script → byte-identical SVG.
+- **Cross-machine reproducible.** Bundled DejaVu Sans + text-as-paths means rendering is identical on Linux, macOS, Windows, headless CI.
+- **Jupyter-native.** `Figure._repr_html_` auto-renders the last expression in a cell.
+- **Tiny output.** Each plot is ~50 KB SVG, self-contained.
+
+## API
+
+`pt.chart(data, **opts)` returns a `Chart` bound to a table — any object that supports `data[col_name]` returning an iterable (pandas / polars DataFrames, dict-of-lists, dict-of-arrays). All methods return `self`; `_repr_html_` makes the chart auto-render as the last expression in a Jupyter cell.
+
+### Frame options
+
+Pass at construction (`pt.chart(data, title=..., grid=True, ...)`) or as chained setters (`c.title(...)`, etc.):
+
+`title`, `xlabel`, `ylabel`, `xlim=(a, b)`, `ylim=(a, b)`, `xscale="log"|"linear"`, `yscale=...`, `grid=True/False`, `legend=True/False`, `width`, `height`
+
+### Mark methods
+
+| call | options |
+| --- | --- |
+| `.line(x=, y=, hue=, **opts)` | `color`, `label`, `linewidth`, `linestyle` (`"-"`, `"--"`, `":"`, `"-."`), `marker` (`"o"`, `"s"`, `"^"`, `"v"`, `"x"`, `"+"`), `markersize` |
+| `.scatter(x=, y=, hue=, **opts)` | `color`, `label`, `s` (size), `alpha`, `marker` |
+| `.bar(x=, y=, **opts)` | `color`, `label`, `alpha` |
+| `.hist(x=, **opts)` | `bins`, `color`, `alpha`, `label` |
+| `.fill_between(x=, y1=, y2=, **opts)` | `color`, `alpha`, `label` |
+
+`hue=<col>` (on `.line` / `.scatter`) splits into one call per unique value with auto-labels and tab10 colors.
+
+### Render / save
+
+```python
+c.show()                     # explicit display() inside a cell
+c.to_svg()                   # raw SVG string
+c.save_svg("plot.svg")       # SVG file
+c.write_html("plot.html")    # standalone HTML
+```
+
+### Color shortcuts
+
+- `"C0"`–`"C9"` → tab10 (matches matplotlib)
+- Named: `"blue"`, `"orange"`, `"green"`, `"red"`, `"purple"`, `"brown"`, `"pink"`, `"gray"`, `"olive"`, `"cyan"`
+- Single-letter: `"k"`, `"w"`, `"b"`, `"g"`, `"r"`
+- Any hex / CSS color string passes through
+
+## Adding a new plot type
+
+plotlet's central hackability claim: a custom plot type is a 3-step recipe (~50–100 lines) that gets axes, scales, legend, grid, and composability for free. The recommended home is your own project, or [`cookbook/`](cookbook/) as reference. Full guide: [docs/EXTENDING.md](docs/EXTENDING.md).
+
+## Testing
+
+```bash
+python tests/test_chart.py            # check vs. committed baselines
+python tests/test_chart.py --update   # regenerate (review the diff!)
+python tests/test_chart.py --gallery  # build tests/baseline_images/chart/index.html
+```
+
+## Non-goals
+
+- No interactivity (hover, zoom, click). Static rendering is the point.
+- Not competing with matplotlib on standard plots; matplotlib is bigger and battle-tested.
+- Not a 3D plotter, not a dashboard tool.
+- Not a feature catalog — new plot types belong in user projects or `cookbook/`, not in the core.
+
+## License
+
+MIT

plotlet-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+plotlet/__init__.py,sha256=3g8RTmrO7NVAPlFgjEOSQaLh8mjZuBk4gMcedcCcOnM,692
+plotlet/_spec.py,sha256=9m6u5HoHLXlFVPb1mBCLdHR8pGT-HVTsKc9HvZdl4Nw,649
+plotlet/artists.py,sha256=lMD6WxYEyF6XSssNQwpUAyZE7bzOjucn8tS766cmrnA,5728
+plotlet/chart.py,sha256=9EgbeHb5ulZlngXiAmAuTlgW56nx0zWyLYPRygO3m-c,5810
+plotlet/colors.py,sha256=OPQTxlqGe80-DjllJFb589idxtmnywdElfMxQARRym8,633
+plotlet/core.py,sha256=kwUOEdua55xMW3bDcREcaYj5czBdMvNqQHtDmH-26cE,14511
+plotlet/font.py,sha256=Qrpw0kYBKKpAKCFXd3iXxS_0eBGIuITrK4DmsjGx-T0,2028
+plotlet/scales.py,sha256=aJ_l32t7JjbvQM61Wyd7Cjo4OFDsAPC_7GaO5KReYfg,3506
+plotlet/spec.json,sha256=rMJqtUEhOOW46J5_R6vG1rX5T7GiZHpkEZrw65ux4IM,1564
+plotlet/fonts/DejaVuSans.ttf,sha256=P99pyr8GBJ6nCgC1kZNA4s4ebQKwzDxLRPtoAb0eDSI,756072
+plotlet-0.1.0.dist-info/licenses/LICENSE,sha256=-eDAeMETlonetrYKJB7m6cBRyYjtTbnurp_9KkbmU_4,1068
+plotlet-0.1.0.dist-info/METADATA,sha256=QDAYYm0dPnqdxnNhqd3pFMgTF9UXEMHLujMdDp80boQ,5541
+plotlet-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+plotlet-0.1.0.dist-info/top_level.txt,sha256=hLvsc31uP3a4QQS-dvoV_Ec_HXluZZ1W31AvDjHrb2I,8
+plotlet-0.1.0.dist-info/RECORD,,

plotlet-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

plotlet-0.1.0.dist-info/licenses/LICENSE

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

plotlet-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+plotlet