d3graph 2.8.2__tar.gz → 2.9.1__tar.gz

{d3graph-2.8.2/d3graph.egg-info → d3graph-2.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: d3graph
-Version: 2.8.2
+Version: 2.9.1
 Summary: Python package to create interactive network based on d3js.
 Author-email: Erdogan Taskesen <erdogant@gmail.com>
 License-Expression: BSD-3-Clause

{d3graph-2.8.2 → d3graph-2.9.1}/d3graph/__init__.py

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

{d3graph-2.8.2 → d3graph-2.9.1}/d3graph/d3graph.py

@@ -121,6 +121,8 @@ class d3graph:
              link_tension: float = None,
              sticky: bool = None,
              node_text_inside: bool = False,
+             max_ticks: int = 300,
+             label_zoom_threshold: float = 0.4,
              ) -> None:
         """Build and show the graph.
 
@@ -166,6 +168,15 @@ class d3graph:
             When False, nodes are released after dragging (default simulation behaviour).
             When None, the value set in __init__ is used.
             Right-click a fixed node to release it back into the simulation.
+        max_ticks : int, (default: 300)
+            Caps how many simulation ticks run before the force layout auto-stops, instead
+            of letting it cool down naturally (which can take thousands of ticks on large
+            graphs, each re-running collision detection over every node).
+            0 or None: disable the cap and run to natural cooldown.
+        label_zoom_threshold : float, (default: 0.6)
+            Node and edge labels are hidden below this zoom scale (unreadable anyway, and
+            costly to keep rendering for large graphs) and reappear once zoomed back in
+            past it. Uses a single CSS class toggle, not per-label work. 0: never hide.
 
         Returns
         -------
@@ -188,6 +199,8 @@ class d3graph:
         self.config['background_color'] = background_color
         self.config['dark_mode'] = dark_mode
         self.config['node_text_inside'] = node_text_inside
+        self.config['max_ticks'] = max_ticks
+        self.config['label_zoom_threshold'] = label_zoom_threshold
 
         # Allow show() to override the link_tension set at __init__ time
         if link_tension is not None:
@@ -339,7 +352,7 @@ class d3graph:
             return
 
         if (not directed) and (marker_end is not None) or (marker_start is not None):
-            logger.info('Set directed=True to see the markers!')
+            logger.info('Markers not shown. Set directed=True to see the markers.')
 
         # Get node color properties which is required to set the edge color
         node_color_map = None
@@ -351,6 +364,7 @@ class d3graph:
                 self.config['edge_color'] = '#808080'
 
         # Set the edge properties
+        logger.info('Set the edge properties')
         self.edge_properties, self.adjmat = adjmat2dict(
             self.adjmat,
             filter_weight=0,
@@ -372,7 +386,7 @@ class d3graph:
             node_color_map=node_color_map,
         )
 
-        logger.debug('Number of edges: %.0d', len(self.edge_properties.keys()))
+        # logger.info(f'Number of edges: {len(self.edge_properties.keys())}')
 
     def set_node_properties(self,
                             label=None,
@@ -697,7 +711,7 @@ class d3graph:
         Parameters
         ----------
         adjmat : pd.DataFrame()
-            Adjacency matrix (symmetric). Values > 0 are edges.
+            Adjacency matrix (symmetric and Values > 0 are edges).
         color : list of strings (default: 'cluster')
             Coloring of the nodes.
             * 'cluster' or None : Colours are based on the community distance clusters.
@@ -801,6 +815,8 @@ class d3graph:
                    'collision': self.config['collision'],
                    'link_tension': self.config.get('link_tension', 1.0),
                    'sticky': self.config.get('sticky', False),
+                   'max_ticks': self.config.get('max_ticks', 300),
+                   'label_zoom_threshold': self.config.get('label_zoom_threshold', 0.6),
                    'node_text_inside': self.config.get('node_text_inside', False),
                    'CLICK_COMMENT': CLICK_COMMENT,
                    'CLICK_FILL': click_properties['fill'],
@@ -1138,21 +1154,23 @@ def adjmat2dict(adjmat: pd.DataFrame,
             'tooltip': Text that is shown when hovering over the edge.
 
     """
