densitty 0.8.2__py3-none-any.whl

densitty/plot.py

@@ -0,0 +1,201 @@
+"""Two-dimensional histogram (density plot) with textual output."""
+
+import dataclasses
+from itertools import chain, zip_longest
+import os
+import sys
+from typing import Callable, Optional, Sequence
+
+from . import ansi, axis, lineart
+from .util import FloatLike
+
+# pylint: disable=invalid-name
+# User can set this to provide a default if os.terminal_size() fails:
+default_terminal_size: Optional[os.terminal_size] = None
+
+
+@dataclasses.dataclass
+class Plot:
+    """Create a textual 2-D density/histogram plot given binned data."""
+
+    # pylint: disable=too-many-instance-attributes
+    data: Sequence[Sequence[FloatLike]]
+    color_map: Callable = ansi.GRAYSCALE  # Can return an ascii character or a color code
+    render_halfheight: bool = (
+        True  # use fg/bg of "▄" to double Y resolution if color_map is non-ASCII
+    )
+    font_mapping: dict = dataclasses.field(default_factory=lambda: lineart.basic_font)
+    min_data: Optional[FloatLike] = None
+    max_data: Optional[FloatLike] = None
+    x_axis: Optional[axis.Axis] = None
+    y_axis: Optional[axis.Axis] = None
+    flip_y: bool = True  # put the first row of data at the bottom of the output
+
+    def as_ascii(self):
+        """Output using direct characters (ASCII-art)."""
+        data = self._normalize_data()
+        for line in data:
+            line_str = (self.color_map(x, None) for x in line)
+            yield "".join(line_str)
+
+    def as_color(self):
+        """Output using ANSI color codes for background, with space character."""
+        data = self._normalize_data()
+        for line in data:
+            colors = (self.color_map(x, None) for x in line)
+            yield (" ".join(chain(colors, [ansi.RESET])))
+
+    def as_halfheight_color(self):
+        """Output using ANSI color codes for foreground & background, with half-block character."""
+        data = self._normalize_data()
+        half_block = "▄"  # Unicode U+2584 "Lower Half Block"
+        line_count = len(data)
+        lines = iter(data)
+        if line_count % 2:
+            # odd number of lines: special-case the first line:
+            line = next(lines, [])
+            colors = (self.color_map(None, x) for x in line)
+            yield (half_block.join(chain(colors, [ansi.RESET])))
+        for bg_line in lines:
+            fg_line = next(lines, [])
+            colors = (self.color_map(x, y) for x, y in zip(bg_line, fg_line))
+            yield (half_block.join(chain(colors, [ansi.RESET])))
+
+    def _normalize_data(self):
+        """Normalize data to 0..1 interval based on min_data/max_data or actual min/max.
+        Also flips data if requested
+        """
+
+        min_data = min(min(line) for line in self.data) if self.min_data is None else self.min_data
+        max_data = max(max(line) for line in self.data) if self.max_data is None else self.max_data
+        data_scale = max_data - min_data
+        if data_scale == 0:
+            # all data has the same value (or we were told it does)
+            data_scale = sys.float_info.min
+        norm_data = tuple(tuple((x - min_data) / data_scale for x in line) for line in self.data)
+
+        return tuple(reversed(norm_data)) if self.flip_y else norm_data
+
+    def is_color(self):
+        """Is color_map returning color codes, not ASCII-art?"""
+        return len(self.color_map(0.5, None)) > 1  # is color_map returning color codes?
+
+    def is_halfheight(self):
+        """Are there two pixels per output character?"""
+        return self.is_color() and self.render_halfheight
+
+    def as_strings(self):
+        """Scale data to 0..1 range and feed it through the appropriate output function"""
+        if self.is_halfheight():
+            plot_lines = tuple(self.as_halfheight_color())
+        elif self.is_color():
+            plot_lines = tuple(self.as_color())
+        else:
+            plot_lines = tuple(self.as_ascii())
+
+        num_rows = len(plot_lines)
+        num_cols = len(self.data[0])
+
+        if self.y_axis:
+            axis_lines = self.y_axis.render_as_y(num_rows, False, bool(self.x_axis), self.flip_y)
+        else:
+            axis_lines = ["" for _ in range(num_rows + bool(self.x_axis))]
+
+        left_margin = lineart.display_len(axis_lines[0])
+        if self.x_axis:
+            x_ticks, x_labels = self.x_axis.render_as_x(num_cols, left_margin)
+            axis_lines[-1] = lineart.merge_lines(x_ticks, axis_lines[-1])
+            axis_lines += [x_labels]
+
+        for frame, plot_line in zip_longest(axis_lines, plot_lines, fillvalue=""):
+            yield frame.translate(self.font_mapping) + plot_line
+
+    def show(self, printer=print):
+        """Simple helper function to output/print a plot"""
+        for line in self.as_strings():
+            printer(line)
+
+    def _compute_scaling_multipliers(
+        self,
+        max_size: tuple[int, int],
+        keep_aspect_ratio: bool,
+    ) -> tuple[float, float]:
+        """Compute multpliers in X and Y (cols/rows) to resize data to fit in specified bounds."""
+        try:
+            terminal_size: Optional[os.terminal_size] = os.get_terminal_size()
+        except OSError:
+            terminal_size = default_terminal_size
+
+        if max_size[1] <= 0:
+            if terminal_size is None:
+                raise OSError("No terminal size from os.get_terminal_size()")
+            user_margin = -int(max_size[1]) if max_size[1] else 0
+            axis_margin = bool(self.x_axis) * 2  # 2 lines at bottom for X axis
+            y_mult = 2 if self.is_halfheight() else 1
+            max_size = (max_size[0], (terminal_size.lines - user_margin - axis_margin) * y_mult)
+
+        if max_size[0] <= 0:
+            if terminal_size is None:
+                raise OSError("No terminal size from os.get_terminal_size()")
+            user_margin = -int(max_size[0]) if max_size[0] else 0
+            if self.y_axis:
+                y_axis_lines = self.y_axis.render_as_y(
+                    max_size[1], False, bool(self.x_axis), self.flip_y
+                )
+                # margin on left from Y axis width. 2-char buffer on right for X axis label:
+                axis_margin = len(y_axis_lines[0]) + 2 * bool(self.x_axis)
+            else:
+                axis_margin = 0
+            max_size = (terminal_size.columns - user_margin - axis_margin, max_size[1])
+
+        scaling = (max_size[0] / len(self.data[0]), max_size[1] / len(self.data))
+        if keep_aspect_ratio:
+            single_scale = min(scaling)
+            return single_scale, single_scale
+        return scaling
+
+    def upscale(
+        self,
+        max_size: tuple[int, int] = (0, 0),
+        max_expansion: tuple[int, int] = (3, 3),
+        keep_aspect_ratio: bool = False,
+    ):
+        """Scale up 'data' by repeating lines and values within lines.
+
+        Parameters
+        ----------
+        max_size : tuple (int, int)
+                   If positive: Maximum number of columns, maximum number of rows
+                   If zero: Use terminal size
+                   If negative: Use as offset from terminal size
+                   Default: Based on terminal size (0).
+        max_expansion : tuple (int, int)
+                   maximum expansion factor in each direction. Default (3,3). 0=> No maximum
+        keep_aspect_ratio : bool
+                   Require that X and Y scaling are equal.
+        """
+
+        float_mult = self._compute_scaling_multipliers(max_size, keep_aspect_ratio)
+        col_mult = max(int(float_mult[0]), 1)
+        row_mult = max(int(float_mult[1]), 1)
+
+        if keep_aspect_ratio and any(max_expansion):
+            # Just in case user specifies keep_aspect_ratio but varying / missing maxima:
+            mult = max(int(m) for m in max_expansion)
+            max_expansion = (mult, mult)
+
+        if max_expansion[0] is not None:
+            col_mult = min(col_mult, max_expansion[0])
+        if max_expansion[1] is not None:
+            row_mult = min(row_mult, max_expansion[1])
+
+        def repeat_each(d, mult):
+            """Repeat each element of 'd' 'mult' times"""
+            return sum(((x,) * mult for x in d), start=tuple())
+
+        # expand each of the lines using the column multiplier
+        x_expanded = (repeat_each(data_line, col_mult) for data_line in self.data)
+
+        # repeat each of those by the row multiplier
+        self.data = repeat_each(x_expanded, row_mult)
+        return self

