densitty 0.9.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

densitty/colorbar.py

@@ -0,0 +1,84 @@
+"""Colorbar generation for density plots."""
+
+from .axis import Axis
+from .plotting import Plot
+
+
+def make_colorbar(
+    source_plot: Plot,
+    label_fmt: str = "{}",
+    vertical: bool = False,
+) -> Plot:
+    """Create a colorbar Plot object from an existing Plot.
+
+    Parameters
+    ----------
+    source_plot : Plot
+        The Plot object to create a colorbar for.
+    label_fmt : str
+        Format string for min/max labels (e.g., "{:.2f}").
+    vertical : bool
+        Vertical/Columnnar bar rather than horizontal/row.
+
+    Returns
+    -------
+    Plot
+        A new Plot object representing the colorbar.
+    """
+    min_value, max_value = source_plot.data_limits()
+
+    color_map = source_plot.color_map
+
+    labels = {
+        min_value: label_fmt.format(min_value),
+        max_value: label_fmt.format(max_value),
+    }
+    axis = Axis(
+        value_range=(min_value, max_value),
+        labels=labels,
+        values_are_edges=False,
+        border_line=False,
+    )
+
+    if vertical:
+        size = len(source_plot.data)  # num rows => height
+        gradient_data = [[i / (size - 1)] for i in range(size)] if size > 1 else [[0.5]]
+    else:
+        size = len(source_plot.data[0])  # num cols => width
+        gradient_data = (
+            [
+                [i / (size - 1) for i in range(size)],
+            ]
+            if size > 1
+            else [[0.5]]
+        )
+
+    if vertical:
+        return Plot(
+            data=gradient_data,
+            color_map=color_map,
+            render_halfheight=source_plot.render_halfheight,
+            font_mapping=source_plot.font_mapping,
+            y_axis=axis,
+            min_data=0,
+            max_data=1,
+            flip_y=True,
+        )
+
+    return Plot(
+        data=gradient_data,
+        color_map=color_map,
+        render_halfheight=source_plot.render_halfheight,
+        font_mapping=source_plot.font_mapping,
+        x_axis=axis,
+        min_data=0,
+        max_data=1,
+        flip_y=False,
+    )
+
+
+def add_colorbar(source_plot: Plot, label_fmt: str = "{}", padding: str = "  ") -> Plot:
+    """Add a vertical colorbar to an existing Plot."""
+    cb = make_colorbar(source_plot, label_fmt, vertical=True)
+    source_plot.glue_on(cb, padding)
+    return source_plot

densitty/detect.py

@@ -9,9 +9,8 @@ from types import MappingProxyType
 from typing import Any, Callable, Optional, Sequence
 import time
 
-from . import ansi, ascii_art, binning, lineart, smoothing, truecolor
-from . import plot as plotmodule
-from .util import FloatLike, ValueRange
+from . import ansi, ascii_art, axis, binning, colorbar, lineart, plotting, smoothing, truecolor
+from .util import FloatLike, ValueRange, make_value_range
 
 if sys.platform == "win32":
     # pylint: disable=import-error
@@ -427,6 +426,24 @@ FADE_IN = MappingProxyType(
     }
 )
 
+RAINBOW = MappingProxyType(
+    {
+        ColorSupport.NONE: ascii_art.EXTENDED,
+        ColorSupport.ANSI_4BIT: ansi.RAINBOW_16,
+        ColorSupport.ANSI_8BIT: ansi.RAINBOW,
+        ColorSupport.ANSI_24BIT: truecolor.RAINBOW,
+    }
+)
+
+REV_RAINBOW = MappingProxyType(
+    {
+        ColorSupport.NONE: ascii_art.EXTENDED,
+        ColorSupport.ANSI_4BIT: ansi.REV_RAINBOW_16,
+        ColorSupport.ANSI_8BIT: ansi.REV_RAINBOW,
+        ColorSupport.ANSI_24BIT: truecolor.REV_RAINBOW,
+    }
+)
+
 
 def pick_colormap(maps: dict[ColorSupport, Callable]) -> Callable:
     """Detect color support and pick the best color map"""
@@ -434,21 +451,33 @@ def pick_colormap(maps: dict[ColorSupport, Callable]) -> Callable:
     return maps[support]
 
 