-    # Convert adjacency matrix into vector
-    df = adjmat.stack().reset_index()
-    # Set columns
-    df.columns = ['source', 'target', 'weight']
-    # Combine source-target values with weights
-    df = create_unique_dataframe(df)
-    # Remove self loops and no-connected edges
-    Iloc = df['source'] != df['target']
-    # Keep only edges with a minimum edge strength
-    if filter_weight is not None:
-        logger.info("Keep only edges with weight>%g" % filter_weight)
-        Iloc2 = df['weight'] > filter_weight
-        Iloc = Iloc & Iloc2
-    df = df.loc[Iloc, :]
-    df.reset_index(drop=True, inplace=True)
+    # # Convert adjacency matrix into vector
+    # df = adjmat.stack().reset_index()
+    # # Set columns
+    # df.columns = ['source', 'target', 'weight']
+    # # Combine source-target values with weights
+    # df = create_unique_dataframe(df)
+    # # Remove self loops and no-connected edges
+    # Iloc = df['source'] != df['target']
+    # # Keep only edges with a minimum edge strength
+    # if filter_weight is not None:
+    #     logger.info(f"Keep only edges with weight>{filter_weight}")
+    #     Iloc2 = df['weight'] > filter_weight
+    #     Iloc = Iloc & Iloc2
+    # df = df.loc[Iloc, :]
+    # df.reset_index(drop=True, inplace=True)
+
+    df = adjmat2vec(adjmat)
 
     # Scale the weights for visualization purposes
     if minmax_distance is not None:
