diff --git a/myst.yml b/myst.yml index 01e305bf2..b0394df61 100644 --- a/myst.yml +++ b/myst.yml @@ -28,7 +28,7 @@ project: copyright: '2025' toc: - file: README.md - - file: '"notebooks/Ch 1_Introduction.ipynb"' + - file: notebooks/ch1_Introduction.ipynb - file: notebooks/ch2-mar-2023-tornado_jdh.ipynb - file: notebooks/ch3_TXfloods.ipynb - file: notebooks/bnf-mrms-qpe-hourly.ipynb diff --git a/notebooks/Ch 1_Introduction.ipynb b/notebooks/Ch 1_Introduction.ipynb deleted file mode 100644 index 0c8d15229..000000000 --- a/notebooks/Ch 1_Introduction.ipynb +++ /dev/null @@ -1,361 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Multi Radar/ Multi Sensor (MRMS) System: Overview, Case Studies, and More!" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Let's start here! If you can directly link to an image relevant to your notebook, such as [canonical logos](https://github.com/numpy/numpy/blob/main/doc/source/_static/numpylogo.svg), do so here at the top of your notebook. You can do this with MyST Markdown syntax, outlined in [this MyST guide](https://mystmd.org/guide/figures), or you edit this cell to see a demonstration. **Be sure to include `alt` text for any embedded images to make your content more accessible.**\n", - "\n", - "```{image} ../thumbnails/thumbnail.png\n", - ":alt: Project Pythia logo\n", - ":width: 200px\n", - "```" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Next, title your notebook appropriately with a top-level Markdown header, `#` (see the very first cell above). Do not use this level header anywhere else in the notebook. Our book build process will use this title in the navbar, table of contents, etc. Keep it short, keep it descriptive. \n", - "\n", - "Follow this with a `---` cell to visually distinguish the transition to the prerequisites section." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "---" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Overview\n", - "This notebook walks users through MRMS, use case scenarios, and more. Follow through the notebook to learn more about MRMS and ways it can be used to aid in your research and decision-making. If you have an introductory paragraph, lead with it here! Keep it short and tied to your material, then be sure to continue into the required list of topics below,\n", - "\n", - "1. This is a numbered list of the specific topics\n", - "1. These should map approximately to your main sections of content\n", - "1. Or each second-level, `##`, header in your notebook\n", - "1. Keep the size and scope of your notebook in check\n", - "1. And be sure to let the reader know up front the important concepts they'll be leaving with" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Prerequisites\n", - "This section was inspired by [this template](https://github.com/alan-turing-institute/the-turing-way/blob/master/book/templates/chapter-template/chapter-landing-page.md) of the wonderful [The Turing Way](https://the-turing-way.netlify.app) Jupyter Book.\n", - "\n", - "Following your overview, tell your reader what concepts, packages, or other background information they'll **need** before learning your material. Tie this explicitly with links to other pages here in Foundations or to relevant external resources. Remove this body text, then populate the Markdown table, denoted in this cell with `|` vertical brackets, below, and fill out the information following. In this table, lay out prerequisite concepts by explicitly linking to other Foundations material or external resources, or describe generally helpful concepts.\n", - "\n", - "Label the importance of each concept explicitly as **helpful/necessary**.\n", - "\n", - "| Concepts | Importance | Notes |\n", - "| --- | --- | --- |\n", - "| [Intro to Cartopy](https://foundations.projectpythia.org/core/cartopy/cartopy) | Necessary | |\n", - "| [Understanding of NetCDF](https://foundations.projectpythia.org/core/data-formats/netcdf-cf) | Helpful | Familiarity with metadata structure |\n", - "| Project management | Helpful | |\n", - "\n", - "- **Time to learn**: estimate in minutes. For a rough idea, use 5 mins per subsection, 10 if longer; add these up for a total. Safer to round up and overestimate.\n", - "- **System requirements**:\n", - " - Populate with any system, version, or non-Python software requirements if necessary\n", - " - Otherwise use the concepts table above and the Imports section below to describe required packages as necessary\n", - " - If no extra requirements, remove the **System requirements** point altogether" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "---" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Imports\n", - "Begin your body of content with another `---` divider before continuing into this section, then remove this body text and populate the following code cell with all necessary Python imports **up-front**:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "import sys" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Your first content section" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "This is where you begin your first section of material, loosely tied to your objectives stated up front. Tie together your notebook as a narrative, with interspersed Markdown text, images, and more as necessary," - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# as well as any and all of your code cells\n", - "print(\"Hello world!\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### A content subsection\n", - "Divide and conquer your objectives with Markdown subsections, which will populate the helpful navbar in Jupyter Lab and here on the Jupyter Book!" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# some subsection code\n", - "a = [1, 2, 3, 4, 5]\n", - "[i + 2 for i in a]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Another content subsection\n", - "Keep up the good work! A note, *try to avoid using code comments as narrative*, and instead let them only exist as brief clarifications where necessary." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Your second content section\n", - "Here we can move on to our second objective, and we can demonstrate..." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### A subsection to the second section\n", - "\n", - "#### a quick demonstration\n", - "\n", - "##### of further and further\n", - "\n", - "###### header levels" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "as well as $m = a * t / h$ text! Similarly, you have access to other $\\LaTeX$ equation [**functionality**](https://jupyter-notebook.readthedocs.io/en/stable/examples/Notebook/Typesetting%20Equations.html) via MathJax:\n", - "\n", - "\\begin{align}\n", - "\\dot{x} & = \\sigma(y-x) \\\\\n", - "\\dot{y} & = \\rho x - y - xz \\\\\n", - "\\dot{z} & = -\\beta z + xy\n", - "\\end{align}" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Check out [**any number of helpful Markdown resources**](https://www.markdownguide.org/basic-syntax/) for further customizing your notebooks and the [**MyST Syntax Overview**](https://mystmd.org/guide/syntax-overview) for MyST-specific formatting information. Don't hesitate to ask questions if you have problems getting it to look *just right*." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Last Section\n", - "\n", - "You can add [admonitions using MyST syntax](https://mystmd.org/guide/admonitions):" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - ":::{note}\n", - "Your relevant information here!\n", - ":::" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Some other admonitions you can put in ([there are 10 total](https://mystmd.org/guide/admonitions#admonitions-list)):" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - ":::{hint}\n", - "A helpful hint.\n", - ":::" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - ":::{warning}\n", - "Be careful!\n", - ":::" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - ":::{danger}\n", - "Scary stuff be here.\n", - ":::" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We also suggest checking out Jupyter Book's [brief demonstration](https://jupyterbook.org/content/metadata.html#jupyter-cell-tags) on adding cell tags to your cells in Jupyter Notebook, Lab, or manually. Using these cell tags can allow you to [customize](https://jupyterbook.org/interactive/hiding.html) how your code content is displayed and even [demonstrate errors](https://jupyterbook.org/content/execute.html#dealing-with-code-that-raises-errors) without altogether crashing our loyal army of machines!" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "---" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Summary\n", - "Add one final `---` marking the end of your body of content, and then conclude with a brief single paragraph summarizing at a high level the key pieces that were learned and how they tied to your objectives. Look to reiterate what the most important takeaways were.\n", - "\n", - "### What's next?\n", - "Let Jupyter book tie this to the next (sequential) piece of content that people could move on to down below and in the sidebar. However, if this page uniquely enables your reader to tackle other nonsequential concepts throughout this book, or even external content, link to it here!" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Resources and references\n", - "Finally, be rigorous in your citations and references as necessary. Give credit where credit is due. Also, feel free to link to relevant external material, further reading, documentation, etc. Then you're done! Give yourself a quick review, a high five, and send us a pull request. A few final notes:\n", - " - `Kernel > Restart Kernel and Run All Cells...` to confirm that your notebook will cleanly run from start to finish\n", - " - `Kernel > Restart Kernel and Clear All Outputs...` before committing your notebook, our machines will do the heavy lifting\n", - " - Take credit! Provide author contact information if you'd like; if so, consider adding information here at the bottom of your notebook\n", - " - Give credit! Attribute appropriate authorship for referenced code, information, images, etc.\n", - " - Only include what you're legally allowed: **no copyright infringement or plagiarism**\n", - " \n", - "Thank you for your contribution!" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python [conda env:notebook] *", - "language": "python", - "name": "conda-env-notebook-py" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.12.8" - }, - "nbdime-conflicts": { - "local_diff": [ - { - "diff": [ - { - "diff": [ - { - "key": 0, - "op": "addrange", - "valuelist": [ - "Python 3" - ] - }, - { - "key": 0, - "length": 1, - "op": "removerange" - } - ], - "key": "display_name", - "op": "patch" - } - ], - "key": "kernelspec", - "op": "patch" - } - ], - "remote_diff": [ - { - "diff": [ - { - "diff": [ - { - "key": 0, - "op": "addrange", - "valuelist": [ - "Python3" - ] - }, - { - "key": 0, - "length": 1, - "op": "removerange" - } - ], - "key": "display_name", - "op": "patch" - } - ], - "key": "kernelspec", - "op": "patch" - } - ] - }, - "toc-autonumbering": false - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/notebooks/ch1_Introduction.ipynb b/notebooks/ch1_Introduction.ipynb index 60ae2673d..b6f528e0d 100644 --- a/notebooks/ch1_Introduction.ipynb +++ b/notebooks/ch1_Introduction.ipynb @@ -4,7 +4,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Multi Radar/ Multi Sensor (MRMS) System: Overview, Case Studies, and More!" + "# Chapter 1: Multi Radar/ Multi Sensor (MRMS) System: Overview, Case Studies, and More!" ] }, { diff --git a/notebooks/ch3_TXfloods.ipynb b/notebooks/ch3_TXfloods.ipynb index 693e5a461..2ebb33d1c 100644 --- a/notebooks/ch3_TXfloods.ipynb +++ b/notebooks/ch3_TXfloods.ipynb @@ -4,7 +4,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# MRMS Reflectivity Animation: July 4, 2025" + "# Chapter 3: July 2025 Central TX Floods" ] }, { @@ -61,29 +61,39 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Core packages\n", - "import numpy as np\n", - "import numpy.ma as ma\n", - "import xarray as xr\n", + "import gzip\n", + "import tempfile\n", + "\n", + "# File handling (if you're downloading MRMS .grib2.gz files manually)\n", + "import urllib.request\n", + "from datetime import datetime, timedelta\n", + "from io import StringIO\n", "\n", - "# Plotting\n", - "import matplotlib.pyplot as plt\n", "import cartopy.crs as ccrs\n", "import cartopy.feature as cfeature\n", - "from metpy.plots import ctables # For NWS reflectivity colormap\n", + "import cmweather # noqa: F401\n", + "import matplotlib.colors as mcolors\n", "\n", - "# File handling (if you're downloading MRMS .grib2.gz files manually)\n", - "import urllib.request\n", - "import gzip\n", - "import tempfile\n", + "# Plotting\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import numpy.ma as ma\n", + "import pandas as pd\n", + "import requests\n", + "import s3fs\n", + "import xarray as xr\n", + "from IPython.display import HTML # To display the animation\n", "\n", "# Animation\n", - "from matplotlib.animation import ArtistAnimation\n", - "from IPython.display import HTML # To display the animation" + "from matplotlib.animation import ArtistAnimation, PillowWriter\n", + "from metpy.plots import ctables # For NWS reflectivity colormap\n", + "from scipy.interpolate import RegularGridInterpolator\n", + "\n" ] }, { @@ -115,18 +125,9 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "ECCODES ERROR : Key dataTime (unpack_long): Truncating time: non-zero seconds(40) ignored\n", - "ECCODES ERROR : Key dataTime (unpack_long): Truncating time: non-zero seconds(40) ignored\n" - ] - } - ], + "outputs": [], "source": [ "# Define the URL to the compressed MRMS GRIB2 file for a specific timestamp\n", "url = \"https://noaa-mrms-pds.s3.amazonaws.com/CONUS/LayerCompositeReflectivity_Low_00.50/20250704/MRMS_LayerCompositeReflectivity_Low_00.50_20250704-001040.grib2.gz\"\n", @@ -181,7 +182,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -199,20 +200,9 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# 3. Plot\n", "fig = plt.figure(figsize=(10, 8))\n", @@ -237,42 +227,6 @@ "plt.show()\n" ] }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "masked_array(\n", - " data=[[--, --, --, ..., --, --, --],\n", - " [--, --, --, ..., --, --, --],\n", - " [--, --, --, ..., --, --, --],\n", - " ...,\n", - " [--, --, --, ..., --, --, --],\n", - " [--, --, --, ..., --, --, --],\n", - " [--, --, --, ..., --, --, --]],\n", - " mask=[[ True, True, True, ..., True, True, True],\n", - " [ True, True, True, ..., True, True, True],\n", - " [ True, True, True, ..., True, True, True],\n", - " ...,\n", - " [ True, True, True, ..., True, True, True],\n", - " [ True, True, True, ..., True, True, True],\n", - " [ True, True, True, ..., True, True, True]],\n", - " fill_value=np.float64(1e+20),\n", - " dtype=float32)" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ma.masked_where(refl<5,refl)" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -306,49 +260,10 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Checking for available MRMS files...\n", - "\n", - " Found: 20250704-001040\n", - " Missing: 20250704-004040\n", - " Found: 20250704-011040\n", - " Missing: 20250704-014040\n", - " Missing: 20250704-021040\n", - " Missing: 20250704-024040\n", - " Found: 20250704-031040\n", - " Missing: 20250704-034040\n", - " Missing: 20250704-041040\n", - " Missing: 20250704-044040\n", - " Missing: 20250704-051040\n", - " Found: 20250704-054040\n", - " Missing: 20250704-061040\n", - " Missing: 20250704-064040\n", - " Found: 20250704-071040\n", - " Missing: 20250704-074040\n", - " Missing: 20250704-081040\n", - " Missing: 20250704-084040\n", - " Found: 20250704-091040\n", - "\n", - " Selected 6 timestamps:\n", - "20250704-001040\n", - "20250704-011040\n", - "20250704-031040\n", - "20250704-054040\n", - "20250704-071040\n", - "20250704-091040\n" - ] - } - ], + "outputs": [], "source": [ - "from datetime import datetime, timedelta\n", - "\n", - "\n", "start = datetime(2025, 7, 4, 0, 10, 40)\n", "end = datetime(2025, 7, 7, 0, 0, 0)\n", "step = timedelta(minutes=30)\n", @@ -380,13668 +295,9 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Loading 20250704-001040...\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "ECCODES ERROR : Key dataTime (unpack_long): Truncating time: non-zero seconds(40) ignored\n", - "ECCODES ERROR : Key dataTime (unpack_long): Truncating time: non-zero seconds(40) ignored\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Loading 20250704-011040...\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "ECCODES ERROR : Key dataTime (unpack_long): Truncating time: non-zero seconds(40) ignored\n", - "ECCODES ERROR : Key dataTime (unpack_long): Truncating time: non-zero seconds(40) ignored\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Loading 20250704-031040...\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "ECCODES ERROR : Key dataTime (unpack_long): Truncating time: non-zero seconds(40) ignored\n", - "ECCODES ERROR : Key dataTime (unpack_long): Truncating time: non-zero seconds(40) ignored\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Loading 20250704-054040...\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "ECCODES ERROR : Key dataTime (unpack_long): Truncating time: non-zero seconds(40) ignored\n", - "ECCODES ERROR : Key dataTime (unpack_long): Truncating time: non-zero seconds(40) ignored\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Loading 20250704-071040...\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "ECCODES ERROR : Key dataTime (unpack_long): Truncating time: non-zero seconds(40) ignored\n", - "ECCODES ERROR : Key dataTime (unpack_long): Truncating time: non-zero seconds(40) ignored\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Loading 20250704-091040...\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "ECCODES ERROR : Key dataTime (unpack_long): Truncating time: non-zero seconds(40) ignored\n", - "ECCODES ERROR : Key dataTime (unpack_long): Truncating time: non-zero seconds(40) ignored\n" - ] - }, - { - "data": { - "text/html": [ - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
\n", - " \n", - "
\n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - "
\n", - "
\n", - "\n", - "\n", - "\n" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# Define the 6 known working timestamps (one every hour)\n", "timestamps = [\n", @@ -14123,20 +379,10 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Animation saved as 'mrms_reflectivity_animation.gif'\n" - ] - } - ], + "outputs": [], "source": [ - "from matplotlib.animation import PillowWriter\n", - "\n", "# Save animation as a .gif\n", "anim.save(\"mrms_reflectivity_animation.gif\", writer=PillowWriter(fps=2))\n", "\n", @@ -14154,152 +400,532 @@ "This workflow is a flexible starting point for working with radar data, especially for case studies or quick visual diagnostics. The next section will continue building on this analysis with more approaches to explore the MRMS dataset!" ] }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Another content subsection\n", - "Keep up the good work! A note, *try to avoid using code comments as narrative*, and instead let them only exist as brief clarifications where necessary." - ] - }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Your second content section\n", - "Here we can move on to our second objective, and we can demonstrate..." + "## Comparison with ASOS Data" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": null, "metadata": {}, + "outputs": [], "source": [ - "### A subsection to the second section\n", "\n", - "#### a quick demonstration\n", + "aws = s3fs.S3FileSystem(anon=True)\n", + "path = aws.ls(\"noaa-mrms-pds/CONUS/RadarOnly_QPE_24H_00.00/20250705/\")[0]\n", "\n", - "##### of further and further\n", + "response = urllib.request.urlopen(\"https://noaa-mrms-pds.s3.amazonaws.com/\" + path[14:])\n", + "compressed_file = response.read()\n", "\n", - "###### header levels" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "as well as $m = a * t / h$ text! Similarly, you have access to other $\\LaTeX$ equation [**functionality**](https://jupyter-notebook.readthedocs.io/en/stable/examples/Notebook/Typesetting%20Equations.html) via MathJax:\n", + "with tempfile.NamedTemporaryFile(suffix=\".grib2\") as f:\n", + " f.write(gzip.decompress(compressed_file))\n", + " f.flush()\n", + " data = xr.load_dataarray(f.name, engine='cfgrib', decode_timedelta=True)\n", + "\n", + "# Set lat and lon bounds\n", + "lat_min, lat_max = 28, 33\n", + "lon_min, lon_max = -102.5, -96.5\n", + "\n", + "# Subset data and delete original\n", + "subset = data.sel(\n", + " latitude=slice(lat_max, lat_min),\n", + " longitude=slice(360 - abs(lon_min), 360 - abs(lon_max)),\n", + ").copy(deep=True)\n", + "\n", + "# Remove original data to free memory\n", + "del data\n", + "\n", + "url = \"https://mesonet.agron.iastate.edu/cgi-bin/request/asos.py\"\n", + "\n", + "params = {\n", + " \"network\": \"TX_ASOS\", # Or just use \"ASOS\" for all U.S.\n", + " \"data\": \"p01i\",\n", + " \"year1\": \"2025\",\n", + " \"month1\": \"7\",\n", + " \"day1\": \"4\",\n", + " \"year2\": \"2025\",\n", + " \"month2\": \"7\",\n", + " \"day2\": \"4\",\n", + " \"format\": \"comma\",\n", + " \"latlon\": \"yes\",\n", + "}\n", + "\n", + "# Make the request\n", + "response = requests.get(url, params=params)\n", + "\n", + "# Parse CSV from response text\n", + "df = pd.read_csv(StringIO(response.text), skiprows=5)\n", + "\n", + "# Drop missing precip values\n", + "df = df[df[\"p01i\"] != \"M\"]\n", + "df[\"p01i\"] = df[\"p01i\"].astype(float)\n", + "\n", + "# Convert timestamp to datetime\n", + "df[\"valid\"] = pd.to_datetime(df[\"valid\"])\n", + "\n", + "# Group by station and sum hourly precip\n", + "daily_precip = (\n", + " df.groupby([\"station\", \"lon\", \"lat\"])[\"p01i\"]\n", + " .sum()\n", + " .reset_index()\n", + " .rename(columns={\"p01i\": \"precip_in\"})\n", + ")\n", "\n", - "\\begin{align}\n", - "\\dot{x} & = \\sigma(y-x) \\\\\n", - "\\dot{y} & = \\rho x - y - xz \\\\\n", - "\\dot{z} & = -\\beta z + xy\n", - "\\end{align}" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Check out [**any number of helpful Markdown resources**](https://www.markdownguide.org/basic-syntax/) for further customizing your notebooks and the [**MyST Syntax Overview**](https://mystmd.org/guide/syntax-overview) for MyST-specific formatting information. Don't hesitate to ask questions if you have problems getting it to look *just right*." + "daily_precip" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": null, "metadata": {}, + "outputs": [], "source": [ - "## Last Section\n", + "# Set levels\n", + "levels = [\n", + " 0,\n", + " 0.01,\n", + " 0.1,\n", + " 0.25,\n", + " 0.50,\n", + " 1,\n", + " 1.5,\n", + " 2,\n", + " 2.5,\n", + " 3,\n", + " 4,\n", + " 5,\n", + " 6,\n", + " 7,\n", + " 8,\n", + " 9,\n", + " 10,\n", + " 12,\n", + " 14,\n", + " 16,\n", + " 18,\n", + "]\n", "\n", - "You can add [admonitions using MyST syntax](https://mystmd.org/guide/admonitions):" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - ":::{note}\n", - "Your relevant information here!\n", - ":::" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Some other admonitions you can put in ([there are 10 total](https://mystmd.org/guide/admonitions#admonitions-list)):" + "# Create a normalization object\n", + "cmap = plt.get_cmap(\"ChaseSpectral\") # Use full-resolution colormap\n", + "norm = mcolors.BoundaryNorm(levels, ncolors=cmap.N, clip=False)\n", + "\n", + "fig = plt.figure(figsize=(10, 8))\n", + "ax = plt.axes(projection=ccrs.PlateCarree())\n", + "ax.set_extent([lon_min, lon_max, lat_min, lat_max], crs=ccrs.PlateCarree())\n", + "\n", + "ax.add_feature(cfeature.COASTLINE, linewidth=1, edgecolor=\"white\")\n", + "ax.add_feature(cfeature.BORDERS, linewidth=1, edgecolor=\"white\")\n", + "ax.add_feature(cfeature.STATES, linewidth=0.5, edgecolor=\"white\")\n", + "# Add counties\n", + "ax.add_feature(\n", + " cfeature.NaturalEarthFeature(\n", + " category=\"cultural\",\n", + " name=\"admin_2_counties\",\n", + " scale=\"10m\",\n", + " facecolor=\"none\",\n", + " edgecolor=\"white\",\n", + " linewidth=0.3,\n", + " )\n", + ")\n", + "\n", + "mesh = ax.pcolormesh(\n", + " subset.longitude,\n", + " subset.latitude,\n", + " subset / 25.4, # Convert mm to inches\n", + " norm=norm,\n", + " cmap=\"ChaseSpectral\",\n", + " transform=ccrs.PlateCarree(),\n", + ")\n", + "\n", + "# Overlay ASOS bubble plot\n", + "sc = ax.scatter(\n", + " daily_precip[\"lon\"],\n", + " daily_precip[\"lat\"],\n", + " s=daily_precip[\"precip_in\"] * 40, # adjust bubble size scaling\n", + " c=daily_precip[\"precip_in\"],\n", + " cmap=cmap,\n", + " norm=norm,\n", + " alpha=0.9,\n", + " edgecolor=\"black\",\n", + " linewidth=0.4,\n", + " transform=ccrs.PlateCarree(),\n", + " zorder=10\n", + ")\n", + "\n", + "for size in [0.1, 0.5, 1.0, 2.0, 4.0]:\n", + " ax.scatter([], [], s=size * 40, c='gray', alpha=0.6, edgecolor='black', label=f\"{size:.1f}\\\"\")\n", + "\n", + "ax.legend(scatterpoints=1, loc=\"lower right\", title=\"ASOS Daily Rain\", frameon=True)\n", + "\n", + "\n", + "cb = plt.colorbar(\n", + " mesh, ax=ax, orientation=\"horizontal\", pad=0.05, aspect=50, shrink=0.8\n", + ")\n", + "cb.set_label(\"Rainfall (in)\")\n", + "# Add tick labels to colorbar\n", + "cb.set_ticks(levels)\n", + "cb.set_ticklabels([f\"{level:.2f}\" for level in levels])\n", + "cb.ax.tick_params(labelsize=10, rotation=45)\n", + "\n", + "plt.title(\"MRMS 24-Hour Radar Only QPE vs. ASOS Stations (July 4, 2025)\", fontsize=16)\n", + "plt.tight_layout()" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": null, "metadata": {}, + "outputs": [], "source": [ - ":::{hint}\n", - "A helpful hint.\n", - ":::" + "# Convert lat/lon coordinates from MRMS subset\n", + "lats = subset.latitude.values\n", + "lons = subset.longitude.values\n", + "\n", + "# Ensure correct orientation (ascending order for interpolator)\n", + "if lats[0] > lats[-1]:\n", + " lats = lats[::-1]\n", + " subset = subset[::-1, :]\n", + "\n", + "# Create interpolator (convert to inches)\n", + "interp_func = RegularGridInterpolator(\n", + " (lats, lons), (subset / 25.4).values, bounds_error=False, fill_value=np.nan\n", + ")\n", + "\n", + "# Convert ASOS longitude from degrees west to degrees east (0–360)\n", + "daily_precip[\"lon_east\"] = daily_precip[\"lon\"].apply(lambda x: x if x >= 0 else 360 + x)\n", + "\n", + "station_coords = list(zip(daily_precip[\"lat\"], daily_precip[\"lon_east\"]))\n", + "daily_precip[\"mrms_in\"] = interp_func(station_coords)\n", + "\n", + "\n", + "daily_precip[\"bias\"] = daily_precip[\"precip_in\"] - daily_precip[\"mrms_in\"]\n" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": null, "metadata": {}, + "outputs": [], "source": [ - ":::{warning}\n", - "Be careful!\n", - ":::" + "# Compute bias normalization\n", + "vmax = np.nanmax(np.abs(daily_precip[\"bias\"]))\n", + "\n", + "# Define bias levels (nonlinear, symmetric)\n", + "bias_levels = [-20, -10, -5, -2, -1, -0.5, -0.1, 0, 0.1, 0.5, 1, 2, 5, 10, 20]\n", + "\n", + "# Create BoundaryNorm\n", + "norm_bias = mcolors.BoundaryNorm(bias_levels, ncolors=plt.get_cmap(\"balance\").N, clip=True)\n", + "\n", + "\n", + "# Compute scatter sizes based on bias magnitude (optional scaling factor)\n", + "sizes = np.sqrt(np.abs(daily_precip[\"bias\"])) * 150 # tweak 100 as needed\n", + "\n", + "# Create figure and axis\n", + "fig = plt.figure(figsize=(10, 8))\n", + "ax = plt.axes(projection=ccrs.PlateCarree())\n", + "ax.set_extent([lon_min, lon_max, lat_min, lat_max], crs=ccrs.PlateCarree())\n", + "\n", + "# Basemap features\n", + "ax.add_feature(cfeature.COASTLINE, linewidth=1, edgecolor=\"white\")\n", + "ax.add_feature(cfeature.BORDERS, linewidth=1, edgecolor=\"white\")\n", + "ax.add_feature(cfeature.STATES, linewidth=0.5, edgecolor=\"white\")\n", + "ax.add_feature(\n", + " cfeature.NaturalEarthFeature(\n", + " category=\"cultural\",\n", + " name=\"admin_2_counties\",\n", + " scale=\"10m\",\n", + " facecolor=\"none\",\n", + " edgecolor=\"white\",\n", + " linewidth=0.3,\n", + " )\n", + ")\n", + "\n", + "# Pcolormesh for MRMS\n", + "mesh = ax.pcolormesh(\n", + " subset.longitude,\n", + " subset.latitude,\n", + " subset / 25.4, # Convert mm to inches\n", + " norm=norm,\n", + " cmap=\"ChaseSpectral\",\n", + " transform=ccrs.PlateCarree(),\n", + ")\n", + "\n", + "sc = ax.scatter(\n", + " daily_precip[\"lon\"],\n", + " daily_precip[\"lat\"],\n", + " c=daily_precip[\"bias\"],\n", + " s=sizes,\n", + " cmap=\"balance\", # cmocean or any diverging colormap\n", + " norm=norm_bias,\n", + " edgecolor=\"black\",\n", + " linewidth=0.4,\n", + " transform=ccrs.PlateCarree(),\n", + " zorder=10,\n", + ")\n", + "\n", + "# Add text labels for each station's bias\n", + "for _, row in daily_precip.iterrows():\n", + " bias_val = row[\"bias\"]\n", + " if not np.isnan(bias_val):\n", + " ax.text(\n", + " row[\"lon\"], row[\"lat\"],\n", + " f\"{bias_val:.2f}\\\"\",\n", + " fontsize=6,\n", + " ha=\"center\", va=\"center\",\n", + " transform=ccrs.PlateCarree(),\n", + " zorder=11,\n", + " color=\"white\" if abs(bias_val) > 0.5 else \"black\", # adjust for contrast\n", + " )\n", + "\n", + "\n", + "\n", + "# Bias colorbar (scatter)\n", + "cb1 = plt.colorbar(sc, ax=ax, orientation=\"horizontal\", pad=0.05, shrink=0.8, aspect=50)\n", + "cb1.set_label(\"ASOS - MRMS Bias (in)\")\n", + "cb1.set_ticks(bias_levels)\n", + "cb1.ax.tick_params(labelsize=10)\n", + "\n", + "\n", + "\n", + "# Add second colorbar (MRMS QPE from pcolormesh)\n", + "cb2 = plt.colorbar(mesh, ax=ax, orientation=\"vertical\", pad=0.02, shrink=0.8)\n", + "cb2.set_label(\"MRMS QPE (in)\")\n", + "cb2.ax.tick_params(labelsize=10)\n", + "\n", + "# Title and layout\n", + "ax.set_title(\"ASOS vs. MRMS Radar-Only QPE Bias (July 4, 2025)\", fontsize=16)\n", + "plt.tight_layout()\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - ":::{danger}\n", - "Scary stuff be here.\n", - ":::" + "## Compare MRMS Radar-Only to Pass 1 and Pass 2 QPE" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": null, "metadata": {}, + "outputs": [], "source": [ - "We also suggest checking out Jupyter Book's [brief demonstration](https://jupyterbook.org/content/metadata.html#jupyter-cell-tags) on adding cell tags to your cells in Jupyter Notebook, Lab, or manually. Using these cell tags can allow you to [customize](https://jupyterbook.org/interactive/hiding.html) how your code content is displayed and even [demonstrate errors](https://jupyterbook.org/content/execute.html#dealing-with-code-that-raises-errors) without altogether crashing our loyal army of machines!" + "def load_mrms_qpe_24h(date_str, product=\"RadarOnly_QPE_24H_00.00\",\n", + " lat_bounds=(28, 33), lon_bounds=(-102.5, -96.5)):\n", + " \"\"\"\n", + " Loads and subsets MRMS 24-hour radar-only QPE data from AWS.\n", + "\n", + " Parameters:\n", + " ----------\n", + " date_str : str\n", + " Date in 'YYYYMMDD' format (e.g., '20250705')\n", + " product : str\n", + " MRMS product folder (default: 'RadarOnly_QPE_24H_00.00' for Pass1)\n", + " lat_bounds : tuple\n", + " Tuple of (lat_min, lat_max)\n", + " lon_bounds : tuple\n", + " Tuple of (lon_min, lon_max) in degrees west\n", + "\n", + " Returns:\n", + " -------\n", + " subset : xarray.DataArray\n", + " Subset of MRMS QPE field for given domain and date\n", + " \"\"\"\n", + "\n", + " # Access file listing on AWS\n", + " aws = s3fs.S3FileSystem(anon=True)\n", + " mrms_path = f\"noaa-mrms-pds/CONUS/{product}/{date_str}/\"\n", + " file_list = aws.ls(mrms_path)\n", + "\n", + " # Only grab the first GRIB2 file for the day (should end in 0000.grib2.gz)\n", + " grib_path = next((f for f in file_list if f.endswith(\".grib2.gz\")), None)\n", + " if grib_path is None:\n", + " raise FileNotFoundError(f\"No GRIB2 file found for {date_str} in {product}\")\n", + "\n", + " url = \"https://noaa-mrms-pds.s3.amazonaws.com/\" + grib_path[len(\"noaa-mrms-pds/\"):]\n", + " response = urllib.request.urlopen(url)\n", + " compressed_file = response.read()\n", + "\n", + " with tempfile.NamedTemporaryFile(suffix=\".grib2\") as f:\n", + " f.write(gzip.decompress(compressed_file))\n", + " f.flush()\n", + " data = xr.load_dataarray(f.name, engine='cfgrib', decode_timedelta=True)\n", + "\n", + " # Subset domain\n", + " lat_min, lat_max = lat_bounds\n", + " lon_min, lon_max = lon_bounds\n", + " subset = data.sel(\n", + " latitude=slice(lat_max, lat_min),\n", + " longitude=slice(360 - abs(lon_min), 360 - abs(lon_max)),\n", + " ).copy(deep=True)\n", + "\n", + " # Clean up\n", + " del data\n", + "\n", + " return subset" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": null, "metadata": {}, + "outputs": [], "source": [ - "---" + "subset_pass1 = load_mrms_qpe_24h(\"20250705\", product=\"MultiSensor_QPE_24H_Pass1_00.00\")\n", + "subset_pass2 = load_mrms_qpe_24h(\"20250705\", product=\"MultiSensor_QPE_24H_Pass2_00.00\")" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": null, "metadata": {}, + "outputs": [], "source": [ - "## Summary\n", - "Add one final `---` marking the end of your body of content, and then conclude with a brief single paragraph summarizing at a high level the key pieces that were learned and how they tied to your objectives. Look to reiterate what the most important takeaways were.\n", + "# Define levels and normalization\n", + "levels = [\n", + " 0, 0.01, 0.1, 0.25, 0.50, 1, 1.5, 2, 2.5,\n", + " 3, 4, 5, 6, 7, 8, 9, 10, 12, 14, 16, 18\n", + "]\n", + "cmap = plt.get_cmap(\"ChaseSpectral\")\n", + "norm = mcolors.BoundaryNorm(levels, ncolors=cmap.N, clip=False)\n", + "\n", + "# Create figure and subplots\n", + "fig, axes = plt.subplots(\n", + " 1, 3, figsize=(15, 6),\n", + " subplot_kw={\"projection\": ccrs.PlateCarree()}\n", + ")\n", + "\n", + "# Title mapping\n", + "titles = [\n", + " \"Radar-Only QPE\",\n", + " \"Gauge-Corrected QPE (Pass 1)\",\n", + " \"Gauge-Corrected QPE (Pass 2)\"\n", + "]\n", "\n", - "### What's next?\n", - "Let Jupyter book tie this to the next (sequential) piece of content that people could move on to down below and in the sidebar. However, if this page uniquely enables your reader to tackle other nonsequential concepts throughout this book, or even external content, link to it here!" + "# Loop through datasets and plot\n", + "for ax, data, title in zip(\n", + " axes,\n", + " [subset, subset_pass1, subset_pass2],\n", + " titles\n", + "):\n", + " ax.set_extent([lon_min, lon_max, lat_min, lat_max], crs=ccrs.PlateCarree())\n", + "\n", + " # Basemap features\n", + " ax.add_feature(cfeature.COASTLINE, linewidth=1, edgecolor=\"white\")\n", + " ax.add_feature(cfeature.BORDERS, linewidth=1, edgecolor=\"white\")\n", + " ax.add_feature(cfeature.STATES, linewidth=0.5, edgecolor=\"white\")\n", + " ax.add_feature(\n", + " cfeature.NaturalEarthFeature(\n", + " category=\"cultural\",\n", + " name=\"admin_2_counties\",\n", + " scale=\"10m\",\n", + " facecolor=\"none\",\n", + " edgecolor=\"white\",\n", + " linewidth=0.3,\n", + " )\n", + " )\n", + "\n", + " # Pcolormesh plot\n", + " mesh = ax.pcolormesh(\n", + " data.longitude,\n", + " data.latitude,\n", + " data / 25.4, # mm to inches\n", + " norm=norm,\n", + " cmap=cmap,\n", + " transform=ccrs.PlateCarree(),\n", + " )\n", + "\n", + " ax.set_title(title, fontsize=13)\n", + "\n", + "# Shared colorbar below all plots\n", + "cb = fig.colorbar(\n", + " mesh, ax=axes, orientation=\"horizontal\", pad=0.08, aspect=50, shrink=0.8\n", + ")\n", + "cb.set_label(\"24-Hour Rainfall (in)\", fontsize=12)\n", + "cb.set_ticks(levels)\n", + "cb.set_ticklabels([f\"{level:.2f}\" for level in levels])\n", + "cb.ax.tick_params(labelsize=10, rotation=45)\n", + "\n", + "plt.suptitle(\"MRMS 24-Hour QPE Products (July 4, 2025)\", fontsize=16)\n", + "plt.tight_layout(rect=[0, 0.25, 1, 0.98]) # leave space for suptitle and colorbar\n", + "plt.show()\n" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": null, "metadata": {}, + "outputs": [], "source": [ - "## Resources and references\n", - "Finally, be rigorous in your citations and references as necessary. Give credit where credit is due. Also, feel free to link to relevant external material, further reading, documentation, etc. Then you're done! Give yourself a quick review, a high five, and send us a pull request. A few final notes:\n", - " - `Kernel > Restart Kernel and Run All Cells...` to confirm that your notebook will cleanly run from start to finish\n", - " - `Kernel > Restart Kernel and Clear All Outputs...` before committing your notebook, our machines will do the heavy lifting\n", - " - Take credit! Provide author contact information if you'd like; if so, consider adding information here at the bottom of your notebook\n", - " - Give credit! Attribute appropriate authorship for referenced code, information, images, etc.\n", - " - Only include what you're legally allowed: **no copyright infringement or plagiarism**\n", - " \n", - "Thank you for your contribution!" + "# Compute differences in inches\n", + "bias_pass1 = (subset_pass1 - subset) / 25.4\n", + "bias_pass2 = (subset_pass2 - subset) / 25.4\n", + "\n", + "# Define nonlinear boundaries for bias (symmetric)\n", + "bias_levels = [-16, -10, -5, -2, -1, -0.5, -0.1, 0, 0.1, 0.5, 1, 2, 5, 10, 16]\n", + "norm_bias = mcolors.BoundaryNorm(bias_levels, ncolors=plt.get_cmap(\"balance\").N, clip=True)\n", + "\n", + "# Create figure and subplots\n", + "fig, axes = plt.subplots(\n", + " 1, 2, figsize=(12, 6), constrained_layout=True,\n", + " subplot_kw={\"projection\": ccrs.PlateCarree()}\n", + ")\n", + "\n", + "# Titles\n", + "titles = [\n", + " \"Pass 1 – Radar-Only Bias (in)\",\n", + " \"Pass 2 – Radar-Only Bias (in)\"\n", + "]\n", + "\n", + "# Loop through plots\n", + "for ax, bias_data, title in zip(\n", + " axes,\n", + " [bias_pass1, bias_pass2],\n", + " titles\n", + "):\n", + " ax.set_extent([lon_min, lon_max, lat_min, lat_max], crs=ccrs.PlateCarree())\n", + "\n", + " # Basemap features\n", + " ax.add_feature(cfeature.COASTLINE, linewidth=1, edgecolor=\"white\")\n", + " ax.add_feature(cfeature.BORDERS, linewidth=1, edgecolor=\"white\")\n", + " ax.add_feature(cfeature.STATES, linewidth=0.5, edgecolor=\"white\")\n", + " ax.add_feature(\n", + " cfeature.NaturalEarthFeature(\n", + " category=\"cultural\",\n", + " name=\"admin_2_counties\",\n", + " scale=\"10m\",\n", + " facecolor=\"none\",\n", + " edgecolor=\"white\",\n", + " linewidth=0.3,\n", + " )\n", + " )\n", + "\n", + " # Pcolormesh\n", + " mesh = ax.pcolormesh(\n", + " bias_data.longitude,\n", + " bias_data.latitude,\n", + " bias_data,\n", + " cmap=\"balance\", # diverging colormap\n", + " norm=norm_bias,\n", + " transform=ccrs.PlateCarree(),\n", + " )\n", + "\n", + " ax.set_title(title, fontsize=13)\n", + "\n", + "# Shared colorbar\n", + "cb = fig.colorbar(\n", + " mesh, ax=axes, orientation=\"horizontal\", pad=0.08, aspect=50, shrink=0.8\n", + ")\n", + "cb.set_label(\"Gauge-Corrected Bias from Radar-Only QPE (in)\", fontsize=12)\n", + "cb.set_ticks(bias_levels)\n", + "cb.ax.tick_params(labelsize=10, rotation=45)\n", + "\n", + "# Suptitle and layout\n", + "plt.suptitle(\"MRMS 24-Hour Gauge Correction Bias (July 4, 2025)\", fontsize=16)\n", + "plt.show()\n" ] } ], diff --git a/notebooks/ch4_realtimeData.ipynb b/notebooks/ch4_realtimeData.ipynb index f00ac17b5..dcedf75c6 100644 --- a/notebooks/ch4_realtimeData.ipynb +++ b/notebooks/ch4_realtimeData.ipynb @@ -4,7 +4,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Real-time MRMS Visualization" + "# Chapter 5: Real-time MRMS Visualization" ] }, { @@ -67,1175 +67,9 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/javascript": [ - "(function(root) {\n", - " function now() {\n", - " return new Date();\n", - " }\n", - "\n", - " const force = true;\n", - " const py_version = '3.7.3'.replace('rc', '-rc.').replace('.dev', '-dev.');\n", - " const reloading = false;\n", - " const Bokeh = root.Bokeh;\n", - "\n", - " // Set a timeout for this load but only if we are not already initializing\n", - " if (typeof (root._bokeh_timeout) === \"undefined\" || (force || !root._bokeh_is_initializing)) {\n", - " root._bokeh_timeout = Date.now() + 5000;\n", - " root._bokeh_failed_load = false;\n", - " }\n", - "\n", - " function run_callbacks() {\n", - " try {\n", - " root._bokeh_onload_callbacks.forEach(function(callback) {\n", - " if (callback != null)\n", - " callback();\n", - " });\n", - " } finally {\n", - " delete root._bokeh_onload_callbacks;\n", - " }\n", - " console.debug(\"Bokeh: all callbacks have finished\");\n", - " }\n", - "\n", - " function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n", - " if (css_urls == null) css_urls = [];\n", - " if (js_urls == null) js_urls = [];\n", - " if (js_modules == null) js_modules = [];\n", - " if (js_exports == null) js_exports = {};\n", - "\n", - " root._bokeh_onload_callbacks.push(callback);\n", - "\n", - " if (root._bokeh_is_loading > 0) {\n", - " // Don't load bokeh if it is still initializing\n", - " console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n", - " return null;\n", - " } else if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n", - " // There is nothing to load\n", - " run_callbacks();\n", - " return null;\n", - " }\n", - "\n", - " function on_load() {\n", - " root._bokeh_is_loading--;\n", - " if (root._bokeh_is_loading === 0) {\n", - " console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n", - " run_callbacks()\n", - " }\n", - " }\n", - " window._bokeh_on_load = on_load\n", - "\n", - " function on_error(e) {\n", - " const src_el = e.srcElement\n", - " console.error(\"failed to load \" + (src_el.href || src_el.src));\n", - " }\n", - "\n", - " const skip = [];\n", - " if (window.requirejs) {\n", - " window.requirejs.config({'packages': {}, 'paths': {}, 'shim': {}});\n", - " root._bokeh_is_loading = css_urls.length + 0;\n", - " } else {\n", - " root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n", - " }\n", - "\n", - " const existing_stylesheets = []\n", - " const links = document.getElementsByTagName('link')\n", - " for (let i = 0; i < links.length; i++) {\n", - " const link = links[i]\n", - " if (link.href != null) {\n", - " existing_stylesheets.push(link.href)\n", - " }\n", - " }\n", - " for (let i = 0; i < css_urls.length; i++) {\n", - " const url = css_urls[i];\n", - " const escaped = encodeURI(url)\n", - " if (existing_stylesheets.indexOf(escaped) !== -1) {\n", - " on_load()\n", - " continue;\n", - " }\n", - " const element = document.createElement(\"link\");\n", - " element.onload = on_load;\n", - " element.onerror = on_error;\n", - " element.rel = \"stylesheet\";\n", - " element.type = \"text/css\";\n", - " element.href = url;\n", - " console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n", - " document.body.appendChild(element);\n", - " } var existing_scripts = []\n", - " const scripts = document.getElementsByTagName('script')\n", - " for (let i = 0; i < scripts.length; i++) {\n", - " var script = scripts[i]\n", - " if (script.src != null) {\n", - " existing_scripts.push(script.src)\n", - " }\n", - " }\n", - " for (let i = 0; i < js_urls.length; i++) {\n", - " const url = js_urls[i];\n", - " const escaped = encodeURI(url)\n", - " if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n", - " if (!window.requirejs) {\n", - " on_load();\n", - " }\n", - " continue;\n", - " }\n", - " const element = document.createElement('script');\n", - " element.onload = on_load;\n", - " element.onerror = on_error;\n", - " element.async = false;\n", - " element.src = url;\n", - " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", - " document.head.appendChild(element);\n", - " }\n", - " for (let i = 0; i < js_modules.length; i++) {\n", - " const url = js_modules[i];\n", - " const escaped = encodeURI(url)\n", - " if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n", - " if (!window.requirejs) {\n", - " on_load();\n", - " }\n", - " continue;\n", - " }\n", - " var element = document.createElement('script');\n", - " element.onload = on_load;\n", - " element.onerror = on_error;\n", - " element.async = false;\n", - " element.src = url;\n", - " element.type = \"module\";\n", - " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", - " document.head.appendChild(element);\n", - " }\n", - " for (const name in js_exports) {\n", - " const url = js_exports[name];\n", - " const escaped = encodeURI(url)\n", - " if (skip.indexOf(escaped) >= 0 || root[name] != null) {\n", - " if (!window.requirejs) {\n", - " on_load();\n", - " }\n", - " continue;\n", - " }\n", - " var element = document.createElement('script');\n", - " element.onerror = on_error;\n", - " element.async = false;\n", - " element.type = \"module\";\n", - " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", - " element.textContent = `\n", - " import ${name} from \"${url}\"\n", - " window.${name} = ${name}\n", - " window._bokeh_on_load()\n", - " `\n", - " document.head.appendChild(element);\n", - " }\n", - " if (!js_urls.length && !js_modules.length) {\n", - " on_load()\n", - " }\n", - " };\n", - "\n", - " function inject_raw_css(css) {\n", - " const element = document.createElement(\"style\");\n", - " element.appendChild(document.createTextNode(css));\n", - " document.body.appendChild(element);\n", - " }\n", - "\n", - " const js_urls = [\"https://cdn.holoviz.org/panel/1.7.5/dist/bundled/reactiveesm/es-module-shims@^1.10.0/dist/es-module-shims.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-3.7.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.7.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.7.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.7.3.min.js\", \"https://cdn.holoviz.org/panel/1.7.5/dist/panel.min.js\"];\n", - " const js_modules = [];\n", - " const js_exports = {};\n", - " const css_urls = [];\n", - " const inline_js = [ function(Bokeh) {\n", - " Bokeh.set_log_level(\"info\");\n", - " },\n", - "function(Bokeh) {} // ensure no trailing comma for IE\n", - " ];\n", - "\n", - " function run_inline_js() {\n", - " if ((root.Bokeh !== undefined) || (force === true)) {\n", - " for (let i = 0; i < inline_js.length; i++) {\n", - " try {\n", - " inline_js[i].call(root, root.Bokeh);\n", - " } catch(e) {\n", - " if (!reloading) {\n", - " throw e;\n", - " }\n", - " }\n", - " }\n", - " // Cache old bokeh versions\n", - " if (Bokeh != undefined && !reloading) {\n", - " var NewBokeh = root.Bokeh;\n", - " if (Bokeh.versions === undefined) {\n", - " Bokeh.versions = new Map();\n", - " }\n", - " if (NewBokeh.version !== Bokeh.version) {\n", - " Bokeh.versions.set(NewBokeh.version, NewBokeh)\n", - " }\n", - " root.Bokeh = Bokeh;\n", - " }\n", - " } else if (Date.now() < root._bokeh_timeout) {\n", - " setTimeout(run_inline_js, 100);\n", - " } else if (!root._bokeh_failed_load) {\n", - " console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n", - " root._bokeh_failed_load = true;\n", - " }\n", - " root._bokeh_is_initializing = false\n", - " }\n", - "\n", - " function load_or_wait() {\n", - " // Implement a backoff loop that tries to ensure we do not load multiple\n", - " // versions of Bokeh and its dependencies at the same time.\n", - " // In recent versions we use the root._bokeh_is_initializing flag\n", - " // to determine whether there is an ongoing attempt to initialize\n", - " // bokeh, however for backward compatibility we also try to ensure\n", - " // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n", - " // before older versions are fully initialized.\n", - " if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n", - " // If the timeout and bokeh was not successfully loaded we reset\n", - " // everything and try loading again\n", - " root._bokeh_timeout = Date.now() + 5000;\n", - " root._bokeh_is_initializing = false;\n", - " root._bokeh_onload_callbacks = undefined;\n", - " root._bokeh_is_loading = 0\n", - " console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n", - " load_or_wait();\n", - " } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n", - " setTimeout(load_or_wait, 100);\n", - " } else {\n", - " root._bokeh_is_initializing = true\n", - " root._bokeh_onload_callbacks = []\n", - " const bokeh_loaded = root.Bokeh != null && (root.Bokeh.version === py_version || (root.Bokeh.versions !== undefined && root.Bokeh.versions.has(py_version)));\n", - " if (!reloading && !bokeh_loaded) {\n", - " if (root.Bokeh) {\n", - " root.Bokeh = undefined;\n", - " }\n", - " console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n", - " }\n", - " load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n", - " console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n", - " run_inline_js();\n", - " });\n", - " }\n", - " }\n", - " // Give older versions of the autoload script a head-start to ensure\n", - " // they initialize before we start loading newer version.\n", - " setTimeout(load_or_wait, 100)\n", - "}(window));" - ], - "application/vnd.holoviews_load.v0+json": "(function(root) {\n function now() {\n return new Date();\n }\n\n const force = true;\n const py_version = '3.7.3'.replace('rc', '-rc.').replace('.dev', '-dev.');\n const reloading = false;\n const Bokeh = root.Bokeh;\n\n // Set a timeout for this load but only if we are not already initializing\n if (typeof (root._bokeh_timeout) === \"undefined\" || (force || !root._bokeh_is_initializing)) {\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_failed_load = false;\n }\n\n function run_callbacks() {\n try {\n root._bokeh_onload_callbacks.forEach(function(callback) {\n if (callback != null)\n callback();\n });\n } finally {\n delete root._bokeh_onload_callbacks;\n }\n console.debug(\"Bokeh: all callbacks have finished\");\n }\n\n function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n if (css_urls == null) css_urls = [];\n if (js_urls == null) js_urls = [];\n if (js_modules == null) js_modules = [];\n if (js_exports == null) js_exports = {};\n\n root._bokeh_onload_callbacks.push(callback);\n\n if (root._bokeh_is_loading > 0) {\n // Don't load bokeh if it is still initializing\n console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n return null;\n } else if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n // There is nothing to load\n run_callbacks();\n return null;\n }\n\n function on_load() {\n root._bokeh_is_loading--;\n if (root._bokeh_is_loading === 0) {\n console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n run_callbacks()\n }\n }\n window._bokeh_on_load = on_load\n\n function on_error(e) {\n const src_el = e.srcElement\n console.error(\"failed to load \" + (src_el.href || src_el.src));\n }\n\n const skip = [];\n if (window.requirejs) {\n window.requirejs.config({'packages': {}, 'paths': {}, 'shim': {}});\n root._bokeh_is_loading = css_urls.length + 0;\n } else {\n root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n }\n\n const existing_stylesheets = []\n const links = document.getElementsByTagName('link')\n for (let i = 0; i < links.length; i++) {\n const link = links[i]\n if (link.href != null) {\n existing_stylesheets.push(link.href)\n }\n }\n for (let i = 0; i < css_urls.length; i++) {\n const url = css_urls[i];\n const escaped = encodeURI(url)\n if (existing_stylesheets.indexOf(escaped) !== -1) {\n on_load()\n continue;\n }\n const element = document.createElement(\"link\");\n element.onload = on_load;\n element.onerror = on_error;\n element.rel = \"stylesheet\";\n element.type = \"text/css\";\n element.href = url;\n console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n document.body.appendChild(element);\n } var existing_scripts = []\n const scripts = document.getElementsByTagName('script')\n for (let i = 0; i < scripts.length; i++) {\n var script = scripts[i]\n if (script.src != null) {\n existing_scripts.push(script.src)\n }\n }\n for (let i = 0; i < js_urls.length; i++) {\n const url = js_urls[i];\n const escaped = encodeURI(url)\n if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n if (!window.requirejs) {\n on_load();\n }\n continue;\n }\n const element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (let i = 0; i < js_modules.length; i++) {\n const url = js_modules[i];\n const escaped = encodeURI(url)\n if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n if (!window.requirejs) {\n on_load();\n }\n continue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (const name in js_exports) {\n const url = js_exports[name];\n const escaped = encodeURI(url)\n if (skip.indexOf(escaped) >= 0 || root[name] != null) {\n if (!window.requirejs) {\n on_load();\n }\n continue;\n }\n var element = document.createElement('script');\n element.onerror = on_error;\n element.async = false;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n element.textContent = `\n import ${name} from \"${url}\"\n window.${name} = ${name}\n window._bokeh_on_load()\n `\n document.head.appendChild(element);\n }\n if (!js_urls.length && !js_modules.length) {\n on_load()\n }\n };\n\n function inject_raw_css(css) {\n const element = document.createElement(\"style\");\n element.appendChild(document.createTextNode(css));\n document.body.appendChild(element);\n }\n\n const js_urls = [\"https://cdn.holoviz.org/panel/1.7.5/dist/bundled/reactiveesm/es-module-shims@^1.10.0/dist/es-module-shims.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-3.7.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.7.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.7.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.7.3.min.js\", \"https://cdn.holoviz.org/panel/1.7.5/dist/panel.min.js\"];\n const js_modules = [];\n const js_exports = {};\n const css_urls = [];\n const inline_js = [ function(Bokeh) {\n Bokeh.set_log_level(\"info\");\n },\nfunction(Bokeh) {} // ensure no trailing comma for IE\n ];\n\n function run_inline_js() {\n if ((root.Bokeh !== undefined) || (force === true)) {\n for (let i = 0; i < inline_js.length; i++) {\n try {\n inline_js[i].call(root, root.Bokeh);\n } catch(e) {\n if (!reloading) {\n throw e;\n }\n }\n }\n // Cache old bokeh versions\n if (Bokeh != undefined && !reloading) {\n var NewBokeh = root.Bokeh;\n if (Bokeh.versions === undefined) {\n Bokeh.versions = new Map();\n }\n if (NewBokeh.version !== Bokeh.version) {\n Bokeh.versions.set(NewBokeh.version, NewBokeh)\n }\n root.Bokeh = Bokeh;\n }\n } else if (Date.now() < root._bokeh_timeout) {\n setTimeout(run_inline_js, 100);\n } else if (!root._bokeh_failed_load) {\n console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n root._bokeh_failed_load = true;\n }\n root._bokeh_is_initializing = false\n }\n\n function load_or_wait() {\n // Implement a backoff loop that tries to ensure we do not load multiple\n // versions of Bokeh and its dependencies at the same time.\n // In recent versions we use the root._bokeh_is_initializing flag\n // to determine whether there is an ongoing attempt to initialize\n // bokeh, however for backward compatibility we also try to ensure\n // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n // before older versions are fully initialized.\n if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n // If the timeout and bokeh was not successfully loaded we reset\n // everything and try loading again\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_is_initializing = false;\n root._bokeh_onload_callbacks = undefined;\n root._bokeh_is_loading = 0\n console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n load_or_wait();\n } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n setTimeout(load_or_wait, 100);\n } else {\n root._bokeh_is_initializing = true\n root._bokeh_onload_callbacks = []\n const bokeh_loaded = root.Bokeh != null && (root.Bokeh.version === py_version || (root.Bokeh.versions !== undefined && root.Bokeh.versions.has(py_version)));\n if (!reloading && !bokeh_loaded) {\n if (root.Bokeh) {\n root.Bokeh = undefined;\n }\n console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n }\n load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n run_inline_js();\n });\n }\n }\n // Give older versions of the autoload script a head-start to ensure\n // they initialize before we start loading newer version.\n setTimeout(load_or_wait, 100)\n}(window));" - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/javascript": [ - "\n", - "if ((window.PyViz === undefined) || (window.PyViz instanceof HTMLElement)) {\n", - " window.PyViz = {comms: {}, comm_status:{}, kernels:{}, receivers: {}, plot_index: []}\n", - "}\n", - "\n", - "\n", - " function JupyterCommManager() {\n", - " }\n", - "\n", - " JupyterCommManager.prototype.register_target = function(plot_id, comm_id, msg_handler) {\n", - " if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n", - " var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n", - " comm_manager.register_target(comm_id, function(comm) {\n", - " comm.on_msg(msg_handler);\n", - " });\n", - " } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n", - " window.PyViz.kernels[plot_id].registerCommTarget(comm_id, function(comm) {\n", - " comm.onMsg = msg_handler;\n", - " });\n", - " } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n", - " google.colab.kernel.comms.registerTarget(comm_id, (comm) => {\n", - " var messages = comm.messages[Symbol.asyncIterator]();\n", - " function processIteratorResult(result) {\n", - " var message = result.value;\n", - " var content = {data: message.data, comm_id};\n", - " var buffers = []\n", - " for (var buffer of message.buffers || []) {\n", - " buffers.push(new DataView(buffer))\n", - " }\n", - " var metadata = message.metadata || {};\n", - " var msg = {content, buffers, metadata}\n", - " msg_handler(msg);\n", - " return messages.next().then(processIteratorResult);\n", - " }\n", - " return messages.next().then(processIteratorResult);\n", - " })\n", - " }\n", - " }\n", - "\n", - " JupyterCommManager.prototype.get_client_comm = function(plot_id, comm_id, msg_handler) {\n", - " if (comm_id in window.PyViz.comms) {\n", - " return window.PyViz.comms[comm_id];\n", - " } else if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n", - " var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n", - " var comm = comm_manager.new_comm(comm_id, {}, {}, {}, comm_id);\n", - " if (msg_handler) {\n", - " comm.on_msg(msg_handler);\n", - " }\n", - " } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n", - " var comm = window.PyViz.kernels[plot_id].connectToComm(comm_id);\n", - " let retries = 0;\n", - " const open = () => {\n", - " if (comm.active) {\n", - " comm.open();\n", - " } else if (retries > 3) {\n", - " console.warn('Comm target never activated')\n", - " } else {\n", - " retries += 1\n", - " setTimeout(open, 500)\n", - " }\n", - " }\n", - " if (comm.active) {\n", - " comm.open();\n", - " } else {\n", - " setTimeout(open, 500)\n", - " }\n", - " if (msg_handler) {\n", - " comm.onMsg = msg_handler;\n", - " }\n", - " } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n", - " var comm_promise = google.colab.kernel.comms.open(comm_id)\n", - " comm_promise.then((comm) => {\n", - " window.PyViz.comms[comm_id] = comm;\n", - " if (msg_handler) {\n", - " var messages = comm.messages[Symbol.asyncIterator]();\n", - " function processIteratorResult(result) {\n", - " var message = result.value;\n", - " var content = {data: message.data};\n", - " var metadata = message.metadata || {comm_id};\n", - " var msg = {content, metadata}\n", - " msg_handler(msg);\n", - " return messages.next().then(processIteratorResult);\n", - " }\n", - " return messages.next().then(processIteratorResult);\n", - " }\n", - " })\n", - " var sendClosure = (data, metadata, buffers, disposeOnDone) => {\n", - " return comm_promise.then((comm) => {\n", - " comm.send(data, metadata, buffers, disposeOnDone);\n", - " });\n", - " };\n", - " var comm = {\n", - " send: sendClosure\n", - " };\n", - " }\n", - " window.PyViz.comms[comm_id] = comm;\n", - " return comm;\n", - " }\n", - " window.PyViz.comm_manager = new JupyterCommManager();\n", - " \n", - "\n", - "\n", - "var JS_MIME_TYPE = 'application/javascript';\n", - "var HTML_MIME_TYPE = 'text/html';\n", - "var EXEC_MIME_TYPE = 'application/vnd.holoviews_exec.v0+json';\n", - "var CLASS_NAME = 'output';\n", - "\n", - "/**\n", - " * Render data to the DOM node\n", - " */\n", - "function render(props, node) {\n", - " var div = document.createElement(\"div\");\n", - " var script = document.createElement(\"script\");\n", - " node.appendChild(div);\n", - " node.appendChild(script);\n", - "}\n", - "\n", - "/**\n", - " * Handle when a new output is added\n", - " */\n", - "function handle_add_output(event, handle) {\n", - " var output_area = handle.output_area;\n", - " var output = handle.output;\n", - " if ((output.data == undefined) || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n", - " return\n", - " }\n", - " var id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n", - " var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n", - " if (id !== undefined) {\n", - " var nchildren = toinsert.length;\n", - " var html_node = toinsert[nchildren-1].children[0];\n", - " html_node.innerHTML = output.data[HTML_MIME_TYPE];\n", - " var scripts = [];\n", - " var nodelist = html_node.querySelectorAll(\"script\");\n", - " for (var i in nodelist) {\n", - " if (nodelist.hasOwnProperty(i)) {\n", - " scripts.push(nodelist[i])\n", - " }\n", - " }\n", - "\n", - " scripts.forEach( function (oldScript) {\n", - " var newScript = document.createElement(\"script\");\n", - " var attrs = [];\n", - " var nodemap = oldScript.attributes;\n", - " for (var j in nodemap) {\n", - " if (nodemap.hasOwnProperty(j)) {\n", - " attrs.push(nodemap[j])\n", - " }\n", - " }\n", - " attrs.forEach(function(attr) { newScript.setAttribute(attr.name, attr.value) });\n", - " newScript.appendChild(document.createTextNode(oldScript.innerHTML));\n", - " oldScript.parentNode.replaceChild(newScript, oldScript);\n", - " });\n", - " if (JS_MIME_TYPE in output.data) {\n", - " toinsert[nchildren-1].children[1].textContent = output.data[JS_MIME_TYPE];\n", - " }\n", - " output_area._hv_plot_id = id;\n", - " if ((window.Bokeh !== undefined) && (id in Bokeh.index)) {\n", - " window.PyViz.plot_index[id] = Bokeh.index[id];\n", - " } else {\n", - " window.PyViz.plot_index[id] = null;\n", - " }\n", - " } else if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n", - " var bk_div = document.createElement(\"div\");\n", - " bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n", - " var script_attrs = bk_div.children[0].attributes;\n", - " for (var i = 0; i < script_attrs.length; i++) {\n", - " toinsert[toinsert.length - 1].childNodes[1].setAttribute(script_attrs[i].name, script_attrs[i].value);\n", - " }\n", - " // store reference to server id on output_area\n", - " output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n", - " }\n", - "}\n", - "\n", - "/**\n", - " * Handle when an output is cleared or removed\n", - " */\n", - "function handle_clear_output(event, handle) {\n", - " var id = handle.cell.output_area._hv_plot_id;\n", - " var server_id = handle.cell.output_area._bokeh_server_id;\n", - " if (((id === undefined) || !(id in PyViz.plot_index)) && (server_id !== undefined)) { return; }\n", - " var comm = window.PyViz.comm_manager.get_client_comm(\"hv-extension-comm\", \"hv-extension-comm\", function () {});\n", - " if (server_id !== null) {\n", - " comm.send({event_type: 'server_delete', 'id': server_id});\n", - " return;\n", - " } else if (comm !== null) {\n", - " comm.send({event_type: 'delete', 'id': id});\n", - " }\n", - " delete PyViz.plot_index[id];\n", - " if ((window.Bokeh !== undefined) & (id in window.Bokeh.index)) {\n", - " var doc = window.Bokeh.index[id].model.document\n", - " doc.clear();\n", - " const i = window.Bokeh.documents.indexOf(doc);\n", - " if (i > -1) {\n", - " window.Bokeh.documents.splice(i, 1);\n", - " }\n", - " }\n", - "}\n", - "\n", - "/**\n", - " * Handle kernel restart event\n", - " */\n", - "function handle_kernel_cleanup(event, handle) {\n", - " delete PyViz.comms[\"hv-extension-comm\"];\n", - " window.PyViz.plot_index = {}\n", - "}\n", - "\n", - "/**\n", - " * Handle update_display_data messages\n", - " */\n", - "function handle_update_output(event, handle) {\n", - " handle_clear_output(event, {cell: {output_area: handle.output_area}})\n", - " handle_add_output(event, handle)\n", - "}\n", - "\n", - "function register_renderer(events, OutputArea) {\n", - " function append_mime(data, metadata, element) {\n", - " // create a DOM node to render to\n", - " var toinsert = this.create_output_subarea(\n", - " metadata,\n", - " CLASS_NAME,\n", - " EXEC_MIME_TYPE\n", - " );\n", - " this.keyboard_manager.register_events(toinsert);\n", - " // Render to node\n", - " var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n", - " render(props, toinsert[0]);\n", - " element.append(toinsert);\n", - " return toinsert\n", - " }\n", - "\n", - " events.on('output_added.OutputArea', handle_add_output);\n", - " events.on('output_updated.OutputArea', handle_update_output);\n", - " events.on('clear_output.CodeCell', handle_clear_output);\n", - " events.on('delete.Cell', handle_clear_output);\n", - " events.on('kernel_ready.Kernel', handle_kernel_cleanup);\n", - "\n", - " OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n", - " safe: true,\n", - " index: 0\n", - " });\n", - "}\n", - "\n", - "if (window.Jupyter !== undefined) {\n", - " try {\n", - " var events = require('base/js/events');\n", - " var OutputArea = require('notebook/js/outputarea').OutputArea;\n", - " if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n", - " register_renderer(events, OutputArea);\n", - " }\n", - " } catch(err) {\n", - " }\n", - "}\n" - ], - "application/vnd.holoviews_load.v0+json": "\nif ((window.PyViz === undefined) || (window.PyViz instanceof HTMLElement)) {\n window.PyViz = {comms: {}, comm_status:{}, kernels:{}, receivers: {}, plot_index: []}\n}\n\n\n function JupyterCommManager() {\n }\n\n JupyterCommManager.prototype.register_target = function(plot_id, comm_id, msg_handler) {\n if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n comm_manager.register_target(comm_id, function(comm) {\n comm.on_msg(msg_handler);\n });\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n window.PyViz.kernels[plot_id].registerCommTarget(comm_id, function(comm) {\n comm.onMsg = msg_handler;\n });\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n google.colab.kernel.comms.registerTarget(comm_id, (comm) => {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n var content = {data: message.data, comm_id};\n var buffers = []\n for (var buffer of message.buffers || []) {\n buffers.push(new DataView(buffer))\n }\n var metadata = message.metadata || {};\n var msg = {content, buffers, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n })\n }\n }\n\n JupyterCommManager.prototype.get_client_comm = function(plot_id, comm_id, msg_handler) {\n if (comm_id in window.PyViz.comms) {\n return window.PyViz.comms[comm_id];\n } else if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n var comm = comm_manager.new_comm(comm_id, {}, {}, {}, comm_id);\n if (msg_handler) {\n comm.on_msg(msg_handler);\n }\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n var comm = window.PyViz.kernels[plot_id].connectToComm(comm_id);\n let retries = 0;\n const open = () => {\n if (comm.active) {\n comm.open();\n } else if (retries > 3) {\n console.warn('Comm target never activated')\n } else {\n retries += 1\n setTimeout(open, 500)\n }\n }\n if (comm.active) {\n comm.open();\n } else {\n setTimeout(open, 500)\n }\n if (msg_handler) {\n comm.onMsg = msg_handler;\n }\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n var comm_promise = google.colab.kernel.comms.open(comm_id)\n comm_promise.then((comm) => {\n window.PyViz.comms[comm_id] = comm;\n if (msg_handler) {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n var content = {data: message.data};\n var metadata = message.metadata || {comm_id};\n var msg = {content, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n }\n })\n var sendClosure = (data, metadata, buffers, disposeOnDone) => {\n return comm_promise.then((comm) => {\n comm.send(data, metadata, buffers, disposeOnDone);\n });\n };\n var comm = {\n send: sendClosure\n };\n }\n window.PyViz.comms[comm_id] = comm;\n return comm;\n }\n window.PyViz.comm_manager = new JupyterCommManager();\n \n\n\nvar JS_MIME_TYPE = 'application/javascript';\nvar HTML_MIME_TYPE = 'text/html';\nvar EXEC_MIME_TYPE = 'application/vnd.holoviews_exec.v0+json';\nvar CLASS_NAME = 'output';\n\n/**\n * Render data to the DOM node\n */\nfunction render(props, node) {\n var div = document.createElement(\"div\");\n var script = document.createElement(\"script\");\n node.appendChild(div);\n node.appendChild(script);\n}\n\n/**\n * Handle when a new output is added\n */\nfunction handle_add_output(event, handle) {\n var output_area = handle.output_area;\n var output = handle.output;\n if ((output.data == undefined) || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n return\n }\n var id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n if (id !== undefined) {\n var nchildren = toinsert.length;\n var html_node = toinsert[nchildren-1].children[0];\n html_node.innerHTML = output.data[HTML_MIME_TYPE];\n var scripts = [];\n var nodelist = html_node.querySelectorAll(\"script\");\n for (var i in nodelist) {\n if (nodelist.hasOwnProperty(i)) {\n scripts.push(nodelist[i])\n }\n }\n\n scripts.forEach( function (oldScript) {\n var newScript = document.createElement(\"script\");\n var attrs = [];\n var nodemap = oldScript.attributes;\n for (var j in nodemap) {\n if (nodemap.hasOwnProperty(j)) {\n attrs.push(nodemap[j])\n }\n }\n attrs.forEach(function(attr) { newScript.setAttribute(attr.name, attr.value) });\n newScript.appendChild(document.createTextNode(oldScript.innerHTML));\n oldScript.parentNode.replaceChild(newScript, oldScript);\n });\n if (JS_MIME_TYPE in output.data) {\n toinsert[nchildren-1].children[1].textContent = output.data[JS_MIME_TYPE];\n }\n output_area._hv_plot_id = id;\n if ((window.Bokeh !== undefined) && (id in Bokeh.index)) {\n window.PyViz.plot_index[id] = Bokeh.index[id];\n } else {\n window.PyViz.plot_index[id] = null;\n }\n } else if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n var bk_div = document.createElement(\"div\");\n bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n var script_attrs = bk_div.children[0].attributes;\n for (var i = 0; i < script_attrs.length; i++) {\n toinsert[toinsert.length - 1].childNodes[1].setAttribute(script_attrs[i].name, script_attrs[i].value);\n }\n // store reference to server id on output_area\n output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n }\n}\n\n/**\n * Handle when an output is cleared or removed\n */\nfunction handle_clear_output(event, handle) {\n var id = handle.cell.output_area._hv_plot_id;\n var server_id = handle.cell.output_area._bokeh_server_id;\n if (((id === undefined) || !(id in PyViz.plot_index)) && (server_id !== undefined)) { return; }\n var comm = window.PyViz.comm_manager.get_client_comm(\"hv-extension-comm\", \"hv-extension-comm\", function () {});\n if (server_id !== null) {\n comm.send({event_type: 'server_delete', 'id': server_id});\n return;\n } else if (comm !== null) {\n comm.send({event_type: 'delete', 'id': id});\n }\n delete PyViz.plot_index[id];\n if ((window.Bokeh !== undefined) & (id in window.Bokeh.index)) {\n var doc = window.Bokeh.index[id].model.document\n doc.clear();\n const i = window.Bokeh.documents.indexOf(doc);\n if (i > -1) {\n window.Bokeh.documents.splice(i, 1);\n }\n }\n}\n\n/**\n * Handle kernel restart event\n */\nfunction handle_kernel_cleanup(event, handle) {\n delete PyViz.comms[\"hv-extension-comm\"];\n window.PyViz.plot_index = {}\n}\n\n/**\n * Handle update_display_data messages\n */\nfunction handle_update_output(event, handle) {\n handle_clear_output(event, {cell: {output_area: handle.output_area}})\n handle_add_output(event, handle)\n}\n\nfunction register_renderer(events, OutputArea) {\n function append_mime(data, metadata, element) {\n // create a DOM node to render to\n var toinsert = this.create_output_subarea(\n metadata,\n CLASS_NAME,\n EXEC_MIME_TYPE\n );\n this.keyboard_manager.register_events(toinsert);\n // Render to node\n var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n render(props, toinsert[0]);\n element.append(toinsert);\n return toinsert\n }\n\n events.on('output_added.OutputArea', handle_add_output);\n events.on('output_updated.OutputArea', handle_update_output);\n events.on('clear_output.CodeCell', handle_clear_output);\n events.on('delete.Cell', handle_clear_output);\n events.on('kernel_ready.Kernel', handle_kernel_cleanup);\n\n OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n safe: true,\n index: 0\n });\n}\n\nif (window.Jupyter !== undefined) {\n try {\n var events = require('base/js/events');\n var OutputArea = require('notebook/js/outputarea').OutputArea;\n if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n register_renderer(events, OutputArea);\n }\n } catch(err) {\n }\n}\n" - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.holoviews_exec.v0+json": "", - "text/html": [ - "
\n", - "
\n", - "
\n", - "" - ] - }, - "metadata": { - "application/vnd.holoviews_exec.v0+json": { - "id": "8b979fd2-452a-44c5-96ef-c008147c60e1" - } - }, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/javascript": [ - "(function(root) {\n", - " function now() {\n", - " return new Date();\n", - " }\n", - "\n", - " const force = false;\n", - " const py_version = '3.7.3'.replace('rc', '-rc.').replace('.dev', '-dev.');\n", - " const reloading = true;\n", - " const Bokeh = root.Bokeh;\n", - "\n", - " // Set a timeout for this load but only if we are not already initializing\n", - " if (typeof (root._bokeh_timeout) === \"undefined\" || (force || !root._bokeh_is_initializing)) {\n", - " root._bokeh_timeout = Date.now() + 5000;\n", - " root._bokeh_failed_load = false;\n", - " }\n", - "\n", - " function run_callbacks() {\n", - " try {\n", - " root._bokeh_onload_callbacks.forEach(function(callback) {\n", - " if (callback != null)\n", - " callback();\n", - " });\n", - " } finally {\n", - " delete root._bokeh_onload_callbacks;\n", - " }\n", - " console.debug(\"Bokeh: all callbacks have finished\");\n", - " }\n", - "\n", - " function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n", - " if (css_urls == null) css_urls = [];\n", - " if (js_urls == null) js_urls = [];\n", - " if (js_modules == null) js_modules = [];\n", - " if (js_exports == null) js_exports = {};\n", - "\n", - " root._bokeh_onload_callbacks.push(callback);\n", - "\n", - " if (root._bokeh_is_loading > 0) {\n", - " // Don't load bokeh if it is still initializing\n", - " console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n", - " return null;\n", - " } else if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n", - " // There is nothing to load\n", - " run_callbacks();\n", - " return null;\n", - " }\n", - "\n", - " function on_load() {\n", - " root._bokeh_is_loading--;\n", - " if (root._bokeh_is_loading === 0) {\n", - " console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n", - " run_callbacks()\n", - " }\n", - " }\n", - " window._bokeh_on_load = on_load\n", - "\n", - " function on_error(e) {\n", - " const src_el = e.srcElement\n", - " console.error(\"failed to load \" + (src_el.href || src_el.src));\n", - " }\n", - "\n", - " const skip = [];\n", - " if (window.requirejs) {\n", - " window.requirejs.config({'packages': {}, 'paths': {}, 'shim': {}});\n", - " root._bokeh_is_loading = css_urls.length + 0;\n", - " } else {\n", - " root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n", - " }\n", - "\n", - " const existing_stylesheets = []\n", - " const links = document.getElementsByTagName('link')\n", - " for (let i = 0; i < links.length; i++) {\n", - " const link = links[i]\n", - " if (link.href != null) {\n", - " existing_stylesheets.push(link.href)\n", - " }\n", - " }\n", - " for (let i = 0; i < css_urls.length; i++) {\n", - " const url = css_urls[i];\n", - " const escaped = encodeURI(url)\n", - " if (existing_stylesheets.indexOf(escaped) !== -1) {\n", - " on_load()\n", - " continue;\n", - " }\n", - " const element = document.createElement(\"link\");\n", - " element.onload = on_load;\n", - " element.onerror = on_error;\n", - " element.rel = \"stylesheet\";\n", - " element.type = \"text/css\";\n", - " element.href = url;\n", - " console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n", - " document.body.appendChild(element);\n", - " } var existing_scripts = []\n", - " const scripts = document.getElementsByTagName('script')\n", - " for (let i = 0; i < scripts.length; i++) {\n", - " var script = scripts[i]\n", - " if (script.src != null) {\n", - " existing_scripts.push(script.src)\n", - " }\n", - " }\n", - " for (let i = 0; i < js_urls.length; i++) {\n", - " const url = js_urls[i];\n", - " const escaped = encodeURI(url)\n", - " if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n", - " if (!window.requirejs) {\n", - " on_load();\n", - " }\n", - " continue;\n", - " }\n", - " const element = document.createElement('script');\n", - " element.onload = on_load;\n", - " element.onerror = on_error;\n", - " element.async = false;\n", - " element.src = url;\n", - " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", - " document.head.appendChild(element);\n", - " }\n", - " for (let i = 0; i < js_modules.length; i++) {\n", - " const url = js_modules[i];\n", - " const escaped = encodeURI(url)\n", - " if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n", - " if (!window.requirejs) {\n", - " on_load();\n", - " }\n", - " continue;\n", - " }\n", - " var element = document.createElement('script');\n", - " element.onload = on_load;\n", - " element.onerror = on_error;\n", - " element.async = false;\n", - " element.src = url;\n", - " element.type = \"module\";\n", - " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", - " document.head.appendChild(element);\n", - " }\n", - " for (const name in js_exports) {\n", - " const url = js_exports[name];\n", - " const escaped = encodeURI(url)\n", - " if (skip.indexOf(escaped) >= 0 || root[name] != null) {\n", - " if (!window.requirejs) {\n", - " on_load();\n", - " }\n", - " continue;\n", - " }\n", - " var element = document.createElement('script');\n", - " element.onerror = on_error;\n", - " element.async = false;\n", - " element.type = \"module\";\n", - " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", - " element.textContent = `\n", - " import ${name} from \"${url}\"\n", - " window.${name} = ${name}\n", - " window._bokeh_on_load()\n", - " `\n", - " document.head.appendChild(element);\n", - " }\n", - " if (!js_urls.length && !js_modules.length) {\n", - " on_load()\n", - " }\n", - " };\n", - "\n", - " function inject_raw_css(css) {\n", - " const element = document.createElement(\"style\");\n", - " element.appendChild(document.createTextNode(css));\n", - " document.body.appendChild(element);\n", - " }\n", - "\n", - " const js_urls = [\"https://cdn.holoviz.org/panel/1.7.5/dist/bundled/reactiveesm/es-module-shims@^1.10.0/dist/es-module-shims.min.js\"];\n", - " const js_modules = [];\n", - " const js_exports = {};\n", - " const css_urls = [];\n", - " const inline_js = [ function(Bokeh) {\n", - " Bokeh.set_log_level(\"info\");\n", - " },\n", - "function(Bokeh) {} // ensure no trailing comma for IE\n", - " ];\n", - "\n", - " function run_inline_js() {\n", - " if ((root.Bokeh !== undefined) || (force === true)) {\n", - " for (let i = 0; i < inline_js.length; i++) {\n", - " try {\n", - " inline_js[i].call(root, root.Bokeh);\n", - " } catch(e) {\n", - " if (!reloading) {\n", - " throw e;\n", - " }\n", - " }\n", - " }\n", - " // Cache old bokeh versions\n", - " if (Bokeh != undefined && !reloading) {\n", - " var NewBokeh = root.Bokeh;\n", - " if (Bokeh.versions === undefined) {\n", - " Bokeh.versions = new Map();\n", - " }\n", - " if (NewBokeh.version !== Bokeh.version) {\n", - " Bokeh.versions.set(NewBokeh.version, NewBokeh)\n", - " }\n", - " root.Bokeh = Bokeh;\n", - " }\n", - " } else if (Date.now() < root._bokeh_timeout) {\n", - " setTimeout(run_inline_js, 100);\n", - " } else if (!root._bokeh_failed_load) {\n", - " console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n", - " root._bokeh_failed_load = true;\n", - " }\n", - " root._bokeh_is_initializing = false\n", - " }\n", - "\n", - " function load_or_wait() {\n", - " // Implement a backoff loop that tries to ensure we do not load multiple\n", - " // versions of Bokeh and its dependencies at the same time.\n", - " // In recent versions we use the root._bokeh_is_initializing flag\n", - " // to determine whether there is an ongoing attempt to initialize\n", - " // bokeh, however for backward compatibility we also try to ensure\n", - " // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n", - " // before older versions are fully initialized.\n", - " if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n", - " // If the timeout and bokeh was not successfully loaded we reset\n", - " // everything and try loading again\n", - " root._bokeh_timeout = Date.now() + 5000;\n", - " root._bokeh_is_initializing = false;\n", - " root._bokeh_onload_callbacks = undefined;\n", - " root._bokeh_is_loading = 0\n", - " console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n", - " load_or_wait();\n", - " } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n", - " setTimeout(load_or_wait, 100);\n", - " } else {\n", - " root._bokeh_is_initializing = true\n", - " root._bokeh_onload_callbacks = []\n", - " const bokeh_loaded = root.Bokeh != null && (root.Bokeh.version === py_version || (root.Bokeh.versions !== undefined && root.Bokeh.versions.has(py_version)));\n", - " if (!reloading && !bokeh_loaded) {\n", - " if (root.Bokeh) {\n", - " root.Bokeh = undefined;\n", - " }\n", - " console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n", - " }\n", - " load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n", - " console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n", - " run_inline_js();\n", - " });\n", - " }\n", - " }\n", - " // Give older versions of the autoload script a head-start to ensure\n", - " // they initialize before we start loading newer version.\n", - " setTimeout(load_or_wait, 100)\n", - "}(window));" - ], - "application/vnd.holoviews_load.v0+json": "(function(root) {\n function now() {\n return new Date();\n }\n\n const force = false;\n const py_version = '3.7.3'.replace('rc', '-rc.').replace('.dev', '-dev.');\n const reloading = true;\n const Bokeh = root.Bokeh;\n\n // Set a timeout for this load but only if we are not already initializing\n if (typeof (root._bokeh_timeout) === \"undefined\" || (force || !root._bokeh_is_initializing)) {\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_failed_load = false;\n }\n\n function run_callbacks() {\n try {\n root._bokeh_onload_callbacks.forEach(function(callback) {\n if (callback != null)\n callback();\n });\n } finally {\n delete root._bokeh_onload_callbacks;\n }\n console.debug(\"Bokeh: all callbacks have finished\");\n }\n\n function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n if (css_urls == null) css_urls = [];\n if (js_urls == null) js_urls = [];\n if (js_modules == null) js_modules = [];\n if (js_exports == null) js_exports = {};\n\n root._bokeh_onload_callbacks.push(callback);\n\n if (root._bokeh_is_loading > 0) {\n // Don't load bokeh if it is still initializing\n console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n return null;\n } else if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n // There is nothing to load\n run_callbacks();\n return null;\n }\n\n function on_load() {\n root._bokeh_is_loading--;\n if (root._bokeh_is_loading === 0) {\n console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n run_callbacks()\n }\n }\n window._bokeh_on_load = on_load\n\n function on_error(e) {\n const src_el = e.srcElement\n console.error(\"failed to load \" + (src_el.href || src_el.src));\n }\n\n const skip = [];\n if (window.requirejs) {\n window.requirejs.config({'packages': {}, 'paths': {}, 'shim': {}});\n root._bokeh_is_loading = css_urls.length + 0;\n } else {\n root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n }\n\n const existing_stylesheets = []\n const links = document.getElementsByTagName('link')\n for (let i = 0; i < links.length; i++) {\n const link = links[i]\n if (link.href != null) {\n existing_stylesheets.push(link.href)\n }\n }\n for (let i = 0; i < css_urls.length; i++) {\n const url = css_urls[i];\n const escaped = encodeURI(url)\n if (existing_stylesheets.indexOf(escaped) !== -1) {\n on_load()\n continue;\n }\n const element = document.createElement(\"link\");\n element.onload = on_load;\n element.onerror = on_error;\n element.rel = \"stylesheet\";\n element.type = \"text/css\";\n element.href = url;\n console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n document.body.appendChild(element);\n } var existing_scripts = []\n const scripts = document.getElementsByTagName('script')\n for (let i = 0; i < scripts.length; i++) {\n var script = scripts[i]\n if (script.src != null) {\n existing_scripts.push(script.src)\n }\n }\n for (let i = 0; i < js_urls.length; i++) {\n const url = js_urls[i];\n const escaped = encodeURI(url)\n if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n if (!window.requirejs) {\n on_load();\n }\n continue;\n }\n const element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (let i = 0; i < js_modules.length; i++) {\n const url = js_modules[i];\n const escaped = encodeURI(url)\n if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n if (!window.requirejs) {\n on_load();\n }\n continue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (const name in js_exports) {\n const url = js_exports[name];\n const escaped = encodeURI(url)\n if (skip.indexOf(escaped) >= 0 || root[name] != null) {\n if (!window.requirejs) {\n on_load();\n }\n continue;\n }\n var element = document.createElement('script');\n element.onerror = on_error;\n element.async = false;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n element.textContent = `\n import ${name} from \"${url}\"\n window.${name} = ${name}\n window._bokeh_on_load()\n `\n document.head.appendChild(element);\n }\n if (!js_urls.length && !js_modules.length) {\n on_load()\n }\n };\n\n function inject_raw_css(css) {\n const element = document.createElement(\"style\");\n element.appendChild(document.createTextNode(css));\n document.body.appendChild(element);\n }\n\n const js_urls = [\"https://cdn.holoviz.org/panel/1.7.5/dist/bundled/reactiveesm/es-module-shims@^1.10.0/dist/es-module-shims.min.js\"];\n const js_modules = [];\n const js_exports = {};\n const css_urls = [];\n const inline_js = [ function(Bokeh) {\n Bokeh.set_log_level(\"info\");\n },\nfunction(Bokeh) {} // ensure no trailing comma for IE\n ];\n\n function run_inline_js() {\n if ((root.Bokeh !== undefined) || (force === true)) {\n for (let i = 0; i < inline_js.length; i++) {\n try {\n inline_js[i].call(root, root.Bokeh);\n } catch(e) {\n if (!reloading) {\n throw e;\n }\n }\n }\n // Cache old bokeh versions\n if (Bokeh != undefined && !reloading) {\n var NewBokeh = root.Bokeh;\n if (Bokeh.versions === undefined) {\n Bokeh.versions = new Map();\n }\n if (NewBokeh.version !== Bokeh.version) {\n Bokeh.versions.set(NewBokeh.version, NewBokeh)\n }\n root.Bokeh = Bokeh;\n }\n } else if (Date.now() < root._bokeh_timeout) {\n setTimeout(run_inline_js, 100);\n } else if (!root._bokeh_failed_load) {\n console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n root._bokeh_failed_load = true;\n }\n root._bokeh_is_initializing = false\n }\n\n function load_or_wait() {\n // Implement a backoff loop that tries to ensure we do not load multiple\n // versions of Bokeh and its dependencies at the same time.\n // In recent versions we use the root._bokeh_is_initializing flag\n // to determine whether there is an ongoing attempt to initialize\n // bokeh, however for backward compatibility we also try to ensure\n // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n // before older versions are fully initialized.\n if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n // If the timeout and bokeh was not successfully loaded we reset\n // everything and try loading again\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_is_initializing = false;\n root._bokeh_onload_callbacks = undefined;\n root._bokeh_is_loading = 0\n console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n load_or_wait();\n } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n setTimeout(load_or_wait, 100);\n } else {\n root._bokeh_is_initializing = true\n root._bokeh_onload_callbacks = []\n const bokeh_loaded = root.Bokeh != null && (root.Bokeh.version === py_version || (root.Bokeh.versions !== undefined && root.Bokeh.versions.has(py_version)));\n if (!reloading && !bokeh_loaded) {\n if (root.Bokeh) {\n root.Bokeh = undefined;\n }\n console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n }\n load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n run_inline_js();\n });\n }\n }\n // Give older versions of the autoload script a head-start to ensure\n // they initialize before we start loading newer version.\n setTimeout(load_or_wait, 100)\n}(window));" - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/javascript": [ - "\n", - "if ((window.PyViz === undefined) || (window.PyViz instanceof HTMLElement)) {\n", - " window.PyViz = {comms: {}, comm_status:{}, kernels:{}, receivers: {}, plot_index: []}\n", - "}\n", - "\n", - "\n", - " function JupyterCommManager() {\n", - " }\n", - "\n", - " JupyterCommManager.prototype.register_target = function(plot_id, comm_id, msg_handler) {\n", - " if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n", - " var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n", - " comm_manager.register_target(comm_id, function(comm) {\n", - " comm.on_msg(msg_handler);\n", - " });\n", - " } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n", - " window.PyViz.kernels[plot_id].registerCommTarget(comm_id, function(comm) {\n", - " comm.onMsg = msg_handler;\n", - " });\n", - " } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n", - " google.colab.kernel.comms.registerTarget(comm_id, (comm) => {\n", - " var messages = comm.messages[Symbol.asyncIterator]();\n", - " function processIteratorResult(result) {\n", - " var message = result.value;\n", - " var content = {data: message.data, comm_id};\n", - " var buffers = []\n", - " for (var buffer of message.buffers || []) {\n", - " buffers.push(new DataView(buffer))\n", - " }\n", - " var metadata = message.metadata || {};\n", - " var msg = {content, buffers, metadata}\n", - " msg_handler(msg);\n", - " return messages.next().then(processIteratorResult);\n", - " }\n", - " return messages.next().then(processIteratorResult);\n", - " })\n", - " }\n", - " }\n", - "\n", - " JupyterCommManager.prototype.get_client_comm = function(plot_id, comm_id, msg_handler) {\n", - " if (comm_id in window.PyViz.comms) {\n", - " return window.PyViz.comms[comm_id];\n", - " } else if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n", - " var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n", - " var comm = comm_manager.new_comm(comm_id, {}, {}, {}, comm_id);\n", - " if (msg_handler) {\n", - " comm.on_msg(msg_handler);\n", - " }\n", - " } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n", - " var comm = window.PyViz.kernels[plot_id].connectToComm(comm_id);\n", - " let retries = 0;\n", - " const open = () => {\n", - " if (comm.active) {\n", - " comm.open();\n", - " } else if (retries > 3) {\n", - " console.warn('Comm target never activated')\n", - " } else {\n", - " retries += 1\n", - " setTimeout(open, 500)\n", - " }\n", - " }\n", - " if (comm.active) {\n", - " comm.open();\n", - " } else {\n", - " setTimeout(open, 500)\n", - " }\n", - " if (msg_handler) {\n", - " comm.onMsg = msg_handler;\n", - " }\n", - " } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n", - " var comm_promise = google.colab.kernel.comms.open(comm_id)\n", - " comm_promise.then((comm) => {\n", - " window.PyViz.comms[comm_id] = comm;\n", - " if (msg_handler) {\n", - " var messages = comm.messages[Symbol.asyncIterator]();\n", - " function processIteratorResult(result) {\n", - " var message = result.value;\n", - " var content = {data: message.data};\n", - " var metadata = message.metadata || {comm_id};\n", - " var msg = {content, metadata}\n", - " msg_handler(msg);\n", - " return messages.next().then(processIteratorResult);\n", - " }\n", - " return messages.next().then(processIteratorResult);\n", - " }\n", - " })\n", - " var sendClosure = (data, metadata, buffers, disposeOnDone) => {\n", - " return comm_promise.then((comm) => {\n", - " comm.send(data, metadata, buffers, disposeOnDone);\n", - " });\n", - " };\n", - " var comm = {\n", - " send: sendClosure\n", - " };\n", - " }\n", - " window.PyViz.comms[comm_id] = comm;\n", - " return comm;\n", - " }\n", - " window.PyViz.comm_manager = new JupyterCommManager();\n", - " \n", - "\n", - "\n", - "var JS_MIME_TYPE = 'application/javascript';\n", - "var HTML_MIME_TYPE = 'text/html';\n", - "var EXEC_MIME_TYPE = 'application/vnd.holoviews_exec.v0+json';\n", - "var CLASS_NAME = 'output';\n", - "\n", - "/**\n", - " * Render data to the DOM node\n", - " */\n", - "function render(props, node) {\n", - " var div = document.createElement(\"div\");\n", - " var script = document.createElement(\"script\");\n", - " node.appendChild(div);\n", - " node.appendChild(script);\n", - "}\n", - "\n", - "/**\n", - " * Handle when a new output is added\n", - " */\n", - "function handle_add_output(event, handle) {\n", - " var output_area = handle.output_area;\n", - " var output = handle.output;\n", - " if ((output.data == undefined) || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n", - " return\n", - " }\n", - " var id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n", - " var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n", - " if (id !== undefined) {\n", - " var nchildren = toinsert.length;\n", - " var html_node = toinsert[nchildren-1].children[0];\n", - " html_node.innerHTML = output.data[HTML_MIME_TYPE];\n", - " var scripts = [];\n", - " var nodelist = html_node.querySelectorAll(\"script\");\n", - " for (var i in nodelist) {\n", - " if (nodelist.hasOwnProperty(i)) {\n", - " scripts.push(nodelist[i])\n", - " }\n", - " }\n", - "\n", - " scripts.forEach( function (oldScript) {\n", - " var newScript = document.createElement(\"script\");\n", - " var attrs = [];\n", - " var nodemap = oldScript.attributes;\n", - " for (var j in nodemap) {\n", - " if (nodemap.hasOwnProperty(j)) {\n", - " attrs.push(nodemap[j])\n", - " }\n", - " }\n", - " attrs.forEach(function(attr) { newScript.setAttribute(attr.name, attr.value) });\n", - " newScript.appendChild(document.createTextNode(oldScript.innerHTML));\n", - " oldScript.parentNode.replaceChild(newScript, oldScript);\n", - " });\n", - " if (JS_MIME_TYPE in output.data) {\n", - " toinsert[nchildren-1].children[1].textContent = output.data[JS_MIME_TYPE];\n", - " }\n", - " output_area._hv_plot_id = id;\n", - " if ((window.Bokeh !== undefined) && (id in Bokeh.index)) {\n", - " window.PyViz.plot_index[id] = Bokeh.index[id];\n", - " } else {\n", - " window.PyViz.plot_index[id] = null;\n", - " }\n", - " } else if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n", - " var bk_div = document.createElement(\"div\");\n", - " bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n", - " var script_attrs = bk_div.children[0].attributes;\n", - " for (var i = 0; i < script_attrs.length; i++) {\n", - " toinsert[toinsert.length - 1].childNodes[1].setAttribute(script_attrs[i].name, script_attrs[i].value);\n", - " }\n", - " // store reference to server id on output_area\n", - " output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n", - " }\n", - "}\n", - "\n", - "/**\n", - " * Handle when an output is cleared or removed\n", - " */\n", - "function handle_clear_output(event, handle) {\n", - " var id = handle.cell.output_area._hv_plot_id;\n", - " var server_id = handle.cell.output_area._bokeh_server_id;\n", - " if (((id === undefined) || !(id in PyViz.plot_index)) && (server_id !== undefined)) { return; }\n", - " var comm = window.PyViz.comm_manager.get_client_comm(\"hv-extension-comm\", \"hv-extension-comm\", function () {});\n", - " if (server_id !== null) {\n", - " comm.send({event_type: 'server_delete', 'id': server_id});\n", - " return;\n", - " } else if (comm !== null) {\n", - " comm.send({event_type: 'delete', 'id': id});\n", - " }\n", - " delete PyViz.plot_index[id];\n", - " if ((window.Bokeh !== undefined) & (id in window.Bokeh.index)) {\n", - " var doc = window.Bokeh.index[id].model.document\n", - " doc.clear();\n", - " const i = window.Bokeh.documents.indexOf(doc);\n", - " if (i > -1) {\n", - " window.Bokeh.documents.splice(i, 1);\n", - " }\n", - " }\n", - "}\n", - "\n", - "/**\n", - " * Handle kernel restart event\n", - " */\n", - "function handle_kernel_cleanup(event, handle) {\n", - " delete PyViz.comms[\"hv-extension-comm\"];\n", - " window.PyViz.plot_index = {}\n", - "}\n", - "\n", - "/**\n", - " * Handle update_display_data messages\n", - " */\n", - "function handle_update_output(event, handle) {\n", - " handle_clear_output(event, {cell: {output_area: handle.output_area}})\n", - " handle_add_output(event, handle)\n", - "}\n", - "\n", - "function register_renderer(events, OutputArea) {\n", - " function append_mime(data, metadata, element) {\n", - " // create a DOM node to render to\n", - " var toinsert = this.create_output_subarea(\n", - " metadata,\n", - " CLASS_NAME,\n", - " EXEC_MIME_TYPE\n", - " );\n", - " this.keyboard_manager.register_events(toinsert);\n", - " // Render to node\n", - " var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n", - " render(props, toinsert[0]);\n", - " element.append(toinsert);\n", - " return toinsert\n", - " }\n", - "\n", - " events.on('output_added.OutputArea', handle_add_output);\n", - " events.on('output_updated.OutputArea', handle_update_output);\n", - " events.on('clear_output.CodeCell', handle_clear_output);\n", - " events.on('delete.Cell', handle_clear_output);\n", - " events.on('kernel_ready.Kernel', handle_kernel_cleanup);\n", - "\n", - " OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n", - " safe: true,\n", - " index: 0\n", - " });\n", - "}\n", - "\n", - "if (window.Jupyter !== undefined) {\n", - " try {\n", - " var events = require('base/js/events');\n", - " var OutputArea = require('notebook/js/outputarea').OutputArea;\n", - " if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n", - " register_renderer(events, OutputArea);\n", - " }\n", - " } catch(err) {\n", - " }\n", - "}\n" - ], - "application/vnd.holoviews_load.v0+json": "\nif ((window.PyViz === undefined) || (window.PyViz instanceof HTMLElement)) {\n window.PyViz = {comms: {}, comm_status:{}, kernels:{}, receivers: {}, plot_index: []}\n}\n\n\n function JupyterCommManager() {\n }\n\n JupyterCommManager.prototype.register_target = function(plot_id, comm_id, msg_handler) {\n if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n comm_manager.register_target(comm_id, function(comm) {\n comm.on_msg(msg_handler);\n });\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n window.PyViz.kernels[plot_id].registerCommTarget(comm_id, function(comm) {\n comm.onMsg = msg_handler;\n });\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n google.colab.kernel.comms.registerTarget(comm_id, (comm) => {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n var content = {data: message.data, comm_id};\n var buffers = []\n for (var buffer of message.buffers || []) {\n buffers.push(new DataView(buffer))\n }\n var metadata = message.metadata || {};\n var msg = {content, buffers, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n })\n }\n }\n\n JupyterCommManager.prototype.get_client_comm = function(plot_id, comm_id, msg_handler) {\n if (comm_id in window.PyViz.comms) {\n return window.PyViz.comms[comm_id];\n } else if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n var comm = comm_manager.new_comm(comm_id, {}, {}, {}, comm_id);\n if (msg_handler) {\n comm.on_msg(msg_handler);\n }\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n var comm = window.PyViz.kernels[plot_id].connectToComm(comm_id);\n let retries = 0;\n const open = () => {\n if (comm.active) {\n comm.open();\n } else if (retries > 3) {\n console.warn('Comm target never activated')\n } else {\n retries += 1\n setTimeout(open, 500)\n }\n }\n if (comm.active) {\n comm.open();\n } else {\n setTimeout(open, 500)\n }\n if (msg_handler) {\n comm.onMsg = msg_handler;\n }\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n var comm_promise = google.colab.kernel.comms.open(comm_id)\n comm_promise.then((comm) => {\n window.PyViz.comms[comm_id] = comm;\n if (msg_handler) {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n var content = {data: message.data};\n var metadata = message.metadata || {comm_id};\n var msg = {content, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n }\n })\n var sendClosure = (data, metadata, buffers, disposeOnDone) => {\n return comm_promise.then((comm) => {\n comm.send(data, metadata, buffers, disposeOnDone);\n });\n };\n var comm = {\n send: sendClosure\n };\n }\n window.PyViz.comms[comm_id] = comm;\n return comm;\n }\n window.PyViz.comm_manager = new JupyterCommManager();\n \n\n\nvar JS_MIME_TYPE = 'application/javascript';\nvar HTML_MIME_TYPE = 'text/html';\nvar EXEC_MIME_TYPE = 'application/vnd.holoviews_exec.v0+json';\nvar CLASS_NAME = 'output';\n\n/**\n * Render data to the DOM node\n */\nfunction render(props, node) {\n var div = document.createElement(\"div\");\n var script = document.createElement(\"script\");\n node.appendChild(div);\n node.appendChild(script);\n}\n\n/**\n * Handle when a new output is added\n */\nfunction handle_add_output(event, handle) {\n var output_area = handle.output_area;\n var output = handle.output;\n if ((output.data == undefined) || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n return\n }\n var id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n if (id !== undefined) {\n var nchildren = toinsert.length;\n var html_node = toinsert[nchildren-1].children[0];\n html_node.innerHTML = output.data[HTML_MIME_TYPE];\n var scripts = [];\n var nodelist = html_node.querySelectorAll(\"script\");\n for (var i in nodelist) {\n if (nodelist.hasOwnProperty(i)) {\n scripts.push(nodelist[i])\n }\n }\n\n scripts.forEach( function (oldScript) {\n var newScript = document.createElement(\"script\");\n var attrs = [];\n var nodemap = oldScript.attributes;\n for (var j in nodemap) {\n if (nodemap.hasOwnProperty(j)) {\n attrs.push(nodemap[j])\n }\n }\n attrs.forEach(function(attr) { newScript.setAttribute(attr.name, attr.value) });\n newScript.appendChild(document.createTextNode(oldScript.innerHTML));\n oldScript.parentNode.replaceChild(newScript, oldScript);\n });\n if (JS_MIME_TYPE in output.data) {\n toinsert[nchildren-1].children[1].textContent = output.data[JS_MIME_TYPE];\n }\n output_area._hv_plot_id = id;\n if ((window.Bokeh !== undefined) && (id in Bokeh.index)) {\n window.PyViz.plot_index[id] = Bokeh.index[id];\n } else {\n window.PyViz.plot_index[id] = null;\n }\n } else if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n var bk_div = document.createElement(\"div\");\n bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n var script_attrs = bk_div.children[0].attributes;\n for (var i = 0; i < script_attrs.length; i++) {\n toinsert[toinsert.length - 1].childNodes[1].setAttribute(script_attrs[i].name, script_attrs[i].value);\n }\n // store reference to server id on output_area\n output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n }\n}\n\n/**\n * Handle when an output is cleared or removed\n */\nfunction handle_clear_output(event, handle) {\n var id = handle.cell.output_area._hv_plot_id;\n var server_id = handle.cell.output_area._bokeh_server_id;\n if (((id === undefined) || !(id in PyViz.plot_index)) && (server_id !== undefined)) { return; }\n var comm = window.PyViz.comm_manager.get_client_comm(\"hv-extension-comm\", \"hv-extension-comm\", function () {});\n if (server_id !== null) {\n comm.send({event_type: 'server_delete', 'id': server_id});\n return;\n } else if (comm !== null) {\n comm.send({event_type: 'delete', 'id': id});\n }\n delete PyViz.plot_index[id];\n if ((window.Bokeh !== undefined) & (id in window.Bokeh.index)) {\n var doc = window.Bokeh.index[id].model.document\n doc.clear();\n const i = window.Bokeh.documents.indexOf(doc);\n if (i > -1) {\n window.Bokeh.documents.splice(i, 1);\n }\n }\n}\n\n/**\n * Handle kernel restart event\n */\nfunction handle_kernel_cleanup(event, handle) {\n delete PyViz.comms[\"hv-extension-comm\"];\n window.PyViz.plot_index = {}\n}\n\n/**\n * Handle update_display_data messages\n */\nfunction handle_update_output(event, handle) {\n handle_clear_output(event, {cell: {output_area: handle.output_area}})\n handle_add_output(event, handle)\n}\n\nfunction register_renderer(events, OutputArea) {\n function append_mime(data, metadata, element) {\n // create a DOM node to render to\n var toinsert = this.create_output_subarea(\n metadata,\n CLASS_NAME,\n EXEC_MIME_TYPE\n );\n this.keyboard_manager.register_events(toinsert);\n // Render to node\n var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n render(props, toinsert[0]);\n element.append(toinsert);\n return toinsert\n }\n\n events.on('output_added.OutputArea', handle_add_output);\n events.on('output_updated.OutputArea', handle_update_output);\n events.on('clear_output.CodeCell', handle_clear_output);\n events.on('delete.Cell', handle_clear_output);\n events.on('kernel_ready.Kernel', handle_kernel_cleanup);\n\n OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n safe: true,\n index: 0\n });\n}\n\nif (window.Jupyter !== undefined) {\n try {\n var events = require('base/js/events');\n var OutputArea = require('notebook/js/outputarea').OutputArea;\n if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n register_renderer(events, OutputArea);\n }\n } catch(err) {\n }\n}\n" - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Packages required to request and open data from AWS S3\n", "import s3fs\n", @@ -1666,9 +500,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python [conda env:notebook] *", + "display_name": "mrms-cookbook-dev", "language": "python", - "name": "conda-env-notebook-py" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -1680,7 +514,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.8" + "version": "3.12.11" }, "nbdime-conflicts": { "local_diff": [ diff --git a/notebooks/mrms_reflectivity_animation.gif b/notebooks/mrms_reflectivity_animation.gif new file mode 100644 index 000000000..7556af3f3 Binary files /dev/null and b/notebooks/mrms_reflectivity_animation.gif differ diff --git a/notebooks/test.ipynb b/notebooks/test.ipynb deleted file mode 100644 index fed66b869..000000000 --- a/notebooks/test.ipynb +++ /dev/null @@ -1,437 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Project Pythia Notebook Template" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Let's start here! If you can directly link to an image relevant to your notebook, such as [canonical logos](https://github.com/numpy/numpy/blob/main/doc/source/_static/numpylogo.svg), do so here at the top of your notebook. You can do this with MyST Markdown syntax, outlined in [this MyST guide](https://mystmd.org/guide/figures), or you edit this cell to see a demonstration. **Be sure to include `alt` text for any embedded images to make your content more accessible.**\n", - "\n", - "```{image} ../thumbnails/thumbnail.png\n", - ":alt: Project Pythia logo\n", - ":width: 200px\n", - "```" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Next, title your notebook appropriately with a top-level Markdown header, `#` (see the very first cell above). Do not use this level header anywhere else in the notebook. Our book build process will use this title in the navbar, table of contents, etc. Keep it short, keep it descriptive. \n", - "\n", - "Follow this with a `---` cell to visually distinguish the transition to the prerequisites section." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "---" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Overview\n", - "If you have an introductory paragraph, lead with it here! Keep it short and tied to your material, then be sure to continue into the required list of topics below,\n", - "\n", - "1. This is a numbered list of the specific topics\n", - "1. These should map approximately to your main sections of content\n", - "1. Or each second-level, `##`, header in your notebook\n", - "1. Keep the size and scope of your notebook in check\n", - "1. And be sure to let the reader know up front the important concepts they'll be leaving with" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Prerequisites\n", - "This section was inspired by [this template](https://github.com/alan-turing-institute/the-turing-way/blob/master/book/templates/chapter-template/chapter-landing-page.md) of the wonderful [The Turing Way](https://the-turing-way.netlify.app) Jupyter Book.\n", - "\n", - "Following your overview, tell your reader what concepts, packages, or other background information they'll **need** before learning your material. Tie this explicitly with links to other pages here in Foundations or to relevant external resources. Remove this body text, then populate the Markdown table, denoted in this cell with `|` vertical brackets, below, and fill out the information following. In this table, lay out prerequisite concepts by explicitly linking to other Foundations material or external resources, or describe generally helpful concepts.\n", - "\n", - "Label the importance of each concept explicitly as **helpful/necessary**.\n", - "\n", - "| Concepts | Importance | Notes |\n", - "| --- | --- | --- |\n", - "| [Intro to Cartopy](https://foundations.projectpythia.org/core/cartopy/cartopy) | Necessary | |\n", - "| [Understanding of NetCDF](https://foundations.projectpythia.org/core/data-formats/netcdf-cf) | Helpful | Familiarity with metadata structure |\n", - "| Project management | Helpful | |\n", - "\n", - "- **Time to learn**: estimate in minutes. For a rough idea, use 5 mins per subsection, 10 if longer; add these up for a total. Safer to round up and overestimate.\n", - "- **System requirements**:\n", - " - Populate with any system, version, or non-Python software requirements if necessary\n", - " - Otherwise use the concepts table above and the Imports section below to describe required packages as necessary\n", - " - If no extra requirements, remove the **System requirements** point altogether" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "---" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Imports\n", - "Begin your body of content with another `---` divider before continuing into this section, then remove this body text and populate the following code cell with all necessary Python imports **up-front**:" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "import s3fs\n", - "import xarray\n", - "import urllib\n", - "import tempfile\n", - "import gzip\n", - "import xarray as xr\n", - "import io" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "response = urllib.request.urlopen(\"https://noaa-mrms-pds.s3.amazonaws.com/CONUS/CREF_1HR_MAX_00.50/20250705/MRMS_CREF_1HR_MAX_00.50_20250705-000000.grib2.gz\")\n", - "compressed_file = response.read()\n", - "\n", - "with tempfile.NamedTemporaryFile(suffix=\".grib2\") as f:\n", - " f.write(gzip.decompress(compressed_file))\n", - " data_in = xr.load_dataarray(f.name, engine='cfgrib', decode_timedelta=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "# Set up S3 filesystem (read-only, anonymous access)\n", - "fs = s3fs.S3FileSystem(anon=True)\n", - "\n", - "# Example S3 path (without scheme)\n", - "s3_path = \"noaa-mrms-pds/CONUS/CREF_1HR_MAX_00.50/20250705/MRMS_CREF_1HR_MAX_00.50_20250705-000000.grib2.gz\"\n", - "\n", - "# Open the file using fsspec to allow lazy, remote reads\n", - "with fs.open(s3_path, mode='rb') as f:\n", - " # Decompress in memory\n", - " decompressed = gzip.decompress(f.read())\n", - " \n", - " # Write to temp file\n", - " with tempfile.NamedTemporaryFile(suffix=\".grib2\") as tmp:\n", - " tmp.write(decompressed)\n", - " tmp.flush() # Ensure file is written\n", - "\n", - " # Load using xarray + cfgrib\n", - " data_in = xr.load_dataarray(tmp.name, engine=\"cfgrib\", decode_timedelta=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "data_in[::10,::10].plot()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Your first content section" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "This is where you begin your first section of material, loosely tied to your objectives stated up front. Tie together your notebook as a narrative, with interspersed Markdown text, images, and more as necessary," - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# as well as any and all of your code cells\n", - "print(\"Hello world!\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### A content subsection\n", - "Divide and conquer your objectives with Markdown subsections, which will populate the helpful navbar in Jupyter Lab and here on the Jupyter Book!" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# some subsection code\n", - "a = [1, 2, 3, 4, 5]\n", - "[i + 2 for i in a]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Another content subsection\n", - "Keep up the good work! A note, *try to avoid using code comments as narrative*, and instead let them only exist as brief clarifications where necessary." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Your second content section\n", - "Here we can move on to our second objective, and we can demonstrate..." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### A subsection to the second section\n", - "\n", - "#### a quick demonstration\n", - "\n", - "##### of further and further\n", - "\n", - "###### header levels" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "as well as $m = a * t / h$ text! Similarly, you have access to other $\\LaTeX$ equation [**functionality**](https://jupyter-notebook.readthedocs.io/en/stable/examples/Notebook/Typesetting%20Equations.html) via MathJax:\n", - "\n", - "\\begin{align}\n", - "\\dot{x} & = \\sigma(y-x) \\\\\n", - "\\dot{y} & = \\rho x - y - xz \\\\\n", - "\\dot{z} & = -\\beta z + xy\n", - "\\end{align}" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Check out [**any number of helpful Markdown resources**](https://www.markdownguide.org/basic-syntax/) for further customizing your notebooks and the [**MyST Syntax Overview**](https://mystmd.org/guide/syntax-overview) for MyST-specific formatting information. Don't hesitate to ask questions if you have problems getting it to look *just right*." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Last Section\n", - "\n", - "You can add [admonitions using MyST syntax](https://mystmd.org/guide/admonitions):" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - ":::{note}\n", - "Your relevant information here!\n", - ":::" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Some other admonitions you can put in ([there are 10 total](https://mystmd.org/guide/admonitions#admonitions-list)):" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - ":::{hint}\n", - "A helpful hint.\n", - ":::" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - ":::{warning}\n", - "Be careful!\n", - ":::" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - ":::{danger}\n", - "Scary stuff be here.\n", - ":::" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We also suggest checking out Jupyter Book's [brief demonstration](https://jupyterbook.org/content/metadata.html#jupyter-cell-tags) on adding cell tags to your cells in Jupyter Notebook, Lab, or manually. Using these cell tags can allow you to [customize](https://jupyterbook.org/interactive/hiding.html) how your code content is displayed and even [demonstrate errors](https://jupyterbook.org/content/execute.html#dealing-with-code-that-raises-errors) without altogether crashing our loyal army of machines!" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "---" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Summary\n", - "Add one final `---` marking the end of your body of content, and then conclude with a brief single paragraph summarizing at a high level the key pieces that were learned and how they tied to your objectives. Look to reiterate what the most important takeaways were.\n", - "\n", - "### What's next?\n", - "Let Jupyter book tie this to the next (sequential) piece of content that people could move on to down below and in the sidebar. However, if this page uniquely enables your reader to tackle other nonsequential concepts throughout this book, or even external content, link to it here!" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Resources and references\n", - "Finally, be rigorous in your citations and references as necessary. Give credit where credit is due. Also, feel free to link to relevant external material, further reading, documentation, etc. Then you're done! Give yourself a quick review, a high five, and send us a pull request. A few final notes:\n", - " - `Kernel > Restart Kernel and Run All Cells...` to confirm that your notebook will cleanly run from start to finish\n", - " - `Kernel > Restart Kernel and Clear All Outputs...` before committing your notebook, our machines will do the heavy lifting\n", - " - Take credit! Provide author contact information if you'd like; if so, consider adding information here at the bottom of your notebook\n", - " - Give credit! Attribute appropriate authorship for referenced code, information, images, etc.\n", - " - Only include what you're legally allowed: **no copyright infringement or plagiarism**\n", - " \n", - "Thank you for your contribution!" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.16" - }, - "nbdime-conflicts": { - "local_diff": [ - { - "diff": [ - { - "diff": [ - { - "key": 0, - "op": "addrange", - "valuelist": [ - "Python 3" - ] - }, - { - "key": 0, - "length": 1, - "op": "removerange" - } - ], - "key": "display_name", - "op": "patch" - } - ], - "key": "kernelspec", - "op": "patch" - } - ], - "remote_diff": [ - { - "diff": [ - { - "diff": [ - { - "key": 0, - "op": "addrange", - "valuelist": [ - "Python3" - ] - }, - { - "key": 0, - "length": 1, - "op": "removerange" - } - ], - "key": "display_name", - "op": "patch" - } - ], - "key": "kernelspec", - "op": "patch" - } - ] - }, - "toc-autonumbering": false - }, - "nbformat": 4, - "nbformat_minor": 4 -}