hvplot 0.9.3a1__py3-none-any.whl

hvplot/tests/plotting/testscattermatrix.py

@@ -0,0 +1,138 @@
+from unittest import TestCase, SkipTest
+import sys
+
+from parameterized import parameterized
+import numpy as np
+import pandas as pd
+
+from holoviews.core import GridMatrix, NdOverlay
+from holoviews.element import (
+    Bivariate,
+    Distribution,
+    HexTiles,
+    Histogram,
+    Scatter,
+)
+from hvplot import scatter_matrix
+
+
+class TestScatterMatrix(TestCase):
+    def setUp(self):
+        self.df = pd.DataFrame(np.random.randn(1000, 4), columns=['a', 'b', 'c', 'd'])
+
+    def test_returns_gridmatrix(self):
+        sm = scatter_matrix(self.df)
+        self.assertIsInstance(sm, GridMatrix)
+
+    def test_wrong_diagonal(self):
+        with self.assertRaises(ValueError):
+            scatter_matrix(self.df, diagonal='wrong')
+
+    def test_wrong_chart(self):
+        with self.assertRaises(ValueError):
+            scatter_matrix(self.df, chart='wrong')
+
+    def test_diagonal_default(self):
+        sm = scatter_matrix(self.df)
+        self.assertIsInstance(sm['a', 'a'], Histogram)
+
+    def test_offdiagonal_default(self):
+        sm = scatter_matrix(self.df)
+        self.assertIsInstance(sm['a', 'b'], Scatter)
+
+    def test_diagonal_kde(self):
+        sm = scatter_matrix(self.df, diagonal='kde')
+        self.assertIsInstance(sm['a', 'a'], Distribution)
+
+    def test_offdiagonal_bivariate(self):
+        sm = scatter_matrix(self.df, chart='bivariate')
+        self.assertIsInstance(sm['a', 'b'], Bivariate)
+
+    def test_offdiagonal_hexbin(self):
+        sm = scatter_matrix(self.df, chart='hexbin')
+        self.assertIsInstance(sm['a', 'b'], HexTiles)
+
+    def test_diagonal_kwargs_mutually_exclusive(self):
+        with self.assertRaises(TypeError):
+            scatter_matrix(self.df, diagonal_kwds=dict(a=1), hist_kwds=dict(a=1))
+        with self.assertRaises(TypeError):
+            scatter_matrix(self.df, diagonal_kwds=dict(a=1), density_kwds=dict(a=1))
+        with self.assertRaises(TypeError):
+            scatter_matrix(self.df, density_kwds=dict(a=1), hist_kwds=dict(a=1))
+
+    def test_diagonal_kwargs(self):
+        sm = scatter_matrix(self.df, diagonal_kwds=dict(line_color='red'))
+        self.assertEqual(sm['a', 'a'].opts.get().kwargs['line_color'], 'red')
+
+    def test_c(self):
+        df = self.df.copy(deep=True)
+        df['e'] = np.random.choice(list('xyz'), size=len(df))
+        sm = scatter_matrix(df, c='e')
+
+        self.assertIsInstance(sm['a', 'a'], NdOverlay)
+        diag_kdims = sm['a', 'a'].kdims
+        self.assertEqual(len(diag_kdims), 1)
+        self.assertEqual(diag_kdims[0].name, 'e')
+
+        self.assertIsInstance(sm['a', 'b'], Scatter)
+        offdiag_vdims = sm['a', 'b'].vdims
+        self.assertTrue('e' in (d.name for d in offdiag_vdims))
+
+
+class TestDatashader(TestCase):
+    def setUp(self):
+        try:
+            import datashader  # noqa
+        except ImportError:
+            raise SkipTest('Datashader not available')
+        if sys.maxsize < 2**32:
+            raise SkipTest('Datashader does not support 32-bit systems')
+        self.df = pd.DataFrame(np.random.randn(1000, 3), columns=['a', 'b', 'c'])
+
+    def test_rasterize_datashade_mutually_exclusive(self):
+        with self.assertRaises(ValueError):
+            scatter_matrix(self.df, rasterize=True, datashade=True)
+
+    def test_spread_but_no_rasterize_or_datashade(self):
+        with self.assertRaises(ValueError):
+            scatter_matrix(self.df, dynspread=True)
+        with self.assertRaises(ValueError):
+            scatter_matrix(self.df, spread=True)
+        with self.assertRaises(ValueError):
+            scatter_matrix(self.df, dynspread=True, spread=True)
+
+    @parameterized.expand([('rasterize',), ('datashade',)])
+    def test_rasterization(self, operation):
+        sm = scatter_matrix(self.df, **{operation: True})
+        dm = sm['a', 'b']
+        self.assertEqual(dm.callback.operation.name, operation)
+        dm[()]
+        self.assertEqual(len(dm.last.pipeline.operations), 3)
+
+    @parameterized.expand([('rasterize',), ('datashade',)])
+    def test_datashade_aggregator(self, operation):
+        sm = scatter_matrix(self.df, aggregator='mean', **{operation: True})
+        dm = sm['a', 'b']
+        dm[()]
+        self.assertEqual(dm.last.pipeline.operations[-1].aggregator, 'mean')
+
+    @parameterized.expand([('spread',), ('dynspread',)])
+    def test_spread_rasterize(self, operation):
+        sm = scatter_matrix(self.df, rasterize=True, **{operation: True})
+        dm = sm['a', 'b']
+        dm[()]
+        self.assertEqual(len(dm.last.pipeline.operations), 4)
+
+    @parameterized.expand([('spread',), ('dynspread',)])
+    def test_spread_datashade(self, operation):
+        sm = scatter_matrix(self.df, datashade=True, **{operation: True})
+        dm = sm['a', 'b']
+        dm[()]
+        self.assertEqual(len(dm.last.pipeline.operations), 4)
+
+    @parameterized.expand([('spread',), ('dynspread',)])
+    def test_spread_kwargs(self, operation):
+        sm = scatter_matrix(self.df, datashade=True, **{operation: True, 'shape': 'circle'})
+        dm = sm['a', 'b']
+        dm[()]
+        self.assertEqual(dm.last.pipeline.operations[-1].args[0].keywords['shape'], 'circle')

