hvplot 0.9.3a1__py3-none-any.whl

hvplot/plotting/lag_plot.py

@@ -0,0 +1,34 @@
+import numpy as np
+import pandas as pd
+
+from ..util import with_hv_extension
+from .core import hvPlotTabular
+
+
+@with_hv_extension
+def lag_plot(data, lag=1, **kwds):
+    """Lag plot for time series.
+
+    Parameters:
+    -----------
+    data: Time series
+    lag: lag of the scatter plot, default 1
+    kwds: hvplot.scatter options, optional
+
+    Returns:
+    --------
+    obj : HoloViews object
+        The HoloViews representation of the plot.
+    """
+    if lag != int(lag) or int(lag) <= 0:
+        raise ValueError('lag must be a positive integer')
+    lag = int(lag)
+
+    values = data.values
+    y1 = 'y(t)'
+    y2 = f'y(t + {lag})'
+    lags = pd.DataFrame({y1: values[:-lag].T.ravel(), y2: values[lag:].T.ravel()})
+    if isinstance(data, pd.DataFrame):
+        lags['variable'] = np.repeat(data.columns, lags.shape[0] / data.shape[1])
+        kwds['c'] = 'variable'
+    return hvPlotTabular(lags)(y1, y2, kind='scatter', **kwds)

hvplot/plotting/parallel_coordinates.py

@@ -0,0 +1,85 @@
+import holoviews as hv
+import colorcet as cc
+
+from ..backend_transforms import _transfer_opts_cur_backend
+from ..util import with_hv_extension
+
+
+@with_hv_extension
+def parallel_coordinates(
+    data,
+    class_column,
+    cols=None,
+    alpha=0.5,
+    width=600,
+    height=300,
+    var_name='variable',
+    value_name='value',
+    cmap=None,
+    colormap=None,
+    **kwds,
+):
+    """
+    Parallel coordinates plotting.
+
+    To show a set of points in an n-dimensional space, a backdrop is drawn
+    consisting of n parallel lines. A point in n-dimensional space is
+    represented as a polyline with vertices on the parallel axes; the
+    position of the vertex on the i-th axis corresponds to the i-th coordinate
+    of the point.
+
+    Parameters
+    ----------
+    frame: DataFrame
+    class_column: str
+        Column name containing class names
+    cols: list, optional
+        A list of column names to use
+    alpha: float, optional
+        The transparency of the lines
+    cmap/colormap: str or colormap object
+        Colormap to use for groups
+
+    Returns
+    -------
+    obj : HoloViews object
+        The HoloViews representation of the plot.
+
+    See Also
+    --------
+    pandas.plotting.parallel_coordinates : matplotlib version of this routine
+    """
+    # Transform the dataframe to be used in Vega-Lite
+    if cols is not None:
+        data = data[list(cols) + [class_column]]
+    cols = data.columns
+    df = data.reset_index()
+    index = (set(df.columns) - set(cols)).pop()
+    assert index in df.columns
+    df = df.melt([index, class_column], var_name=var_name, value_name=value_name)
+
+    labelled = [] if var_name == 'variable' else ['x']
+    if value_name != 'value':
+        labelled.append('y')
+    options = {
+        'Curve': dict(kwds, labelled=labelled, alpha=alpha, width=width, height=height),
+        'Overlay': dict(legend_limit=5000),
+    }
+
+    dataset = hv.Dataset(df)
+    groups = dataset.to(hv.Curve, var_name, value_name).overlay(index).items()
+
+    if cmap and colormap:
+        raise TypeError('Only specify one of `cmap` and `colormap`.')
+    cmap = cmap or colormap or cc.palette['glasbey_category10']
+    colors = hv.plotting.util.process_cmap(cmap, categorical=True, ncolors=len(groups))
+
+    el = hv.Overlay(
+        [
+            curve.relabel(k).options('Curve', color=c, backend='bokeh')
+            for c, (k, v) in zip(colors, groups)
+            for curve in v
+        ]
+    ).options(options, backend='bokeh')
+    el = _transfer_opts_cur_backend(el)
+    return el

hvplot/plotting/scatter_matrix.py

