hvplot 0.9.3a1__py3-none-any.whl

hvplot/tests/testpanel.py

@@ -0,0 +1,70 @@
+"""
+Tests for panel widgets and param objects as arguments
+"""
+
+from unittest import TestCase, SkipTest
+
+from hvplot.util import process_xarray  # noqa
+
+
+def look_for_class(panel, classname, items=None):
+    """
+    Descend a panel object and find any instances of the given class
+    """
+    import panel as pn
+
+    if items is None:
+        items = []
+    if isinstance(panel, pn.layout.ListPanel):
+        for p in panel:
+            items = look_for_class(p, classname, items)
+    elif isinstance(panel, classname):
+        items.append(panel)
+    return items
+
+
+class TestPanelObjects(TestCase):
+    def setUp(self):
+        try:
+            import panel as pn  # noqa
+            import hvplot.pandas  # noqa
+        except ImportError:
+            raise SkipTest('panel not available')
+
+        from bokeh.sampledata.iris import flowers
+
+        self.flowers = flowers
+        self.cols = list(self.flowers.columns[:-1])
+
+    def test_using_explicit_widgets_works(self):
+        import panel as pn
+
+        x = pn.widgets.Select(name='x', value='sepal_length', options=self.cols)
+        y = pn.widgets.Select(name='y', value='sepal_width', options=self.cols)
+        kind = pn.widgets.Select(name='kind', value='scatter', options=['bivariate', 'scatter'])
+        by_species = pn.widgets.Checkbox(name='By species')
+        color = pn.widgets.ColorPicker(value='#ff0000')
+
+        @pn.depends(by_species.param.value, color.param.value)
+        def by_species_fn(by_species, color):
+            return 'species' if by_species else color
+
+        self.flowers.hvplot(x, y=y, kind=kind.param.value, c=color)
+
+    def test_casting_widgets_to_different_classes(self):
+        import panel as pn
+
+        pane = self.flowers.hvplot.scatter(
+            groupby='species', legend='top_right', widgets={'species': pn.widgets.DiscreteSlider}
+        )
+
+        assert len(look_for_class(pane, pn.widgets.DiscreteSlider)) == 1
+
+    def test_using_explicit_widgets_with_groupby_does_not_raise_error(self):
+        import panel as pn
+
+        x = pn.widgets.Select(name='x', value='sepal_length', options=self.cols)
+        y = pn.widgets.Select(name='y', value='sepal_width', options=self.cols)
+
+        pane = self.flowers.hvplot(x, y, groupby='species')
+        assert isinstance(pane, pn.param.ParamFunction)

hvplot/tests/testpatch.py