@@ -1210,6 +1228,7 @@ def adjmat2dict(adjmat: pd.DataFrame,
     source_target = list(zip(df['source'], df['target']))
     if len(source_target)==0:
         raise Exception('There are no links in the input data set that have unique source-target value with weight > 0')
+    
     # Return
     d = {edge: {'weight': df['weight'].iloc[i],
                    'weight_scaled': df['weight_scaled'].iloc[i],
@@ -1234,6 +1253,36 @@ def adjmat2dict(adjmat: pd.DataFrame,
 
 
 # %% Create unique dataframe and update weights
+# def create_unique_dataframe(X, logger=None):
+#     """Combine source-target into adjacency matrix with updated weights.
+
+#     Parameters
+#     ----------
+#     X : DataFrame
+#         Data frame containing the columns [source, target, weight].
+#     logger : Object, optional
+#         Logger object. The default is None.
+
+#     Returns
+#     -------
+#     X : pd.DataFrame
+#         Unique adjacency matrix containing with index as source and columns as target labels. Weights are in the matrix.
+
+#     References
+#     ----------
+#     * This function is similar to that of d3blocks.
+
+#     """
+#     # Check whether labels are unique
+#     if isinstance(X, pd.DataFrame):
+#         Iloc = ismember(X.columns, ['source', 'target', 'weight'])[0]
+#         X = X.loc[:, Iloc]
+#         if 'weight' in X.columns: X['weight'] = X['weight'].astype(float)
+#         # Groupby values and sum the weights
+#         X = X.groupby(by=['source', 'target']).sum()
+#         X.reset_index(drop=False, inplace=True)
+#     return X
+
 def create_unique_dataframe(X, logger=None):
     """Combine source-target into adjacency matrix with updated weights.
 
@@ -1254,15 +1303,12 @@ def create_unique_dataframe(X, logger=None):
     * This function is similar to that of d3blocks.
 
     """
-    # Check whether labels are unique
-    if isinstance(X, pd.DataFrame):
-        Iloc = ismember(X.columns, ['source', 'target', 'weight'])[0]
-        X = X.loc[:, Iloc]
-        if 'weight' in X.columns: X['weight'] = X['weight'].astype(float)
-        # Groupby values and sum the weights
-        X = X.groupby(by=['source', 'target']).sum()
-        X.reset_index(drop=False, inplace=True)
-    return X
+    X = X[['source', 'target', 'weight']]
+    return (
+        X.groupby(['source', 'target'], sort=False, observed=True)
+         .agg({'weight': 'sum'})
+         .reset_index()
+    )
 
 
 # %% Convert dict with edges to graph (G) (also works with lower versions of networkx)
@@ -1565,61 +1611,80 @@ def vec2adjmat(source, target, weight=None, symmetric: bool = True, aggfunc='sum
 
 
 # %%  Convert adjacency matrix to vector
+# def adjmat2vec(adjmat, min_weight: float = 1.0) -> pd.DataFrame:
+#     """Convert adjacency matrix into vector with source and target.
+
+#     Parameters
+#     ----------
+#     adjmat : pd.DataFrame()
+#         Adjacency matrix.
+
+#     min_weight : float
+#         edges are returned with a minimum weight.
+
+#     Returns
+#     -------
+#     pd.DataFrame()
+#         nodes that are connected based on source and target
+
+#     Examples
+#     --------
+#     >>> source = ['Cloudy', 'Cloudy', 'Sprinkler', 'Rain']
+#     >>> target = ['Sprinkler', 'Rain', 'Wet_Grass', 'Wet_Grass']
+#     >>> adjmat = vec2adjmat(source, target, weight=[1, 2, 1, 3])
+#     >>> vector = adjmat2vec(adjmat)
+
+#     """
+#     # Convert adjacency matrix into vector
+#     logger.info('Converting adjacency matrix into source-target..')
+#     adjmat = adjmat.stack().reset_index()
+#     # Set columns
+#     adjmat.columns = ['source', 'target', 'weight']
+#     # Remove self loops and no-connected edges
+#     Iloc1 = adjmat['source'] != adjmat['target']
+#     Iloc2 = adjmat['weight'] >= min_weight
+#     Iloc = Iloc1 & Iloc2
+#     # Take only connected nodes
+#     adjmat = adjmat.loc[Iloc, :]
+#     adjmat.reset_index(drop=True, inplace=True)
+#     return adjmat
+
+
 def adjmat2vec(adjmat, min_weight: float = 1.0) -> pd.DataFrame:
-    """Convert adjacency matrix into vector with source and target.
+    """
+    Fast conversion of adjacency matrix → edge list.
+    Removes self-loops and filters by min_weight.
+    """
+    weights = adjmat.to_numpy(copy=False)
 
-    Parameters
-    ----------
-    adjmat : pd.DataFrame()
-        Adjacency matrix.
+    # Mask of valid edges (stack() drops NaN, so we mimic that)
+    mask = ~np.isnan(weights)
 
-    min_weight : float
-        edges are returned with a minimum weight.
+    # Extract coordinates of non-NaN entries
+    row_idx, col_idx = np.nonzero(mask)
 
-    Returns
-    -------
-    pd.DataFrame()
-        nodes that are connected based on source and target
+    index = adjmat.index.to_numpy()
+    columns = adjmat.columns.to_numpy()
 
-    Examples
-    --------
-    >>> source = ['Cloudy', 'Cloudy', 'Sprinkler', 'Rain']
-    >>> target = ['Sprinkler', 'Rain', 'Wet_Grass', 'Wet_Grass']
-    >>> adjmat = vec2adjmat(source, target, weight=[1, 2, 1, 3])
-    >>> vector = adjmat2vec(adjmat)
+    # Build edge list
+    df = pd.DataFrame({
+        'source': index[row_idx],
+        'target': columns[col_idx],
+        'weight': weights[row_idx, col_idx],
+    })
 
-    """
-    # Convert adjacency matrix into vector
-    logger.info('Converting adjacency matrix into source-target..')
-    adjmat = adjmat.stack().reset_index()
-    # Set columns
-    adjmat.columns = ['source', 'target', 'weight']
-    # Remove self loops and no-connected edges
-    Iloc1 = adjmat['source'] != adjmat['target']
-    Iloc2 = adjmat['weight'] >= min_weight
-    Iloc = Iloc1 & Iloc2
-    # Take only connected nodes
-    adjmat = adjmat.loc[Iloc, :]
-    adjmat.reset_index(drop=True, inplace=True)
-    return adjmat
+    # Remove self-loops
+    df = df[df['source'] != df['target']]
 
+    # Apply minimum weight filter
+    if min_weight is not None:
+        df = df[df['weight'] >= min_weight]
+
+    df.reset_index(drop=True, inplace=True)
+    return df
 
-# def _check_hex_color(color, n=None, cmap='Set1'):
-#     if isinstance(color, str) and len(color) != 7:
-#         logger.warning('Input parameter [color] has wrong format. Must be like color="#000000" <auto-fixing>')
-#         return get_hex_color(color, cmap=cmap)[0]
-#     if isinstance(color, (list, np.ndarray, pd.Series, pd.Series, StringArray)) and len(color) == 0:
-#         logger.warning('Input parameter [color] has wrong format and length. Must be like: color=["#000000", "...", "#000000"] <auto-fixing>')
-#         return get_hex_color(color, cmap=cmap)[0]
-#     if isinstance(color, (list, np.ndarray, pd.Series, pd.Series, StringArray)) and (not np.all(list(map(lambda x: len(x) == 7, color)))):
-#         logger.warning('[color] contains incorrect hex-colors. Hex must be of length 7: ["#000000", "#000000", etc] <auto-fixing>')
-#         return get_hex_color(color, cmap=cmap)[0]
-#     if (n is not None) and isinstance(color, (list, np.ndarray, pd.Series, pd.Series, StringArray)) and len(color) != n:
-#         logger.warning(f'Input parameter [color] has wrong length. Must be of length: {str(n)} <auto-fixing>')
-#         return get_hex_color(color, cmap=cmap)[0]
-#     # Return original input
-#     return color
 
+# %%
 def _check_hex_color(color, n=None, cmap='Set1'):
     seq_types = (list, np.ndarray, pd.Series, StringArray)
 

{d3graph-2.8.2 → d3graph-2.9.1}/d3graph/d3js/d3graphscript.js

@@ -10,6 +10,8 @@ function d3graphscript(config = {
     sticky: false,
     background_color: '#FFFFFF',
     node_text_inside: false,
+    max_ticks: 300,
+    label_zoom_threshold: 0.6,
     }) {
     
     //Constants for the SVG
@@ -17,6 +19,17 @@ function d3graphscript(config = {
     var height = config.height;
     var background_color = config.background_color || '#FFFFFF';
     var sticky = config.sticky || false;
+    // Cap how many simulation ticks run before auto-stopping, instead of
+    // letting a large graph's force layout cool down naturally over
+    // thousands of ticks (each one re-running collision detection over
+    // every node). Restarting the simulation (drag, slider changes) resets
+    // this counter so it still settles again after each change.
+    var maxTicks = (config.max_ticks !== undefined && config.max_ticks !== null) ? config.max_ticks : 300;
+    var tickCount = 0;
+    // Below this zoom scale, labels are unreadable anyway — hide them (via a
+    // single CSS class, not per-element work) instead of rendering thousands
+    // of illegible <text> nodes. They reappear once zoomed back in past it.
+    var labelZoomThreshold = (config.label_zoom_threshold !== undefined && config.label_zoom_threshold !== null) ? config.label_zoom_threshold : 0.6;
     
     // Set the body background color
     document.body.style.backgroundColor = background_color;
@@ -42,6 +55,7 @@ function d3graphscript(config = {
       d3.select(this).classed("dragging", true);
       if (sticky) {
         d.fixed = true;
+        tickCount = 0;
         force.start();
       }
     }
@@ -214,12 +228,26 @@ function d3graphscript(config = {
       .attr("width", width)
       .attr("height", height)
       .style("background-color", background_color)
-      .call(d3.behavior.zoom().on("zoom", function () { svg.attr("transform", "translate(" + d3.event.translate + ")" + " scale(" + d3.event.scale + ")") }))
+      .call(d3.behavior.zoom().on("zoom", function () {
+        svg.attr("transform", "translate(" + d3.event.translate + ")" + " scale(" + d3.event.scale + ")");
+        // Single class toggle (cheap) rather than iterating every label on
+        // every zoom/pan event — CSS handles hiding all descendant <text>.
+        svg.classed("labels-hidden", d3.event.scale < labelZoomThreshold);
+      }))
       .on("dblclick.zoom", null)
       .append("g")
     
-    graphRec = JSON.parse(JSON.stringify(graph));
-    
+    graphRec = JSON.parse(JSON.stringify(graph));   // Full, unfiltered copy — used by the slider to restore edges later
+
+    // Apply the initial slider threshold BEFORE building any DOM elements.
+    // Without this, the browser would create a <line>/<title>/<text> for every
+    // single edge (e.g. 100,000+) and immediately delete most of them once the
+    // slider filter ran — doubling the work and freezing the page in the meantime.
+    (function applyInitialThreshold() {
+      var initialThresh = {{ SET_SLIDER }};
+      graph.links = graph.links.filter(function(d) { return d.edge_weight > initialThresh; });
+    })();
+
     //Creates the graph data structure out of the json data
     force.nodes(graph.nodes)
       .links(graph.links)
@@ -268,6 +296,7 @@ function d3graphscript(config = {
         d3.select(this).select(".node-shape")
           .style("stroke-dasharray", null)
           .style("stroke-width", function(d) { return d.node_size_edge; });
+        tickCount = 0;
         force.resume();
       });
     }
@@ -309,6 +338,14 @@ function d3graphscript(config = {
     
     //Now we are giving the SVGs co-ordinates - the force layout is generating the co-ordinates which this code is using to update the attributes of the SVG elements
     force.on("tick", function() {
+      // Auto-stop after maxTicks so a large graph doesn't keep re-running
+      // collision detection / layout math for thousands of frames while
+      // settling. maxTicks <= 0 disables the cap (run to natural cooldown).
+      if (maxTicks > 0 && ++tickCount > maxTicks) {
+        force.stop();
+        return;
+      }
+
       link.attr("x1", function(d) { return d.source.x; })
         .attr("y1", function(d) { return d.source.y; })
         .attr("x2", function(d) { return d.target.x; })
@@ -317,7 +354,9 @@ function d3graphscript(config = {
       // Position each shape according to its SVG element type:
       //   circle / ellipse  →  cx / cy attributes
       //   path              →  transform translate(x, y)
-      d3.selectAll(".node-shape").each(function(d) {
+      // Scoped to the bound `node` selection instead of re-querying the
+      // entire DOM every tick (was: d3.selectAll(".node-shape")).
+      node.select(".node-shape").each(function(d) {
         var el  = d3.select(this);
         var tag = this.tagName.toLowerCase();
         if (tag === 'circle' || tag === 'ellipse') {
@@ -327,7 +366,9 @@ function d3graphscript(config = {
         }
       });
 
-      d3.selectAll("text").attr("x", function(d) { return d.x; })
+      // Scoped to node labels only (was: d3.selectAll("text"), which also
+      // re-matched every link-text element on every tick).
+      node.select("text").attr("x", function(d) { return d.x; })
         .attr("y", function(d) { return d.y; })
       linkText.attr("x", function(d) { return (d.source.x + d.target.x) / 2; })  // ADD TEXT ON THE EDGES (PART 2/2)
         .attr("y", function(d) { return (d.source.y + d.target.y) / 2; })
@@ -534,6 +575,7 @@ function d3graphscript(config = {
 
     node = node.data(graph.nodes);
     node.enter().insert("circle", ".cursor").attr("class", "node").attr("r", 5).call(force.drag);
+    tickCount = 0;
     force.start();
   }
 

{d3graph-2.8.2 → d3graph-2.9.1}/d3graph/d3js/index.html.j2

@@ -130,6 +130,8 @@
                 sticky: {{ sticky | lower }},
                 background_color: '{{ background_color }}',
                 node_text_inside: {{ node_text_inside | lower }},
+                max_ticks: {{ max_ticks }},
+                label_zoom_threshold: {{ label_zoom_threshold }},
             })
         });
 

{d3graph-2.8.2 → d3graph-2.9.1}/d3graph/d3js/style.css

@@ -27,4 +27,12 @@ h3 {
 /* Shared pointer cursor for all node shapes */
 .node .node-shape {
   cursor: pointer;
+}
+
+/* Zoom-linked label visibility (performance): when zoomed far out, node and
+   edge labels are unreadable anyway, so they're hidden via this single class
+   toggle instead of being permanently removed. Placed after .node text so it
+   wins on specificity ties. */
+.labels-hidden text {
+  display: none;
 }

{d3graph-2.8.2 → d3graph-2.9.1}/d3graph/examples.py

@@ -1,3 +1,25 @@
+# %%
+from d3graph import d3graph, vec2adjmat, import_example
+import pandas as pd
+import time
+
+
+df = pd.read_csv('https://github.com/d3blocks/d3blocks/files/11995798/Df.csv', sep=',', index_col=False)
+del df['Unnamed: 0']
+df = df[0:10000]
+adjmat = vec2adjmat(source=df['source'], target=df['target'], weight=df['weight'])
+
+d3 = d3graph()
+
+start = time.perf_counter()
+d3.graph(adjmat)
+end = time.perf_counter()
+
+d3.show()
+
+print(f"Elapsed: {end - start:.6f} seconds")
+
+
 # %% SET PATH ISSUE https://github.com/erdogant/d3graph/issues/42
 from pathlib import Path
 from d3graph import d3graph, vec2adjmat, import_example
@@ -109,15 +131,18 @@ adjmat = vec2adjmat(source=df['source'], target=df['target'], weight=df['weight'
 
 
 # sticky=True (default) — drag to pin, right-click to release
-d3 = d3graph(adjmat, sticky=True)
+d3 = d3graph(sticky=True)
+d3.graph(adjmat)
 d3.show()
 
 # sticky=False — classic spring-back behaviour
-d3 = d3graph(adjmat, sticky=False)
+d3 = d3graph(sticky=False)
+d3.graph(adjmat)
 d3.show()
 
 # Can also be overridden per-render:
-d3.show(adjmat, sticky=False)
+d3.show(sticky=False)
+d3.graph(adjmat)
 d3.show()
 
 

{d3graph-2.8.2 → d3graph-2.9.1/d3graph.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: d3graph
-Version: 2.8.2
+Version: 2.9.1
 Summary: Python package to create interactive network based on d3js.
 Author-email: Erdogan Taskesen <erdogant@gmail.com>
 License-Expression: BSD-3-Clause