feat(matplotlib): implement network-force-directed (#5432)

## Implementation: `network-force-directed` - python/matplotlib

Implements the **python/matplotlib** version of
`network-force-directed`.

**File:**
`plots/network-force-directed/implementations/python/matplotlib.py`

**Parent Issue:** #990

---
:robot: *[impl-generate
workflow](https://github.com/MarkusNeusinger/anyplot/actions/runs/24952381723)*

---------

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

Author: github-actions[bot]

plots/network-force-directed/implementations/python/matplotlib.py

@@ -1,67 +1,62 @@
-""" pyplots.ai
+""" anyplot.ai
 network-force-directed: Force-Directed Graph
-Library: matplotlib 3.10.8 | Python 3.13.11
-Quality: 92/100 | Created: 2025-12-23
+Library: matplotlib 3.10.9 | Python 3.14.4
+Quality: 85/100 | Updated: 2026-04-26
 """
 
+import os
+
 import matplotlib.pyplot as plt
 import numpy as np
 from matplotlib.collections import LineCollection
 
 
-# Set seed for reproducibility
+# Theme tokens (see prompts/default-style-guide.md)
+THEME = os.getenv("ANYPLOT_THEME", "light")
+PAGE_BG = "#FAF8F1" if THEME == "light" else "#1A1A17"
+ELEVATED_BG = "#FFFDF6" if THEME == "light" else "#242420"
+INK = "#1A1A17" if THEME == "light" else "#F0EFE8"
+INK_SOFT = "#4A4A44" if THEME == "light" else "#B8B7B0"
+INK_MUTED = "#6B6A63" if THEME == "light" else "#A8A79F"
+
+# Okabe-Ito palette — first series is always #009E73
+COMMUNITY_COLORS = ["#009E73", "#D55E00", "#0072B2"]
+COMMUNITY_NAMES = ["Engineering", "Marketing", "Sales"]
+
+# Data: a 50-person company social network with 3 departments
 np.random.seed(42)
+community_sizes = [18, 17, 15]
 
-# Data: A social network with 50 nodes in 3 communities
-# Demonstrates force-directed layout with clear community structure
 nodes = []
-edges = []
-
-# Create 3 communities representing company departments
-community_sizes = [18, 17, 15]  # Total: 50 nodes
-community_names = ["Engineering", "Marketing", "Sales"]
 node_id = 0
-
 for comm_idx, size in enumerate(community_sizes):
     for _ in range(size):
         nodes.append({"id": node_id, "community": comm_idx})
         node_id += 1
 
-# Intra-community edges (dense connections within communities)
-# Engineering: nodes 0-17
-for i in range(18):
-    for j in range(i + 1, 18):
-        if np.random.random() < 0.3:
-            edges.append((i, j))
-
-# Marketing: nodes 18-34
-for i in range(18, 35):
-    for j in range(i + 1, 35):
-        if np.random.random() < 0.3:
-            edges.append((i, j))
-
-# Sales: nodes 35-49
-for i in range(35, 50):
-    for j in range(i + 1, 50):
-        if np.random.random() < 0.3:
-            edges.append((i, j))
-
-# Inter-community edges (sparse bridges between communities)
+edges = []
+# Intra-community edges (dense connections within departments)
+ranges = [(0, 18), (18, 35), (35, 50)]
+for start, stop in ranges:
+    for i in range(start, stop):
+        for j in range(i + 1, stop):
+            if np.random.random() < 0.3:
+                edges.append((i, j))
+
+# Inter-community edges (sparse bridges between departments)
 bridge_edges = [(0, 18), (5, 20), (10, 25), (18, 35), (22, 40), (30, 45), (8, 38), (15, 48)]
 edges.extend(bridge_edges)
 
-# Force-directed layout algorithm (Fruchterman-Reingold)
+# Force-directed layout (Fruchterman-Reingold)
 n = len(nodes)
-positions = np.random.rand(n, 2) * 2 - 1  # Initial random positions
-
-# Optimal distance parameter
+positions = np.random.rand(n, 2) * 2 - 1
 k = 0.5
 iterations = 200
 
 for iteration in range(iterations):
     displacement = np.zeros((n, 2))
 
-    # Repulsive forces between all node pairs (nodes push apart)
+    # Repulsive forces between all node pairs
     for i in range(n):
         for j in range(i + 1, n):
             diff = positions[i] - positions[j]
@@ -70,99 +65,114 @@
             displacement[i] += repulsive_force
             displacement[j] -= repulsive_force
 
-    # Attractive forces along edges (connected nodes pull together)
+    # Attractive forces along edges
     for src, tgt in edges:
         diff = positions[src] - positions[tgt]
         dist = max(np.linalg.norm(diff), 0.01)
         attractive_force = (dist * dist / k) * (diff / dist)
         displacement[src] -= attractive_force
         displacement[tgt] += attractive_force
 
-    # Apply displacement with cooling (decreasing temperature)
+    # Apply displacement with cooling
     temperature = 1 - iteration / iterations
     for i in range(n):
         disp_norm = np.linalg.norm(displacement[i])
         if disp_norm > 0:
-            # Limit movement by temperature
             positions[i] += (displacement[i] / disp_norm) * min(disp_norm, 0.15 * temperature)
 
-# Normalize positions to [0.08, 0.92] range for better margins
+# Normalize positions to [0.08, 0.92] for comfortable margins
 pos_min = positions.min(axis=0)
 pos_max = positions.max(axis=0)
 positions = (positions - pos_min) / (pos_max - pos_min + 1e-6) * 0.84 + 0.08
 pos = {node["id"]: positions[i] for i, node in enumerate(nodes)}
 
-# Calculate node degrees (number of connections)
+# Node degrees
 degrees = {node["id"]: 0 for node in nodes}
 for src, tgt in edges:
     degrees[src] += 1
     degrees[tgt] += 1
 
-# Create plot
-fig, ax = plt.subplots(figsize=(16, 9))
-
-# Community colors (Python Blue, Python Yellow, and a colorblind-safe coral)
-community_colors = ["#306998", "#FFD43B", "#E07B53"]
+# Plot
+fig, ax = plt.subplots(figsize=(16, 9), facecolor=PAGE_BG)
+ax.set_facecolor(PAGE_BG)
 
-# Draw edges first (behind nodes)
+# Edges (behind nodes), theme-adaptive low-contrast color
 edge_lines = [[(pos[src][0], pos[src][1]), (pos[tgt][0], pos[tgt][1])] for src, tgt in edges]
-lc = LineCollection(edge_lines, colors="#888888", linewidths=1.5, alpha=0.35, zorder=1)
+lc = LineCollection(edge_lines, colors=INK_SOFT, linewidths=1.5, alpha=0.30, zorder=1)
 ax.add_collection(lc)
 
-# Draw nodes sized by degree
+# Nodes sized by degree
+node_sizes = {}
 for node in nodes:
     x, y = pos[node["id"]]
     degree = degrees[node["id"]]
-    size = 450 + degree * 120  # Scale size by connections
-    color = community_colors[node["community"]]
-    ax.scatter(x, y, s=size, c=color, edgecolors="#333333", linewidths=1.5, alpha=0.85, zorder=2)
+    size = 450 + degree * 120
+    node_sizes[node["id"]] = size
+    color = COMMUNITY_COLORS[node["community"]]
+    ax.scatter(x, y, s=size, c=color, edgecolors=PAGE_BG, linewidths=2.0, alpha=0.92, zorder=2)
 
-# Label only top hubs (highest degree nodes per community)
-# Find top 2 nodes per community to avoid clutter
+# Label top 2 hubs per community, with size-aware offset to prevent overlap
 top_hubs = []
 for comm_idx in range(3):
-    comm_nodes = [n for n in nodes if n["community"] == comm_idx]
-    comm_degrees = [(n["id"], degrees[n["id"]]) for n in comm_nodes]
+    comm_degrees = [(node["id"], degrees[node["id"]]) for node in nodes if node["community"] == comm_idx]
     comm_degrees.sort(key=lambda x: x[1], reverse=True)
-    top_hubs.extend([n_id for n_id, _ in comm_degrees[:2]])
+    top_hubs.extend([node_id for node_id, _ in comm_degrees[:2]])
 
 for node in nodes:
-    if node["id"] in top_hubs:
-        x, y = pos[node["id"]]
-        team_initial = community_names[node["community"]][0]
+    node_id = node["id"]
+    if node_id in top_hubs:
+        x, y = pos[node_id]
+        # Offset scales with marker radius (s is area in pt²)
+        offset = 0.012 + 0.0009 * np.sqrt(node_sizes[node_id])
+        team_initial = COMMUNITY_NAMES[node["community"]][0]
         ax.text(
             x,
-            y + 0.045,
+            y + offset,
             f"Hub ({team_initial})",
             fontsize=14,
             fontweight="bold",
             ha="center",
             va="bottom",
-            color="#333333",
-            zorder=3,
+            color=INK,
+            zorder=4,
+            bbox={"facecolor": ELEVATED_BG, "edgecolor": "none", "boxstyle": "round,pad=0.25", "alpha": 0.85},
         )
 
-# Styling
-ax.set_title("network-force-directed · matplotlib · pyplots.ai", fontsize=24, fontweight="bold", pad=20)
+# Title and frame
+ax.set_title("network-force-directed · matplotlib · anyplot.ai", fontsize=24, fontweight="medium", color=INK, pad=20)
 ax.set_xlim(-0.02, 1.02)
 ax.set_ylim(-0.02, 1.02)
 ax.axis("off")
 
-# Legend for communities
+# Legend
 legend_handles = [
-    ax.scatter([], [], c=color, s=600, edgecolors="#333333", linewidths=1.5, label=name)
-    for color, name in zip(community_colors, community_names, strict=True)
+    ax.scatter([], [], c=color, s=600, edgecolors=PAGE_BG, linewidths=2.0, label=name)
+    for color, name in zip(COMMUNITY_COLORS, COMMUNITY_NAMES, strict=True)
 ]
-ax.legend(
+leg = ax.legend(
     handles=legend_handles,
     loc="upper left",
     fontsize=16,
-    framealpha=0.95,
     title="Teams",
     title_fontsize=18,
-    edgecolor="#CCCCCC",
+    framealpha=0.95,
     fancybox=True,
 )
+leg.get_frame().set_facecolor(ELEVATED_BG)
+leg.get_frame().set_edgecolor(INK_SOFT)
+leg.get_title().set_color(INK)
+plt.setp(leg.get_texts(), color=INK_SOFT)
+
+# Footer
+fig.text(
+    0.5,
+    0.02,
+    f"50 nodes · {len(edges)} edges · node size scales with degree",
+    ha="center",
+    va="bottom",
+    fontsize=12,
+    color=INK_MUTED,
+)
 
 plt.tight_layout()
-plt.savefig("plot.png", dpi=300, bbox_inches="tight", facecolor="white")
+plt.savefig(f"plot-{THEME}.png", dpi=300, bbox_inches="tight", facecolor=PAGE_BG)