hammock-plot 1.1.0__tar.gz → 1.2.0__tar.gz

{hammock_plot-1.1.0 → hammock_plot-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hammock-plot
-Version: 1.1.0
+Version: 1.2.0
 Summary: Hammock plot visualization for categorical and mixed categorical-continuous data
 Author-email: Tiancheng Yang <t77yang@uwaterloo.ca>, Sandra Huang <sandra.huang@uwaterloo.ca>, Matthias Schonlau <schonlau@uwaterloo.ca>
 License: MIT

{hammock_plot-1.1.0 → hammock_plot-1.2.0}/README.md

@@ -121,7 +121,7 @@ hammock = hammock_plot.Hammock(data_df = df)
 ax = hammock.plot(var=var, 
         missing=True, 
         numerical_var_levels={"sataces": None, "satcomm": None, "satrate": None}, 
-        min_bar_height=0.2, 
+        min_bar_height_unibar=0.2, 
         uni_vfill=0.3) 
 ```
 
@@ -265,7 +265,8 @@ ax = hammock.plot(
 | |              `width` |  `float`  |  Width of the plot in inches. Default is 15. Caution: Width too narrow may distort the plot. |
 | Other options |              `shape` |  `str`  | Shape of the boxes. "rectangle" or "parallelogram". Default is "rectangle". |
 | |              `same_scale` |  `List[str]`  | List of variables that have the same scale. Default is `None`. |
-| |              `min_bar_height` | `float` | Minimal bar height of unibars (connectors are unchanged). Bars representing only a tiny fraction of the data may be so narrow, that they are invisible in a plot. The default value tries to ensure this does not happen.  Default is 0.1.
+| |              `min_bar_height_unibar` | `float` | Minimal drawn height of a unibar. Bars representing only a tiny fraction of the data may be so narrow that they are invisible in a plot; this sets an absolute floor on their thickness. With `hi_box="stacked"`, each colour segment within a unibar is also kept at least this tall (by trading height with the larger segments, so the bar height and layout are unchanged), keeping a colour visible even when it is a tiny share of the bar. The default value tries to ensure this does not happen. Default is 0.15 (0.15% of the entire plot height).
+| |              `min_bar_height_connectors` | `float` | Minimal drawn thickness of a connector (independent of `connector_fraction`). Like `min_bar_height_unibar` but for the connectors between unibars. Default is 0.12 (0.12% of the entire plot height).
 | |              `display_figure` |  `bool`  | Whether or not to display the figure. This can be useful if you just want to save the plots. Default is `True`. |
 | |              `save_path` |  `str`  |   If it is not `None`, the figure will be saved to the given path with given name and format. Default is `None`. |
 | |             `violin_bw_method` | `str` or `float` | Specifies the bw method used to plot a violin plot. See https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.violinplot.html for more details. |

{hammock_plot-1.1.0 → hammock_plot-1.2.0}/hammock_plot/figure.py

@@ -26,7 +26,7 @@ class Figure:
         var_types:
         - Dict of the types of each variable. Either: np.str_, np.floating, or np.integer
 
-        numerical_var_levels, display_type, missing, missing_placeholder, label, unibar, hi_box, width, height, uni_vfill, connector_fraction, min_bar_height, uni_hfill, label_options, shape_type, same_scale, violin_bw_method: refer to README file
+        numerical_var_levels, display_type, missing, missing_placeholder, label, unibar, hi_box, width, height, uni_vfill, connector_fraction, min_bar_height_unibar, min_bar_height_connectors, uni_hfill, label_options, shape_type, same_scale, violin_bw_method: refer to README file
     """
     def __init__(self,
                 # general
@@ -50,7 +50,8 @@ class Figure:
                 height: float,
                 uni_vfill: float,
                 connector_fraction: float,
-                min_bar_height: float,
+                min_bar_height_unibar: float,
+                min_bar_height_connectors: float,
                 uni_hfill: float,
 
                 # Other
@@ -79,7 +80,8 @@ class Figure:
         self.height = height # height of the entire plot
         self.uni_vfill = uni_vfill
         self.connector_fraction = connector_fraction
-        self.min_bar_height = min_bar_height
+        self.min_bar_height_unibar = min_bar_height_unibar
+        self.min_bar_height_connectors = min_bar_height_connectors
         self.uni_hfill = uni_hfill
         
         self.label_options = label_options
@@ -155,7 +157,7 @@ class Figure:
                 missing=self.missing,
                 missing_placeholder=self.missing_placeholder,
                 val_order=order,
-                min_bar_height=self.min_bar_height,
+                min_bar_height=self.min_bar_height_unibar,
                 colors=self.colors,
                 hi_box=self.hi_box,
                 display_type = uni_display_type,
@@ -235,7 +237,7 @@ class Figure:
 
             max_missing_height = max_missing_occ * self.bar_unit
 
-            missing_padding = (max(self.min_bar_height, max_missing_height) + Defaults.SPACE_ABOVE_MISSING)
+            missing_padding = (max(self.min_bar_height_unibar, max_missing_height) + Defaults.SPACE_ABOVE_MISSING)
 
         # if there are horizontal bar charts, calculate the bar unit differently.
         max_num_categories = 0
@@ -250,7 +252,7 @@ class Figure:
                 max_val_occ = max(max_val_occ, max(val.occurrences for val in uni.values))
                 max_num_categories = max(max_num_categories, len(uni.non_missing_vals))
         if max_num_categories > 0:
-            hbar_height = max(max_val_occ * self.bar_unit, self.min_bar_height)
+            hbar_height = max(max_val_occ * self.bar_unit, self.min_bar_height_unibar)
             # if the horizontal bar charts overlap
             available_height = (self.height - 2 * self.ymargin * self.height) * self.scale
         
@@ -260,15 +262,14 @@ class Figure:
                 self.bar_unit = (available_height * self.uni_vfill) / (max_val_occ * max_num_categories)
                 if self.missing:
                     self.bar_unit = self.bar_unit / (1 + max_missing_occ * self.uni_vfill)
-                    max_missing_height = max_missing_occ * self.bar_unit
-                
+
                 nonmissing_height = available_height
                 if self.missing:
                     max_missing_height = max_missing_occ * self.bar_unit
-                    missing_padding = (max(self.min_bar_height, max_missing_height) + Defaults.SPACE_ABOVE_MISSING)
+                    missing_padding = (max(self.min_bar_height_unibar, max_missing_height) + Defaults.SPACE_ABOVE_MISSING)
                     nonmissing_height -= missing_padding
                 
-                hbar_height = max(nonmissing_height * self.uni_vfill / max_num_categories, self.min_bar_height)
+                hbar_height = max(nonmissing_height * self.uni_vfill / max_num_categories, self.min_bar_height_unibar)
 
         # set bar_unit in unibars, set missing_padding in unibars, set hbar heights, set unibar widths
         for uni in self.unibars:
@@ -284,18 +285,20 @@ class Figure:
             # Determine ranges for unibars that should use same_scale
             global_range = None
             if same_scale:
-                # Collect all numeric values across the same_scale group
-                combined_vals = []
+                # Take the min/max across the same_scale group column-by-column
+                # (vectorised) rather than gathering every value into one list.
+                global_min, global_max = None, None
                 for uni_name in same_scale:
-                    uni_series = self.data_df[uni_name]
-                    numeric_vals = pd.to_numeric(uni_series, errors="coerce").dropna()
-                    combined_vals.extend(numeric_vals.tolist())
+                    numeric_vals = pd.to_numeric(self.data_df[uni_name], errors="coerce").dropna()
+                    if numeric_vals.empty:
+                        continue
+                    col_min, col_max = numeric_vals.min(), numeric_vals.max()
+                    global_min = col_min if global_min is None else min(global_min, col_min)
+                    global_max = col_max if global_max is None else max(global_max, col_max)
 
-                if combined_vals:
-                    global_min, global_max = min(combined_vals), max(combined_vals)
+                if global_min is not None:
                     # Assign the same global range to all unibars in same_scale
-                    for uni_name in same_scale:
-                        global_range = (global_min, global_max)
+                    global_range = (global_min, global_max)
                 
                 # set variables so that same_scale variables align with each other.
                 # Only unibars whose display draws a *value-specific bar* at min/max
@@ -406,11 +409,9 @@ class Figure:
             uni.draw(
                 ax,
                 rectangle_painter=rect_painter,
-                y_start=self.y_start,
-                y_end=self.y_end,
                 alpha=alpha,
             )
-        
+
         return ax
 
     def draw_connections(self, alpha, color, ax=None):
@@ -538,7 +539,11 @@ class Figure:
 
                 left_center_pts.append((lx, ly))
                 right_center_pts.append((rx, ry))
-                heights.append(total_cnt * self.bar_unit * self.connector_fraction)
+                # min_bar_height_connectors floors the drawn thickness only (not the
+                # stacking math above), so a too-thin connector stays centred but renders
+                # visibly. The floor is absolute - independent of connector_fraction.
+                h = total_cnt * self.bar_unit * self.connector_fraction
+                heights.append(max(h, self.min_bar_height_connectors))
                 weights.append(wts)
 
             if left_center_pts:

{hammock_plot-1.1.0 → hammock_plot-1.2.0}/hammock_plot/main.py

@@ -5,9 +5,10 @@ import matplotlib.pyplot as plt
 from hammock_plot.figure import Figure
 from hammock_plot.utils import Defaults
 import numpy as np
-from hammock_plot.utils import safe_numeric, validate_expression, resolve_ordering, assign_color_index, get_formatted_label
+from hammock_plot.utils import safe_numeric, validate_expression, resolve_ordering, assign_color_index, get_formatted_label, clamp_unit
 import warnings
 
+
 class Hammock:
     """
         Initializes a Hammock plot with dataframe 
@@ -45,7 +46,8 @@ class Hammock:
              label_options: dict = None,
              height: float = 10,
              width: float = 15,
-             min_bar_height: float = Defaults.MIN_BAR_HEIGHT,
+             min_bar_height_unibar: float = Defaults.MIN_BAR_HEIGHT_UNIBAR,
+             min_bar_height_connectors: float = Defaults.MIN_BAR_HEIGHT_CONNECTORS,
              alpha: float = Defaults.ALPHA,
 
              # Other
@@ -94,36 +96,20 @@ class Hammock:
                     f'The weight variable {weights} must be numeric.'
                 )
 
-            for idx, val in self.data_df[weights].items():
-                if val <= 0:
-                    raise ValueError(
-                        f'There is a nonpositive variable in {weights}. This is not allowed.'
-                    )
+            if (self.data_df[weights] <= 0).any():
+                raise ValueError(
+                    f'There is a nonpositive variable in {weights}. This is not allowed.'
+                )
             
             
-        if uni_hfill < 0:
-            warnings.warn("uni_hfill < 0. Value has been clamped to 0.")
-            uni_hfill = 0
-        elif uni_hfill > 1:
-            warnings.warn("uni_hfill > 1. Value has been clamped to 1.")
-            uni_hfill = 1
+        uni_hfill = clamp_unit(uni_hfill, "uni_hfill")
 
         if uni_hfill == 1:
             warnings.warn("Tip: To leave a bit of a gap between the univariate bars, set uni_hfill to something close to 1 but not quite one (ex 0.9)")
-        
-        if uni_vfill < 0:
-            warnings.warn("uni_vfill < 0. Value has been clamped to 0.")
-            uni_vfill = 0
-        elif uni_vfill > 1:
-            warnings.warn("uni_vfill > 1. Value has been clamped to 1.")
-            uni_vfill = 1
-
-        if alpha < 0:
-            warnings.warn("alpha < 0. Value has been clamped to 0.")
-            alpha = 0
-        elif alpha > 1:
-            warnings.warn("alpha > 1. Value has been clamped to 1.")
-            alpha = 1
+
+        uni_vfill = clamp_unit(uni_vfill, "uni_vfill")
+
+        alpha = clamp_unit(alpha, "alpha")
 
         # drop missing values if missing values should not be plotted
         if not missing:
@@ -144,7 +130,7 @@ class Hammock:
                     var_types[varname] = np.integer
                 else:
                     var_types[varname] = np.floating
-            elif pd.api.types.is_categorical_dtype(dtype) or pd.api.types.is_string_dtype(dtype):
+            elif isinstance(dtype, pd.CategoricalDtype) or pd.api.types.is_string_dtype(dtype):
                 var_types[varname] = np.str_
             else:
                 raise RuntimeError("Invalid dtype detected - logic error in code. dtype: ", dtype)
@@ -461,7 +447,8 @@ class Hammock:
             height=height,
             uni_vfill=uni_vfill,
             connector_fraction=connector_fraction,
-            min_bar_height=min_bar_height,
+            min_bar_height_unibar=min_bar_height_unibar,
+            min_bar_height_connectors=min_bar_height_connectors,
             uni_hfill=uni_hfill,
             
             # Other

{hammock_plot-1.1.0 → hammock_plot-1.2.0}/hammock_plot/shapes.py

@@ -17,6 +17,45 @@ class FigureBase(ABC):
         order = np.argsort(np.arctan2(y - y.mean(), x - x.mean()))
         return x[order], y[order]
 
+    @staticmethod
+    def _floor_fractions(fracs, min_frac):
+        """
+        Raise every non-zero colour fraction to at least ``min_frac`` by shrinking
+        the larger fractions to compensate, keeping the total at 1 (so the bar's
+        height and position are unchanged). Zero fractions stay zero - a colour
+        absent from this bar is never given a sliver. Used to keep each colour
+        segment at least ``min_bar_height`` tall even when a colour is a tiny
+        share of the bar. If the minimum cannot be met for every colour (the bar
+        is too short to fit them all), the segments are split equally as a best
+        effort.
+        """
+        f = np.array(fracs, dtype=float)
+        nz = f > 0
+        k = int(nz.sum())
+        if k == 0 or min_frac <= 0:
+            return f
+        if min_frac * k >= 1.0:
+            out = np.zeros_like(f)
+            out[nz] = 1.0 / k
+            return out
+        out = f.copy()
+        # Water-filling: lift deficient segments to min_frac, draw the shortfall
+        # from segments still above min_frac in proportion to their surplus.
+        for _ in range(k + 1):
+            deficient = nz & (out < min_frac)
+            if not deficient.any():
+                break
+            out[deficient] = min_frac
+            shortfall = out.sum() - 1.0
+            donors = nz & (out > min_frac)
+            surplus = out[donors] - min_frac
+            total_surplus = surplus.sum()
+            if total_surplus <= 0:
+                out[nz] = 1.0 / k
+                break
+            out[donors] -= shortfall * (surplus / total_surplus)
+        return out
+
     def plot(self, ax,
             alpha: float,
             left_center_pts: List[Tuple[float, float]],
@@ -27,7 +66,8 @@ class FigureBase(ABC):
             orientation: str = "side-by-side",
             zorder: int = 0,
             check_overlap: bool = False,
-            unibar_name: str = None):
+            unibar_name: str = None,
+            min_seg_height: float = 0.0):
         """
         Draw polygons (rectangles or parallelograms) with segmented coloring.
 
@@ -77,6 +117,13 @@ class FigureBase(ABC):
                 right_top = np.array([poly_x[2], poly_y[2]])
                 right_bot = np.array([poly_x[3], poly_y[3]])
 
+                # Keep each colour segment at least min_seg_height tall (absolute),
+                # by trading height between segments within this fixed-height bar.
+                if min_seg_height > 0:
+                    bar_h = abs(poly_y[1] - poly_y[0])
+                    if bar_h > 0:
+                        fracs = self._floor_fractions(fracs, min_seg_height / bar_h)
+
                 cum = 0.0
                 for f, col in zip(fracs, colors):
                     f0, f1 = cum, cum + f

{hammock_plot-1.1.0 → hammock_plot-1.2.0}/hammock_plot/unibar.py

@@ -1,11 +1,10 @@
 # unibar.py
-from typing import List, Dict, Tuple, Optional
+from typing import List
 import numpy as np
 import matplotlib.pyplot as plt
 from hammock_plot.value import Value
 from hammock_plot.utils import edge_color_from_face
 from .utils import Defaults, get_formatted_label
-from fractions import Fraction
 from scipy.stats import gaussian_kde
 
 class Unibar:
@@ -65,8 +64,6 @@ class Unibar:
         Create Value objects for this unibar from self.df.
         Each Value has total occurrences and breakdown by colour_index.
         """
-        uni_series = self.df[self.name]
-        counts = uni_series.value_counts()
         values: List[Value] = []
 
         dtype = self.val_type
@@ -77,34 +74,26 @@ class Unibar:
         # Determine order
         order = self.val_order
 
+        # Count occurrences per (value, colour) in one grouped pass rather than
+        # scanning the whole frame once per value. Rows = each value, columns =
+        # each colour index; weighted sums the weight column, else just counts.
+        grouped = self.df.groupby([self.name, "color_index"], observed=True)
+        if self.weights is None:
+            occ_table = grouped.size().unstack("color_index", fill_value=0)
+        else:
+            occ_table = grouped[self.weights].sum().unstack("color_index", fill_value=0)
+        occ_table = occ_table.reindex(columns=all_colors, fill_value=0)
+
         for val in order:
-            # get number of occurrences of the value, and assign to the Value object.
-            if self.weights is None:
-                cnt = int(counts.get(val, 0))
-            else:
-                mask = self.df[self.name] == val
-                cnt = self.df.loc[mask, self.weights].sum()
-
-            # assigns a list of # occurrences which corresponds to each of the highlight colours.
-            if cnt > 0:
-                subset = self.df[self.df[self.name] == val]
-
-                if self.weights is None:
-                    occ_by_colour = (
-                        subset["color_index"]
-                        .value_counts()
-                        .reindex(all_colors, fill_value=0)
-                        .tolist()
-                    )
-                else:
-                    occ_by_colour = (
-                        subset.groupby("color_index")[self.weights]
-                        .sum()
-                        .reindex(all_colors, fill_value=0)
-                        .tolist()
-                    )
+            # look up this value's per-colour occurrences. A value that's in the
+            # order but absent from the data (e.g. an empty same_scale slot) isn't
+            # in the table, so it gets all zeros.
+            if val in occ_table.index:
+                occ_by_colour = occ_table.loc[val].tolist()
+                cnt = sum(occ_by_colour)
             else:
                 occ_by_colour = [0] * len(all_colors)
+                cnt = 0
 
             # puts the constructed Value in a list associated with the Unibar.
             values.append(Value(
@@ -128,6 +117,9 @@ class Unibar:
         # sort values before separating missing and non-missing values
         self._sort_values()
 
+        # id -> Value lookup so get_value_by_id doesn't rescan the list each call
+        self._values_by_id = {v.id: v for v in self.values}
+
         # Separate missing and non-missing values
         self.missing_vals = [v for v in self.values
                             if self.missing_placeholder is not None and str(v.id) == str(self.missing_placeholder)]
@@ -135,7 +127,7 @@ class Unibar:
 
     
     def set_measurements(self, pos_x=None, width=None, bar_unit=None, missing_padding=None,
-                        scale_ypos: Tuple[float, float] = None, hbar_height=None):
+                        hbar_height=None):
         if pos_x is not None:
             self.pos_x = pos_x
         if width is not None:
@@ -144,8 +136,6 @@ class Unibar:
             self.bar_unit = bar_unit
         if missing_padding is not None:
             self.missing_padding = missing_padding
-        if scale_ypos is not None:
-            self.scale_ypos = scale_ypos
         if hbar_height is not None:
             self.hbar_height = hbar_height
 
@@ -300,8 +290,7 @@ class Unibar:
             self.values.sort(key=lambda v: order_map.get(v.id, len(order_map)))
             
 
-    def draw(self, ax, alpha, rectangle_painter=None,
-             color="lightskyblue", y_start: int = None, y_end: int = None):
+    def draw(self, ax, alpha, rectangle_painter=None, color="lightskyblue"):
         """
         Template Method for drawing a unibar:
         1. Draw the background according to display_type
@@ -312,16 +301,16 @@ class Unibar:
 
         # Step 1: Draw background based on display_type
         if self.unibar:
-            self._draw_background(ax, rectangle_painter, y_start, y_end)
+            self._draw_background(ax, rectangle_painter)
 
         # Step 2: Draw labels
         if self.label:
-            self._draw_labels(ax, y_start, y_end)
+            self._draw_labels(ax)
 
         return ax
 
     # ---------- Template Method ----------
-    def _draw_background(self, ax, rectangle_painter, y_start, y_end):
+    def _draw_background(self, ax, rectangle_painter):
         """
         Template Method for drawing the backgrounds in a unibar
         3 types of backgrounds:
@@ -373,64 +362,78 @@ class Unibar:
             right_pts.append((self.pos_x + half_label_space, val.vert_centre))
             weights.append(val.occ_by_colour)
 
-        rectangle_painter.plot(ax, self.alpha, left_pts, right_pts, heights, self.colors, weights, orientation=self.hi_box,zorder=1, 
-                               check_overlap=True, unibar_name=self.name)
-        
+        rectangle_painter.plot(ax, self.alpha, left_pts, right_pts, heights, self.colors, weights, orientation=self.hi_box,zorder=1,
+                               check_overlap=True, unibar_name=self.name, min_seg_height=self.min_bar_height)
+
         if self.draw_white_dividers and len(values) > 1:
-            divider_height = Defaults.WHITE_DIVIDER_HEIGHT
-
-            divider_left_pts = []
-            divider_right_pts = []
-            divider_heights = []
-            divider_weights = []
-
-            for i in range(len(values) - 1):
-                top_of_i = values[i].vert_centre + heights[i] / 2
-                bottom_of_next = values[i + 1].vert_centre - heights[i + 1] / 2
-                divider_y = (top_of_i + bottom_of_next) / 2
-                half_label_space = width / 2
-
-                divider_left_pts.append((self.pos_x - half_label_space, divider_y))
-                divider_right_pts.append((self.pos_x + half_label_space, divider_y))
-                divider_heights.append(divider_height)
-
-                # white divider bar (use 2D structure)
-                divider_weights.append([1])
-
-            rectangle_painter.plot(
-                ax, 
-                alpha=1, 
-                left_center_pts=divider_left_pts,
-                right_center_pts=divider_right_pts,
-                heights=divider_heights,
-                colors=["white"],
-                weights=divider_weights,
-                orientation=self.hi_box,
-                zorder=2,  # slightly above bars
-                check_overlap=False
-            )
-        
+            # each rectangle's edge is half its own bar height from its centre
+            half_heights = [h / 2 for h in heights]
+            self._draw_white_dividers(ax, values, rectangle_painter, half_heights, width)
+
+    def _draw_white_dividers(self, ax, values, rectangle_painter, half_heights, width):
+        """
+        Draw thin white lines dividing adjacent bars (used when uni_vfill == 1).
+        half_heights[i] is the half-height of values[i], so each divider lands
+        midway between the top edge of one bar and the bottom edge of the next.
+        """
+        divider_height = Defaults.WHITE_DIVIDER_HEIGHT
+
+        divider_left_pts = []
+        divider_right_pts = []
+        divider_heights = []
+        divider_weights = []
+
+        half_label_space = width / 2
+
+        for i in range(len(values) - 1):
+            top_of_i = values[i].vert_centre + half_heights[i]
+            bottom_of_next = values[i + 1].vert_centre - half_heights[i + 1]
+            divider_y = (top_of_i + bottom_of_next) / 2
+
+            divider_left_pts.append((self.pos_x - half_label_space, divider_y))
+            divider_right_pts.append((self.pos_x + half_label_space, divider_y))
+            divider_heights.append(divider_height)
+
+            # white divider bar (use 2D structure)
+            divider_weights.append([1])
+
+        rectangle_painter.plot(
+            ax,
+            alpha=1,
+            left_center_pts=divider_left_pts,
+            right_center_pts=divider_right_pts,
+            heights=divider_heights,
+            colors=["white"],
+            weights=divider_weights,
+            orientation=self.hi_box,
+            zorder=2,  # slightly above bars
+            check_overlap=False
+        )
+
     def _prepare_scaled_data(self, y_start, y_end):
         """
-        Collect the y-positions for the box/violin plots, split by colour.
+        Collect the y-positions for the box/violin plots, split by colour, along
+        with the frequency sitting at each position.
 
         Each value's number is mapped onto the [y_start, y_end] span, and that
-        position is recorded once per colour it appears in. Repetition by count
-        is left to _prepare_weights, which lines up with this output entry for
-        entry.
+        position is recorded once per colour it appears in. The matching entry in
+        weights_per_color carries how many observations sit there (occurrence
+        count, or weight-sum if a weights column is set), so the KDE and quantile
+        code can zip the two together entry for entry.
 
         Args:
             y_start, y_end: bottom and top of the drawable vertical span.
 
-        Returns (data_per_color, facecolors, edgecolors): the y-positions per
-        colour, the fill colours, and their matching edge colours. Empty lists
-        if there are no non-missing values.
+        Returns (data_per_color, weights_per_color, facecolors, edgecolors): the
+        y-positions and their frequencies per colour, the fill colours, and their
+        matching edge colours. Empty lists if there are no non-missing values.
         """
         if not self.non_missing_vals:
-            return [], [], []
+            return [], [], [], []
 
         n_colors = len(self.colors)
         data_per_color = [[] for _ in range(n_colors)]
+        weights_per_color = [[] for _ in range(n_colors)]
 
         all_numeric_vals = [v.numeric for v in self.non_missing_vals]
         min_val, max_val = self.range if self.range else (min(all_numeric_vals), max(all_numeric_vals))
@@ -448,35 +451,10 @@ class Unibar:
             for i, occ in enumerate(occs):
                 if occ > 0:
                     data_per_color[i].append(scaled)
-
-        return data_per_color, self.colors, [edge_color_from_face(c) for c in self.colors]
-
-    def _prepare_weights(self, n_colors):
-        """
-        Give the frequency of each y-position from _prepare_scaled_data.
-
-        Walks the values the same way that method does, but records the
-        occurrence count (or weight-sum, if a weights column is set) instead of
-        the position. The box/violin code zips the two together so the KDE and
-        quantiles know how many observations sit at each spot.
-
-        Args:
-            n_colors: number of colours to split the weights across.
-
-        Returns weights_per_color: a list of weights per colour, aligned with
-        _prepare_scaled_data's output.
-        """
-        weights_per_color = [[] for _ in range(n_colors)]
-        for v in self.non_missing_vals:
-            occs = v.occ_by_colour
-            if len(occs) < n_colors:
-                occs = occs + [0] * (n_colors - len(occs))
-            for i, occ in enumerate(occs):
-                if occ > 0:
                     # if no weight column, occ is an integer count — use it directly as the weight
                     weights_per_color[i].append(float(occ))
 
-        return weights_per_color
+        return data_per_color, weights_per_color, self.colors, [edge_color_from_face(c) for c in self.colors]
 
     def _weighted_quantile(self, data, weights, quantiles):
         """
@@ -519,8 +497,7 @@ class Unibar:
         its occurrence count or weight-sum.
         """
 
-        data_per_color, facecolors, edgecolors = self._prepare_scaled_data(y_start, y_end)
-        weights_per_color = self._prepare_weights(len(self.colors))
+        data_per_color, weights_per_color, facecolors, edgecolors = self._prepare_scaled_data(y_start, y_end)
 
         # ---- helpers ----
 
@@ -608,8 +585,7 @@ class Unibar:
                 return lst[1:] + lst[:1]
             return lst
 
-        data_per_color, facecolors, edgecolors = self._prepare_scaled_data(y_start, y_end)
-        weights_per_color = self._prepare_weights(len(self.colors))
+        data_per_color, weights_per_color, facecolors, edgecolors = self._prepare_scaled_data(y_start, y_end)
 
         n = len(data_per_color)
         if n == 0:
@@ -699,7 +675,17 @@ class Unibar:
                              self.non_missing_vals,
                              rectangle_painter)
     
-    def _draw_spiky_beanplot(self, ax, y_start, y_end, rectangle_painter, bins=14):
+    def _weighted_centre(self, weight_fn):
+        """
+        Weighted mean of vert_centre across the non-missing values, weighting each
+        value by weight_fn(val). Returns None when the weights sum to zero.
+        """
+        total = sum(weight_fn(val) for val in self.non_missing_vals)
+        if total == 0:
+            return None
+        return sum(val.vert_centre * weight_fn(val) for val in self.non_missing_vals) / total
+
+    def _draw_spiky_beanplot(self, ax, y_start, y_end, rectangle_painter):
         # draw violin
         self._draw_violin(ax, y_start, y_end, draw_boxplot=False)
 
@@ -730,11 +716,7 @@ class Unibar:
                                 zorder=1)
             
             # draw the mean line
-            total_weight = sum(val.occurrences for val in self.non_missing_vals)
-            mean_y = sum(
-                val.vert_centre * val.occurrences
-                for val in self.non_missing_vals
-            ) / total_weight
+            mean_y = self._weighted_centre(lambda val: val.occurrences)
 
             rectangle_painter.plot(ax, alpha=1,
                                    left_center_pts=[(self.pos_x - self.width / 2, mean_y)], 
@@ -798,13 +780,8 @@ class Unibar:
             
             # draw the mean lines
             # LEFT (highlighted)
-            l_total = sum(val.occ_by_colour[1] for val in self.non_missing_vals)
-            if l_total > 0:
-                l_mean_y = sum(
-                    val.vert_centre * val.occ_by_colour[1]
-                    for val in self.non_missing_vals
-                ) / l_total
-
+            l_mean_y = self._weighted_centre(lambda val: val.occ_by_colour[1])
+            if l_mean_y is not None:
                 rectangle_painter.plot(
                     ax,
                     alpha=1,
@@ -817,13 +794,8 @@ class Unibar:
                 )
 
             # RIGHT (non-highlighted)
-            r_total = sum(val.occ_by_colour[0] for val in self.non_missing_vals)
-            if r_total > 0:
-                r_mean_y = sum(
-                    val.vert_centre * val.occ_by_colour[0]
-                    for val in self.non_missing_vals
-                ) / r_total
-
+            r_mean_y = self._weighted_centre(lambda val: val.occ_by_colour[0])
+            if r_mean_y is not None:
                 rectangle_painter.plot(
                     ax,
                     alpha=1,
@@ -866,42 +838,11 @@ class Unibar:
                                zorder=1)
         
         if self.draw_white_dividers and len(values) > 1:
-            divider_height = Defaults.WHITE_DIVIDER_HEIGHT
-
-            divider_left_pts = []
-            divider_right_pts = []
-            divider_heights = []
-            divider_weights = []
-
-            space_between_dividers = self.hbar_height / 2
-
-            for i in range(len(values) - 1):
-                top_of_i = values[i].vert_centre + space_between_dividers
-                bottom_of_next = values[i + 1].vert_centre - space_between_dividers
-                divider_y = (top_of_i + bottom_of_next) / 2
-                half_label_space = self.width / 2
-
-                divider_left_pts.append((self.pos_x - half_label_space, divider_y))
-                divider_right_pts.append((self.pos_x + half_label_space, divider_y))
-                divider_heights.append(divider_height)
-                
-                # white divider bar (use 2D structure)
-                divider_weights.append([1])
-            
-            rectangle_painter.plot(
-                ax, 
-                alpha=1, 
-                left_center_pts=divider_left_pts,
-                right_center_pts=divider_right_pts,
-                heights=divider_heights,
-                colors=["white"],
-                weights=divider_weights,
-                orientation=self.hi_box,
-                zorder=2,  # slightly above bars
-                check_overlap=False
-            )
+            # bar charts draw every value at a constant hbar_height
+            half_heights = [self.hbar_height / 2] * len(values)
+            self._draw_white_dividers(ax, values, rectangle_painter, half_heights, self.width)
     # ---------- Label Drawing ----------
-    def _draw_labels(self, ax, y_start, y_end):
+    def _draw_labels(self, ax):
         """
         Draws labels depending on the display type.
         2 types of labels:
@@ -913,14 +854,14 @@ class Unibar:
         if self.missing:
             for mv in self.missing_vals:
                 # don't draw the labels if there are no missing values
-                if mv.occurrences > 0: 
+                if mv.occurrences > 0:
                     # Place missing labels just above the bottom with missing_padding
                     ax.text(x, mv.vert_centre, self.missing_placeholder, ha='center', va='center', **(self.label_options or {}))
-        
+
         if self.label_type == "values":
             self._draw_value_labels(ax) #draws labels directly according to the values
         elif self.label_type == "levels":
-            self._draw_level_labels(ax, y_start, y_end)
+            self._draw_level_labels(ax)
         else:
             raise ValueError(f"invalid label_type {self.label_type}")
 
@@ -934,7 +875,7 @@ class Unibar:
                 ax.text(self.pos_x, val.vert_centre, self._get_formatted_label(val.dtype, val.id), ha='center', va='center', **(self.label_options or {}))
 
     # -------- Label drawing - levels (starting from y_start and ending at y_end) ------
-    def _draw_level_labels(self, ax, y_start, y_end):
+    def _draw_level_labels(self, ax):
         """
         2 ways to draw levels:
         1. Display type == rug
@@ -995,10 +936,7 @@ class Unibar:
         Returns a Value, given its id
         Assumes that all ids are unique (true)
         """
-        for v in self.values:
-            if v.id == id:
-                return v
-        return None
+        return self._values_by_id.get(id)
 
     def __repr__(self):
         return f"unibar(name={self.name!r}, x={self.pos_x:.2f}, nvals={len(self.values)})"

{hammock_plot-1.1.0 → hammock_plot-1.2.0}/hammock_plot/utils.py

@@ -1,5 +1,6 @@
 import re
 import colorsys
+import warnings
 import matplotlib.colors as mcolors
 import pandas as pd
 from typing import List, Dict, Any
@@ -20,7 +21,8 @@ class Defaults:
     UNI_VFILL: float = 0.08 # default unibar vertical fill
     CONNECTOR_FRACTION: float = 1 # default proportion fraction of connectors : vfill
     UNI_HFILL: float = 0.3 # default horizontal fill
-    MIN_BAR_HEIGHT: float = 0.15 # minimum bar height
+    MIN_BAR_HEIGHT_UNIBAR: float = 0.15 # minimum drawn height of a unibar (and its colour segments)
+    MIN_BAR_HEIGHT_CONNECTORS: float = 0.12 # minimum drawn thickness of a connector; slightly less than the unibar floor
     BAR_UNIT: float = 1.0 # default bar unit (how many pixels/obs.) is recalculated on init.
     XMARGIN: float = 0.02 # margin on x axis
     YMARGIN: float = 0.04 # margin on y axis
@@ -92,6 +94,17 @@ def safe_numeric(val):
             except (ValueError, TypeError):
                 return val
 
+def clamp_unit(value, name):
+    """Clamp a 0-1 layout fraction, warning (with the parameter's name) when the
+    given value falls outside the range."""
+    if value < 0:
+        warnings.warn(f"{name} < 0. Value has been clamped to 0.")
+        return 0
+    elif value > 1:
+        warnings.warn(f"{name} > 1. Value has been clamped to 1.")
+        return 1
+    return value
+
 def resolve_ordering(orders):
     """
         Merge several category orderings (from variables in same_scale) into one
@@ -235,7 +248,39 @@ def assign_color_index(df: pd.DataFrame, var_list: List[str], hi_missing, missin
             if v != hi_var:
                 continue
             mask = df["color_index"] == 0
-            df.loc[mask, "color_index"] = df.loc[mask, v].apply(lambda val: _compute_color_index(val, hi_missing, hi_value))
+            col = df.loc[mask, v]
+            if isinstance(hi_value, list):
+                # Fast path: a list of highlight values is a straight lookup.
+                # Build the same mapping _compute_color_index applies — first
+                # occurrence in hi_value wins (list.index semantics), exact match
+                # first, then a numeric-coercion fallback for non-string values.
+                buffer = 1 if hi_missing else 0
+                exact_map = {}
+                numeric_map = {}
+                for i, hv in enumerate(hi_value):
+                    if hv not in exact_map:
+                        exact_map[hv] = i + 1 + buffer
+                    try:
+                        fk = float(hv)
+                    except (ValueError, TypeError):
+                        continue
+                    if fk not in numeric_map:
+                        numeric_map[fk] = i + 1 + buffer
+
+                def _numeric_index(val):
+                    # numeric fallback only applies to non-string, non-NaN values
+                    if isinstance(val, str) or pd.isna(val):
+                        return np.nan
+                    try:
+                        return numeric_map.get(float(val), np.nan)
+                    except (ValueError, TypeError):
+                        return np.nan
+
+                result = col.map(exact_map).fillna(col.map(_numeric_index))
+                df.loc[mask, "color_index"] = result.fillna(0).astype(int)
+            else:
+                # regex / numeric-range expressions stay on the row-wise path
+                df.loc[mask, "color_index"] = col.apply(lambda val: _compute_color_index(val, hi_missing, hi_value))
     return df
 
 def get_formatted_label(datatype, value):

{hammock_plot-1.1.0 → hammock_plot-1.2.0}/hammock_plot/value.py

@@ -1,5 +1,5 @@
 # value.py
-from typing import Dict, List, Optional
+from typing import List, Optional
 import numpy as np
 
 class Value:
@@ -13,7 +13,6 @@ class Value:
                 occurrences: how many times the value occurs in the unibar
                 occ_by_color: the # occurrences of each of the highlighted groups in the Value
                 vert_centre: the vertical coordinate of the Value's centre
-                next: the Values in the next unibar that this Value is associated with
                 numeric: the numeric value associated with the Value (if it is categorical, there is no numeric value associated.)
         """
         self.dtype = dtype
@@ -22,7 +21,6 @@ class Value:
         # occ_by_colour: [non_highlight_count, hi_count_1, hi_count_2, ...]
         self.occ_by_colour = occ_by_colour if occ_by_colour is not None else [self.occurrences]
         self.vert_centre: float = 0.0
-        self.next: Dict[str, int] = {}
         if dtype != np.str_:
             self.numeric = float(id)
         else:
@@ -36,22 +34,6 @@ class Value:
             self.vert_centre = float(centre)
             return
 
-    def add_next(self, next_id: str, count: int = 1):
-        """
-            Helper function to add the Values in the next unibar that this Value connects to
-        """
-        self.next[next_id] = self.next.get(id, 0) + int(count)
-
-    def set_occurrences(self, total: int, occ_by_colour: Optional[List[int]] = None):
-        """
-            Sets the number of occurrences of this Value.
-        """
-        self.occurrences = int(total)
-        if occ_by_colour is not None:
-            self.occ_by_colour = [int(x) for x in occ_by_colour]
-        else:
-            self.occ_by_colour = [int(total)]
-
     def __repr__(self):
         """
             Debugging statement that print's Value's ID, number of occurrences, and the y-coordinate of the Value

{hammock_plot-1.1.0 → hammock_plot-1.2.0}/hammock_plot.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hammock-plot
-Version: 1.1.0
+Version: 1.2.0
 Summary: Hammock plot visualization for categorical and mixed categorical-continuous data
 Author-email: Tiancheng Yang <t77yang@uwaterloo.ca>, Sandra Huang <sandra.huang@uwaterloo.ca>, Matthias Schonlau <schonlau@uwaterloo.ca>
 License: MIT

{hammock_plot-1.1.0 → hammock_plot-1.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "hammock-plot"
-version = "1.1.0"
+version = "1.2.0"
 description = "Hammock plot visualization for categorical and mixed categorical-continuous data"
 readme = {text = "For the current project description, documentation, and examples, please see the GitHub repository: https://github.com/TianchengY/hammock_plot", content-type = "text/markdown"}
 license = {text = "MIT"}