hvplot 0.9.3a1__py3-none-any.whl

hvplot/networkx.py

@@ -0,0 +1,625 @@
+from collections import defaultdict
+
+import numpy as np
+import networkx as nx
+import holoviews as _hv
+
+from bokeh.models import HoverTool
+from holoviews import Graph, Labels, dim
+from holoviews.core.options import Store
+from holoviews.core.util import dimension_sanitizer
+from holoviews.plotting.bokeh import GraphPlot, LabelsPlot
+from holoviews.plotting.bokeh.styles import markers
+
+from .backend_transforms import _transfer_opts_cur_backend
+from .util import process_crs
+from .utilities import save, show  # noqa
+
+if _hv.extension and not getattr(_hv.extension, '_loaded', False):
+    _hv.extension('bokeh', logo=False)
+
+
+def _from_networkx(G, positions, nodes=None, cls=Graph, **kwargs):
+    """
+    Generate a Graph element from a networkx.Graph object and networkx
+    layout function or dictionary of node positions.  Any keyword
+    arguments will be passed to the layout function. By default it
+    will extract all node and edge attributes from the networkx.Graph
+    but explicit node information may also be supplied. Any non-scalar
+    attributes, such as lists or dictionaries will be ignored.
+
+    Parameters
+    ----------
+    G : networkx.Graph
+       Graph to convert to Graph element
+    positions : dict or callable
+       Node positions defined as a dictionary mapping from node id to
+       (x, y) tuple or networkx layout function which computes a
+       positions dictionary.
+    kwargs : dict
+       Keyword arguments for the element
+
+    Returns
+    -------
+    graph : holoviews.Graph
+       Graph element
+    """
+
+    # Unpack edges
+    edges = defaultdict(list)
+    for start, end in G.edges():
+        for attr, value in sorted(G.adj[start][end].items()):
+            if isinstance(value, (list, dict)):
+                continue  # Cannot handle list or dict attrs
+            edges[attr].append(value)
+
+        # Handle tuple node indexes (used in 2D grid Graphs)
+        if isinstance(start, tuple):
+            start = str(start)
+        if isinstance(end, tuple):
+            end = str(end)
+        edges['start'].append(start)
+        edges['end'].append(end)
+    edge_cols = sorted(
+        k for k in edges if k not in ('start', 'end') and len(edges[k]) == len(edges['start'])
+    )
+    edge_vdims = [str(col) if isinstance(col, int) else col for col in edge_cols]
+    edge_data = tuple(edges[col] for col in ['start', 'end'] + edge_cols)
+
+    # Unpack user node info
+    xdim, ydim, idim = cls.node_type.kdims[:3]
+    if nodes:
+        node_columns = nodes.columns()
+        idx_dim = nodes.kdims[0].name
+        info_cols, values = zip(*((k, v) for k, v in node_columns.items() if k != idx_dim))
+        node_info = {i: vals for i, vals in zip(node_columns[idx_dim], zip(*values))}
+    else:
+        info_cols = []
+        node_info = None
+    node_columns = defaultdict(list)
+
+    # Unpack node positions
+    for idx, pos in positions.items():
+        node = G.nodes.get(idx)
+        if node is None:
+            continue
+        x, y = pos
+        node_columns[xdim.name].append(x)
+        node_columns[ydim.name].append(y)
+        for attr, value in node.items():
+            if isinstance(value, (list, dict, tuple)):
+                continue
+            node_columns[attr].append(value)
+        for i, col in enumerate(info_cols):
+            node_columns[col].append(node_info[idx][i])
+        if isinstance(idx, tuple):
+            idx = str(idx)  # Tuple node indexes handled as strings
+        node_columns[idim.name].append(idx)
+    node_cols = sorted(
+        k
+        for k in node_columns
+        if k not in cls.node_type.kdims and len(node_columns[k]) == len(node_columns[xdim.name])
+    )
+    columns = [xdim.name, ydim.name, idim.name] + node_cols + list(info_cols)
+    node_data = tuple(node_columns[col] for col in columns)
+
+    # Construct nodes
+    vdims = []
+    for col in node_cols:
+        if isinstance(col, int):
+            dim = str(col)
+        elif nodes is not None and col in nodes.vdims:
+            dim = nodes.get_dimension(col)
+        else:
+            dim = col
+        vdims.append(dim)
+    nodes = cls.node_type(node_data, vdims=vdims)
+
+    # Construct graph
+    return cls((edge_data, nodes), vdims=edge_vdims)
+
+
+def draw(G, pos=None, **kwargs):
+    """
+    Draw the graph G using hvPlot.
+
+    Draw the graph with hvPlot with options for node positions,
+    labeling, titles, and many other drawing features.
+
+    Parameters
+    ----------
+    G : graph
+       A networkx graph
+    pos : dictionary, optional
+       A dictionary with nodes as keys and positions as values.
+       If not specified a spring layout positioning will be computed.
+       See :py:mod:`networkx.drawing.layout` for functions that
+       compute node positions.
+    arrows : bool, optional (default=True)
+       For directed graphs, if True draw arrowheads.
+       Note: Arrows will be the same color as edges.
+    arrowhead_length : float, optional (default=0.025)
+       The length of the arrows as fraction of the overall extent of
+       the graph
+    with_labels :  bool, optional (default=True)
+       Set to True to draw labels on the nodes.
+    nodelist : list, optional (default G.nodes())
+       Draw only specified nodes
+    edgelist : list, optional (default=G.edges())
+       Draw only specified edges
+    node_size : scalar or array, optional (default=300)
+       Size of nodes.  If an array is specified it must be the
+       same length as nodelist.
+    node_color : color string, node attribute, or array of floats, (default='r')
+       Can be a single color, the name of an attribute on the nodes or
+       sequence of colors with the same length as nodelist.  If the
+       node_color references an attribute on the nodes or is a list of
+       values they will be colormapped using the cmap and vmin, vmax
+       parameters.
+    node_shape :  string, optional (default='o')
+       The shape of the node. Specification is as valid bokeh marker.
+    alpha : float, optional (default=1.0)
+       The node and edge transparency
+    cmap : Colormap, optional (default=None)
+       Colormap for mapping intensities of nodes
+    vmin,vmax : float, optional (default=None)
+       Minimum and maximum for node colormap scaling
+    linewidths : [None | scalar | sequence]
+       Line width of symbol border (default =1.0)
+    edge_width : float, optional (default=1.0)
+       Line width of edges
+    edge_color : color string, or array of floats (default='r')
+       Can be a single color, the name of an attribute on the edges or
+       sequence of colors with the same length as the edges.  If the
+       edge_color references an attribute on the edges or is a list of
+       values they will be colormapped using the edge_cmap and
+       edge_vmin, edge_vmax parameters.
+    edge_cmap : Matplotlib colormap, optional (default=None)
+       Colormap for mapping intensities of edges
+    edge_vmin,edge_vmax : floats, optional (default=None)
+       Minimum and maximum for edge colormap scaling
+    style : string, optional (default='solid')
+       Edge line style (solid|dashed|dotted,dashdot)
+    labels : dictionary or string, optional (default=None)
+       Node labels in a dictionary keyed by node of text labels or
+       a string referencing a node attribute
+    font_size : int, optional (default=12)
+       Font size for text labels
+    font_color : string, optional (default='black')
+       Font color string
+    font_family : string, optional (default='sans-serif')
+       Font family
+    label : string, optional
+       Label for graph legend
+    selection_policy : string, optional (default='nodes')
+       Whether to select 'nodes', 'edges' or None on tap and selection
+       events.
+    inspection_policy : string, optional (default='nodes')
+       Whether to select 'nodes', 'edges' or None on tap and selection
+       events.
+    geo : boolean, optional (default=False)
+       Whether to return a GeoViews graph
+    crs : cartopy.crs.CRS
+       A cartopy coordinate reference system (enables a geographic plot)
+    height : int, optional (default=400)
+       The height of the plot in pixels
+    width : int, optional (default=400)
+       The width of the plot in pixels
+    """
+    if pos is None:
+        pos = nx.drawing.spring_layout
+
+    if not isinstance(pos, dict):
+        pos = pos(G, **kwargs.get('layout_kwargs', {}))
+
+    params, label_params = {}, {}
+    label_element = Labels
+    if kwargs.get('geo', False) or 'crs' in kwargs:
+        try:
+            import geoviews
+        except ImportError:
+            raise ImportError(
+                'In order to use geo-related features '
+                'the geoviews library must be available. '
+                'It can be installed with pip or conda.'
+            )
+        crs = process_crs(kwargs.get('crs'))
+        label_element = geoviews.Labels
+        params['cls'] = geoviews.Graph
+        params['crs'] = crs
+        label_params['crs'] = crs
+
+    # Construct Graph object
+    g = _from_networkx(G, pos, **params)
+
+    if 'nodelist' in kwargs:
+        g.nodes.data = g.nodes.data.iloc[list(kwargs['nodelist'])]
+
+    if 'edgelist' in kwargs:
+        edges = g.array([0, 1])
+        comparisons = []
+        for edge in kwargs['edgelist']:
+            comparisons.append(edges == edge)
+        if len(comparisons):
+            selector = np.logical_and(*np.logical_or.reduce(comparisons).T)
+            g = g.iloc[selector]
+        else:
+            g = g.iloc[:0]
+
+    # Compute options
+    inspection_policy = kwargs.pop('inspection_policy', 'nodes')
+    opts = dict(
+        axiswise=True,
+        arrowhead_length=kwargs.get('arrowhead_length', 0.025),
+        directed=kwargs.pop('arrows', isinstance(G, nx.DiGraph)),
+        colorbar=kwargs.pop('colorbar', False),
+        padding=kwargs.get('padding', 0.1),
+        width=kwargs.pop('width', 400),
+        height=kwargs.pop('height', 400),
+        selection_policy=kwargs.pop('selection_policy', 'nodes'),
+        inspection_policy=inspection_policy,
+        node_fill_color='red',
+    )
+
+    if '_axis_defaults':
+        opts.update(xaxis=None, yaxis=None, show_frame=False)
+
+    opts.update({k: kwargs.pop(k) for k in list(kwargs) if k in GraphPlot.style_opts})
+    if 'node_size' in opts:
+        if isinstance(opts['node_size'], str):
+            opts['node_size'] = dim(opts['node_size'])
+        opts['node_size'] = np.sqrt(opts['node_size'])
+    if 'node_color' in opts:
+        opts['node_fill_color'] = opts.pop('node_color')
+    if 'edge_color' in opts:
+        opts['edge_line_color'] = opts.pop('edge_color')
+    if 'node_shape' in kwargs:
+        marker = kwargs.pop('node_shape')
+        if marker in markers:
+            marker_opts = markers[marker]
+            marker = marker_opts['marker']
+            if 'angle' in marker_opts:
+                Store.add_style_opts(Graph, ['node_angle'], 'bokeh')
+                opts['node_angle'] = marker_opts['angle']
+        opts['node_marker'] = marker
+    if 'alpha' in kwargs:
+        alpha = kwargs.pop('alpha')
+        opts['node_alpha'] = alpha
+        opts['edge_alpha'] = alpha
+    if 'linewidths' in kwargs:
+        opts['node_line_width'] = kwargs.pop('linewidths')
+    if 'edge_width' in kwargs:
+        opts['edge_line_width'] = kwargs.pop('edge_width')
+    if 'style' in kwargs:
+        opts['edge_line_dash'] = kwargs.pop('style')
+
+    node_styles = ('node_fill_color', 'node_size', 'node_alpha', 'node_line_width')
+    for node_style in node_styles:
+        if isinstance(opts.get(node_style), (np.ndarray, list, range)):
+            g = g.clone(
+                (
+                    g.data,
+                    g.nodes.add_dimension(node_style, len(g.nodes.vdims), opts[node_style], True),
+                )
+            )
+            opts[node_style] = node_style
+
+    edge_styles = ('edge_line_color', 'edge_line_alpha', 'edge_alpha', 'edge_line_width')
+    for edge_style in edge_styles:
+        if isinstance(opts.get(edge_style), (np.ndarray, list, range)):
+            g = g.add_dimension(edge_style, len(g.vdims), opts[edge_style], True)
+            opts[edge_style] = edge_style
+
+    if opts.get('node_fill_color') in g.nodes.dimensions():
+        lims = (kwargs.get('vmin', None), kwargs.get('vmax', None))
+        if lims != (None, None):
+            dimension = g.nodes.get_dimension(opts.get('node_fill_color'))
+            dimension.range = lims
+
+    if opts.get('edge_line_color') in g.dimensions():
+        lims = (kwargs.get('edge_vmin', None), kwargs.get('edge_vmax', None))
+        if lims != (None, None):
+            dimension = g.get_dimension(opts.get('edge_line_color'))
+            dimension.range = lims
+
+    if inspection_policy == 'nodes':
+        tooltip_dims = [
+            (d.label, 'index_hover' if d in g.nodes.kdims else d.name)
+            for d in g.nodes.kdims[2:] + g.nodes.vdims
+        ]
+    else:
+        tooltip_dims = [
+            (d.label, d.name + '_values' if d in g.kdims else d.name) for d in g.kdims + g.vdims
+        ]
+    tooltips = [
+        (label, '@{%s}' % dimension_sanitizer(name))
+        for label, name in tooltip_dims
+        if name not in node_styles + edge_styles
+    ]
+    opts['tools'] = [HoverTool(tooltips=tooltips), 'tap']
+
+    g.opts(**opts, backend='bokeh')
+
+    # Construct Labels
+    if kwargs.get('with_labels', kwargs.get('labels', False)):
+        label_opts = {k: kwargs.pop(k) for k in list(kwargs) if k in LabelsPlot.style_opts}
+        if 'xoffset' in kwargs:
+            label_opts['xoffset'] = kwargs.pop('xoffset')
+        if 'yoffset' in kwargs:
+            label_opts['yoffset'] = kwargs.pop('yoffset')
+        if 'font_size' in kwargs:
+            label_opts['text_font_size'] = kwargs.pop('font_size')
+        if 'font_color' in kwargs:
+            label_opts['text_color'] = kwargs.pop('font_color')
+        if 'font_family' in kwargs:
+            label_opts['text_font'] = kwargs.pop('font_family')
+        labels = kwargs.get('labels', g.nodes.kdims[2])
+        if isinstance(labels, dict):
+            values = g.nodes.array(g.nodes.kdims)
+            data = [(x, y, labels[i]) for (x, y, i) in values if i in labels]
+            labels = label_element(data, g.nodes.kdims[:2], 'text', **label_params)
+        else:
+            labels = label_element(g.nodes, g.nodes.kdims[:2], labels, **label_params)
+        g = g * labels.opts(**label_opts, backend='bokeh')
+
+    # Apply label
+    if 'label' in kwargs:
+        g = g.relabel(kwargs.pop('label'))
+
+    # Process options
+    g = _transfer_opts_cur_backend(g)
+
+    return g
+
+
+def draw_networkx(G, pos=None, **kwargs):
+    """Draw a networkx graph.
+
+    Draw the graph with hvPlot with options for node positions,
+    labeling, titles, and many other drawing features. See draw() for
+    simple drawing without labels or axes.
+
+    Parameters
+    ----------
+    G : graph
+       A networkx graph
+    pos : dictionary, optional
+       A dictionary with nodes as keys and positions as values or a
+       layout `networkx.drawing.layout` function.  If not specified a
+       spring layout positioning will be computed. See
+       :py:mod:`networkx.drawing.layout` for functions that compute
+       node positions.
+    kwargs : optional keywords
+       See hvplot.networkx.draw() for a description of optional
+       keywords, with the exception of the pos parameter which is not
+       used by this function.
+
+    Returns
+    -------
+    graph : holoviews.Graph or holoviews.Overlay
+       Graph element
+    """
+    kwargs['_axis_defaults'] = False
+    return draw(G, pos, **kwargs)
+
+
+def draw_networkx_nodes(G, pos, **kwargs):
+    """Draw networkx graph nodes.
+
+    Parameters
+    ----------
+    G : graph
+       A networkx graph
+    kwargs : optional keywords
+       See hvplot.networkx.draw() for a description of optional
+       keywords, with the exception of the pos parameter which is not
+       used by this function.
+
+    Returns
+    -------
+    graph: holoviews.Graph or holoviews.Overlay
+       Graph element
+    """
+    if 'alpha' in kwargs:
+        kwargs['node_alpha'] = kwargs.pop('alpha')
+    kwargs.pop('edgelist', None)
+    kwargs['_axis_defaults'] = False
+    kwargs['edge_alpha'] = 0
+    kwargs['edge_hover_alpha'] = 0
+    kwargs['edge_nonselection_alpha'] = 0
+    return draw(G, pos, **kwargs)
+
+
+def draw_networkx_edges(G, pos, **kwargs):
+    """Draw networkx graph edges.
+
+    Parameters
+    ----------
+    G : graph
+       A networkx graph
+    kwargs : optional keywords
+       See hvplot.networkx.draw() for a description of optional
+       keywords, with the exception of the pos parameter which is not
+       used by this function.
+
+    Returns
+    -------
+    graph : holoviews.Graph or (holoviews.Graph * holoviews.Labels)
+       Graph element
+    """
+    if 'alpha' in kwargs:
+        kwargs['edge_alpha'] = kwargs.pop('alpha')
+    kwargs.pop('nodelist', None)
+    kwargs['node_alpha'] = 0
+    kwargs['node_hover_alpha'] = 0
+    kwargs['node_nonselection_alpha'] = 0
+    kwargs['_axis_defaults'] = False
+    if kwargs.get('selection_policy') is not None:
+        kwargs['selection_policy'] = 'edges'
+    if kwargs.get('inspection_policy') is not None:
+        kwargs['inspection_policy'] = 'edges'
+    return draw(G, pos, **kwargs)
+
+
+def draw_networkx_labels(G, pos, **kwargs):
+    """Draw networkx graph node labels.
+
+    Parameters
+    ----------
+    G : graph
+       A networkx graph
+    kwargs : optional keywords
+       See hvplot.networkx.draw() for a description of optional
+       keywords, with the exception of the pos parameter which is not
+       used by this function.
+
+    Returns
+    -------
+    graph : Labels element
+       Labels element
+    """
+    g = draw(G, pos, **kwargs)
+    return Labels(g.nodes, g.nodes.kdims[:2], g.nodes.kdims[2])
+
+
+def draw_circular(G, **kwargs):
+    """Draw networkx graph with circular layout.
+
+    Parameters
+    ----------
+    G : graph
+       A networkx graph
+    kwargs : optional keywords
+       See hvplot.networkx.draw() for a description of optional
+       keywords, with the exception of the pos parameter which is not
+       used by this function.
+
+    Returns
+    -------
+    graph : holoviews.Graph or holoviews.Overlay
+       Graph element or Graph and Labels
+    """
+    return draw(G, pos=nx.circular_layout, **kwargs)
+
+
+def draw_kamada_kawai(G, **kwargs):
+    """Draw networkx graph with circular layout.
+
+    Parameters
+    ----------
+    G : graph
+       A networkx graph
+    kwargs : optional keywords
+       See hvplot.networkx.draw() for a description of optional
+       keywords, with the exception of the pos parameter which is not
+       used by this function.
+
+    Returns
+    -------
+    graph : holoviews.Graph or holoviews.Overlay
+       Graph element or Graph and Labels
+    """
+    return draw(G, pos=nx.kamada_kawai_layout, **kwargs)
+
+
+def draw_random(G, **kwargs):
+    """Draw networkx graph with random layout.
+
+    Parameters
+    ----------
+    G : graph
+       A networkx graph
+    kwargs : optional keywords
+       See hvplot.networkx.draw() for a description of optional
+       keywords, with the exception of the pos parameter which is not
+       used by this function.
+
+    Returns
+    -------
+    graph : holoviews.Graph or holoviews.Overlay
+       Graph element
+    """
+    return draw(G, nx.random_layout, **kwargs)
+
+
+def draw_shell(G, **kwargs):
+    """Draw networkx graph with shell layout.
+
+    Parameters
+    ----------
+    G : graph
+       A networkx graph
+    kwargs : optional keywords
+       See hvplot.networkx.draw() for a description of optional
+       keywords, with the exception of the pos parameter which is not
+       used by this function.
+
+    Returns
+    -------
+    graph : holoviews.Graph or holoviews.Overlay
+       Graph element or Graph and Labels
+    """
+    nlist = kwargs.pop('nlist', None)
+    if nlist is not None:
+        kwargs['layout_kwargs'] = {'nlist': nlist}
+    return draw(G, nx.shell_layout, **kwargs)
+
+
+def draw_spectral(G, **kwargs):
+    """Draw networkx graph with spectral layout.
+
+    Parameters
+    ----------
+    G : graph
+       A networkx graph
+    kwargs : optional keywords
+       See hvplot.networkx.draw() for a description of optional
+       keywords, with the exception of the pos parameter which is not
+       used by this function.
+
+    Returns
+    -------
+    graph : holoviews.Graph or holoviews.Overlay
+       Graph element or Graph and Labels
+    """
+    return draw(G, nx.spectral_layout, **kwargs)
+
+
+def draw_spring(G, **kwargs):
+    """Draw networkx graph with spring layout.
+
+    Parameters
+    ----------
+    G : graph
+       A networkx graph
+    kwargs : optional keywords
+       See hvplot.networkx.draw() for a description of optional
+       keywords, with the exception of the pos parameter which is not
+       used by this function.
+
+    Returns
+    -------
+    graph : holoviews.Graph or holoviews.Overlay
+       Graph element or Graph and Labels
+    """
+    return draw(G, nx.spring_layout, **kwargs)
+
+
+def draw_planar(G, **kwargs):
+    """Draw networkx graph with planar layout.
+
+    Parameters
+    ----------
+    G : graph
+       A networkx graph
+    kwargs : optional keywords
+       See hvplot.networkx.draw() for a description of optional
+       keywords, with the exception of the pos parameter which is not
+       used by this function.
+
+    Returns
+    -------
+    graph : holoviews.Graph or holoviews.Overlay
+       Graph element or Graph and Labels
+    """
+    return draw(G, nx.planar_layout, **kwargs)

hvplot/pandas.py

@@ -0,0 +1,30 @@
+"""Adds the `.hvplot` method to pd.DataFrame and pd.Series"""
+
+from .interactive import Interactive
+
+
+def patch(name='hvplot', interactive='interactive', extension='bokeh', logo=False):
+    from . import hvPlotTabular, post_patch
+
+    try:
+        import pandas as pd
+    except ImportError:
+        raise ImportError(
+            'Could not patch plotting API onto pandas. Pandas could not be imported.'
+        )
+    _patch_plot = lambda self: hvPlotTabular(self)  # noqa: E731
+    _patch_plot.__doc__ = hvPlotTabular.__call__.__doc__
+    plot_prop = property(_patch_plot)
+    setattr(pd.DataFrame, name, plot_prop)
+    setattr(pd.Series, name, plot_prop)
+
+    _patch_interactive = lambda self: Interactive(self)  # noqa: E731
+    _patch_interactive.__doc__ = Interactive.__call__.__doc__
+    interactive_prop = property(_patch_interactive)
+    setattr(pd.DataFrame, interactive, interactive_prop)
+    setattr(pd.Series, interactive, interactive_prop)
+
+    post_patch(extension, logo)
+
+
+patch()