hvplot/tests/test_links.py

@@ -0,0 +1,99 @@
+"""Urls in docstrings etc. should be valid and secure, i.e.
+
+- exist, i.e. provide a 200 response
+- use https:// instead of http:// unless
+    - https:// is not supported by the web site
+    - https:// cannot be used. For example in SVGs.
+"""
+
+import pathlib
+import re
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from urllib.request import urlopen
+import glob
+
+import pytest
+
+# Note: The regex will find urls from code cells in notebooks ending with '\\' because the are really inside \"some_url\"
+URL_REGEX = r"(?i)\b((?:https?://|www\d{0,3}[.]|[a-z0-9.\-]+[.][a-z]{2,4}/)(?:[^\s()<>]+|\(([^\s()<>]+|(\([^\s()<>]+\)))*\))+(?:\(([^\s()<>]+|(\([^\s()<>]+\)))*\)|[^\s`!()\[\]{};:'\".,<>?«»“”‘’]))"  # pylint: disable=line-too-long
+ROOT = pathlib.Path(__file__).parent
+PACKAGE_ROOT = ROOT.parent
+MAX_WORKERS = 10
+POST_FIXES = ['.py', '.ipynb', '.md', '.yaml']
+SKIP_URLS = [
+    'https://anaconda.org/anaconda/hvplot',
+    'https://anaconda.org/conda-forge/hvplot',
+    'https://anaconda.org/pyviz/hvplot',
+    'https://creativecommons.org/publicdomain/zero/1.0/',
+    'https://github.com/rasterio/rasterio',
+    'https://www.dask.org',
+    'pyproject.toml/equivalent',
+]
+
+
+def _get_files_to_check():
+    for post_fix in POST_FIXES:
+        for file in glob.glob('**/*' + post_fix, recursive=True):
+            yield pathlib.Path(file)
+
+
+FIXTURES = [pytest.param(file, id=str(file)) for file in _get_files_to_check()]
+
+
+def _skip_url(url: str):
+    if url in SKIP_URLS:
+        return True
+    if url.startswith('https://github.com/holoviz/hvplot/pull/'):
+        return True
+    if url.startswith('https://img.shields.io'):
+        return True
+    if url.startswith('assets.holoviews.org/data/'):
+        return True
+    if url.startswith('Math.PI'):
+        return True
+    return False
+
+
+def _clean_url(url: str):
+    if url.endswith('\\'):
+        return url[0:-1]
+    return url
+
+
+def _find_urls(text):
+    url = re.findall(URL_REGEX, text)
+    return {_clean_url(x[0]) for x in url if not _skip_url(x[0])}
+
+
+def _request_a_response(url):
+    return urlopen(url)
+
+
+def _verify_urls(urls):
+    """Returns True if all urls are valid"""
+    futures = {}
+    with ThreadPoolExecutor(max_workers=MAX_WORKERS) as executor:
+        futures = {}
+        for url in urls:
+            futures[executor.submit(_request_a_response, url)] = url
+
+        for future in as_completed(futures):
+            url = futures[future]
+            try:
+                result = future.result()
+            except Exception as ex:
+                raise ValueError(f'The url {url} raised an exception') from ex
+            if not result.status == 200:
+                raise ValueError(f'The url {url} responded with status {result.status}, not 200.')
+
+        return True
+
+
+# @pytest.mark.parametrize(["file"], FIXTURES)
+# def test_urls(file: pathlib.Path):
+#     """The urls is docstring should be valid"""
+#     # Given
+#     text = file.read_text()
+#     urls = _find_urls(text)
+#     # When/ Then
+#     assert _verify_urls(urls)