densitty/truecolor.py

@@ -0,0 +1,170 @@
+"""ANSI "True color" (24b, 16M colors) support."""
+
+import math
+
+from typing import Optional, Sequence
+
+from . import ansi
+from .util import clamp, clamp_rgb, interp, Vec
+
+# Note: by default, we usethe widely supported 38;2;R;G;B to set foreground color
+# An alternate spec is ODA which is 38:2::R:G:B (NB: colons rather than semicolons).
+# The default (semicolons) is not nicely backwards-compatible, since the R;G;B appear
+# to be control codes, and can e.g. turn on underline. But it is more widely supported.
+
+# pylint: disable=invalid-name
+# User can override this to use ODA codes if desired
+use_oda_colorcodes = False
+
+# Probably overkill: linear interpolation of RGB values gets muddy in the middle.
+#    Interpolating in CIE "L*a*b*" space typically gives much nicer results.
+
+
+def _rgb_to_linear_rgb(channel):
+    """Gamma correction: Convert RGB to 'linear' RGB with gamma of 2.4."""
+    channel = channel / 255.0
+    if channel > 0.04045:
+        return math.pow((channel + 0.055) / 1.055, 2.4)
+    return channel / 12.92
+
+
+def _linear_rgb_to_rgb(channel):
+    """Inverse gamma correction: Convert 'linear' RGB back to RGB."""
+    if channel > 0.0031308:
+        return clamp(round(255 * 1.055 * math.pow(channel, 1.0 / 2.4) - 0.055), 0, 255)
+    return clamp(round(255 * 12.92 * channel), 0, 255)
+
+
+def _vector_transform(v, m):
+    """Returns v * m, where v is a vector and m is a matrix (list of columns)."""
+    return [math.sumprod(v, col) for col in m]
+
+
+def _rgb_to_lab(rgb: Vec) -> Vec:
+    """Convert RGB triple to CIE LAB triple."""
+
+    linear_rgb = tuple(map(_rgb_to_linear_rgb, rgb))
+    # Conversion to XYZ that also includes white point calibration of [0.95047, 1.00000, 1.08883]
+    linear_rgb_to_xyzn = [
+        [0.43394994055572506, 0.376209769903311, 0.18984028954096394],
+        [0.2126729, 0.7151522, 0.072175],
+        [0.01775658275396527, 0.10946796102238184, 0.8727754562236529],
+    ]
+    xyzn = _vector_transform(linear_rgb, linear_rgb_to_xyzn)
+
+    def f(t):
+        """common part of xyz->lab transform"""
+        if t > 0.008856451679035631:
+            return math.pow(t, 1 / 3)
+        return 0.13793103448275862 + t / 0.12841854934601665
+
+    fxyz = tuple(map(f, xyzn))
+
+    lum = 116 * fxyz[1] - 16
+    a = 500 * (fxyz[0] - fxyz[1])
+    b = 200 * (fxyz[1] - fxyz[2])
+    return (lum, a, b)
+
+
+def _lab_to_rgb(lab: Vec) -> Vec:
+    """Convert CIE LAB triple to RGB."""
+
+    fy = (lab[0] + 16) / 116
+    fx = lab[1] / 500 + fy
+    fz = fy - lab[2] / 200
+
+    def f_inv(t):
+        if t > 0.20689655172413793:
+            return t**3
+        return 0.12841854934601665 * (t - 0.13793103448275862)
+
+    xyzn = (f_inv(fx), f_inv(fy), f_inv(fz))
+
+    # Conversion from XYZ that also includes the white point calibration/normalization:
+    xyzn_to_linear_rgb = [
+        [3.079954503474, -1.5371385, -0.542815944262],
+        [-0.92125825502, 1.8760108, 0.04524741948],
+        [0.052887382398000005, -0.2040259, 1.151138514516],
+    ]
+    linear_rgb = _vector_transform(xyzn, xyzn_to_linear_rgb)
+
+    rgb = tuple(map(_linear_rgb_to_rgb, linear_rgb))
+    return rgb
+
+
+def colormap_24b(color_points: Sequence[Vec], num_output_colors=256, interp_in_rgb=False):
+    """Produce a function that returns ANSI colors interpolated from the provided sequence
+    Parameters
+    ----------
+    color_points: Sequence[Vec]
+                  Evenly-spaced color values corresponding to 0.0..1.0
+    num_output_colors: int
+                  Number of distinct interpolated output colors to use
+    interp_in_rgb: bool
+                  Interpolate in RGB space rather than Lab space
+    """
+    # create the color map by interpolating between the given color points
+    if interp_in_rgb:
+        scale = tuple(
+            clamp_rgb(interp(color_points, x / (num_output_colors - 1)))
+            for x in range(num_output_colors)
+        )
+    else:
+        lab_color_points = tuple(_rgb_to_lab(point) for point in color_points)
+        lab_scale = [
+            interp(lab_color_points, x / (num_output_colors - 1)) for x in range(num_output_colors)
+        ]
+        scale = tuple(clamp_rgb(_lab_to_rgb(point)) for point in lab_scale)
+
+    def colorcode(bg_frac: Optional[float], fg_frac: Optional[float]):
+        codes = []
+        if fg_frac is not None:
+            fg_idx = clamp(round(fg_frac * num_output_colors), 0, num_output_colors - 1)
+            if use_oda_colorcodes:
+                codes += [f"38:2::{scale[fg_idx][0]}:{scale[fg_idx][1]}:{scale[fg_idx][2]}"]
+            else:
+                codes += [f"38;2;{scale[fg_idx][0]};{scale[fg_idx][1]};{scale[fg_idx][2]}"]
+        if bg_frac is not None:
+            bg_idx = clamp(round(bg_frac * num_output_colors), 0, num_output_colors - 1)
+            if use_oda_colorcodes:
+                codes += [f"48:2::{scale[bg_idx][0]}:{scale[bg_idx][1]}:{scale[bg_idx][2]}"]
+            else:
+                codes += [f"48;2;{scale[bg_idx][0]};{scale[bg_idx][1]};{scale[bg_idx][2]}"]
+        return ansi.compose(codes)
+
+    return colorcode
+
+
+# RGB Color triples to use in making color scales:
+BLACK = (0, 0, 0)
+WHITE = (255, 255, 255)
+RED = (255, 0, 0)
+GREEN = (0, 255, 0)
+BLUE = (0, 0, 255)
+YELLOW = (255, 255, 0)
+ORANGE = (255, 128, 0)
+CYAN = (0, 255, 255)
+PURPLE = (102, 0, 102)
+MAGENTA = (255, 0, 255)
+
+
+# pylint: disable=invalid-name
+# (0,0,0), (1,1,1), (2,2,2)...(255,255,255):
+GRAYSCALE = colormap_24b([BLACK, WHITE], interp_in_rgb=True)
+
+# More uniform gradation of lightness across the scale:
+GRAYSCALE_LINEAR = colormap_24b([BLACK, WHITE], num_output_colors=512)
+
+# Blue->Red
+BLUE_RED = colormap_24b([BLUE, RED])
+
+RAINBOW = colormap_24b([RED, ORANGE, YELLOW, GREEN, CYAN, BLUE, PURPLE])
+
+REV_RAINBOW = colormap_24b([PURPLE, BLUE, CYAN, GREEN, YELLOW, ORANGE, RED])
+
+# Starting from black, fade into reverse rainbow:
+FADE_IN = colormap_24b([BLACK, PURPLE, BLUE, CYAN, GREEN, YELLOW, ORANGE, RED])
+
+HOT = colormap_24b([BLACK, RED, ORANGE, YELLOW, WHITE])
+
+COOL = colormap_24b([CYAN, MAGENTA])

