d3graph 2.9.0__tar.gz → 2.9.2__tar.gz

{d3graph-2.9.0/d3graph.egg-info → d3graph-2.9.2}/PKG-INFO

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

{d3graph-2.9.0 → d3graph-2.9.2}/d3graph/__init__.py

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

{d3graph-2.9.0 → d3graph-2.9.2}/d3graph/d3graph.py

@@ -253,6 +253,7 @@ class d3graph:
                             edge_style=0,
                             edge_color: (str, list) = '#808080',
                             edge_opacity: (float, str, list) = 'weight',
+                            min_weight: float = 1.0,
                             scaler: str = 'zscore',
                             directed: bool = False,
                             marker_start=None,
@@ -287,6 +288,8 @@ class d3graph:
         edge_opacity : (float, str, list), (default: 1.0)
             * 0.8 : Opacity of the edges [0-1] where 0=transparent and 1=fully opaque.
             * 'weight' : Set opacity based on the weight of the edge and the scaler
+        min_weight : float
+            edges are kept with >= weight.
         scaler : str, (default: 'zscore')
             Scale the edge-width using the following scaler:
             * 'zscore' : Scale values to Z-scores.
@@ -346,13 +349,14 @@ class d3graph:
         self.config['label'] = label
         self.config['label_color'] = label_color
         self.config['label_fontsize'] = label_fontsize
+        self.config['min_weight'] = min_weight
         
         if not hasattr(self, 'adjmat'):
             logger.error('adjmat is missing. Initialize first with d3 = d3graph(adjmat)')
             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
@@ -364,9 +368,10 @@ 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,
+            min_weight=self.config['min_weight'],
             minmax=self.config['minmax'],
             minmax_distance=self.config['minmax_distance'],
             scaler=self.config['edge_scaler'],
@@ -385,7 +390,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,6 +702,7 @@ class d3graph:
 
     def graph(self,
               adjmat,
+              min_weight: float = 1.0,
               color: str = 'cluster',
               opacity: str = 'degree',
               size='degree',
@@ -710,7 +716,9 @@ class d3graph:
         Parameters
         ----------
         adjmat : pd.DataFrame()
-            Adjacency matrix (symmetric). Values > 0 are edges.
+            Adjacency matrix (symmetric and Values > 0 are edges).
+        min_weight : float
+            edges are kept with >= weight.
         color : list of strings (default: 'cluster')
             Coloring of the nodes.
             * 'cluster' or None : Colours are based on the community distance clusters.
@@ -764,7 +772,7 @@ class d3graph:
         # Checks
         self.adjmat = data_checks(adjmat.copy())
         # Set default edge properties
-        self.set_edge_properties(scaler=scaler)
+        self.set_edge_properties(scaler=scaler, min_weight=min_weight)
         # Set default node properties
         self.set_node_properties(color=color, opacity=opacity, size=size, scaler=scaler, cmap=cmap)
 
@@ -1059,7 +1067,7 @@ def json_create(G: nx.Graph) -> str:
 
 # %%  Convert adjacency matrix to vector
 def adjmat2dict(adjmat: pd.DataFrame,
-                filter_weight: float = 0.0,
+                min_weight: float = 1.0,
                 scaler: str = 'zscore',
                 marker_start=None,
                 marker_end='arrow',
@@ -1083,8 +1091,8 @@ def adjmat2dict(adjmat: pd.DataFrame,
     ----------
     adjmat : pd.DataFrame()
         Adjacency matrix.
-    filter_weight : float
-        edges are returned with a minimum weight.
+    min_weight : float
+        edges are kept with >= weight.
     scaler : str, (default: 'zscore')
         Scale the edge-width using the following scaler:
         'zscore' : Scale values to Z-scores.
@@ -1153,21 +1161,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 min_weight is not None:
+    #     logger.info(f"Keep only edges with weight>{min_weight}")
+    #     Iloc2 = df['weight'] > min_weight
+    #     Iloc = Iloc & Iloc2
+    # df = df.loc[Iloc, :]
+    # df.reset_index(drop=True, inplace=True)
+
+    df = adjmat2vec(adjmat, min_weight=min_weight)
 
     # Scale the weights for visualization purposes
     if minmax_distance is not None:
@@ -1225,6 +1235,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],
@@ -1249,6 +1260,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.
 
@@ -1269,15 +1310,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)
@@ -1580,61 +1618,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.9.0 → d3graph-2.9.2}/d3graph/examples.py

@@ -1,17 +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:5000]
 adjmat = vec2adjmat(source=df['source'], target=df['target'], weight=df['weight'])
 
-# sticky=False — classic spring-back behaviour
 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
@@ -123,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.9.0 → d3graph-2.9.2/d3graph.egg-info}/PKG-INFO

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