hvplot 0.10.0rc2__tar.gz → 0.11.0a2__tar.gz

{hvplot-0.10.0rc2 → hvplot-0.11.0a2}/.github/workflows/build.yaml

@@ -62,9 +62,7 @@ jobs:
         with:
           python-version: ${{ env.PYTHON_VERSION }}
       - name: env setup
-        run: |
-          python -m pip install --upgrade pip setuptools
-          python -m pip install build
+        run: python -m pip install build
       - name: pip build
         run: python -m build
       - name: Publish package to PyPI

{hvplot-0.10.0rc2 → hvplot-0.11.0a2}/.github/workflows/docs.yaml

@@ -50,8 +50,6 @@ jobs:
         run: |
           echo "Deploying from ref ${GITHUB_REF#refs/*/}"
           echo "tag=${GITHUB_REF#refs/*/}" >> $GITHUB_OUTPUT
-      - name: bokeh sampledata
-        run: bokeh sampledata
       - name: install dev nbsite
         run: pip install --pre -U nbsite
       - name: conda info
@@ -105,7 +103,7 @@ jobs:
         with:
           python-version: ${{ env.PYTHON_VERSION }}
       - name: install
-        run: pip install ."[doc, examples, geo]"
+        run: pip install -v --prefer-binary -e ."[doc, examples, geo]"
       - name: install dev nbsite
         run: pip install --pre -U nbsite
       - name: pip list
@@ -115,8 +113,6 @@ jobs:
         run: |
           echo "Deploying from ref ${GITHUB_REF#refs/*/}"
           echo "tag=${GITHUB_REF#refs/*/}" >> $GITHUB_OUTPUT
-      - name: bokeh sampledata
-        run: bokeh sampledata
       - name: build docs
         run: sphinx-build -b html doc builtdocs
       - name: report failure

{hvplot-0.10.0rc2 → hvplot-0.11.0a2}/.github/workflows/test.yaml