@@ -0,0 +1,135 @@
+"""
+Tests patching of supported libraries
+"""
+
+from unittest import TestCase, SkipTest
+
+import numpy as np
+
+from hvplot.plotting import hvPlotTabular, hvPlot
+
+
+class TestPatchPandas(TestCase):
+    def setUp(self):
+        import hvplot.pandas  # noqa
+
+    def test_pandas_series_patched(self):
+        import pandas as pd
+
+        series = pd.Series([0, 1, 2])
+        self.assertIsInstance(series.hvplot, hvPlotTabular)
+
+    def test_pandas_dataframe_patched(self):
+        import pandas as pd
+
+        df = pd.DataFrame([[1, 2], [3, 4], [5, 6]], columns=['x', 'y'])
+        self.assertIsInstance(df.hvplot, hvPlotTabular)
+
+
+class TestPatchDask(TestCase):
+    def setUp(self):
+        try:
+            import dask.dataframe as dd  # noqa
+        except ImportError:
+            raise SkipTest('Dask not available')
+        import hvplot.dask  # noqa
+
+    def test_dask_series_patched(self):
+        import pandas as pd
+        import dask.dataframe as dd
+
+        series = pd.Series([0, 1, 2])
+        dseries = dd.from_pandas(series, 2)
+        self.assertIsInstance(dseries.hvplot, hvPlotTabular)
+
+    def test_dask_dataframe_patched(self):
+        import pandas as pd
+        import dask.dataframe as dd
+
+        df = pd.DataFrame([[1, 2], [3, 4], [5, 6]], columns=['x', 'y'])
+        ddf = dd.from_pandas(df, 2)
+        self.assertIsInstance(ddf.hvplot, hvPlotTabular)
+
+
+class TestPatchXArray(TestCase):
+    def setUp(self):
+        try:
+            import xarray as xr  # noqa
+        except ImportError:
+            raise SkipTest('XArray not available')
+        import hvplot.xarray  # noqa
+
+    def test_xarray_dataarray_patched(self):
+        import xarray as xr
+
+        array = np.random.rand(100, 100)
+        xr_array = xr.DataArray(array, coords={'x': range(100), 'y': range(100)}, dims=('y', 'x'))
+        self.assertIsInstance(xr_array.hvplot, hvPlot)
+
+    def test_xarray_dataset_patched(self):
+        import xarray as xr
+
+        array = np.random.rand(100, 100)
+        xr_array = xr.DataArray(array, coords={'x': range(100), 'y': range(100)}, dims=('y', 'x'))
+        xr_ds = xr.Dataset({'z': xr_array})
+        self.assertIsInstance(xr_ds.hvplot, hvPlot)
+
+
+class TestPatchStreamz(TestCase):
+    def setUp(self):
+        try:
+            import streamz  # noqa
+        except ImportError:
+            raise SkipTest('streamz not available')
+        import hvplot.streamz  # noqa
+
+    def test_streamz_dataframe_patched(self):
+        from streamz.dataframe import Random
+
+        random_df = Random()
+        self.assertIsInstance(random_df.hvplot, hvPlotTabular)
+
+    def test_streamz_series_patched(self):
+        from streamz.dataframe import Random
+
+        random_df = Random()
+        self.assertIsInstance(random_df.x.hvplot, hvPlotTabular)
+
+    def test_streamz_dataframes_patched(self):
+        from streamz.dataframe import Random
+
+        random_df = Random()
+        self.assertIsInstance(random_df.groupby('x').sum().hvplot, hvPlotTabular)
+
+    def test_streamz_seriess_patched(self):
+        from streamz.dataframe import Random
+
+        random_df = Random()
+        self.assertIsInstance(random_df.groupby('x').sum().y.hvplot, hvPlotTabular)
+
+
+class TestPatchPolars(TestCase):
+    def setUp(self):
+        try:
+            import polars as pl  # noqa
+        except ImportError:
+            raise SkipTest('Polars not available')
+        import hvplot.polars  # noqa
+
+    def test_polars_series_patched(self):
+        import polars as pl
+
+        pseries = pl.Series([0, 1, 2])
+        self.assertIsInstance(pseries.hvplot, hvPlotTabular)
+
+    def test_polars_dataframe_patched(self):
+        import polars as pl
+
+        pdf = pl.DataFrame({'x': [1, 3, 5], 'y': [2, 4, 6]})
+        self.assertIsInstance(pdf.hvplot, hvPlotTabular)
+
+    def test_polars_lazyframe_patched(self):
+        import polars as pl
+
+        pldf = pl.LazyFrame({'x': [1, 3, 5], 'y': [2, 4, 6]})
+        self.assertIsInstance(pldf.hvplot, hvPlotTabular)

hvplot/tests/testplotting.py