@@ -0,0 +1,220 @@
+from functools import partial
+import warnings
+
+import holoviews as _hv
+import numpy as _np
+
+from packaging.version import Version
+
+from ..backend_transforms import _transfer_opts_cur_backend
+from ..converter import HoloViewsConverter
+from ..util import with_hv_extension, _convert_col_names_to_str
+
+
+@with_hv_extension
+def scatter_matrix(
+    data,
+    c=None,
+    chart='scatter',
+    diagonal='hist',
+    alpha=0.5,
+    nonselection_alpha=0.1,
+    tools=None,
+    cmap=None,
+    colormap=None,
+    diagonal_kwds=None,
+    hist_kwds=None,
+    density_kwds=None,
+    datashade=False,
+    rasterize=False,
+    dynspread=False,
+    spread=False,
+    **kwds,
+):
+    """
+    Scatter matrix of numeric columns.
+
+    A scatter_matrix shows all the pairwise relationships between the columns.
+    Each non-diagonal plots the corresponding columns against each other,
+    while the diagonal plot shows the distribution of each individual column.
+
+    This function is closely modelled on :func:`pandas.plotting.scatter_matrix`.
+
+    Parameters:
+    -----------
+    data: DataFrame
+        The data to plot. Every column is compared to every other column.
+    c: str, optional
+        Column to color by
+    chart: str, optional
+        Chart type for the off-diagonal plots (one of 'scatter', 'bivariate', 'hexbin')
+    diagonal: str, optional
+        Chart type for the diagonal plots (one of 'hist', 'kde')
+    alpha: float, optional
+        Transparency level for the off-diagonal plots
+    nonselection_alpha: float, optional
+        Transparency level for nonselected object in the off-diagonal plots
+    tools: list of str, optional
+        Interaction tools to include
+        Defaults are 'box_select' and 'lasso_select'
+    cmap/colormap: str or colormap object, optional
+        Colormap to use when ``c`` is set.
+        Default is `Category10 <https://github.com/d3/d3-3.x-api-reference/blob/master/Ordinal-Scales.md#category10>`.
+    diagonal_kwds/hist_kwds/density_kwds: dict, optional
+        Keyword options for the diagonal plots
+    datashade (default=False):
+        Whether to apply rasterization and shading (colormapping) using
+        the Datashader library, returning an RGB object instead of
+        individual points
+    rasterize (default=False):
+        Whether to apply rasterization using the Datashader library,
+        returning an aggregated Image (to be colormapped by the
+        plotting backend) instead of individual points
+    dynspread (default=False):
+        For plots generated with datashade=True or rasterize=True,
+        automatically increase the point size when the data is sparse
+        so that individual points become more visible.
+        kwds supported include ``max_px``, ``threshold``,  ``shape``, ``how`` and ``mask``.
+    spread (default=False):
+        Make plots generated with datashade=True or rasterize=True
+        increase the point size to make points more visible, by
+        applying a fixed spreading of a certain number of cells/pixels. kwds
+        supported include: ``px``, ``shape``, ``how`` and ``mask``.
+    kwds: Keyword options for the off-diagonal plots and datashader's spreading , optional
+
+    Returns:
+    --------
+    obj : HoloViews object
+        The HoloViews representation of the plot.
+
+    See Also
+    --------
+        :func:`pandas.plotting.scatter_matrix` : Equivalent pandas function.
+    """
+
+    data = _hv.Dataset(_convert_col_names_to_str(data))
+    supported = list(HoloViewsConverter._kind_mapping)
+    if diagonal not in supported:
+        raise ValueError(f'diagonal type must be one of: {supported}, found {diagonal}')
+    if chart not in supported:
+        raise ValueError(f'Chart type must be one of: {supported}, found {chart}')
+    diagonal = HoloViewsConverter._kind_mapping[diagonal]
+    chart = HoloViewsConverter._kind_mapping[chart]
+
+    if rasterize or datashade:
+        try:
+            import datashader  # noqa
+        except ImportError:
+            raise ImportError('rasterize and datashade require datashader to be installed.')
+        from ..util import hv_version
+
+        if hv_version <= Version('1.14.6'):
+            warnings.warn(
+                'Versions of holoviews before 1.14.7 did not support '
+                'dynamic update of rasterized/datashaded scatter matrix. '
+                'Update holoviews to a newer version.'
+            )
+
+    if rasterize and datashade:
+        raise ValueError('Choose to either rasterize or datashade the scatter matrix, not both.')
+
+    if not rasterize and not datashade and (spread or dynspread):
+        raise ValueError('dynspread or spread need rasterize or datashade to be set to True.')
+
+    if rasterize:
+        import holoviews.operation.datashader as hd
+
+        if dynspread or spread:
+            if hd.ds_version < Version('0.12.0'):
+                raise RuntimeError(
+                    'Any version of datashader less than 0.12.0 does '
+                    'not support rasterize with dynspread or spread.'
+                )
+
+    # remove datashade kwds
+    if datashade or rasterize:
+        import holoviews.operation.datashader as hd
+
+        ds_kwds = {}
+        if 'aggregator' in kwds:
+            ds_kwds['aggregator'] = kwds.pop('aggregator')
+
+    # remove dynspread kwds
+    sp_kwds = {}
+    if dynspread:
+        if 'max_px' in kwds:
+            sp_kwds['max_px'] = kwds.pop('max_px')
+        if 'threshold' in kwds:
+            sp_kwds['threshold'] = kwds.pop('threshold')
+        if 'shape' in kwds:
+            sp_kwds['shape'] = kwds.pop('shape')
+        if 'how' in kwds:
+            sp_kwds['how'] = kwds.pop('how')
+        if 'mask' in kwds:
+            sp_kwds['mask'] = kwds.pop('mask')
+    if spread:
+        if 'px' in kwds:
+            sp_kwds['px'] = kwds.pop('px')
+        if 'shape' in kwds:
+            sp_kwds['shape'] = kwds.pop('shape')
+        if 'how' in kwds:
+            sp_kwds['how'] = kwds.pop('how')
+        if 'mask' in kwds:
+            sp_kwds['mask'] = kwds.pop('mask')
+
+    tools = tools or ['box_select', 'lasso_select']
+    chart_opts = dict(alpha=alpha, tools=tools, nonselection_alpha=nonselection_alpha, **kwds)
+    if c:
+        if cmap and colormap:
+            raise TypeError('Only specify `cmap` or `colormap`.')
+        ncolors = len(_np.unique(data.dimension_values(c)))
+        cmap = cmap or colormap or 'Category10'
+        cmap = _hv.plotting.util.process_cmap(cmap, ncolors=ncolors, categorical=True)
+        chart_opts['cmap'] = cmap
+
+    # get initial scatter matrix.  No color.
+    grid = _hv.operation.gridmatrix(data, diagonal_type=diagonal, chart_type=chart)
+
+    if c:
+        # change colors for scatter matrix
+        chart_opts['color'] = c
+        # Add color vdim to each plot.
+        grid = grid.map(lambda x: x.clone(vdims=x.vdims + [c]), 'Scatter')
+        # create a new scatter matrix with groups for each catetory, so now the histogram will
+        # show separate colors for each group.
+        groups = _hv.operation.gridmatrix(
+            data.groupby(c).overlay(), chart_type=chart, diagonal_type=diagonal
+        )
+        # take the correct layer from each Overlay object within the scatter matrix.
+        grid = (grid * groups).map(
+            lambda x: x.get(0) if isinstance(x.get(0), chart) else x.get(1), _hv.Overlay
+        )
+
+    if (
+        (diagonal_kwds and hist_kwds)
+        or (diagonal_kwds and density_kwds)
+        or (hist_kwds and density_kwds)
+    ):
+        raise TypeError('Specify at most one of `diagonal_kwds`, `hist_kwds`, or `density_kwds`.')
+
+    diagonal_opts = diagonal_kwds or hist_kwds or density_kwds or {}
+    # set the histogram colors
+    if c:
+        diagonal_opts['fill_color'] = _hv.Cycle(cmap)
+    # actually changing to the same color scheme for both scatter and histogram plots.
+    grid = grid.options(
+        {chart.__name__: chart_opts, diagonal.__name__: diagonal_opts},
+        backend='bokeh',
+    )
+
+    # Perform datashade options after all the coloring is finished.
+    if datashade or rasterize:
+        aggregatefn = hd.datashade if datashade else hd.rasterize
+        grid = grid.map(partial(aggregatefn, **ds_kwds), specs=chart)
+        if spread or dynspread:
+            spreadfn = hd.dynspread if dynspread else (hd.spread if spread else lambda z, **_: z)
+            eltype = _hv.RGB if datashade else _hv.Image
+            grid = grid.map(partial(spreadfn, **sp_kwds), specs=eltype)
+
+    grid = _transfer_opts_cur_backend(grid)
+    return grid