@@ -60,10 +60,10 @@ jobs:
         run: |
           MATRIX=$(jq -nsc '{
               "os": ["ubuntu-latest", "macos-latest", "windows-latest"],
-              "python-version": ["3.8", "3.12"],
+              "python-version": ["3.9", "3.12"],
               "exclude": [
                 {
-                  "python-version": "3.8",
+                  "python-version": "3.9",
                   "os": "macos-latest"
                 }
               ]
@@ -74,7 +74,7 @@ jobs:
         run: |
           MATRIX=$(jq -nsc '{
               "os": ["ubuntu-latest", "macos-latest", "windows-latest"],
-              "python-version": ["3.8", "3.12"],
+              "python-version": ["3.9", "3.12"],
               "include": [
                 {
                   "python-version": "3.9",
@@ -91,7 +91,7 @@ jobs:
               ],
               "exclude": [
                 {
-                  "python-version": "3.8",
+                  "python-version": "3.9",
                   "os": "macos-latest"
                 }
               ]
@@ -132,13 +132,14 @@ jobs:
       - name: conda list
         run: conda list
       - name: bokeh sampledata
+        if: ${{ matrix.python-version == '3.9'}}
         run: bokeh sampledata
       - name: unit tests
         run: pytest -v hvplot --cov=hvplot --cov-append
       - name: unit tests geo
         run: pytest -v hvplot --geo --cov=hvplot --cov-append
       - name: examples tests
-        run: pytest -n auto --dist loadscope --nbval-lax -p no:python
+        run: pytest -n logical --dist loadscope --nbval-lax -p no:python
   pip_test:
     name: pip tests:${{ matrix.os }}:${{ matrix.python-version }}
     needs: [pre_commit, setup]
@@ -157,25 +158,19 @@ jobs:
       - uses: actions/setup-python@v5
         with:
           python-version: ${{ matrix.python-version }}
-      - name: upgrade pip / setuptools
-        run: pip install -U pip setuptools
-      - name: install without geo
-        # Because cartopy cannot be installed on Python 3.8 on these platforms
-        if: matrix.python-version == '3.8' && contains(fromJSON('["ubuntu-latest", "windows-latest"]'), matrix.os)
-        run: pip install -ve '.[tests, examples-tests, hvdev, dev-extras]'
       - name: install with geo
-        if: matrix.python-version != '3.8' || !contains(fromJSON('["ubuntu-latest", "windows-latest"]'), matrix.os)
-        run: pip install -ve '.[tests, examples-tests, geo, hvdev, hvdev-geo, dev-extras]'
+        run: pip install -v --prefer-binary -e '.[tests, examples-tests, geo, hvdev, hvdev-geo, dev-extras]'
       - name: pip list
         run: pip list
       - name: bokeh sampledata
+        if: ${{ matrix.python-version == '3.9'}}
         run: bokeh sampledata
       - name: unit tests
         run: pytest -v hvplot --cov=hvplot --cov-append
       - name: unit tests geo
         run: pytest -v hvplot --geo --cov=hvplot --cov-append
       - name: examples tests
-        run: pytest -n auto --dist loadscope --nbval-lax -p no:python
+        run: pytest -n logical --dist loadscope --nbval-lax -p no:python
       - name: Upload coverage reports to Codecov
         if: github.event_name == 'push' || github.event_name == 'pull_request'
         uses: codecov/codecov-action@v4

{hvplot-0.10.0rc2 → hvplot-0.11.0a2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hvplot
-Version: 0.10.0rc2
+Version: 0.11.0a2
 Summary: A high-level plotting API for the PyData ecosystem built on HoloViews.
 Author-email: Philipp Rudiger <developers@holoviz.org>
 Maintainer-email: HoloViz developers <developers@holoviz.org>
@@ -10,7 +10,6 @@ Project-URL: Source, http://github.com/holoviz/hvplot
 Project-URL: HoloViz, https://holoviz.org/
 Classifier: License :: OSI Approved :: BSD License
 Classifier: Development Status :: 5 - Production/Stable
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
@@ -21,16 +20,16 @@ Classifier: Intended Audience :: Developers
 Classifier: Natural Language :: English
 Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Software Development :: Libraries
-Requires-Python: >=3.8
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: bokeh>=1.0.0
+Requires-Dist: bokeh>=3.1
 Requires-Dist: colorcet>=2
-Requires-Dist: holoviews>=1.11.0
-Requires-Dist: numpy>=1.15
+Requires-Dist: holoviews>=1.19.0
+Requires-Dist: numpy>=1.21
 Requires-Dist: packaging
-Requires-Dist: pandas
-Requires-Dist: panel>=0.11.0
+Requires-Dist: pandas>=1.3
+Requires-Dist: panel>=1.0
 Requires-Dist: param<3.0,>=1.12.0
 Provides-Extra: tests-core
 Requires-Dist: dask[dataframe]; extra == "tests-core"
@@ -45,12 +44,16 @@ Requires-Dist: pytest; extra == "tests-core"
 Requires-Dist: ruff; extra == "tests-core"
 Requires-Dist: scipy; extra == "tests-core"
 Requires-Dist: xarray; extra == "tests-core"
+Requires-Dist: bokeh_sampledata; python_version >= "3.10" and extra == "tests-core"
+Requires-Dist: psutil; extra == "tests-core"
 Provides-Extra: tests
 Requires-Dist: hvplot[tests-core]; extra == "tests"
 Requires-Dist: fugue[sql]; extra == "tests"
 Requires-Dist: hvplot[fugue-sql]; extra == "tests"
 Requires-Dist: ibis-framework[duckdb]; extra == "tests"
 Requires-Dist: polars; extra == "tests"
+Requires-Dist: dask; extra == "tests"
+Requires-Dist: spatialpandas; extra == "tests"
 Provides-Extra: fugue-sql
 Requires-Dist: qpd>=0.4.4; extra == "fugue-sql"
 Requires-Dist: fugue-sql-antlr>=0.2.0; extra == "fugue-sql"
@@ -93,6 +96,7 @@ Requires-Dist: streamz>=0.3.0; extra == "examples"
 Requires-Dist: xarray>=0.18.2; extra == "examples"
 Requires-Dist: xyzservices>=2022.9.0; extra == "examples"
 Requires-Dist: geodatasets>=2023.12.0; extra == "examples"
+Requires-Dist: bokeh_sampledata; python_version >= "3.10" and extra == "examples"
 Provides-Extra: tests-nb
 Requires-Dist: pytest-xdist; extra == "tests-nb"
 Requires-Dist: nbval; extra == "tests-nb"

{hvplot-0.10.0rc2 → hvplot-0.11.0a2}/doc/conftest.py

@@ -1,7 +1,11 @@
-import dask
 from importlib.util import find_spec
+
+import dask
+
+from packaging.version import Version
 from bokeh.io.webdriver import webdriver_control
 
+
 collect_ignore_glob = [
     'user_guide/Streaming.ipynb',
 ]
@@ -45,3 +49,19 @@ finally:
 # 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})
+
+
+# https://github.com/pydata/xarray/pull/9182
+try:
+    import xarray as xr
+except ImportError:
+    pass
+else:
+    import numpy as np
+
+    if Version(np.__version__) >= Version('2.0.0') and Version(xr.__version__) <= Version(
+        '2024.6.0'
+    ):
+        collect_ignore_glob += [
+            'user_guide/Gridded_Data.ipynb',
+        ]

{hvplot-0.10.0rc2 → hvplot-0.11.0a2}/doc/developer_guide/index.md

@@ -79,7 +79,7 @@ source .venv/bin/activate
 Install the test dependencies:
 
 ``` bash
-pip install -e '.[tests, examples-tests, geo, hvdev, hvdev-geo, dev-extras]'
+pip install --prefer-binary -e '.[tests, examples-tests, geo, hvdev, hvdev-geo, dev-extras]'
 ```
 
 :::

{hvplot-0.10.0rc2 → hvplot-0.11.0a2}/doc/getting_started/installation.md

@@ -5,7 +5,7 @@
 | Latest release | [![Github release](https://img.shields.io/github/release/holoviz/hvplot.svg?label=tag&colorB=11ccbb)](https://github.com/holoviz/hvplot/releases) [![PyPI version](https://img.shields.io/pypi/v/hvplot.svg?colorB=cc77dd)](https://pypi.python.org/pypi/hvplot) [![hvplot version](https://img.shields.io/conda/v/pyviz/hvplot.svg?colorB=4488ff&style=flat)](https://anaconda.org/pyviz/hvplot) [![conda-forge version](https://img.shields.io/conda/v/conda-forge/hvplot.svg?label=conda%7Cconda-forge&colorB=4488ff)](https://anaconda.org/conda-forge/hvplot) [![defaults version](https://img.shields.io/conda/v/anaconda/hvplot.svg?label=conda%7Cdefaults&style=flat&colorB=4488ff)](https://anaconda.org/anaconda/hvplot) |
 | Python | [![Python support](https://img.shields.io/pypi/pyversions/hvplot.svg)](https://pypi.org/project/hvplot/) |
 
-hvPlot supports Python 3.8 and above on Linux, Windows, or Mac. hvPlot can be installed with [conda](https://conda.io/en/latest/):
+hvPlot supports Python 3.9 and above on Linux, Windows, or Mac. hvPlot can be installed with [conda](https://conda.io/en/latest/):
 
     conda install hvplot
 
@@ -13,7 +13,7 @@ or with `pip`:
 
     pip install hvplot
 
-For versions of `jupyterlab>=3.0` the necessary extension is automatically bundled in the `pyviz_comms` package, which must be >=2.0. However note that for version of `jupyterlab<3.0` you must also manually install the JupyterLab extension with:
+Note that `hvplot` needs to run in a Jupyter environment to automatically show output plots. However, if you are using a raw Python or IPython console, it is still possible to [show the plots](https://hvplot.holoviz.org/user_guide/Viewing.html#python-command-prompt-scripts) with `hvplot.show()` or [save the plots](https://hvplot.holoviz.org/user_guide/Viewing.html#saving-plots) even if you cannot view them interactively. For versions of `jupyterlab>=3.0` the necessary extension is automatically bundled in the `pyviz_comms` package, which must be >=2.0. However note that for version of `jupyterlab<3.0` you must also manually install the JupyterLab extension with:
 
     conda install jupyterlab
     jupyter labextension install @pyviz/jupyterlab_pyviz

{hvplot-0.10.0rc2 → hvplot-0.11.0a2}/doc/index.md

@@ -89,11 +89,11 @@ align: center
 
 :::{tab-item} GeoPandas
 ```python
-import geopandas as gpd
+import geopandas as gpd, geodatasets
 import hvplot.pandas
 
-gdf = gpd.read_file(gpd.datasets.get_path('naturalearth_cities'))
-gdf.hvplot(global_extent=True, tiles=True)
+chicago = gpd.read_file(geodatasets.get_path("geoda.chicago_commpop"))
+chicago.hvplot.polygons(geo=True, c='POP2010', hover_cols='all')
 ```
 ```{image} ./_static/home/geopandas.gif
 ---

{hvplot-0.10.0rc2 → hvplot-0.11.0a2}/doc/reference/geopandas/points.ipynb

@@ -31,8 +31,18 @@
    "source": [
     "import geopandas as gpd\n",
     "\n",
-    "cities = gpd.read_file(gpd.datasets.get_path('naturalearth_cities'))\n",
-    "cities.sample(5)"
+    "\n",
+    "data = {\n",
+    "    'City': ['London', 'Paris', 'Berlin', 'Madrid', 'Rome', 'Vienna', 'Warsaw', 'Amsterdam'],\n",
+    "    'Country': ['United Kingdom', 'France', 'Germany', 'Spain', 'Italy', 'Austria', 'Poland', 'Netherlands'],\n",
+    "    'Latitude': [51.5074, 48.8566, 52.5200, 40.4168, 41.9028, 48.2082, 52.2297, 52.3676],\n",
+    "    'Longitude': [-0.1278, 2.3522, 13.4050, -3.7038, 12.4964, 16.3738, 21.0122, 4.9041]\n",
+    "}\n",
+    "cities = gpd.GeoDataFrame(\n",
+    "    data,\n",
+    "    geometry=gpd.points_from_xy(data['Longitude'], data['Latitude']),\n",
+    "    crs=\"EPSG:4326\",\n",
+    ")"
    ]
   },
   {
@@ -82,7 +92,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "cities.hvplot(coastline=True, projection=ccrs.Geostationary(central_longitude=-30), global_extent=True)"
+    "cities.hvplot(coastline=True, projection=ccrs.Geostationary(central_longitude=10), global_extent=True)"
    ]
   }
  ],

{hvplot-0.10.0rc2 → hvplot-0.11.0a2}/doc/reference/geopandas/polygons.ipynb

@@ -29,10 +29,11 @@
    "metadata": {},
    "outputs": [],
    "source": [
+    "import geodatasets\n",
     "import geopandas as gpd\n",
     "\n",
-    "countries = gpd.read_file(gpd.datasets.get_path('naturalearth_lowres'))\n",
-    "countries.sample(5)"
+    "chicago = gpd.read_file(geodatasets.get_path(\"geoda.chicago_commpop\"))\n",
+    "chicago.sample(3)"
    ]
   },
   {
@@ -41,7 +42,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "countries.hvplot(geo=True)"
+    "chicago.hvplot(geo=True)"
    ]
   },
   {
@@ -57,7 +58,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "countries.hvplot.polygons(geo=True, c='pop_est', hover_cols='all')"
+    "chicago.hvplot.polygons(geo=True, c='POP2010', hover_cols='all')"
    ]
   },
   {
@@ -73,7 +74,11 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "countries.hvplot.polygons(geo=True, c=countries.pop_est/countries.area, clabel='pop density')"
+    "chicago.hvplot.polygons(\n",
+    "    geo=True,\n",
+    "    c=chicago.POP2010/chicago.to_crs('EPSG:32616').area,\n",
+    "    clabel='pop density',\n",
+    ")"
    ]
   }
  ],

hvplot-0.11.0a2/doc/reference/tabular/paths.ipynb

@@ -0,0 +1,80 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Paths"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "import hvplot.pandas  # noqa\n",
+    "import cartopy.crs as ccrs"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Paths are useful if you are plotting lines on a geographic map."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df = pd.DataFrame({\"city\": [\"NY\", \"Delhi\"], \"lon\": [-75, 77.23], \"lat\": [43, 28.61]})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Notice how the line in blue between New York and Delhi is not straight on a flat PlateCarree map, this is because the Geodetic coordinate system is a truly spherical coordinate system, where a line between two points is defined as the shortest path between those points on the globe rather than 2d Cartesian space."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "common_kwargs = dict(\n",
+    "    x=\"lon\",\n",
+    "    y=\"lat\",\n",
+    "    geo=True,\n",
+    "    project=True,\n",
+    "    projection=ccrs.GOOGLE_MERCATOR,\n",
+    "    global_extent=True\n",
+    ")\n",
+    "shortest_path = df.hvplot.paths(color=\"blue\", crs=ccrs.Geodetic(), tiles=True, **common_kwargs)\n",
+    "straight_path = df.hvplot.paths(color=\"grey\", line_dash=\"dashed\", **common_kwargs)\n",
+    "labels = df.hvplot.labels(text_color=\"black\", text=\"city\", **common_kwargs)\n",
+    "shortest_path * straight_path * labels"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Example adapted from https://scitools.org.uk/cartopy/docs/latest/matplotlib/intro.html."
+   ]
+  }
+ ],
+ "metadata": {
+  "language_info": {
+   "name": "python",
+   "pygments_lexer": "ipython3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

{hvplot-0.10.0rc2 → hvplot-0.11.0a2}/doc/reference/xarray/image.ipynb

@@ -79,6 +79,22 @@
     "data.hvplot.image(x='lon', y='lat', z='air', title=time, clabel='T [C]')"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can also override the colorbar ticks and labels with `cticks`, specified as an integer, list of ticks positions, or list of tuples of the tick positions and labels."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data.hvplot.image(x='lon', y='lat', z='air', title=time, clabel='T [C]', cticks=[(-40, \"Below Freezing\"), (0, \"Freezing\"), (40, \"Above Freezing\")])"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},

hvplot-0.11.0a2/doc/reference/xarray/vectorfield.ipynb

@@ -0,0 +1,230 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Vectorfield"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import hvplot.xarray  # noqa"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`vectorfield` accepts 2d arrays of magnitude and angle on a grid and produces an array of vectors. x and y can be 2d or 1d coordinates. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import xarray as xr\n",
+    "import holoviews as hv\n",
+    "import cartopy.crs as ccrs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def sample_data(shape=(20, 30)):\n",
+    "    \"\"\"\n",
+    "    Return ``(x, y, u, v, crs)`` of some vector data\n",
+    "    computed mathematically. The returned crs will be a rotated\n",
+    "    pole CRS, meaning that the vectors will be unevenly spaced in\n",
+    "    regular PlateCarree space.\n",
+    "\n",
+    "    \"\"\"\n",
+    "    crs = ccrs.RotatedPole(pole_longitude=177.5, pole_latitude=37.5)\n",
+    "\n",
+    "    x = np.linspace(311.9, 391.1, shape[1])\n",
+    "    y = np.linspace(-23.6, 24.8, shape[0])\n",
+    "\n",
+    "    x2d, y2d = np.meshgrid(x, y)\n",
+    "    u = 10 * (2 * np.cos(2 * np.deg2rad(x2d) + 3 * np.deg2rad(y2d + 30)) ** 2)\n",
+    "    v = 20 * np.cos(6 * np.deg2rad(x2d))\n",
+    "\n",
+    "    return x, y, u, v, crs\n",
+    "\n",
+    "xs, ys, U, V, crs = sample_data()\n",
+    "\n",
+    "mag = np.sqrt(U**2 + V**2)\n",
+    "angle = (np.pi/2.) - np.arctan2(U/mag, V/mag)\n",
+    "\n",
+    "ds = xr.Dataset({'mag': xr.DataArray(mag, dims=('y', 'x'), coords={'y': ys, 'x': xs}),\n",
+    "                 'angle': xr.DataArray(angle, dims=('y', 'x'), coords={'y': ys, 'x': xs})}, \n",
+    "                attrs={'crs': crs})\n",
+    "ds"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ds.hvplot.vectorfield(x='x', y='y', angle='angle', mag='mag', hover=False).opts(magnitude='mag')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Geographic Data\n",
+    "If a dataset has an attr called `crs` which is a cartopy object or a proj4 string, then just by setting the option `geo=True` will use the correct crs."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ds.hvplot.vectorfield(x='x', y='y', angle='angle', mag='mag',\n",
+    "                      hover=False, geo=True, tiles=\"CartoLight\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "If you set `coastline` or `features` it will keep the original crs and transform the features to the data crs."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ds.hvplot.vectorfield(x='x', y='y', angle='angle', mag='mag',\n",
+    "                      hover=False, geo=True, coastline=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Large Data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The visualization of vector fields from large datasets often presents a challenge.  Direct plotting methods can quickly consume excessive memory, leading to crashes or unresponsive applications. To address this issue, we introduce a dynamic downsampling technique that enables interactive exploration of vector fields without sacrificing performance. We first create a `sample_data` that contains 4,000,000 points."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "xs, ys, U, V, crs = sample_data(shape=(2000, 2000))\n",
+    "\n",
+    "mag = np.sqrt(U**2 + V**2)\n",
+    "angle = (np.pi/2.) - np.arctan2(U/mag, V/mag)\n",
+    "\n",
+    "ds = xr.Dataset({'mag': xr.DataArray(mag, dims=('y', 'x'), coords={'y': ys, 'x': xs}),\n",
+    "                 'angle': xr.DataArray(angle, dims=('y', 'x'), coords={'y': ys, 'x': xs})}, \n",
+    "                attrs={'crs': crs})\n",
+    "ds"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "If we just try to call `ds.hvplot.vectorfield` this is probably returning `MemoryError`. The alternative is to dynamically downsample the data based on the visible range. This helps manage memory consumption when dealing with large datasets, especially when plotting vector fields. We are going to use HoloViews to create a view (`hv.DynamicMap`) whose content is dynamically updated based on the data range displayed (tracked by the `hv.streams.RangeXY` stream), [find out more about these concepts](https://holoviews.org/user_guide/Custom_Interactivity.html)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def downsample_quiver(x_range=None, y_range=None, nmax=10):\n",
+    "    \"\"\"\n",
+    "    Creates a HoloViews vector field plot from a dataset, dynamically downsampling \n",
+    "    data based on the visible range to optimize memory usage.\n",
+    "\n",
+    "    Args:\n",
+    "        x_range (tuple, optional): Range of x values to include. Defaults to None (full range).\n",
+    "        y_range (tuple, optional): Range of y values to include. Defaults to None (full range).\n",
+    "        nmax (int, optional): Maximum number of points along each axis after coarsening. \n",
+    "                              Defaults to 10.\n",
+    "\n",
+    "    Returns:\n",
+    "        HoloViews DynamicMap: A dynamic vector field plot that updates based on the visible range.\n",
+    "    \"\"\"\n",
+    "\n",
+    "    if x_range is None or y_range is None:\n",
+    "        # No range provided, downsample the entire dataset for initial display\n",
+    "        xs, ys = ds.x.size, ds.y.size        # Get dataset dimensions\n",
+    "        ix, iy = xs // nmax, ys // nmax      # Calculate downsampling intervals\n",
+    "\n",
+    "        ix = max(1, ix)                     # Ensure interval is at least 1\n",
+    "        iy = max(1, iy)\n",
+    "\n",
+    "        sub = ds.coarsen(x=ix, y=iy, side=\"center\", boundary=\"trim\").mean()  # Downsample\n",
+    "    else:\n",
+    "        # Select data within the specified range\n",
+    "        sub = ds.sel(x=slice(*x_range), y=slice(*y_range))\n",
+    "\n",
+    "        # Downsample the selected data\n",
+    "        xs, ys = sub.x.size, sub.y.size\n",
+    "        ix, iy = xs // nmax, ys // nmax\n",
+    "        ix = max(1, ix)\n",
+    "        iy = max(1, iy)\n",
+    "        sub = sub.coarsen(x=ix, y=iy, side=\"center\", boundary=\"trim\").mean()\n",
+    "\n",
+    "    # Create the vector field plot\n",
+    "    quiver = sub.hvplot.vectorfield(\n",
+    "        x=\"x\",\n",
+    "        y=\"y\",\n",
+    "        mag=\"mag\",\n",
+    "        angle=\"angle\",\n",
+    "        hover=False,\n",
+    "    ).opts(magnitude=\"mag\")\n",
+    "\n",
+    "    return quiver"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create interactive plot components\n",
+    "range_xy = hv.streams.RangeXY()               # Stream to capture range changes\n",
+    "filtered = hv.DynamicMap(downsample_quiver, streams=[range_xy])  # Dynamic plot\n",
+    "filtered                                      # Display the plot"
+   ]
+  }
+ ],
+ "metadata": {
+  "language_info": {
+   "name": "python",
+   "pygments_lexer": "ipython3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}