@@ -0,0 +1,69 @@
+"""
+Tests pandas.options.backend setting
+"""
+
+from unittest import TestCase, SkipTest
+
+import holoviews as hv
+import pandas as pd
+import pytest
+
+from packaging.version import Version
+from parameterized import parameterized
+
+from hvplot.converter import HoloViewsConverter
+from hvplot.plotting import plot
+from hvplot.tests.util import makeDataFrame
+
+no_args = ['line', 'area', 'hist', 'box', 'kde', 'density', 'bar', 'barh']
+x_y = ['scatter', 'hexbin']
+
+no_args_mapping = [
+    (kind, el) for kind, el in HoloViewsConverter._kind_mapping.items() if kind in no_args
+]
+x_y_mapping = [(kind, el) for kind, el in HoloViewsConverter._kind_mapping.items() if kind in x_y]
+
+
+class TestPandasHoloviewsPlotting(TestCase):
+    def setUp(self):
+        if Version(pd.__version__) < Version('0.25.1'):
+            raise SkipTest('entrypoints for plotting.backends was added in pandas 0.25.1')
+        pd.options.plotting.backend = 'holoviews'
+
+    @parameterized.expand(no_args_mapping)
+    def test_pandas_series_plot_returns_holoviews_object(self, kind, el):
+        series = pd.Series([0, 1, 2])
+        plot = getattr(series.plot, kind)()
+        self.assertIsInstance(plot, el)
+
+    @parameterized.expand(no_args_mapping)
+    def test_pandas_dataframe_plot_returns_holoviews_object(self, kind, el):
+        df = pd.DataFrame([0, 1, 2])
+        plot = getattr(df.plot, kind)()
+        self.assertIsInstance(plot, el)
+
+    @parameterized.expand(x_y_mapping)
+    def test_pandas_dataframe_plot_returns_holoviews_object_when_x_and_y_set(self, kind, el):
+        df = pd.DataFrame({'a': [0, 1, 2], 'b': [5, 7, 2]})
+        plot = getattr(df.plot, kind)(x='a', y='b')
+        self.assertIsInstance(plot, el)
+
+    def test_pandas_dataframe_plot_does_not_implement_pie(self):
+        df = pd.DataFrame({'a': [0, 1, 2], 'b': [5, 7, 2]})
+        with self.assertRaisesRegex(NotImplementedError, 'pie'):
+            df.plot.pie(y='a')
+
+
+class TestPandasHvplotPlotting(TestPandasHoloviewsPlotting):
+    def setUp(self):
+        if Version(pd.__version__) < Version('0.25.1'):
+            raise SkipTest('entrypoints for plotting.backends was added in pandas 0.25.1')
+        pd.options.plotting.backend = 'hvplot'
+
+
+def test_plot_supports_polars():
+    pl = pytest.importorskip('polars')
+    dfp = pl.DataFrame(makeDataFrame())
+    out = plot(dfp, 'line')
+    assert isinstance(out, hv.NdOverlay)
+    assert out.keys() == dfp.columns

hvplot/tests/teststreaming.py

@@ -0,0 +1,28 @@
+from unittest import TestCase
+
+import pandas as pd
+
+from holoviews.streams import Buffer, Pipe
+
+
+class TestExplicitStreamPlotting(TestCase):
+    def setUp(self):
+        import hvplot.pandas  # noqa
+
+        self.df = pd.DataFrame([[1, 2], [3, 4], [5, 6]], columns=['x', 'y'])
+
+    def test_pipe_stream(self):
+        stream = Pipe(data=self.df)
+        plot = self.df.hvplot('x', 'y', stream=stream)
+        pd.testing.assert_frame_equal(plot[()].data, self.df)
+        new_df = pd.DataFrame([[7, 8], [9, 10]], columns=['x', 'y'])
+        stream.send(new_df)
+        pd.testing.assert_frame_equal(plot[()].data, new_df)
+
+    def test_buffer_stream(self):
+        stream = Buffer(data=self.df, index=False)
+        plot = self.df.hvplot('x', 'y', stream=stream)
+        pd.testing.assert_frame_equal(plot[()].data, self.df)
+        new_df = pd.DataFrame([[7, 8], [9, 10]], columns=['x', 'y'])
+        stream.send(new_df)
+        pd.testing.assert_frame_equal(plot[()].data, pd.concat([self.df, new_df]))

hvplot/tests/testtransforms.py

@@ -0,0 +1,39 @@
+from unittest import SkipTest
+
+import holoviews as hv
+import numpy as np
+import pandas as pd
+
+from holoviews.element.comparison import ComparisonTestCase
+
+
+class TestPandasTransforms(ComparisonTestCase):
+    def setUp(self):
+        import hvplot.pandas  # noqa
+
+    def test_pandas_transform(self):
+        demo_df = pd.DataFrame({'value': np.random.randn(50), 'probability': np.random.rand(50)})
+        percent = hv.dim('probability') * 100
+        scatter = demo_df.hvplot.scatter(
+            x='value', y='probability', transforms=dict(probability=percent)
+        )
+        self.assertEqual((scatter.data['probability']).values, demo_df['probability'].values * 100)
+
+
+class TestXArrayTransforms(ComparisonTestCase):
+    def setUp(self):
+        try:
+            import xarray as xr  # noqa
+        except ImportError:
+            raise SkipTest('xarray not available')
+        import hvplot.xarray  # noqa
+
+    def test_xarray_transform(self):
+        import xarray as xr
+
+        data = np.arange(0, 60).reshape(6, 10)
+        x = np.arange(10)
+        y = np.arange(6)
+        da = xr.DataArray(data, coords={'y': y, 'x': x}, dims=('y', 'x'), name='value')
+        img = da.hvplot.image(transforms=dict(value=hv.dim('value') * 10))
+        self.assertEqual(img.data.value.data, da.data * 10)