hvplot/polars.py

@@ -0,0 +1,21 @@
+"""Adds the `.hvplot` method to pl.DataFrame, pl.LazyFrame and pl.Series"""
+
+from hvplot import post_patch
+from hvplot.plotting.core import hvPlotTabularPolars
+
+
+def patch(name='hvplot', extension='bokeh', logo=False):
+    try:
+        import polars as pl
+    except ImportError:
+        raise ImportError(
+            'Could not patch plotting API onto Polars. Polars could not be imported.'
+        )
+    pl.api.register_dataframe_namespace(name)(hvPlotTabularPolars)
+    pl.api.register_series_namespace(name)(hvPlotTabularPolars)
+    pl.api.register_lazyframe_namespace(name)(hvPlotTabularPolars)
+
+    post_patch(extension, logo)
+
+
+patch()

hvplot/sample_data.py

@@ -0,0 +1,30 @@
+"""
+Loads hvPlot sample data using intake catalogue.
+"""
+
+import os
+
+try:
+    from intake import open_catalog
+    import intake_parquet  # noqa
+    import intake_xarray  # noqa
+    import s3fs  # noqa
+except ImportError:
+    raise ImportError(
+        """Loading hvPlot sample data requires:
+                * intake
+                * intake-parquet
+                * intake-xarray
+                * s3fs
+             Install these using conda or pip before loading data."""
+    )
+
+_file_path = os.path.dirname(__file__)
+_cat_path = os.path.join(_file_path, 'datasets.yaml')
+
+# Load catalogue
+catalogue = open_catalog(_cat_path)
+
+# Add catalogue entries to namespace
+for _c in catalogue:
+    globals()[_c] = catalogue[_c]

