d3graph 2.9.3__tar.gz → 2.9.4__tar.gz

{d3graph-2.9.3/d3graph.egg-info → d3graph-2.9.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: d3graph
-Version: 2.9.3
+Version: 2.9.4
 Summary: Python package to create interactive network based on d3js.
 Author-email: Erdogan Taskesen <erdogant@gmail.com>
 License-Expression: BSD-3-Clause
@@ -103,6 +103,14 @@ from d3graph import d3graph
   </a>
 </p>
 
+
+<p align="left">
+  <a href="https://erdogant.github.io/docs/d3graph/titanic_example/index.html">
+     <img src="https://github.com/d3blocks/d3blocks/blob/main/docs/figs/d3graph/socialmedia.gif" width="1000"/>
+  </a>
+</p>
+
+
 <hr>
 
 ### Contributors

{d3graph-2.9.3 → d3graph-2.9.4}/README.md

@@ -72,6 +72,14 @@ from d3graph import d3graph
   </a>
 </p>
 
+
+<p align="left">
+  <a href="https://erdogant.github.io/docs/d3graph/titanic_example/index.html">
+     <img src="https://github.com/d3blocks/d3blocks/blob/main/docs/figs/d3graph/socialmedia.gif" width="1000"/>
+  </a>
+</p>
+
+
 <hr>
 
 ### Contributors

{d3graph-2.9.3 → d3graph-2.9.4}/d3graph/__init__.py

@@ -17,7 +17,7 @@ from d3graph.d3graph import (
 
 __author__ = 'Erdogan Tasksen'
 __email__ = 'erdogant@gmail.com'
-__version__ = '2.9.3'
+__version__ = '2.9.4'
 
 # Setup root logger
 _logger = logging.getLogger('d3graph')

{d3graph-2.9.3 → d3graph-2.9.4}/d3graph/d3graph.py

@@ -128,6 +128,7 @@ class d3graph:
              density_grid_size: int = 60,
              density_blur: int = 10,
              density_opacity: float = 0.6,
+             show_controls: bool = True,
              ) -> None:
         """Build and show the graph.
 
@@ -207,6 +208,14 @@ class d3graph:
             blocky grid.
         density_opacity : float, (default: 0.6)
             Maximum heatmap opacity, reached at the highest-density grid cell.
+        show_controls : bool, (default: True)
+            Whether to render the top-panel buttons (Dark Mode, Hide Edges, Show Density,
+            Save) at all. Set to False when embedding the generated HTML into an existing
+            page/app that provides its own UI chrome and doesn't need d3graph's built-in
+            controls - the buttons (and their JS wiring) are omitted entirely rather than
+            just hidden, so there's no extra DOM/clutter in the embed. The weight/component
+            sliders are controlled separately via show_slider; the Save button specifically
+            is also controlled via save_button, independent of this.
 
         Returns
         -------
@@ -236,6 +245,7 @@ class d3graph:
         self.config['density_grid_size'] = density_grid_size
         self.config['density_blur'] = density_blur
         self.config['density_opacity'] = density_opacity
+        self.config['show_controls'] = show_controls
 
         # Allow show() to override the link_tension set at __init__ time
         if link_tension is not None:
@@ -837,7 +847,6 @@ class d3graph:
 
         # Hide slider
         show_slider = ['', ''] if self.config['show_slider'] else ['<!--', '-->']
-        show_save_button = ['', ''] if self.config['save_button'] else ['<!--', '-->']
         # Set width and height to screen resolution if None.
         width = 'window.screen.width' if self.config['figsize'][0] is None else self.config['figsize'][0]
         height = 'window.screen.height' if self.config['figsize'][1] is None else self.config['figsize'][1]
@@ -864,6 +873,8 @@ class d3graph:
                    'density_grid_size': self.config.get('density_grid_size', 40),
                    'density_blur': self.config.get('density_blur', 8),
                    'density_opacity': self.config.get('density_opacity', 0.6),
+                   'show_controls': self.config.get('show_controls', True),
+                   'save_button': self.config['save_button'],
                    'node_text_inside': self.config.get('node_text_inside', False),
                    'CLICK_COMMENT': CLICK_COMMENT,
                    'CLICK_FILL': click_properties['fill'],
@@ -872,8 +883,6 @@ class d3graph:
                    'CLICK_STROKEW': click_properties['stroke-width'],
                    'slider_comment_start': show_slider[0],
                    'slider_comment_stop': show_slider[1],
-                   'save_button_comment_start': show_save_button[0],
-                   'save_button_comment_stop': show_save_button[1],
                    'SET_SLIDER': self.config['set_slider'],
                    'SUPPORT': support,
                    'background_color': self.config['background_color'],

{d3graph-2.9.3 → d3graph-2.9.4}/d3graph/d3js/index.html.j2

@@ -101,17 +101,14 @@
 <body style="background-color: {{ background_color }};{% if dark_mode %} color: #eee;{% endif %}"{% if dark_mode %} class="dark-mode"{% endif %}>
 
 <!-- Top right panel with dark mode and save buttons -->
+{% if show_controls %}
 <div class="top-panel">
     <button id="darkModeSwitch" class="button-switch">{% if dark_mode %}☀ Light Mode{% else %}🌙 Dark Mode{% endif %}</button>
     <button id="edgeToggleButton" class="button-switch">Hide Edges</button>
     <button id="densityToggleButton" class="button-switch">{% if show_density %}Hide Density{% else %}Show Density{% endif %}</button>
-    <button id="saveButton" class="button-switch">Save</button>
+    {% if save_button %}<button id="saveButton" class="button-switch">Save</button>{% endif %}
 </div>
-
-<!-- Create save button (removed old location) -->
-{{ save_button_comment_start }}
-    <!-- Save button now in top-panel -->
-{{ save_button_comment_stop }}
+{% endif %}
 
     <script>
         {% include "d3.v3.js" %}
@@ -153,29 +150,33 @@
                 document.body.style.color = '#eee';
                 let graphBg = document.getElementById('graphContainer');
                 if (graphBg) graphBg.style.backgroundColor = '#222';
-                darkSwitch.textContent = '☀ Light Mode';
+                if (darkSwitch) darkSwitch.textContent = '☀ Light Mode';
             } else {
                 document.body.classList.remove('dark-mode');
                 document.body.style.backgroundColor = originalBg;
                 document.body.style.color = '';
                 let graphBg = document.getElementById('graphContainer');
                 if (graphBg) graphBg.style.backgroundColor = originalBg;
-                darkSwitch.textContent = '🌙 Dark Mode';
+                if (darkSwitch) darkSwitch.textContent = '🌙 Dark Mode';
             }
             if (window.d3graphSetDarkMode) window.d3graphSetDarkMode(on);
         }
         // Set initial mode
         setDarkMode(darkMode);
-        darkSwitch.addEventListener('click', function () {
-            darkMode = !darkMode;
-            setDarkMode(darkMode);
-        });
+        if (darkSwitch) {
+            darkSwitch.addEventListener('click', function () {
+                darkMode = !darkMode;
+                setDarkMode(darkMode);
+            });
+        }
 
         // Save image to svg
         // Note: when the graph is large enough to switch to canvas-rendered edges
         // (see canvas_edge_threshold), this export will include nodes but not edges,
         // since edges live on a separate <canvas> element, not in the SVG DOM.
-        document.getElementById('saveButton').addEventListener('click', function () {
+        var saveBtn = document.getElementById('saveButton');
+        if (saveBtn) {
+            saveBtn.addEventListener('click', function () {
             var svgData = document.querySelector('svg').outerHTML;
             var blob = new Blob([svgData], {type: "image/svg+xml;charset=utf-8"});
             var url = URL.createObjectURL(blob);
@@ -183,7 +184,8 @@
             link.href = url;
             link.download = '{{ title }}.svg';
             link.click();
-        });
+            });
+        }
         
         
     </script>

{d3graph-2.9.3 → d3graph-2.9.4}/d3graph/examples.py

@@ -6,7 +6,7 @@ d3 = d3graph()
 # Load example data
 df = d3.import_example('socialmedia')
 # Slice first 10000 rows
-df = df[0:10000]
+df = df[0:1000]
 # Create adjmat
 adjmat = vec2adjmat(source=df['source'], target=df['target'], weight=df['weight'])
 # Update matrix with random weights
@@ -20,7 +20,14 @@ d3.graph(adjmat)
 # d3.show()
 
 # Show graph with custom specific settings
-d3.show(density_grid_size=60, density_blur=10, density_opacity=0.6, dark_mode=True, show_density=True)
+d3.show(density_grid_size=60,
+        density_blur=100,
+        density_opacity=0.6,
+        dark_mode=True,
+        show_density=True,
+        show_slider=True,
+        show_controls=True,
+        )
 
 # %%
 from d3graph import d3graph, vec2adjmat
@@ -60,7 +67,7 @@ d3.set_path(output_path)
 d3.config['filepath']
 
 d3.graph(adjmat)
-d3.show()
+d3.show(show_controls=True)
 
 # sticky=False — classic spring-back behaviour
 d3 = d3graph(adjmat, sticky=False)

d3graph-2.9.4/d3graph/examples_rankings.py

@@ -0,0 +1,308 @@
+from d3graph import d3graph, vec2adjmat
+
+import matplotlib.pyplot as plt
+import networkx as nx
+import numpy as np
+import pandas as pd
+
+
+# ---------------------------------------------------------
+# Helper functions
+# ---------------------------------------------------------
+def scale_values(values, min_value=8, max_value=40):
+    """Scale numeric values to an integer range."""
+    values = np.asarray(values, dtype=float)
+
+    if np.allclose(values.min(), values.max()):
+        return np.full(values.shape, min_value, dtype=int)
+
+    scaled = (
+        min_value
+        + (values - values.min())
+        * (max_value - min_value)
+        / (values.max() - values.min())
+    )
+
+    return np.round(scaled).astype(int)
+
+
+def values_to_colors(values, cmap="viridis"):
+    """Convert numeric values to hexadecimal colors."""
+    values = np.asarray(values, dtype=float)
+
+    if np.allclose(values.min(), values.max()):
+        normalized = np.zeros_like(values)
+    else:
+        normalized = (
+            (values - values.min())
+            / (values.max() - values.min())
+        )
+
+    colormap = plt.get_cmap(cmap)
+
+    return [
+        "#{:02x}{:02x}{:02x}".format(
+            int(r * 255),
+            int(g * 255),
+            int(b * 255),
+        )
+        for r, g, b, _ in colormap(normalized)
+    ]
+
+
+# ---------------------------------------------------------
+# Load data
+# ---------------------------------------------------------
+d3 = d3graph()
+df = d3.import_example("socialmedia")
+
+# Slice the first 1,000 interactions
+df = df.iloc[:10000].copy()
+# Create adjacency matrix
+adjmat = vec2adjmat(source=df["source"], target=df["target"], weight=df["weight"])
+
+
+# ---------------------------------------------------------
+# Compute weighted HITS
+# ---------------------------------------------------------
+G = nx.from_pandas_adjacency(adjmat, create_using=nx.DiGraph)
+hub_scores, authority_scores = nx.hits(G, max_iter=1000, tol=1e-8, normalized=True)
+
+# Make sure scores follow exactly the adjacency-matrix order
+nodes = adjmat.index.tolist()
+
+scores = pd.DataFrame({
+    "node": nodes,
+    "hub_score": [hub_scores[node] for node in nodes],
+    "authority_score": [
+        authority_scores[node]
+        for node in nodes
+    ],
+})
+
+scores["combined_score"] = (scores["hub_score"] + scores["authority_score"]) / 2
+
+
+# ---------------------------------------------------------
+# Convert scores into visual properties
+# ---------------------------------------------------------
+
+# Large node = strong authority
+node_size = scale_values(scores["authority_score"], min_value=8, max_value=100)
+
+# Bright color = strong hub
+node_color = values_to_colors(
+    scores["hub_score"],
+    cmap="plasma",
+)
+
+node_tooltip = [
+    (
+        f"{row.node}<br>"
+        f"Authority: {row.authority_score:.4f}<br>"
+        f"Hub: {row.hub_score:.4f}<br>"
+        f"Combined: {row.combined_score:.4f}"
+    )
+    for row in scores.itertuples()
+]
+
+
+# ---------------------------------------------------------
+# Create d3graph
+# ---------------------------------------------------------
+d3.graph(adjmat)
+d3.set_node_properties(size=node_size, color=node_color, tooltip=node_tooltip)
+
+# ---------------------------------------------------------
+# Show graph
+# ---------------------------------------------------------
+d3.show(
+    density_grid_size=150,
+    density_blur=10,
+    density_opacity=0.6,
+    dark_mode=True,
+    show_density=True,
+    show_slider=True,
+    show_controls=True,
+)
+
+# %%
+
+top_authorities = scores.sort_values("authority_score", ascending=False).head(10)
+top_hubs = scores.sort_values("hub_score", ascending=False).head(10)
+
+print("Top authorities")
+print(
+    top_authorities[
+        ["node", "authority_score", "hub_score"]
+    ]
+)
+
+print("\nTop hubs")
+print(
+    top_hubs[
+        ["node", "hub_score", "authority_score"]
+    ]
+)
+
+# These nodes have the highest hub scores, which means they are good connectors rather than necessarily being the most influential or popular accounts.
+
+# In HITS:
+# Hub score answers: "Does this account point to important accounts?"
+# Authority score answers: "Do important accounts point to this account?"
+
+# | Node                    |          Hub | Authority | Interpretation                                                                       |
+# | ----------------------- | -----------: | --------: | ------------------------------------------------------------------------------------ |
+# | @Uzbekmastodon.social   | **0.014656** |  0.001477 | Connects to many important accounts but is not itself frequently referenced by them. |
+# | @you_laugh2@...         | **0.013841** |  0.000501 | Acts as a curator or broadcaster, directing attention toward authoritative users.    |
+# | @alegrilmastodon.social | **0.013661** |  0.000205 | Similar role: a strong connector but not a central authority.                        |
+
+
+# Intuition
+# Imagine a conference:
+# Authorities are the keynote speakers everyone refers to.
+# Hubs are the attendees who know all the keynote speakers and introduce people to them.
+
+# A hub doesn't have to be famous—it becomes valuable because it connects others to influential people.
+# Why are the authority scores so small?
+# This is perfectly normal. HITS computes the dominant eigenvectors of the graph, and the absolute values themselves have no intrinsic meaning. What matters is the ranking.
+
+# A good way to explain this in your blog
+
+# HITS distinguishes two different notions of importance. Authorities are users that receive attention from well-connected users, 
+# while hubs are users that actively connect to many authorities.
+# In social networks, authorities often represent influential individuals, whereas hubs act more like curators, aggregators, 
+# or information distributors.
+
+# This distinction is one of the main advantages of HITS over methods like PageRank, which produces a single influence score.
+# HITS reveals different roles that users play within the network rather than collapsing everything into one ranking.
+
+
+
+# %%
+# =============================================================================
+# PAGERANKS
+# =============================================================================
+import networkx as nx
+import pandas as pd
+
+# Create directed graph from adjacency matrix
+G = nx.from_pandas_adjacency(adjmat, create_using=nx.DiGraph)
+
+# Compute weighted PageRank
+pagerank = nx.pagerank(G, alpha=0.85, weight="weight")
+
+# Convert to dataframe
+scores = (
+    pd.DataFrame({
+        "node": list(pagerank.keys()),
+        "pagerank": list(pagerank.values())
+    })
+    .sort_values("pagerank", ascending=False)
+    .reset_index(drop=True)
+)
+
+print(scores.head(10))
+
+
+# Node size
+node_size = scale_values(
+    scores["pagerank"],
+    min_value=8,
+    max_value=45,
+)
+
+# Node color
+node_color = values_to_colors(
+    scores["pagerank"],
+    cmap="plasma",
+)
+
+node_tooltip = [
+    f"{row.node}<br>PageRank: {row.pagerank:.5f}"
+    for row in scores.itertuples()
+]
+
+d3.graph(adjmat)
+
+d3.set_node_properties(
+    size=node_size,
+    color=node_color,
+    tooltip=node_tooltip,
+)
+
+d3.show(
+    density_grid_size=150,
+    density_blur=10,
+    density_opacity=0.6,
+    dark_mode=True,
+    show_density=True,
+    show_slider=True,
+    show_controls=True,
+)
+
+# %%
+# For a social network, permute the edges while preserving the number of nodes, or even better, preserve the degree distribution if you want a stronger null model. For a blog, simple edge permutation is easy to explain.
+
+# 1 Compute the observed PageRank.
+# 2 Destroy the network structure by random permutation.
+# 3 Compute PageRank again.
+# 4 Repeat many times (e.g., 1000).
+# 5 This gives a null distribution for every node.
+# 6 Use distfit to estimate the null distribution (or use the empirical distribution directly).
+# 7 Compute p-values and FDR.
+
+G = nx.from_pandas_adjacency(adjmat, create_using=nx.DiGraph)
+pagerank_obs = nx.pagerank(G, alpha=0.85, weight="weight")
+nodes = list(adjmat.index)
+pagerank_obs = np.array([pagerank_obs[n] for n in nodes])
+
+# %%
+# =============================================================================
+# PERMUTE
+# =============================================================================
+
+n_perm = 100
+pagerank_null = np.zeros((n_perm, len(nodes)))
+adj = adjmat.values.copy()
+
+for i in range(n_perm):
+    # Randomize edge locations
+    shuffled = adj.flatten().copy()
+    np.random.shuffle(shuffled)
+    shuffled = shuffled.reshape(adj.shape)
+    G_perm = nx.from_numpy_array(shuffled, create_using=nx.DiGraph)
+    pr = nx.pagerank(G_perm, alpha=0.85, weight="weight")
+    pagerank_null[i] = np.array([pr[k] for k in range(len(nodes))])
+
+# %%
+# =============================================================================
+#  Use distfit to estimate the null distribution (or use the empirical distribution directly).
+# =============================================================================
+from distfit import distfit
+
+results = []
+
+for i, node in enumerate(nodes):
+    dfit = distfit(verbose=0)
+    dfit.fit_transform(pagerank_null[:, i])
+    p = dfit.predict(pagerank_obs[i])["y_proba"]
+    results.append([node, pagerank_obs[i], p, dfit.model["name"]])
+
+df = pd.DataFrame(results, columns=["node", "pagerank", "pvalue", "distribution"])
+
+# %%
+node = 0
+
+dfit = distfit()
+dfit.fit_transform(pagerank_null[:, node])
+
+dfit.plot()
+dfit.plot_summary()
+node = 0
+
+dfit = distfit()
+dfit.fit_transform(pagerank_null[:, node])
+
+dfit.plot()
+dfit.plot_summary()

d3graph-2.9.4/d3graph/examples_rankings_Pvalue.py

@@ -0,0 +1,378 @@
+import networkx as nx
+import numpy as np
+import pandas as pd
+
+from distfit import distfit
+from scipy import stats
+from statsmodels.stats.multitest import multipletests
+
+from d3graph import d3graph, vec2adjmat
+
+import matplotlib.pyplot as plt
+
+# ---------------------------------------------------------
+# Helper functions
+# ---------------------------------------------------------
+def scale_values(values, min_value=8, max_value=40):
+    """Scale numeric values to an integer range."""
+    values = np.asarray(values, dtype=float)
+
+    if np.allclose(values.min(), values.max()):
+        return np.full(values.shape, min_value, dtype=int)
+
+    scaled = (
+        min_value
+        + (values - values.min())
+        * (max_value - min_value)
+        / (values.max() - values.min())
+    )
+
+    return np.round(scaled).astype(int)
+
+
+def values_to_colors(values, cmap="viridis"):
+    """Convert numeric values to hexadecimal colors."""
+    values = np.asarray(values, dtype=float)
+
+    if np.allclose(values.min(), values.max()):
+        normalized = np.zeros_like(values)
+    else:
+        normalized = (
+            (values - values.min())
+            / (values.max() - values.min())
+        )
+
+    colormap = plt.get_cmap(cmap)
+
+    return [
+        "#{:02x}{:02x}{:02x}".format(
+            int(r * 255),
+            int(g * 255),
+            int(b * 255),
+        )
+        for r, g, b, _ in colormap(normalized)
+    ]
+
+
+
+def pagerank_permutation_test(
+    adjmat,
+    n_perm=1000,
+    alpha=0.85,
+    swaps_per_edge=10,
+    random_state=42,
+    fit_distributions=True,
+    verbose=0,
+):
+    """Test PageRank scores using directed degree-preserving permutations.
+
+    The null model preserves:
+    - number of nodes
+    - number of edges
+    - in-degree of every node
+    - out-degree of every node
+    - global edge-weight distribution
+
+    Parameters
+    ----------
+    adjmat : pandas.DataFrame
+        Directed adjacency matrix. Rows are sources and columns are targets.
+
+    n_perm : int, default=1000
+        Number of randomized networks.
+
+    alpha : float, default=0.85
+        PageRank damping parameter.
+
+    swaps_per_edge : int, default=10
+        Requested edge swaps per edge for each randomized graph.
+
+    random_state : int, default=42
+        Random seed.
+
+    fit_distributions : bool, default=True
+        Fit a parametric null distribution with distfit for each node.
+
+    verbose : int, default=0
+        Print progress when larger than zero.
+
+    Returns
+    -------
+    results : pandas.DataFrame
+        Observed PageRank, empirical p-values, fitted p-values and FDR values.
+
+    pagerank_null : pandas.DataFrame
+        Null PageRank values. Rows are permutations and columns are nodes.
+
+    fitted_models : dict
+        Fitted distfit objects keyed by node.
+    """
+    if not isinstance(adjmat, pd.DataFrame):
+        raise TypeError("adjmat must be a pandas DataFrame.")
+
+    if adjmat.shape[0] != adjmat.shape[1]:
+        raise ValueError("adjmat must be square.")
+
+    if not adjmat.index.equals(adjmat.columns):
+        raise ValueError(
+            "The row and column labels of adjmat must have the same order."
+        )
+
+    rng = np.random.default_rng(random_state)
+
+    # Build observed graph
+    G = nx.from_pandas_adjacency(
+        adjmat,
+        create_using=nx.DiGraph,
+    )
+
+    # Remove zero-weight edges and self-loops
+    zero_edges = [
+        (source, target)
+        for source, target, data in G.edges(data=True)
+        if data.get("weight", 0) <= 0
+    ]
+    G.remove_edges_from(zero_edges)
+    G.remove_edges_from(nx.selfloop_edges(G))
+
+    nodes = list(adjmat.index)
+    n_edges = G.number_of_edges()
+
+    if n_edges < 3:
+        raise ValueError(
+            "At least three directed edges are required for directed edge swaps."
+        )
+
+    # Observed PageRank
+    observed_dict = nx.pagerank(
+        G,
+        alpha=alpha,
+        weight="weight",
+    )
+
+    observed = np.array(
+        [observed_dict[node] for node in nodes],
+        dtype=float,
+    )
+
+    # Preserve the global edge-weight distribution
+    original_weights = np.array(
+        [
+            data.get("weight", 1.0)
+            for _, _, data in G.edges(data=True)
+        ],
+        dtype=float,
+    )
+
+    pagerank_null = np.full(
+        shape=(n_perm, len(nodes)),
+        fill_value=np.nan,
+        dtype=float,
+    )
+
+    nswap = max(1, swaps_per_edge * n_edges)
+    max_tries = max(100, nswap * 20)
+
+    for permutation in range(n_perm):
+        G_null = G.copy()
+
+        # Topology only: remove weights before rewiring
+        for source, target in G_null.edges():
+            G_null[source][target]["weight"] = 1.0
+
+        try:
+            nx.directed_edge_swap(
+                G_null,
+                nswap=nswap,
+                max_tries=max_tries,
+                seed=int(rng.integers(0, 2**32 - 1)),
+            )
+        except nx.NetworkXAlgorithmError:
+            # Dense or highly constrained networks may not permit all swaps.
+            # Retry with fewer requested swaps.
+            nx.directed_edge_swap(
+                G_null,
+                nswap=max(1, nswap // 10),
+                max_tries=max_tries,
+                seed=int(rng.integers(0, 2**32 - 1)),
+            )
+
+        # Randomly assign original weights to the rewired edges
+        shuffled_weights = rng.permutation(original_weights)
+
+        for edge, weight in zip(G_null.edges(), shuffled_weights):
+            source, target = edge
+            G_null[source][target]["weight"] = float(weight)
+
+        pr_null = nx.pagerank(
+            G_null,
+            alpha=alpha,
+            weight="weight",
+        )
+
+        pagerank_null[permutation, :] = [
+            pr_null[node] for node in nodes
+        ]
+
+        if verbose and (permutation + 1) % 100 == 0:
+            print(
+                f"Completed {permutation + 1}/{n_perm} permutations"
+            )
+
+    # Empirical upper-tail permutation p-value.
+    #
+    # Adding 1 prevents a zero p-value:
+    # p = (number of null scores >= observed + 1) / (n_perm + 1)
+    empirical_pvalue = (
+        1
+        + np.sum(
+            pagerank_null >= observed[np.newaxis, :],
+            axis=0,
+        )
+    ) / (n_perm + 1)
+
+    null_mean = np.nanmean(pagerank_null, axis=0)
+    null_std = np.nanstd(
+        pagerank_null,
+        axis=0,
+        ddof=1,
+    )
+
+    null_zscore = np.divide(
+        observed - null_mean,
+        null_std,
+        out=np.full_like(observed, np.nan),
+        where=null_std > 0,
+    )
+
+    results = pd.DataFrame({
+        "node": nodes,
+        "pagerank": observed,
+        "null_mean": null_mean,
+        "null_std": null_std,
+        "zscore": null_zscore,
+        "pvalue_empirical": empirical_pvalue,
+    })
+
+    fitted_models = {}
+
+    if fit_distributions:
+        distribution_names = []
+        fitted_pvalues = []
+
+        for node_index, node in enumerate(nodes):
+            null_values = pagerank_null[:, node_index]
+            null_values = null_values[np.isfinite(null_values)]
+
+            dfit = distfit(verbose=0)
+            dfit.fit_transform(null_values)
+
+            fitted_models[node] = dfit
+
+            model_name = dfit.model["name"]
+            model_params = dfit.model["params"]
+
+            distribution = getattr(stats, model_name)
+
+            # One-sided upper-tail probability:
+            # probability of observing this PageRank or a larger one.
+            pvalue = distribution.sf(
+                observed[node_index],
+                *model_params,
+            )
+
+            distribution_names.append(model_name)
+            fitted_pvalues.append(float(pvalue))
+
+        results["distribution"] = distribution_names
+        results["pvalue_fitted"] = fitted_pvalues
+
+        results["qvalue_fitted"] = multipletests(
+            results["pvalue_fitted"],
+            method="fdr_bh",
+        )[1]
+
+    results["qvalue_empirical"] = multipletests(
+        results["pvalue_empirical"],
+        method="fdr_bh",
+    )[1]
+
+    results["significant"] = (
+        results["qvalue_empirical"] < 0.05
+    )
+
+    results = results.sort_values(
+        ["qvalue_empirical", "pagerank"],
+        ascending=[True, False],
+    ).reset_index(drop=True)
+
+    pagerank_null = pd.DataFrame(
+        pagerank_null,
+        columns=nodes,
+    )
+
+    return results, pagerank_null, fitted_models
+
+# %%
+d3 = d3graph()
+
+df = d3.import_example('socialmedia')
+adjmat = vec2adjmat(source=df['source'], target=df['target'], weight=df['weight'])
+results, pagerank_null, fitted_models = pagerank_permutation_test(adjmat, n_perm=1000, swaps_per_edge=10, random_state=42, fit_distributions=True, verbose=1)
+
+print(results[["node", "pagerank", "null_mean", "zscore", "pvalue_empirical", "qvalue_empirical", "distribution", "pvalue_fitted", "significant"]].head(20))
+
+# The interpretation is:
+# The observed PageRank of @important_user.social is higher than almost all PageRank scores obtained from randomized networks with exactly the same node-level in-degree and out-degree. Its position is therefore unlikely to be explained by degree alone.
+
+# %%
+
+node = results.iloc[0]["node"]
+dfit = fitted_models[node]
+dfit.plot(title=f"Null PageRank distribution: {node}")
+observed_pagerank = results.loc[results["node"] == node, "pagerank"].iloc[0]
+
+print("Observed PageRank:", observed_pagerank)
+print("Empirical p-value:", results.loc[results["node"] == node, "pvalue_empirical"].iloc[0])
+
+# %%
+
+node_results = results.set_index("node").reindex(adjmat.index)
+
+node_size = scale_values(
+    node_results["pagerank"].values,
+    min_value=8,
+    max_value=45,
+)
+
+node_color = np.where(
+    node_results["significant"].values,
+    "#ff4d4d",
+    "#808080",
+).tolist()
+
+node_tooltip = [
+    (
+        f"{node}<br>"
+        f"PageRank: {row.pagerank:.5f}<br>"
+        f"Expected: {row.null_mean:.5f}<br>"
+        f"Z-score: {row.zscore:.2f}<br>"
+        f"Empirical p: {row.pvalue_empirical:.4g}<br>"
+        f"FDR q: {row.qvalue_empirical:.4g}<br>"
+        f"Significant: {row.significant}"
+    )
+    for node, row in node_results.iterrows()
+]
+
+
+d3.graph(adjmat)
+
+d3.set_node_properties(
+    size=node_size,
+    color=node_color,
+    tooltip=node_tooltip,
+)
+
+
+# For reporting significance, I recommend using pvalue_empirical and qvalue_empirical as the primary results. The fitted distfit distribution is useful for smoothing and visualization, but the empirical permutation p-value makes fewer distributional assumptions.
+

{d3graph-2.9.3 → d3graph-2.9.4/d3graph.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: d3graph
-Version: 2.9.3
+Version: 2.9.4
 Summary: Python package to create interactive network based on d3js.
 Author-email: Erdogan Taskesen <erdogant@gmail.com>
 License-Expression: BSD-3-Clause
@@ -103,6 +103,14 @@ from d3graph import d3graph
   </a>
 </p>
 
+
+<p align="left">
+  <a href="https://erdogant.github.io/docs/d3graph/titanic_example/index.html">
+     <img src="https://github.com/d3blocks/d3blocks/blob/main/docs/figs/d3graph/socialmedia.gif" width="1000"/>
+  </a>
+</p>
+
+
 <hr>
 
 ### Contributors

{d3graph-2.9.3 → d3graph-2.9.4}/d3graph.egg-info/SOURCES.txt

@@ -6,6 +6,8 @@ d3graph/__init__.py
 d3graph/d3graph.py
 d3graph/examples.py
 d3graph/examples_docs.py
+d3graph/examples_rankings.py
+d3graph/examples_rankings_Pvalue.py
 d3graph.egg-info/PKG-INFO
 d3graph.egg-info/SOURCES.txt
 d3graph.egg-info/dependency_links.txt