update(bubble-packed): seaborn — comprehensive quality review (#4359)

## Summary

Updated **seaborn** implementation for **bubble-packed**.

**Changes:** Comprehensive quality review

### Changes
- Renamed data dict to sectors for clarity
- Removed unused matplotlib.patches import
- Simplified circle packing logic
- Removed unnecessary random seed (deterministic data)

## Test Plan

- [x] Preview images uploaded to GCS staging
- [x] Implementation file passes ruff format/check
- [x] Metadata YAML updated with current versions
- [ ] Automated review triggered

---
Generated with [Claude Code](https://claude.com/claude-code) `/update`
command

---------

Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>

Author: MarkusNeusinger

plots/bubble-packed/implementations/seaborn.py

@@ -1,207 +1,185 @@
 """ pyplots.ai
 bubble-packed: Basic Packed Bubble Chart
-Library: seaborn 0.13.2 | Python 3.13.11
-Quality: 90/100 | Created: 2025-12-23
+Library: seaborn 0.13.2 | Python 3.14.3
+Quality: 90/100 | Updated: 2026-02-23
 """
 
-import matplotlib.patches as mpatches
 import matplotlib.pyplot as plt
 import numpy as np
 import pandas as pd
 import seaborn as sns
 
 
 # Data - Company market values by sector (billions USD)
-np.random.seed(42)
-data = {
+sectors = {
     "Technology": [("Apple", 180), ("Microsoft", 160), ("Google", 120), ("NVIDIA", 95), ("Meta", 75)],
     "Finance": [("JPMorgan", 85), ("Visa", 70), ("Mastercard", 55), ("Goldman Sachs", 45)],
     "Healthcare": [("UnitedHealth", 90), ("J&J", 65), ("Merck", 50), ("Pfizer", 40)],
     "Retail": [("Amazon", 140), ("Walmart", 60), ("Costco", 45), ("Target", 30)],
 }
 
-# Prepare circles sorted by size (largest first for better packing)
-all_circles = []
-for group, items in data.items():
-    for name, value in items:
-        radius = np.sqrt(value) * 4  # Scale by area
-        all_circles.append({"name": name, "radius": radius, "group": group, "value": value})
-
-all_circles.sort(key=lambda x: -x["radius"])
+records = []
+for sector, companies in sectors.items():
+    for name, value in companies:
+        records.append({"name": name, "value": value, "sector": sector, "radius": np.sqrt(value) * 4})
+
+df = pd.DataFrame(records).sort_values("radius", ascending=False).reset_index(drop=True)
+
+# Circle packing - place circles greedily closest to center without overlap
+placed_x, placed_y, placed_r = [], [], []
+
+for _, row in df.iterrows():
+    r = row["radius"]
+
+    if not placed_x:
+        placed_x.append(0.0)
+        placed_y.append(0.0)
+        placed_r.append(r)
+        continue
+
+    best_pos, best_dist = None, float("inf")
+    px_arr, py_arr, pr_arr = np.array(placed_x), np.array(placed_y), np.array(placed_r)
+
+    for i in range(len(placed_x)):
+        for angle in np.linspace(0, 2 * np.pi, 72, endpoint=False):
+            gap = placed_r[i] + r + 2
+            tx = placed_x[i] + gap * np.cos(angle)
+            ty = placed_y[i] + gap * np.sin(angle)
+
+            dists = np.sqrt((px_arr - tx) ** 2 + (py_arr - ty) ** 2)
+            if np.all(dists >= pr_arr + r + 1):
+                cdist = np.sqrt(tx**2 + ty**2)
+                if cdist < best_dist:
+                    best_dist = cdist
+                    best_pos = (tx, ty)
+
+    bx, by = best_pos if best_pos else (0.0, 0.0)
+    placed_x.append(bx)
+    placed_y.append(by)
+    placed_r.append(r)
+
+df["x"] = placed_x
+df["y"] = placed_y
+
+# Recenter coordinates into positive space
+pad = 20
+df["x"] = df["x"] - (df["x"] - df["radius"]).min() + pad
+df["y"] = df["y"] - (df["y"] - df["radius"]).min() + pad
+plot_w = (df["x"] + df["radius"]).max() + pad
+plot_h = (df["y"] + df["radius"]).max() + pad
+
+# Seaborn styling - distinctive context and style management
+sns.set_context("poster", font_scale=0.85)
+sns.set_style("white")
 
-# Circle packing - place circles one by one without overlap (inline, no functions)
-placed_circles = []
-cx, cy = 0, 0
+# Custom colorblind-safe palette anchored on Python Blue (#306998)
+sector_order = list(sectors.keys())
+base_colors = ["#306998", "#DE8F05", "#029E73", "#CC78BC"]
+sector_palette = dict(zip(sector_order, sns.color_palette(base_colors), strict=True))
 
-for circle in all_circles:
-    new_radius = circle["radius"]
+# Square canvas for better packing utilization (bubbles pack roughly circular)
+fig, ax = plt.subplots(figsize=(12, 12))
+ax.set_xlim(0, plot_w)
+ax.set_ylim(0, plot_h)
+ax.set_aspect("equal")
 
-    if not placed_circles:
-        # First circle at origin
-        best_x, best_y = cx, cy
-    else:
-        # Try positions around existing circles, find closest to center
-        best_pos = None
-        best_dist = float("inf")
-
-        for p in placed_circles:
-            for angle in np.linspace(0, 2 * np.pi, 72, endpoint=False):
-                dist = p["radius"] + new_radius + 2
-                test_x = p["x"] + dist * np.cos(angle)
-                test_y = p["y"] + dist * np.sin(angle)
-
-                # Check overlap with all placed circles
-                valid = True
-                for other in placed_circles:
-                    d = np.sqrt((test_x - other["x"]) ** 2 + (test_y - other["y"]) ** 2)
-                    if d < other["radius"] + new_radius + 1:
-                        valid = False
-                        break
-
-                if valid:
-                    center_dist = np.sqrt((test_x - cx) ** 2 + (test_y - cy) ** 2)
-                    if center_dist < best_dist:
-                        best_dist = center_dist
-                        best_pos = (test_x, test_y)
-
-        best_x, best_y = best_pos if best_pos else (cx, cy)
-
-    placed_circles.append(
-        {
-            "x": best_x,
-            "y": best_y,
-            "radius": new_radius,
-            "name": circle["name"],
-            "group": circle["group"],
-            "value": circle["value"],
-        }
-    )
-
-# Calculate bounds and recenter
-all_x = [c["x"] for c in placed_circles]
-all_y = [c["y"] for c in placed_circles]
-all_r = [c["radius"] for c in placed_circles]
-
-min_x = min(x - r for x, r in zip(all_x, all_r, strict=True))
-max_x = max(x + r for x, r in zip(all_x, all_r, strict=True))
-min_y = min(y - r for y, r in zip(all_y, all_r, strict=True))
-max_y = max(y + r for y, r in zip(all_y, all_r, strict=True))
-
-# Offset to center in plot area
-padding = 20
-offset_x = -min_x + padding
-offset_y = -min_y + padding
-
-for c in placed_circles:
-    c["x"] += offset_x
-    c["y"] += offset_y
-
-plot_width = max_x - min_x + 2 * padding
-plot_height = max_y - min_y + 2 * padding
-
-# Create DataFrame for seaborn
-df = pd.DataFrame(placed_circles)
-# Scale marker size for scatterplot (s parameter uses area in points^2)
-df["marker_size"] = (df["radius"] * 2) ** 2 * 3.14  # Convert radius to area for proper sizing
-
-# Set seaborn style
-sns.set_style("white")
-palette = sns.color_palette("Set2", n_colors=len(data))
-group_colors = {group: palette[i] for i, group in enumerate(data.keys())}
+# Convert data-unit radii to scatter marker sizes (points²)
+fig.canvas.draw()
+px_per_unit = ax.transData.transform((1, 0))[0] - ax.transData.transform((0, 0))[0]
+pts_per_unit = px_per_unit * 72 / fig.dpi
+df["marker_size"] = (df["radius"] * 2 * pts_per_unit) ** 2
 
-# Create figure
-fig, ax = plt.subplots(figsize=(16, 9))
+# Categorical ordering for consistent palette mapping
+df["sector"] = pd.Categorical(df["sector"], categories=sector_order, ordered=True)
 
-# Use seaborn scatterplot for the bubbles
+# Draw bubbles with seaborn scatterplot and hue mapping
 sns.scatterplot(
     data=df,
     x="x",
     y="y",
-    hue="group",
+    hue="sector",
     size="marker_size",
     sizes=(df["marker_size"].min(), df["marker_size"].max()),
-    palette="Set2",
-    alpha=0.9,
+    hue_order=sector_order,
+    palette=sector_palette,
+    alpha=0.92,
     edgecolor="white",
     linewidth=3,
-    legend=False,
+    legend="brief",
     ax=ax,
 )
 
-# Add labels for all circles using annotations
-# Sort by x position to manage external annotation placement
-df_sorted = df.sort_values("x")
-used_y_positions = []  # Track y positions for external labels to avoid overlap
+# Filter legend to sector entries only, then reposition with sns.move_legend
+handles, labels = ax.get_legend_handles_labels()
+sector_h = [h for h, lab in zip(handles, labels, strict=False) if lab in sector_order]
+sector_lab = [lab for lab in labels if lab in sector_order]
+ax.legend(sector_h, sector_lab)
+sns.move_legend(
+    ax,
+    loc="upper center",
+    bbox_to_anchor=(0.5, -0.02),
+    ncol=4,
+    fontsize=16,
+    framealpha=0.95,
+    title="Sector",
+    title_fontsize=18,
+    edgecolor="#CCCCCC",
+)
 
-for _, row in df_sorted.iterrows():
+# Labels with value annotations for data storytelling
+for _, row in df.iterrows():
+    r = row["radius"]
     name = row["name"]
-    # Abbreviate long names for internal labels
-    short_name = name if len(name) <= 10 else name[:9] + "."
-
-    if row["radius"] > 38:
-        # Large circles - full name with large font
-        ax.text(row["x"], row["y"], short_name, ha="center", va="center", fontsize=18, fontweight="bold", color="white")
-    elif row["radius"] > 32:
-        # Medium-large circles
-        ax.text(row["x"], row["y"], short_name, ha="center", va="center", fontsize=14, fontweight="bold", color="white")
-    elif row["radius"] > 26:
-        # Medium circles - smaller font
-        ax.text(row["x"], row["y"], short_name, ha="center", va="center", fontsize=11, fontweight="bold", color="white")
+    value = row["value"]
+
+    if r > 38:
+        fs_name, max_chars, show_val = 20, 12, True
+    elif r > 30:
+        fs_name, max_chars, show_val = 16, 12, True
+    elif r > 24:
+        fs_name, max_chars, show_val = 12, 10, True
     else:
-        # Small circles - external annotation with arrow
-        # Determine label position (alternate left/right based on position)
-        if row["x"] < plot_width / 2:
-            # Left side - annotate to the left
-            offset_x = -row["radius"] - 20
-            ha = "right"
-        else:
-            # Right side - annotate to the right
-            offset_x = row["radius"] + 20
-            ha = "left"
-
-        # Adjust y to avoid overlapping labels
-        target_y = row["y"]
-        for used_y in used_y_positions:
-            if abs(target_y - used_y) < 25:
-                target_y = used_y + 25 if target_y >= used_y else used_y - 25
-        used_y_positions.append(target_y)
-
-        ax.annotate(
+        fs_name, max_chars, show_val = 9, 8, False
+
+    if len(name) > max_chars:
+        name = name[: max_chars - 1] + "."
+
+    if show_val:
+        y_off = r * 0.13
+        ax.text(
+            row["x"],
+            row["y"] + y_off,
             name,
-            xy=(row["x"], row["y"]),
-            xytext=(row["x"] + offset_x, target_y),
-            fontsize=11,
+            ha="center",
+            va="center",
+            fontsize=fs_name,
             fontweight="bold",
-            color="#444444",
-            arrowprops={"arrowstyle": "->", "color": "#888888", "lw": 1.5, "connectionstyle": "arc3,rad=0.1"},
-            ha=ha,
+            color="white",
+        )
+        ax.text(
+            row["x"],
+            row["y"] - y_off * 2,
+            f"${value}B",
+            ha="center",
             va="center",
+            fontsize=fs_name - 4,
+            color="white",
+            alpha=0.8,
         )
+    else:
+        ax.text(row["x"], row["y"], name, ha="center", va="center", fontsize=fs_name, fontweight="bold", color="white")
 
-# Configure axes
-ax.set_xlim(0, plot_width)
-ax.set_ylim(0, plot_height)
-ax.set_aspect("equal")
 ax.axis("off")
 
 # Title
-ax.set_title("bubble-packed · seaborn · pyplots.ai", fontsize=24, fontweight="bold", pad=20)
-
-# Create legend - position below the plot to avoid any overlap with data
-legend_elements = [
-    mpatches.Patch(facecolor=group_colors[group], edgecolor="white", linewidth=2, label=group) for group in data.keys()
-]
-ax.legend(
-    handles=legend_elements,
-    loc="upper center",
-    bbox_to_anchor=(0.5, -0.02),
-    ncol=4,
-    fontsize=14,
-    framealpha=0.95,
-    title="Sector",
-    title_fontsize=16,
-    edgecolor="gray",
+ax.set_title(
+    "Market Capitalization by Sector\nbubble-packed \u00b7 seaborn \u00b7 pyplots.ai",
+    fontsize=26,
+    fontweight="medium",
+    pad=25,
+    linespacing=1.4,
 )
 
+sns.despine(left=True, bottom=True)
 plt.tight_layout()
 plt.savefig("plot.png", dpi=300, bbox_inches="tight", facecolor="white")