densitty/util.py

@@ -0,0 +1,234 @@
+"""Utility functions."""
+
+from bisect import bisect_left
+from collections import namedtuple
+from decimal import Decimal
+import math
+from typing import Any, Protocol, Sequence, SupportsFloat
+
+
+class FloatLike[T](SupportsFloat, Protocol):
+    """A Protocol that supports the arithmetic ops we require, and can convert to float"""
+
+    def __lt__(self, __other: T) -> bool: ...
+    def __add__(self, __other: Any) -> T: ...
+    def __sub__(self, __other: Any) -> T: ...
+    def __mul__(self, __other: Any) -> T: ...
+    def __truediv__(self, __other: Any) -> T: ...
+    def __abs__(self) -> T: ...
+
+
+ValueRange = namedtuple("ValueRange", ["min", "max"])
+
+type Vec = Sequence[FloatLike]
+
+
+def clamp(x, min_x, max_x):
+    """Returns the value if within min/max range, else the range boundary."""
+    return max(min_x, min(max_x, x))
+
+
+def clamp_rgb(rgb):
+    """Returns closest valid RGB value"""
+    return tuple(clamp(round(x), 0, 255) for x in rgb)
+
+
+def interp(piecewise: Sequence[Vec], x: float) -> Vec:
+    """Evaluate a piecewise linear function, i.e. interpolate between the two closest values.
+    Parameters
+    ----------
+    piecewise: Sequence[Vec]
+               Evenly spaced function values. piecewise[0] := f(0.0), piecewise[-1] := f(1.0)
+    x:         float
+               value between 0.0 and 1.0
+    returns:   Vec
+               f(x)
+    """
+    max_idx = len(piecewise) - 1
+    float_idx = x * max_idx
+    lower_idx = math.floor(float_idx)
+
+    if lower_idx < 0:
+        return piecewise[0]
+    if lower_idx + 1 > max_idx:
+        return piecewise[-1]
+    frac = float_idx - lower_idx
+    lower_vec = piecewise[lower_idx]
+    upper_vec = piecewise[lower_idx + 1]
+    return tuple(lower * (1.0 - frac) + upper * frac for lower, upper in zip(lower_vec, upper_vec))
+
+
+def nearest(stepwise: Sequence, x: float):
+    """Given a list of function values, return the value closest to the specified point
+    Parameters
+    ----------
+    stepwise: Sequence[Any]
+              Evenly spaced function values. piecewise[0] := f(0.0), piecewise[-1] := f(1.0)
+    x:        float
+              value between 0.0 and 1.0
+    returns:  Any
+              f(x') for x' closest to x in the original sequence
+    """
+    max_idx = len(stepwise) - 1
+    idx = round(x * max_idx)
+
+    clamped_idx = clamp(idx, 0, max_idx)
+    return stepwise[clamped_idx]
+
+
+def decimal_value_range(v: ValueRange | Sequence):
+    """Produce a ValueRange containing Decimal values"""
+    return ValueRange(Decimal(v[0]), Decimal(v[1]))
+
+
+def sfrexp10(value):
+    """Returns sign, base-10 fraction (mantissa), and exponent.
+    i.e. (s, f, e) such that value = s * f * 10 ** e with 0 <= f < 1.0
+    """
+    if value == 0:
+        return 1, 0, -100
+
+    sign = -1 if value < 0 else 1
+
+    v = Decimal(abs(value))
+    exponent = v.adjusted() + 1
+    frac = v.scaleb(-exponent)  # scale frac's exponent to be 0
+
+    return sign, frac, exponent
+
+
+round_fractions = (
+    Decimal(1) / Decimal(10),
+    Decimal(1) / Decimal(8),
+    Decimal(1) / Decimal(6),
+    Decimal(1) / Decimal(5),
+    Decimal(1) / Decimal(4),
+    Decimal(1) / Decimal(3),
+    Decimal(2) / Decimal(5),
+    Decimal(1) / Decimal(2),
+    Decimal(2) / Decimal(3),
+    Decimal(4) / Decimal(5),
+    Decimal(1),
+)
+
+
+def round_up_ish(value, round_fracs=round_fractions):
+    """'Round' the value up to the next highest value in 'round_vals' times a multiple of 10
+
+    Parameters
+    ----------
+    value: input value
+    round_vals: the allowable values (mantissa in base 10)
+    return: the closest round_vals[i] * 10**N equal to or larger than 'value'
+    """
+    sign, frac, exp = sfrexp10(value)
+
+    # if we're passed in a float that can't be represented in binary (say 0.1 or 0.2), it will be
+    # rounded up to the next representable float. Subtract the smallest possible value (ulp) to
+    # so that when we round up, it can match an exact Decimal("0.1") or such:
+    frac -= Decimal(math.ulp(frac))
+
+    idx = bisect_left(round_fracs, frac)  # find index that this would be inserted before (>= frac)
+    round_frac = round_fracs[idx]
+
+    return sign * round_frac.scaleb(exp)
+
+
+def roundness(value):
+    """Metric for how 'round' a value is. 10 is rounder than 1, is rounder than 1.1."""
+
+    # if value is a sequence, combine the roundness of all elements, prioritizing in order:
+    if isinstance(value, Sequence):
+        out, weight = 0, 1
+        for v in value:
+            out += roundness(v) * weight
+            weight *= 0.99
+        return out
+
+    if value == 0:
+        # 0 is the roundest value
+        return 1000  # equivalent to roundness of 1e1000
+    _, frac, exp = sfrexp10(value)
+
+    round_frac = round(frac, 5)  # round to specific # of digits so we can interpret as fraction
+    penalties = {
+        1.00000: 0.0,  # no penalty for multiples of 10
+        0.50000: 0.5,  # penalty for multiple of 5 vs multiple of 10
+        0.25000: 0.6,  # penalty for multiple of 4 vs multiple of 10
+        0.75000: 0.6,  #
+        Decimal("0.33333"): 0.7,  # penalty for multiple of 3 vs multiple of 10
+        Decimal("0.66667"): 0.7,  #
+        0.12500: 0.8,  # penalty for multiple of 8 vs multiple of 10
+        0.37500: 0.8,
+        0.62500: 0.8,
+        0.87500: 0.8,
+    }
+
+    if round_frac in penalties:
+        return exp - penalties[round_frac]
+
+    # Ouch: our fractional part is just not nice, so maximally un-round:
+    return -1000  # equivalent to roundness of 1e-1000
+
+
+def most_round(values):
+    """Pick the most round of the input values. Ties go to the earliest."""
+    best_r = -1e100
+    best_v = 0
+    for v in values:
+        r = roundness(v)
+        if r > best_r:
+            best_r, best_v = r, v
+    return best_v
+
+
+def pick_step_size(value_range, num_steps_hint, min_steps_per_label=1) -> tuple[Decimal, Decimal]:
+    """Try to pick a step size that gives nice round values for step positions.
+    For coming up with nice tick positions for an axis, and with nice bin sizes for binning.
+    For an axis, it is also useful to produce an interval between labeled ticks.
+
+    Parameters
+    ----------
+    value_range: bounds of interval
+    num_steps_hint: approximate number of steps desired for the interval
+    min_steps_per_label: for use with axis/label generation, as labels take more space than ticks
+    return: step size, interval between labeled steps/ticks
+    """
+    num_steps_hint = max(1, num_steps_hint)
+    # if steps are 0,1,2,3,4,5,6... or 0,2,4,6,8,10,... steps_per_label of 5 is sensible,
+    # if steps are 0,5,10,15,20,... steps_per_label of 4 is sensible
+    nominal_step = (value_range.max - value_range.min) / num_steps_hint
+
+    # Figure out the order-of-magnitude (power of 10), aka "decade" of the steps:
+    log_nominal = math.log10(nominal_step)
+    log_decade = math.floor(log_nominal)  # i.e. # of digits
+    decade = Decimal(10) ** log_decade
+
+    # Now figure out where in that decade we are, so we can pick the closest 1/2/5 value
+    log_frac = log_nominal - log_decade  # remainder after decade taken out
+    frac = 10**log_frac  # i.e. fraction through the decade (shift decimal point to front)
+
+    # common-case: label every or every-other, or every 5th, or every 10th
+    if min_steps_per_label <= 2:
+        steps_per_label = min_steps_per_label
+    elif min_steps_per_label <= 5:
+        steps_per_label = 5
+    else:
+        steps_per_label = max(min_steps_per_label, 10)
+
+    if frac < 1.1:
+        step = decade
+    elif frac < 2.2:
+        step = 2 * decade
+        # Steps of .2, don't label every other one
+        if steps_per_label == 2:
+            steps_per_label = 5
+    elif frac < 5.5:
+        step = 5 * decade
+        # ticks every .5, don't label every 5th
+        if steps_per_label == 5:
+            steps_per_label = max(round(min_steps_per_label / 2) * 2, 6)
+    else:
+        step = 10 * decade
+
+    return step, step * steps_per_label