hvplot/streamz.py

@@ -0,0 +1,21 @@
+def patch(name='hvplot', extension='bokeh', logo=False):
+    from . import hvPlotTabular, post_patch
+
+    try:
+        import streamz.dataframe as sdf
+    except ImportError:
+        raise ImportError(
+            'Could not patch plotting API onto streamz. Streamz could not be imported.'
+        )
+    _patch_plot = lambda self: hvPlotTabular(self)  # noqa: E731
+    _patch_plot.__doc__ = hvPlotTabular.__call__.__doc__
+    patch_property = property(_patch_plot)
+    setattr(sdf.DataFrame, name, patch_property)
+    setattr(sdf.DataFrames, name, patch_property)
+    setattr(sdf.Series, name, patch_property)
+    setattr(sdf.Seriess, name, patch_property)
+
+    post_patch(extension, logo)
+
+
+patch()

hvplot/tests/conftest.py

@@ -0,0 +1,44 @@
+import dask
+
+optional_markers = {
+    'geo': {
+        'help': 'Run the tests that require GeoViews',
+        'marker-descr': 'Geo test marker',
+        'skip-reason': 'Test only runs with the --geo option.',
+    },
+}
+
+
+def pytest_addoption(parser):
+    for marker, info in optional_markers.items():
+        parser.addoption(
+            '--{}'.format(marker), action='store_true', default=False, help=info['help']
+        )
+
+
+def pytest_configure(config):
+    for marker, info in optional_markers.items():
+        config.addinivalue_line('markers', '{}: {}'.format(marker, info['marker-descr']))
+
+
+def pytest_collection_modifyitems(config, items):
+    skipped, selected = [], []
+    markers = [m for m in optional_markers if config.getoption(f'--{m}')]
+    empty = not markers
+    for item in items:
+        if empty and any(m in item.keywords for m in optional_markers):
+            skipped.append(item)
+        elif empty:
+            selected.append(item)
+        elif not empty and any(m in item.keywords for m in markers):
+            selected.append(item)
+        else:
+            skipped.append(item)
+
+    config.hook.pytest_deselected(items=skipped)
+    items[:] = selected
+
+
+# From Dask 2024.3.0 they now use `dask_expr` by default
+# https://github.com/dask/dask/issues/10995
+dask.config.set({'dataframe.query-planning': False})

hvplot/tests/data/README.md