-def plot(data, colors=FADE_IN, **plotargs):
-    """Wrapper for plot.Plot that picks colormap from dict"""
+def plot(data, colors=FADE_IN, colorscale=False, **plotargs):
+    """Wrapper for plot.Plot that picks colormap from dict
+
+    Parameters
+     ----------
+     data : Sequence[Sequence[float]]
+            The data to be plotted.
+     colors : Dict mapping color support to color map
+            The color scale (e.g. GRAYSCALE, FADE_IN)
+     colorscale: bool
+            Display a vertical color scale on the right
+            (for horizontal, just directly create a colorbar
+              and output it after outputting the plot)
+     plotargs: any Plot() keyword arguments
+    """
     colormap = pick_colormap(colors)
-    return plotmodule.Plot(data, colormap, **plotargs)
+    the_plot = plotting.Plot(data, colormap, **plotargs)
+    if colorscale:
+        colorbar.add_colorbar(the_plot)
+    return the_plot
 
 
 def histplot2d(
     points: Sequence[tuple[FloatLike, FloatLike]],
-    bins: (
-        int
-        | tuple[int, int]
-        | Sequence[FloatLike]
-        | tuple[Sequence[FloatLike], Sequence[FloatLike]]
-    ) = 10,
+    bins: binning.FullBinsArg = None,
     ranges: Optional[tuple[Optional[ValueRange], Optional[ValueRange]]] = None,
+    bin_size: Optional[FloatLike | tuple[FloatLike, FloatLike]] = None,
     align=True,
     drop_outside=True,
     colors=FADE_IN,
@@ -461,8 +490,9 @@ def histplot2d(
     """Wrapper for binning.histogram2d / plot.Plot to simplify 2-D histogram plotting"""
     binned_data, x_axis, y_axis = binning.histogram2d(
         points,
-        bins,
+        bins=bins,
         ranges=ranges,
+        bin_size=bin_size,
         align=align,
         drop_outside=drop_outside,
         border_line=border_line,
@@ -472,7 +502,7 @@ def histplot2d(
     if scale is True:
         p.upscale()
     elif scale:
-        p.upscale(max_expansion=(scale, scale))
+        p.upscale(max_expansion=scale)
 
     return p
 
@@ -480,12 +510,7 @@ def histplot2d(
 def densityplot2d(
     points: Sequence[tuple[FloatLike, FloatLike]],
     kernel: Optional[smoothing.SmoothingFunc] = None,
-    bins: (
-        int
-        | tuple[int, int]
-        | Sequence[FloatLike]
-        | tuple[Sequence[FloatLike], Sequence[FloatLike]]
-    ) = 0,
+    bins: binning.FullBinsArg = None,
     ranges: Optional[tuple[Optional[ValueRange], Optional[ValueRange]]] = None,
     align=True,
     colors=FADE_IN,
@@ -496,11 +521,11 @@ def densityplot2d(
 ):
     """Wrapper for smoothing.smooth2d / plot.Plot to simplify 2-D density plots"""
 
-    if bins == 0:
+    if not bins:
         try:
             terminal_size: Optional[os.terminal_size] = os.get_terminal_size()
         except OSError:
-            terminal_size = plotmodule.default_terminal_size
+            terminal_size = plotting.default_terminal_size
         if terminal_size is None:
             raise OSError("No terminal size from os.get_terminal_size()")
         size_x = terminal_size.columns - 10
@@ -508,7 +533,16 @@ def densityplot2d(
         bins = (size_x, size_y)
 
     if kernel is None:
-        x_width, y_width = smoothing.pick_kernel_bandwidth(points, bins=(size_x, size_y))
+        _, num_bins, bin_centers = binning.expand_bins_arg(bins)
+        if bin_centers:
+            # we were given a list of bin centers, so generate bounds from that:
+            x_bin_range = make_value_range((bin_centers[0][0], bin_centers[0][-1]))
+            y_bin_range = make_value_range((bin_centers[1][0], bin_centers[1][-1]))
+            x_width, y_width = smoothing.pick_kernel_bandwidth(
+                points, bins=num_bins, ranges=(x_bin_range, y_bin_range)
+            )
+        else:
+            x_width, y_width = smoothing.pick_kernel_bandwidth(points, bins=num_bins)
         kernel = smoothing.gaussian_with_sigmas(x_width, y_width)
 
     smoothed, x_axis, y_axis = smoothing.smooth2d(
@@ -523,3 +557,27 @@ def densityplot2d(
     p = plot(smoothed, colors, x_axis=x_axis, y_axis=y_axis, **plotargs)
 
     return p
+
+
+def grid_heatmap(data, x_labels, y_labels, colors=REV_RAINBOW, max_cell_size=0, **plotargs):
+    """Create a grid-style heatmap, with explicit X and Y labels for each bin"""
+    if max_cell_size == 0:
+        max_x_label = max(len(x) for x in x_labels)
+        max_cell_size = max_x_label + 2
+
+    num_rows = len(data)
+    num_cols = len(data[0])
+    if y_labels and len(y_labels) != num_rows:
+        raise ValueError("Number of Y labels does not match number of rows")
+    if x_labels and len(x_labels) != num_cols:
+        raise ValueError("Number of X labels does not match number of columns")
+
+    # value range along axis is arbitrary, but is needed to locate the labels along the axis
+    # so just use integers 0..N-1
+    x_axis = axis.Axis((0, num_cols - 1), dict(enumerate(x_labels)))
+    y_axis = axis.Axis((0, num_rows - 1), dict(enumerate(y_labels)))
+
+    plt = plot(data, colors=colors, x_axis=x_axis, y_axis=y_axis, flip_y=False, **plotargs)
+    plt.upscale(max_expansion=max_cell_size)
+
+    return plt

densitty/{plot.py → plotting.py}

@@ -37,6 +37,14 @@ class Plot:
     x_axis: Optional[Axis] = None
     y_axis: Optional[Axis] = None
     flip_y: bool = True  # put the first row of data at the bottom of the output
+    to_right: Optional["Plot" | Sequence[str]] = None
+    right_padding: Optional[str] = None
+
+    def data_limits(self):
+        """Return (min,max) of the plot data."""
+        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
+        return (min_data, max_data)
 
     def as_ascii(self):
         """Output using direct characters (ASCII-art)."""
@@ -73,8 +81,7 @@ class Plot:
         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
+        min_data, max_data = self.data_limits()
         data_scale = max_data - min_data
         if data_scale == 0:
             # all data has the same value (or we were told it does)
@@ -91,6 +98,17 @@ class Plot:
         """Are there two pixels per output character?"""
         return self.is_color() and self.render_halfheight
 
+    def left_margin(self):
+        """Returns the column of the first plotted data"""
+        if self.y_axis:
+            if self.is_halfheight():
+                num_rows = (len(self.data) + 1) // 2
+            else:
+                num_rows = len(self.data)
+            y_axis_lines = self.y_axis.render_as_y(num_rows, False, False, False)
+            return lineart.display_len(y_axis_lines[0])
+        return 0
+
     def as_strings(self):
         """Scale data to 0..1 range and feed it through the appropriate output function"""
         if self.is_halfheight():
@@ -115,13 +133,24 @@ class Plot:
             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
+        if isinstance(self.to_right, Plot):
+            lines_to_right = self.to_right.as_strings()
+        elif self.to_right is not None:
+            lines_to_right = self.to_right
+        else:
+            lines_to_right = []
+
+        padding = self.right_padding if self.right_padding is not None else ""
+
+        for frame, plot_line, glued_on in zip_longest(
+            axis_lines, plot_lines, lines_to_right, fillvalue=""
+        ):
+            yield frame.translate(self.font_mapping) + plot_line + padding + glued_on
 
-    def show(self, printer=print):
+    def show(self, prefix="", printer=print):
         """Simple helper function to output/print a plot"""
         for line in self.as_strings():
-            printer(line)
+            printer(prefix + line)
 
     def _compute_scaling_multipliers(
         self,
@@ -164,24 +193,29 @@ class Plot:
 
     def upscale(
         self,
-        max_size: tuple[int, int] = (0, 0),
-        max_expansion: tuple[int, int] = (3, 3),
-        keep_aspect_ratio: bool = False,
+        max_size: int | tuple[int, int] = 0,
+        max_expansion: int | tuple[int, int] = 3,
+        keep_aspect_ratio: bool = True,
     ):
         """Scale up 'data' by repeating lines and values within lines.
 
         Parameters
         ----------
-        max_size : tuple (int, int)
+        max_size : int or 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
+        max_expansion : int or tuple (int, int)
+                   maximum expansion factor in each direction. Default (3,3). None=> No maximum
         keep_aspect_ratio : bool
                    Require that X and Y scaling are equal.
         """
+        if isinstance(max_size, int):
+            max_size = (max_size, max_size)
+
+        if isinstance(max_expansion, int) or max_expansion is None:
+            max_expansion = (max_expansion, max_expansion)
 
         float_mult = self._compute_scaling_multipliers(max_size, keep_aspect_ratio)
         col_mult = max(int(float_mult[0]), 1)
@@ -206,4 +240,20 @@ class Plot:
 
         # repeat each of those by the row multiplier
         self.data = repeat_each(x_expanded, row_mult)
+
+        # If we have axes, adjust for the new pixel/bin size
+        if self.x_axis:
+            self.x_axis.upscale(len(self.data[0]), col_mult)
+
+        if self.y_axis:
+            self.y_axis.upscale(len(self.data), row_mult)
+
+        # if we have a glued-on plot to the right (likely a colorbar), scale it up in Y to match
+        if isinstance(self.to_right, Plot):
+            self.to_right.upscale(max_size=0, max_expansion=(1, col_mult), keep_aspect_ratio=False)
         return self
+
+    def glue_on(self, to_right, padding="  "):
+        """Add lines or another plot to the right of this one."""
+        self.right_padding = padding
+        self.to_right = to_right

densitty/smoothing.py

@@ -5,8 +5,14 @@ import math
 from typing import Callable, Optional, Sequence
 
 from .axis import Axis
-from .binning import expand_bins_arg, histogram2d, process_bin_args
-from .util import FloatLike, ValueRange, partial_first, partial_second
+from .binning import (
+    FullBinsArg,
+    calc_value_range,
+    expand_bins_arg,
+    histogram2d,
+    segment_interval,
+)
+from .util import FloatLike, ValueRange, make_decimal, partial_first, partial_second
 
 BareSmoothingFunc = Callable[[FloatLike, FloatLike], FloatLike]
 
@@ -57,43 +63,6 @@ def gaussian_with_sigmas(sigma_x, sigma_y) -> SmoothingFunc:
     return gaussian_with_inv_cov(inv_cov)
 
 
-def covariance(points: Sequence[tuple[FloatLike, FloatLike]]):
-    """Calculate the covariance matrix of a list of points"""
-    num = len(points)
-    xs = tuple(x for x, _ in points)
-    ys = tuple(y for _, y in points)
-    mean_x = sum(xs) / num
-    mean_y = sum(ys) / num
-    cov_xx = sum((x - mean_x) ** 2 for x in xs) / num
-    cov_yy = sum((y - mean_y) ** 2 for y in ys) / num
-    cov_xy = sum((x - mean_x) * (y - mean_y) for x, y in points) / num
-    return ((cov_xx, cov_xy), (cov_xy, cov_yy))
-
-
-def kde(points: Sequence[tuple[FloatLike, FloatLike]]):
-    """Kernel for Kernel Density Estimation
-    Note that the resulting smoothing function is quite broad, since the
-    covariance estimate converges very slowly.
-
-    This may make sense to use if the distribution of points is itself a
-    Gaussian, but makes much less sense if it has any internal structure,
-    as that will all get smoothed out.
-    """
-    # From Scott's rule / Silverman's factor: Bandwidth is n**(-1/6)
-    # That is to scale the std deviation (characteristic width)
-    # We're using the square of that: (co)variance, so scale by n**(-1/3)
-    # And invert to get something we can pass to the gaussian func
-    cov = covariance(points)
-    scale = len(points) ** (1 / 3)
-    scaled_det = scale * (cov[0][0] * cov[1][1] - cov[1][0] * cov[0][1])
-    inv_scaled_cov = (
-        (cov[1][1] / scaled_det, -cov[0][1] / scaled_det),
-        (-cov[1][0] / scaled_det, cov[0][0] / scaled_det),
-    )
-
-    return gaussian_with_inv_cov(inv_scaled_cov)
-
-
 def triangle(width_x, width_y) -> SmoothingFunc:
     """Produce a kernel function for a 2-D triangle with specified width/height
     This is much cheaper computationally than the Gaussian, and gives decent results.
@@ -142,6 +111,17 @@ def pick_kernel_bandwidth(
     if bins[0] <= 0 or bins[1] <= 0:
         raise ValueError("Number of bins must be nonzero")
 
+    # we'll reduce the number of bins gradually until we get the right smoothness
+    # track the number of bins in each direction as a float, so we can maintain the
+    # aspect ratio without roundoff error accumulating:
+    float_bins: tuple[float, float] = bins
+
+    # bin_step: how much we reduce the # of bins by each iteration.
+    # 1.0 in the larger direction, a fraction in the smaller direction:
+    if bins[0] > bins[1]:
+        bin_step = (1.0, (bins[1] / bins[0]))
+    else:
+        bin_step = ((bins[0] / bins[1]), 1.0)
     while bins[0] > 0 and bins[1] > 0:
         binned, x_axis, y_axis = histogram2d(points, bins, ranges, align=False)
         nonzero_bins = [b for row in binned for b in row if b > 0]
@@ -149,13 +129,14 @@ def pick_kernel_bandwidth(
         test_val = sorted(nonzero_bins)[test_pos]
         if test_val >= smoothness:
             break
-        bins = (bins[0] - 1, bins[1] - 1)
+        float_bins = (float_bins[0] - bin_step[0], float_bins[1] - bin_step[1])
+        bins = (round(float_bins[0]), round(float_bins[1]))
     else:
         # We never managed to get 'smoothness' per bin, so just give up and smooth a lot
-        bins = (1, 1)
+        float_bins = (1, 1)
 
-    x_width = float(x_axis.value_range.max - x_axis.value_range.min) / bins[0] / 4
-    y_width = float(y_axis.value_range.max - y_axis.value_range.min) / bins[1] / 4
+    x_width = float(x_axis.value_range.max - x_axis.value_range.min) / float_bins[0] / 4
+    y_width = float(y_axis.value_range.max - y_axis.value_range.min) / float_bins[1] / 4
 
     return (x_width, y_width)
 
@@ -226,7 +207,7 @@ def smooth_to_bins(
     x_centers: Sequence[FloatLike],
     y_centers: Sequence[FloatLike],
 ) -> Sequence[Sequence[float]]:
-    """Bin points into a 2-D histogram given bin edges
+    """Generate smoothed/density values over a grid, given data points and a kernel
 
     Parameters
     ----------
@@ -263,15 +244,16 @@ def smooth_to_bins(
     return out
 
 
+def pad_range(range_unpadded: ValueRange, padding: FloatLike):
+    """Add padding to both sides of a ValueRange"""
+    range_padding = make_decimal(padding)
+    return ValueRange(range_unpadded.min - range_padding, range_unpadded.max + range_padding)
+
+
 def smooth2d(
     points: Sequence[tuple[FloatLike, FloatLike]],
     kernel: SmoothingFunc,
-    bins: (
-        int
-        | tuple[int, int]
-        | Sequence[FloatLike]
-        | tuple[Sequence[FloatLike], Sequence[FloatLike]]
-    ) = 10,
+    bins: FullBinsArg = None,
     ranges: Optional[tuple[Optional[ValueRange], Optional[ValueRange]]] = None,
     align=True,
     **axis_args,
@@ -288,29 +270,45 @@ def smooth2d(
                 (int,int): number of columns (X), rows (Y)
                 list[float]: Column/Row centers
                 (list[float], list[float]): column centers for X, column centers for Y
+                Default: binning.DEFAULT_NUM_BINS
     ranges: Optional (ValueRange, ValueRange)
                 ((x_min, x_max), (y_min, y_max)) for the row/column centers if 'bins' is int
                 Default: take from data min/max, with buffer based on kernel width
     align: bool (default: True)
                 pick bin edges at 'round' values if # of bins is provided
-    drop_outside: bool (default: True)
-                True: Drop any data points outside the ranges
-                False: Put any outside points in closest bin (i.e. edge bins include outliers)
     axis_args: Extra arguments to pass through to Axis constructor
 
     returns: Sequence[Sequence[int]], (x-)Axis, (y-)Axis
     """
 
-    expanded_bins = expand_bins_arg(bins)
+    _, num_bins, bin_centers = expand_bins_arg(bins)
 
-    if isinstance(expanded_bins[0], Sequence):
-        # we were given the bin centers, so just use them
-        padding: tuple[FloatLike, FloatLike] = (0, 0)
+    if bin_centers and ranges:
+        # First and last bin centers imply a range, which may be inconsistent
+        # with the passed-in ranges. Only supply one or the other.
+        raise ValueError("Both 'ranges' and bin centers provided")
+
+    if bin_centers:
+        x_centers, y_centers = bin_centers
     else:
-        # we're computing the bin centers, so include some padding based on kernel width
+        # No centers, just number of bins, and maybe user-specified ranges
+        if ranges:
+            x_range, y_range = ranges
+        else:
+            x_range, y_range = None, None
+        # if we use a range based on the min/max of the data, we also
+        # include some padding based on the half-width of the kernel
         padding = func_width_half_height(kernel)
+        if not x_range:
+            x_range = calc_value_range(tuple(x for x, _ in points))
+            x_range = pad_range(x_range, padding[0])
+        if not y_range:
+            y_range = calc_value_range(tuple(y for _, y in points))
+            y_range = pad_range(y_range, padding[1])
+
+        x_centers = segment_interval(num_bins[0], x_range, align)
+        y_centers = segment_interval(num_bins[1], y_range, align)
 
-    x_centers, y_centers = process_bin_args(points, expanded_bins, ranges, align, padding)
     x_axis = Axis((x_centers[0], x_centers[-1]), values_are_edges=False, **axis_args)
     y_axis = Axis((y_centers[0], y_centers[-1]), values_are_edges=False, **axis_args)
 

densitty/util.py

@@ -6,11 +6,10 @@ import math
 import typing
 
 from bisect import bisect_left
-from decimal import Decimal, BasicContext
+from decimal import BasicContext, Decimal, DecimalTuple
 from fractions import Fraction
 from typing import Any, Callable, NamedTuple, Sequence
 
-
 # FloatLike and Vec are defined in the stubs file util.pyi for type checking
 # At runtime, define as Any so older Python versions don't choke:
 if not typing.TYPE_CHECKING:
@@ -86,6 +85,30 @@ def make_decimal(x: FloatLike) -> Decimal:
     return BasicContext.create_decimal_from_float(float(x))
 
 
+def sanitize_decimals(values: Sequence[Decimal]) -> Sequence[Decimal]:
+    """Strip trailing "0"s if all values in the list have the trailing "0"s
+    So [1.000, 2.000] becomes [1, 2]"""
+    if not values:
+        return []
+
+    as_tuples = [v.as_tuple() for v in values]
+    cur_exponent = as_tuples[0].exponent
+    if not all(t.exponent == cur_exponent for t in as_tuples):
+        # inconsistent exponent: just return them as is
+        return values
+    while cur_exponent < 0 and all(t.digits[-1] == 0 for t in as_tuples):
+        # all values have a trailing 0. Remove, and add a leading 0 to prevent (0,) from vanishing:
+        as_tuples = [
+            DecimalTuple(t.sign, (0,) + t.digits[:-1], cur_exponent + 1) for t in as_tuples
+        ]
+        cur_exponent += 1
+
+    as_decimals = (Decimal(t) for t in as_tuples)
+
+    # zero values may be something like "0E8" or "0E-2". Make them just be "0":
+    return [d if d != 0 else Decimal(0) for d in as_decimals]
+
+
 def make_value_range(v: ValueRange | Sequence[FloatLike]) -> ValueRange:
     """Produce a ValueRange from from something that may be a sequence of FloatLikes"""
     return ValueRange(make_decimal(v[0]), make_decimal(v[1]))

densitty/util.pyi

@@ -24,6 +24,7 @@ def clamp_rgb(rgb): ...
 def interp(piecewise: Sequence[Vec], x: float) -> Vec: ...
 def nearest(stepwise: Sequence, x: float): ...
 def make_decimal(x: FloatLike) -> Decimal: ...
+def sanitize_decimals(values: Sequence[Decimal]) -> Sequence[Decimal]: ...
 def make_value_range(v: ValueRange | Sequence[FloatLike]) -> ValueRange: ...
 def partial_first(f: Callable[[FloatLike, FloatLike], FloatLike]) -> Callable: ...
 def partial_second(f: Callable[[FloatLike, FloatLike], FloatLike]) -> Callable: ...

{densitty-0.9.0.dist-info → densitty-1.0.0.dist-info}/METADATA

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: densitty
-Version: 0.9.0
+Version: 1.0.0
 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: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console
 Classifier: Operating System :: OS Independent
 Classifier: Intended Audience :: Developers
@@ -24,7 +24,7 @@ License-File: LICENSE
 Dynamic: license-file
 
 <h1 align="center">densitty</h1>
-<h2 align="center"> Terminal-based 2-D Histogram, Density Plots, and Heatmaps</h2>
+<h2 align="center">Terminal-based 2-D Histogram, Density Plots, and Heatmaps in Python</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.
 
@@ -32,8 +32,10 @@ Generate 2-D histograms (density plots, heat maps, eye diagrams) similar to [mat
 
 ## [Examples/Gallery](https://billtompkins.github.io/densitty/docs/examples.html)
 
-## [Sub-modules / Usage Notes](https://billtompkins.github.io/densitty/docs/usage.html)
+## [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](https://billtompkins.github.io/densitty/docs/api.html)
+
+## [GitHub](https://github.com/BillTompkins/densitty/tree/main)

densitty-1.0.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+densitty/__init__.py,sha256=BeG85uFYNLaO6TaG-Q1zWgllq9SJfgH1fyKTixSz3Lw,336
+densitty/ansi.py,sha256=fm6yHRszx0sF-inGurtxC_-TL0dvePLcSQ8r-Okm20w,3660
+densitty/ascii_art.py,sha256=-MUppQkEeCAqSxdLCfuDRD1NKtzSrJAt2WdJEL56_fI,589
+densitty/axis.py,sha256=1yv3ohhzF7hICGu8dB3zluD5i0U7-X9E8A2TxzJMgSU,17372
+densitty/binning.py,sha256=6r0NCMKVs6lGl_7Uec4WXuI0yYDHYqkuyjKsOx2burk,13343
+densitty/colorbar.py,sha256=63XIm-KQm1Dzh_vp5rgU7fmsIdcgfmfEKjQJdll8FEU,2247
+densitty/detect.py,sha256=tARq3Uhv_r8V4Xtjvdnbgq16esKdzXzOJCKZb1eu3MI,22241
+densitty/lineart.py,sha256=Qkw_F1QEK9yd0ttNjg62bomIavMPza3pk8w7DA85zWs,4124
+densitty/plotting.py,sha256=u8GJQIHECpR-ayDDirabVAZS9Mrw9rxIYgnC2wK83e8,10427
+densitty/smoothing.py,sha256=r-fjRQmEO9OZxBN7Y5f1FFzUGPh0OYixHM6AUt1Rui4,12284
+densitty/truecolor.py,sha256=6UDLJRUKP8rProemJyfSIgtZ5IdB1v8R_PV41fW6CjA,6016
+densitty/util.py,sha256=nCVQAUNNK6VrG32GmqJ7ZU2OeWcWDpD_vMmGCe2llqU,8291
+densitty/util.pyi,sha256=3nELig5yUy6b_cxb-3tjEIzmWHFNa7DX5sf3RGd0p-k,1436
+densitty-1.0.0.dist-info/licenses/LICENSE,sha256=LexlQlxS7F07WxcVOOmZAZ_3vReYv0cM8Zg6pTx7_fI,1073
+densitty-1.0.0.dist-info/METADATA,sha256=Ugrt_V4ljCRkjn5ipr87lxpvxS5i91IDqrqbW_xSMIU,1922
+densitty-1.0.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+densitty-1.0.0.dist-info/top_level.txt,sha256=Q50fHzFeZkhO_61VVAIJZyKU44Upacx_blojlLpYqNo,9
+densitty-1.0.0.dist-info/RECORD,,