densitty-0.8.2.dist-info/METADATA

@@ -0,0 +1,36 @@
+Metadata-Version: 2.4
+Name: densitty
+Version: 0.8.2
+Summary: densitty - create textual 2-D density plots, heatmaps, and 2-D histograms in Python
+Author: Bill Tompkins
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/BillTompkins/densitty
+Keywords: densitty,ascii,ascii-art,plotting,terminal,Python
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Free Threading :: 3 - Stable
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+<h1 align="center">densitty</h1>
+<h2 align="center"> Terminal-based 2-D Histogram, Density Plots, and Heatmaps</h2>
+
+Generate 2-D histograms (density plots, heat maps, eye diagrams) similar to [matplotlib's hist2d](https://matplotlib.org/stable/gallery/statistics/hist.html "hist2d"), but with output in the terminal, and no external dependencies.
+
+![Plot Output](https://billtompkins.github.io/densitty/docs/inline-histplot2d.png "example output image")
+
+## [Examples/Gallery](https://billtompkins.github.io/densitty/docs/examples.html)
+
+## [Sub-modules / Usage Notes](https://billtompkins.github.io/densitty/docs/usage.html)
+
+## [Color, Size, and Glyph Support](https://billtompkins.github.io/densitty/docs/terminal_support.html)
+
+## API (TODO)

densitty-0.8.2.dist-info/RECORD

@@ -0,0 +1,15 @@
+densitty/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+densitty/ansi.py,sha256=YHagUsCwbyNlOkV2pXJuxolWwjvs1E4hxMnJaohqTfE,3661
+densitty/ascii_art.py,sha256=-MUppQkEeCAqSxdLCfuDRD1NKtzSrJAt2WdJEL56_fI,589
+densitty/axis.py,sha256=XANbgvOltS0XhUvUB9dfUBvybEfOmcjI5xGc2NZDgak,10120
+densitty/binning.py,sha256=LioKw7A0xK_lzUEY2tINiL4fySxVNllxrgh2bD4T9AA,9549
+densitty/detect.py,sha256=LBRUDHxpqLq3p0zRUNS7-3YCBSyclfM0vVy0ZmzSVNs,17725
+densitty/lineart.py,sha256=Qkw_F1QEK9yd0ttNjg62bomIavMPza3pk8w7DA85zWs,4124
+densitty/plot.py,sha256=dxdPRensTxWd9CcD2SbekqAe0iOMcKSKR24wrNc5aCw,8340
+densitty/truecolor.py,sha256=uSrT4Qm0T0ZFwXxm1oyNTrdNCDO7ZfUTI687bX5r-8I,5990
+densitty/util.py,sha256=U0B5RSxQOdq5M6no3OC_buZizAcVjTPwwqKvk4QJ5Rc,7888
+densitty-0.8.2.dist-info/licenses/LICENSE,sha256=LexlQlxS7F07WxcVOOmZAZ_3vReYv0cM8Zg6pTx7_fI,1073
+densitty-0.8.2.dist-info/METADATA,sha256=QK1lEOpas0eZ86enDAObh3bxuS1GoQ_Gmk5X2c6lgpg,1646
+densitty-0.8.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+densitty-0.8.2.dist-info/top_level.txt,sha256=Q50fHzFeZkhO_61VVAIJZyKU44Upacx_blojlLpYqNo,9
+densitty-0.8.2.dist-info/RECORD,,

densitty-0.8.2.dist-info/WHEEL

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

densitty-0.8.2.dist-info/licenses/LICENSE

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

densitty-0.8.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+densitty