@@ -0,0 +1,5 @@
+# Test data
+
+Test files required by the test suite:
+
+* The RGB-red.byte.tif file was obtained from [rasterio](https://github.com/rasterio/rasterio) test suite and downsampled to reduce its size. The original image is derived from USGS Landsat 7 ETM imagery and is licensed under the [CC0 1.0 Universal (CC0 1.0) Public Domain Dedication](https://creativecommons.org/publicdomain/zero/1.0/).

hvplot/tests/plotting/testcore.py

@@ -0,0 +1,108 @@
+from packaging.version import Version
+from unittest import SkipTest
+
+import numpy as np
+import pandas as pd
+import hvplot.pandas  # noqa
+import pytest
+
+from hvplot import hvPlotTabular
+from hvplot.tests.util import makeDataFrame
+
+try:
+    import polars as pl
+    import hvplot.polars  # noqa
+
+    skip_polar = False
+except ImportError:
+
+    class pl:
+        DataFrame = None
+        LazyFrame = None
+        Series = None
+
+    skip_polar = True
+
+try:
+    import dask.dataframe as dd
+    import hvplot.dask  # noqa
+except ImportError:
+    dd = None
+
+
+TYPES = {t for t in dir(hvPlotTabular) if not t.startswith('_') and t != 'explorer'}
+FRAME_TYPES = TYPES - {'bivariate', 'heatmap', 'hexbin', 'labels', 'vectorfield'}
+SERIES_TYPES = FRAME_TYPES - {'points', 'polygons', 'ohlc', 'paths'}
+frame_kinds = pytest.mark.parametrize('kind', sorted(FRAME_TYPES))
+series_kinds = pytest.mark.parametrize('kind', sorted(SERIES_TYPES))
+
+y_combinations = pytest.mark.parametrize(
+    'y',
+    (
+        ['A', 'B', 'C', 'D'],
+        ('A', 'B', 'C', 'D'),
+        {'A', 'B', 'C', 'D'},
+        np.array(['A', 'B', 'C', 'D']),
+        pd.Index(['A', 'B', 'C', 'D']),
+        pd.Series(['A', 'B', 'C', 'D']),
+    ),
+    ids=lambda x: type(x).__name__,
+)
+
+
+@frame_kinds
+@y_combinations
+def test_dataframe_pandas(kind, y):
+    df = makeDataFrame()
+    df.hvplot(y=y, kind=kind)
+
+
+@series_kinds
+def test_series_pandas(kind):
+    ser = pd.Series(np.random.rand(10), name='A')
+    ser.hvplot(kind=kind)
+
+
+@pytest.mark.skipif(dd is None, reason='dask not installed')
+@frame_kinds
+@y_combinations
+def test_dataframe_dask(kind, y):
+    df = dd.from_pandas(makeDataFrame(), npartitions=2)
+    assert isinstance(df, dd.DataFrame)
+    df.hvplot(y=y, kind=kind)
+
+
+@pytest.mark.skipif(dd is None, reason='dask not installed')
+@series_kinds
+def test_series_dask(kind):
+    ser = dd.from_pandas(pd.Series(np.random.rand(10), name='A'), npartitions=2)
+    assert isinstance(ser, dd.Series)
+    ser.hvplot(kind=kind)
+
+
+@pytest.mark.skipif(skip_polar, reason='polars not installed')
+@pytest.mark.parametrize('cast', (pl.DataFrame, pl.LazyFrame))
+@frame_kinds
+@y_combinations
+def test_dataframe_polars(kind, y, cast):
+    df = cast(makeDataFrame())
+    assert isinstance(df, cast)
+    df.hvplot(y=y, kind=kind)
+
+
+@pytest.mark.skipif(skip_polar, reason='polars not installed')
+@series_kinds
+def test_series_polars(kind):
+    ser = pl.Series(values=np.random.rand(10), name='A')
+    assert isinstance(ser, pl.Series)
+    ser.hvplot(kind=kind)
+
+
+@pytest.mark.skipif(skip_polar, reason='polars not installed')
+@series_kinds
+def test_series_polars_downstream(kind):
+    if Version(pl.__version__) < Version('0.20.3'):
+        raise SkipTest('plot namespace in Polars introduced in 0.20.3')
+    ser = pl.Series(values=np.random.rand(10), name='A')
+    assert isinstance(ser, pl.Series)
+    ser.plot(kind=kind)

hvplot/tests/plotting/testohlc.py

@@ -0,0 +1,34 @@
+import pandas as pd
+import hvplot.pandas  # noqa
+
+
+df = pd.DataFrame(
+    {
+        'Open': [100.00, 101.25, 102.75],
+        'High': [104.10, 105.50, 110.00],
+        'Low': [94.00, 97.10, 99.20],
+        'Close': [101.15, 99.70, 109.50],
+        'Volume': [10012, 5000, 18000],
+    },
+    index=[pd.Timestamp('2022-08-01'), pd.Timestamp('2022-08-03'), pd.Timestamp('2022-08-04')],
+)
+
+ohlc_cols = ['Open', 'High', 'Low', 'Close']
+
+
+def test_ohlc_hover_cols():
+    plot = df.hvplot.ohlc(y=ohlc_cols, hover_cols=['Volume'])
+    segments = plot.Segments.I
+    assert 'Volume' in segments
+    tooltips = segments.opts.get('plot').kwargs['tools'][0].tooltips
+    assert len(tooltips) == len(df.columns) + 1
+    assert tooltips[-1] == ('Volume', '@Volume')
+
+
+def test_ohlc_hover_cols_all():
+    plot = df.hvplot.ohlc(y=ohlc_cols, hover_cols='all')
+    segments = plot.Segments.I
+    assert 'Volume' in segments
+    tooltips = segments.opts.get('plot').kwargs['tools'][0].tooltips
+    assert len(tooltips) == len(df.columns) + 1
+    assert tooltips[-1] == ('Volume', '@Volume')