hvplot/tests/testbackend_transforms.py

@@ -0,0 +1,89 @@
+import holoviews
+import pytest
+from holoviews.core import Store
+from holoviews.element import Area, Curve
+
+from hvplot.backend_transforms import (
+    _transfer_opts,
+    _transform_size_to_mpl,
+    _is_interactive_opt,
+)
+
+
+@pytest.mark.parametrize(
+    ('width', 'height', 'aspect', 'opts'),
+    (
+        (300, 100, None, {'aspect': 3.0, 'fig_size': 100.0}),
+        (300, None, 3, {'aspect': 3, 'fig_size': 100.0}),
+        (None, 300, 3, {'aspect': 3, 'fig_size': 100.0}),
+        (300, None, None, {'fig_size': 100.0}),
+        (None, 300, None, {'fig_size': 100.0}),
+    ),
+)
+def test_transform_size_to_mpl(width, height, aspect, opts):
+    assert _transform_size_to_mpl(width, height, aspect) == opts
+
+
+@pytest.mark.parametrize(
+    ('element', 'opt', 'val', 'backend', 'opt_kind', 'transf_opt', 'transf_val'),
+    (
+        (Curve([]), 'line_dash', 'dashed', 'matplotlib', 'style', 'linestyle', 'dashed'),
+        (Curve([]), 'line_alpha', 0.123, 'matplotlib', 'style', None, None),
+        (Area([]), 'line_cap', 'square', 'matplotlib', 'style', 'capstyle', 'projecting'),
+        (Curve([]), 'line_dash', 'dashed', 'plotly', 'style', 'dash', 'dash'),
+    ),
+)
+def test_transfer_opts(element, opt, val, backend, opt_kind, transf_opt, transf_val):
+    current_backend = Store.current_backend
+    if backend not in Store.registry:
+        holoviews.extension(backend)
+    Store.set_current_backend(backend)
+    try:
+        element = element.opts(backend='bokeh', **{opt: val})
+        new_element = element.apply(_transfer_opts, backend=backend)
+        new_opts = new_element.opts.get(opt_kind).kwargs
+        if transf_opt is None:
+            assert val not in new_opts.values()
+        else:
+            assert transf_opt in new_opts
+            assert new_opts[transf_opt] == transf_val
+    finally:
+        Store.set_current_backend(current_backend)
+
+
+@pytest.mark.parametrize(
+    ('opt', 'val', 'backend', 'opt_kind', 'transf_opt', 'transf_val'),
+    (
+        ('line_dash', 'dashed', 'matplotlib', 'style', 'linestyle', 'dashed'),
+        ('line_dash', 'dashed', 'plotly', 'style', 'dash', 'dash'),
+    ),
+)
+def test_transfer_opts_compositeoverlay(opt, val, backend, opt_kind, transf_opt, transf_val):
+    current_backend = Store.current_backend
+    if backend not in Store.registry:
+        holoviews.extension(backend)
+    Store.set_current_backend(backend)
+    try:
+        element = Area([]) * Curve([]).opts(backend='bokeh', **{opt: val})
+        new_element = element.apply(_transfer_opts, backend=backend)
+        transformed_element = new_element.Curve.I
+        new_opts = transformed_element.opts.get(opt_kind).kwargs
+        assert transf_opt in new_opts
+        assert new_opts[transf_opt] == transf_val
+    finally:
+        Store.set_current_backend(current_backend)
+
+
+@pytest.mark.parametrize(
+    ('bk_option', 'expected'),
+    (
+        ('height', False),
+        ('hover_line_alpha', True),
+        ('nonselection_line_alpha', True),
+        ('muted_line_alpha', True),
+        ('selection_line_alpha', True),
+        ('annular_muted_alpha', True),
+    ),
+)
+def test_is_interactive_opt(bk_option, expected):
+    assert _is_interactive_opt(bk_option) == expected