diff --git a/.gitignore b/.gitignore
index b236259..187e244 100644
--- a/.gitignore
+++ b/.gitignore
@@ -152,4 +152,6 @@ dmypy.json
 commit-msg
 
 # Mac OS specfic
-.DS_Store
\ No newline at end of file
+.DS_Store
+
+examples/data/
\ No newline at end of file
diff --git a/examples/bcferry/twsb_sovi_thermosalinograph.ipynb b/examples/bcferry/twsb_sovi_thermosalinograph.ipynb
new file mode 100644
index 0000000..b29a09d
--- /dev/null
+++ b/examples/bcferry/twsb_sovi_thermosalinograph.ipynb
@@ -0,0 +1,637 @@
+{
+ "cells": [
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-09-05T19:29:57.027169Z",
+     "start_time": "2025-09-05T19:29:57.018047Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "## Additional Python Packages Needed for This Notebook\n",
+    "# !pip install cartopy\n",
+    "# !pip install gsw\n",
+    "# !pip install matplotlib\n",
+    "# !pip install numpy\n",
+    "# !pip instal pandas\n",
+    "# !pip install xarray"
+   ],
+   "id": "b443e87449f2c75a",
+   "outputs": [],
+   "execution_count": 1
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": [
+    "# Thermosalinograph Data from the M/V Spirit of Vancouver Island \n",
+    "\n",
+    "In this example you will be using the Ocean Networks Canada (ONC) Python package to acquire, process, and visualize density data associated with a thermosalinograph installed on the BC Ferry Spirit of Vancouver Island during July 30, 2025.\n",
+    "\n",
+    "The `locationCode` for the SOVI begins with `TWDP`.\n",
+    "The `deviceCategoryCode` for the thermosalinograph is `TSG`.\n",
+    "\n",
+    "In addition, you will need navigational and system engineering data to clean up the data.\n",
+    "The `locationCode` + `deviceCategoryCode` for these instruments are `TWSB.N1` + `NAV` and `TWSB` + `PVCS`, respectively, over the data dates requested in this notebook."
+   ],
+   "id": "4c982c4620f8fce1"
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": "## Imports",
+   "id": "2ca7cedb8fb5fa3f"
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-09-05T19:29:57.946267Z",
+     "start_time": "2025-09-05T19:29:57.038458Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "import cartopy.crs as ccrs\n",
+    "from datetime import datetime, timedelta\n",
+    "import gsw\n",
+    "import matplotlib\n",
+    "import matplotlib.pyplot as plt\n",
+    "from matplotlib.animation import FuncAnimation\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import xarray as xr\n",
+    "\n",
+    "from onc import ONC\n",
+    "from onc.util import get_onc_token, dt2str\n",
+    "from onc.util.xarray import json2xarray, nan_onc_flags"
+   ],
+   "id": "initial_id",
+   "outputs": [],
+   "execution_count": 2
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": [
+    "### Instantiate ONC Class\n",
+    "\n",
+    "A utility function is available for retrieving your ONC API token from a .netrc file.\n",
+    "By default the `get_onc_token()` function looks for a `.netrc` file in your home directory.\n",
+    "\n",
+    "\n",
+    "The `.netrc` file should contain a line like the following:\n",
+    "\n",
+    "\n",
+    "```\n",
+    "machine data.oceannetworks.ca \n",
+    "login <your_login> \n",
+    "password <your_onc_api_token>\n",
+    "```"
+   ],
+   "id": "93fb0555cc8b0d6f"
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-09-05T19:29:57.950687Z",
+     "start_time": "2025-09-05T19:29:57.946267Z"
+    }
+   },
+   "cell_type": "code",
+   "source": "onc = ONC(token = get_onc_token())",
+   "id": "3dede048d4616e39",
+   "outputs": [],
+   "execution_count": 3
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": "## Acquire Spirit of Vancouver Island (TWSB) Data",
+   "id": "ddae3fba3b3af0d7"
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-09-05T19:30:19.150243Z",
+     "start_time": "2025-09-05T19:29:57.950687Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "%%time\n",
+    "date_from = dt2str(datetime(2025,7,30,0,0,0,0)) # Start of the data request.\n",
+    "date_to = dt2str(datetime(2025,7,30,23,59,59,999999)) # End of the data request.\n",
+    "\n",
+    "twsb_loc_dev = [('TWSB.N1','NAV'),\n",
+    "                ('TWSB','PVCS'),\n",
+    "                ('TWSB','TSG')]\n",
+    "\n",
+    "ds_list = []\n",
+    "for loc_code, dev_cat_code in twsb_loc_dev:\n",
+    "    \n",
+    "    # See https://data.oceannetworks.ca/OpenAPI#get-/scalardata/location for a complete list of accepted parameters.\n",
+    "    params = {'locationCode': loc_code,\n",
+    "              'deviceCategoryCode': dev_cat_code,\n",
+    "              'dateFrom': date_from,\n",
+    "              'dateTo': date_to,\n",
+    "              'metadata': 'full',\n",
+    "              'qualityControl': 'raw',\n",
+    "              'rowLimit': 100000,\n",
+    "              'outputFormat': 'array'}\n",
+    "    \n",
+    "    json_response_data = onc.getScalardata(filters=params, allPages=True)\n",
+    "    ds = json2xarray(json_response_data)  # Convert the JSON response to an xarray Dataset.\n",
+    "    ds_list.append(ds) # Append the dataset to a list for merging later\n",
+    "    \n",
+    "# Combine the datasets into a single xarray Dataset.\n",
+    "twsb = xr.combine_by_coords(ds_list, join = 'outer',combine_attrs='drop_conflicts') "
+   ],
+   "id": "3ee024926dab8357",
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "CPU times: total: 3.19 s\n",
+      "Wall time: 21.2 s\n"
+     ]
+    }
+   ],
+   "execution_count": 4
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": "## Review Dataset",
+   "id": "324dddd327c040c9"
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-09-05T19:30:19.165342Z",
+     "start_time": "2025-09-05T19:30:19.150243Z"
+    }
+   },
+   "cell_type": "code",
+   "source": "twsb.data_vars",
+   "id": "9f4038fc8a5fb24e",
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Data variables:\n",
+       "    flag_heave               (time) float32 2MB nan nan nan 1.0 ... nan 1.0 nan\n",
+       "    flag_latitude            (time) float32 2MB 1.0 nan nan nan ... nan nan nan\n",
+       "    flag_longitude           (time) float32 2MB 1.0 nan nan nan ... nan nan nan\n",
+       "    flag_pitch               (time) float32 2MB 1.0 nan nan nan ... nan nan nan\n",
+       "    flag_roll                (time) float32 2MB 1.0 nan nan nan ... nan nan nan\n",
+       "    flag_ship_course         (time) float32 2MB nan nan 1.0 nan ... 1.0 nan nan\n",
+       "    flag_speed_over_ground   (time) float32 2MB nan nan 1.0 nan ... 1.0 nan nan\n",
+       "    flag_true_heading        (time) float32 2MB 1.0 nan nan nan ... nan nan nan\n",
+       "    heave                    (time) float64 3MB nan nan nan ... nan -0.06 nan\n",
+       "    latitude                 (time) float64 3MB 49.01 nan nan ... nan nan nan\n",
+       "    longitude                (time) float64 3MB -123.1 nan nan ... nan nan nan\n",
+       "    pitch                    (time) float64 3MB -3.08 nan nan ... nan nan nan\n",
+       "    roll                     (time) float64 3MB -0.1 nan nan nan ... nan nan nan\n",
+       "    ship_course              (time) float64 3MB nan nan 218.0 ... 166.0 nan nan\n",
+       "    speed_over_ground        (time) float64 3MB nan nan 0.8951 ... nan nan\n",
+       "    true_heading             (time) float64 3MB 29.32 nan nan ... nan nan nan\n",
+       "    flag_leak_indicator      (time) float32 2MB nan 0.0 nan nan ... nan nan nan\n",
+       "    flag_outlet_flow         (time) float32 2MB nan 0.0 nan nan ... nan nan nan\n",
+       "    flag_pump_current        (time) float32 2MB nan 0.0 nan nan ... nan nan nan\n",
+       "    flag_system_state        (time) float32 2MB nan 0.0 nan nan ... nan nan nan\n",
+       "    flag_tank_level          (time) float32 2MB nan 0.0 nan nan ... nan nan nan\n",
+       "    flag_valve_position      (time) float32 2MB nan 0.0 nan nan ... nan nan nan\n",
+       "    leak_indicator           (time) float64 3MB nan 0.0 nan nan ... nan nan nan\n",
+       "    outlet_flow              (time) float64 3MB nan -0.551 nan ... nan nan nan\n",
+       "    pump_current             (time) float64 3MB nan 0.0 nan nan ... nan nan nan\n",
+       "    system_state             (time) float64 3MB nan 0.0 nan nan ... nan nan nan\n",
+       "    tank_level               (time) float64 3MB nan 97.1 nan nan ... nan nan nan\n",
+       "    valve_position           (time) float64 3MB nan 0.0 nan nan ... nan nan nan\n",
+       "    conductivity             (time) float64 3MB nan nan nan ... nan nan 3.537\n",
+       "    flag_conductivity        (time) float32 2MB nan nan nan nan ... nan nan 4.0\n",
+       "    flag_practical_salinity  (time) float32 2MB nan nan nan nan ... nan nan 4.0\n",
+       "    flag_temperature         (time) float32 2MB nan nan nan nan ... nan nan 4.0\n",
+       "    practical_salinity       (time) float64 3MB nan nan nan nan ... nan nan 26.6\n",
+       "    temperature              (time) float64 3MB nan nan nan ... nan nan 17.36"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "execution_count": 5
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-09-05T19:30:19.169910Z",
+     "start_time": "2025-09-05T19:30:19.165342Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "# Root Level Attributes\n",
+    "twsb.attrs"
+   ],
+   "id": "d6fc7f21aac11fa9",
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'qaqcFlagInfo': '0:No Quality Control\\n1:Data Passed All Tests\\n2:Data Probably Good\\n3:Data Probably Bad\\n4:Data Bad\\n6:Insufficient Valid Data for Reliable Down-Sampling (ONC-defined flag)\\n7:Averaged Value (ONC defined flag)\\n8:Interpolated Value\\n9:Missing Data',\n",
+       " 'depth': 3.0}"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "execution_count": 6
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-09-05T19:30:19.174058Z",
+     "start_time": "2025-09-05T19:30:19.169910Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "# Variable Level Attributes\n",
+    "twsb.practical_salinity.attrs"
+   ],
+   "id": "739243f251608be8",
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'units': 'psu',\n",
+       " 'long_name': 'Practical Salinity',\n",
+       " 'propertyCode': 'salinity',\n",
+       " 'sensorCategoryCode': 'salinity',\n",
+       " 'sensorName': 'Practical Salinity',\n",
+       " 'sensorCode': 'salinity',\n",
+       " 'deviceCategoryCode': 'TSG'}"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "execution_count": 7
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-09-05T19:30:19.178165Z",
+     "start_time": "2025-09-05T19:30:19.174058Z"
+    }
+   },
+   "cell_type": "code",
+   "source": "twsb.flag_practical_salinity.attrs",
+   "id": "57cf19d744225e8e",
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'variable': 'practical_salinity',\n",
+       " 'qaqcFlagInfo': '0:No Quality Control\\n1:Data Passed All Tests\\n2:Data Probably Good\\n3:Data Probably Bad\\n4:Data Bad\\n6:Insufficient Valid Data for Reliable Down-Sampling (ONC-defined flag)\\n7:Averaged Value (ONC defined flag)\\n8:Interpolated Value\\n9:Missing Data'}"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "execution_count": 8
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": [
+    "## Interpolate Key Variables and Cleanup Data\n",
+    "\n",
+    "Not all data from the BC ferries are stamped by location, but they all do share the same common network time. You will need to interpolate to assign a position to each measurement.\n",
+    " \n",
+    "In the example below, linear interpolation is used for latitude, longitude, pump current, and outlet flow. Nearest neighbor interpolation is used for system state and valve position. \n",
+    "\n",
+    "System state and valve position are state values that indicate whether or not the system is sampling environmental data.\n",
+    "Generally, you will want to look at data where both the system state and valve position are 1, which indicates ON/OPEN.\n",
+    "\n",
+    "We will also exclude flowthrough data where the pump current and outlet flow are less than 1, as this likely indicates that water is not being pumped effectively through the system to obtain a measurement that represents the environment."
+   ],
+   "id": "7d50a5ff7257c52a"
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-09-05T19:30:19.965428Z",
+     "start_time": "2025-09-05T19:30:19.178165Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "linear_matchup_vars = ['latitude', 'longitude', 'pump_current','outlet_flow']\n",
+    "for lmv in linear_matchup_vars:\n",
+    "    twsb[lmv] = twsb[lmv].interpolate_na(dim = 'time', method = 'linear', max_gap = timedelta(milliseconds = 3000), fill_value = 'extrapolate')\n",
+    "\n",
+    "nearest_matchup_vars = ['system_state', 'valve_position']\n",
+    "for nmv in nearest_matchup_vars:\n",
+    "    twsb[nmv] = twsb[nmv].interpolate_na(dim = 'time', method = 'nearest', max_gap = timedelta(milliseconds = 3000), fill_value = 'extrapolate')"
+   ],
+   "id": "3fb5fbd396c69db3",
+   "outputs": [],
+   "execution_count": 9
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-09-05T19:30:20.274184Z",
+     "start_time": "2025-09-05T19:30:19.965743Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "# Remove data based on other engineering data. \n",
+    "# If the following conditions are not met, then we consider ALL data at that time to be invalid.\n",
+    "twsb = twsb.where(twsb['system_state'] == 1, drop = True)\n",
+    "twsb = twsb.where(twsb['valve_position'] == 1, drop = True)\n",
+    "twsb = twsb.where(twsb['outlet_flow'] >= 1, drop = True)\n",
+    "twsb = twsb.where(twsb['pump_current'] >= 1, drop = True)\n",
+    "\n",
+    "# Also remove any data that failed ONC QAQC tests. \n",
+    "# The nan_onc_flags utility function only nullifies data in the corresponding variable.\n",
+    "twsb = nan_onc_flags(twsb, flags_to_nan=[4]) "
+   ],
+   "id": "4ed8ae55066ab0af",
+   "outputs": [],
+   "execution_count": 10
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": "## Calculate Sea Water Density",
+   "id": "14054cf92687daf4"
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-09-05T19:30:20.297924Z",
+     "start_time": "2025-09-05T19:30:20.274184Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "p = gsw.p_from_z(3, twsb['latitude']) # The intake is approximately 3 meters below the average water line of the vessel.\n",
+    "sa = gsw.SA_from_SP(twsb['practical_salinity'], p, twsb['longitude'], twsb['latitude']) # Absolute Salinity\n",
+    "ct = gsw.CT_from_t(sa, twsb['temperature'], p) # Conservative Temperature\n",
+    "twsb['density'] = gsw.density.rho(sa, ct, p) "
+   ],
+   "id": "f12e06d4cc030d2d",
+   "outputs": [],
+   "execution_count": 11
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": "## Resample and Subset",
+   "id": "8ee3614a0701bac2"
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-09-05T19:30:24.782889Z",
+     "start_time": "2025-09-05T19:30:20.298216Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "# Resample to 30 second intervals to reduce the number of points to plot.\n",
+    "twsb = twsb.resample({'time': '30s'}, skipna = True).mean()\n",
+    "\n",
+    "# Only keep variables of interest and remove any nans to simplify plotting.\n",
+    "twsb = twsb[['latitude','longitude','density']].dropna(dim = 'time', how = 'any')"
+   ],
+   "id": "578e773c54c8e42c",
+   "outputs": [],
+   "execution_count": 12
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": "## Define Terminal Locations",
+   "id": "fee92b0cc86d2612"
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-09-05T19:30:24.786941Z",
+     "start_time": "2025-09-05T19:30:24.783677Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "class Tsawwassen:\n",
+    "    latitude: float = 49.006621\n",
+    "    longitude: float = -123.132309\n",
+    "    \n",
+    "class SwartzBay:\n",
+    "    latitude: float = 48.689047\n",
+    "    longitude: float = -123.410817"
+   ],
+   "id": "13b6070b651cb87e",
+   "outputs": [],
+   "execution_count": 13
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": "## Static Plot",
+   "id": "f547cffce31ef7e1"
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-09-05T19:30:25.485575Z",
+     "start_time": "2025-09-05T19:30:24.786941Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "t = twsb.time.values\n",
+    "x = twsb.longitude.values\n",
+    "y = twsb.latitude.values\n",
+    "c = twsb.density.values\n",
+    "\n",
+    "xmin, xmax = np.nanmin(x) - 0.075, np.nanmax(x) + 0.075\n",
+    "ymin, ymax = np.nanmin(y)  - 0.075, np.nanmax(y)  + 0.075\n",
+    "major_locator = 0.1 \n",
+    "vmin, vmax = 1015,1022 # Density min/max for color scale.\n",
+    "\n",
+    "cmap = matplotlib.colormaps.get_cmap('viridis')\n",
+    "norm = matplotlib.colors.Normalize(vmin = vmin , vmax = vmax) \n",
+    "\n",
+    "crs = ccrs.PlateCarree()\n",
+    "fig, ax = plt.subplots(1,1,figsize = (6,6), constrained_layout = True, subplot_kw={'projection': crs})\n",
+    "ax.set_extent([xmin, xmax, ymin, ymax])\n",
+    "ax.coastlines()\n",
+    "\n",
+    "pscat = ax.scatter(x, y, c = c, cmap = 'viridis', vmin = vmin, vmax = vmax, s=10, marker = '.')\n",
+    "ax.set_title(pd.to_datetime(t[0]).strftime('%Y-%m-%d'))\n",
+    "ax.set_xticks(np.arange(xmin, xmax,major_locator))\n",
+    "ax.set_yticks(np.arange(ymin, ymax,major_locator))\n",
+    "ax.set_xlabel(r'Longitude ($^{\\circ}E$)')\n",
+    "ax.set_ylabel(r'Latitude ($^{\\circ}N$)')\n",
+    "cbar = fig.colorbar(pscat, ax = ax, cmap = cmap, norm = norm, label = r'Sea Surface Density ($\\frac{kg}{m^3}$)', shrink = 0.6)\n",
+    "\n",
+    "ax.scatter(Tsawwassen.longitude, Tsawwassen.latitude, marker = '<', color = 'black', s = 100, label = 'Tsawwassen')\n",
+    "ax.scatter(SwartzBay.longitude, SwartzBay.latitude, marker = '>', color = 'black', s = 100, label = 'Swartz Bay')\n",
+    "\n",
+    "ax.legend(loc = 'lower right')\n",
+    "\n",
+    "plt.show()"
+   ],
+   "id": "5afc57ef6996f762",
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 600x600 with 2 Axes>"
+      ],
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "execution_count": 14
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": "## Build Animation",
+   "id": "5aeb6e135623ea14"
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-09-05T19:30:25.524283Z",
+     "start_time": "2025-09-05T19:30:25.485575Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "%matplotlib notebook\n",
+    "\n",
+    "t = twsb.time.values\n",
+    "x = twsb.longitude.values\n",
+    "y = twsb.latitude.values\n",
+    "c = twsb.density.values\n",
+    "\n",
+    "xmin, xmax = np.nanmin(x) - 0.075, np.nanmax(x) + 0.075\n",
+    "ymin, ymax = np.nanmin(y)  - 0.075, np.nanmax(y)  + 0.075\n",
+    "major_locator = 0.1 \n",
+    "vmin, vmax = 1015,1022 # Density min/max for color scale.\n",
+    "\n",
+    "cmap = matplotlib.colormaps.get_cmap('viridis')\n",
+    "norm = matplotlib.colors.Normalize(vmin = vmin , vmax = vmax) \n",
+    "\n",
+    "crs = ccrs.PlateCarree()\n",
+    "fig, ax = plt.subplots(1,1,figsize = (6,6), constrained_layout = True, subplot_kw={'projection': crs})\n",
+    "ax.set_extent([xmin, xmax, ymin, ymax])\n",
+    "ax.coastlines()\n",
+    "\n",
+    "pscat = ax.scatter(x[0], y[0], c = c[0], cmap = 'viridis', vmin = vmin, vmax = vmax, s=10, marker = '.')\n",
+    "ax.set_title(pd.to_datetime(t[0]).strftime('%Y-%m-%dT%H:%M:%SZ'))\n",
+    "ax.set_xticks(np.arange(xmin, xmax,major_locator))\n",
+    "ax.set_yticks(np.arange(ymin, ymax,major_locator))\n",
+    "ax.set_xlabel(r'Longitude ($^{\\circ}E$)')\n",
+    "ax.set_ylabel(r'Latitude ($^{\\circ}N$)')\n",
+    "cbar = fig.colorbar(pscat, ax = ax, cmap = cmap, norm = norm, label = r'Sea Surface Density ($\\frac{kg}{m^3}$)', shrink = 0.6)\n",
+    "\n",
+    "\n",
+    "ax.scatter(Tsawwassen.longitude, Tsawwassen.latitude, marker = '<', color = 'black', s = 100, label = 'Tsawwassen')\n",
+    "ax.scatter(SwartzBay.longitude, SwartzBay.latitude, marker = '>', color = 'black', s = 100, label = 'Swartz Bay')\n",
+    "\n",
+    "ax.legend(loc = 'lower right')\n",
+    "\n",
+    "\n",
+    "def update(frame):\n",
+    "    data = np.stack([x[:frame], y[:frame]]).T\n",
+    "    pscat.set_offsets(data)\n",
+    "    pscat.set_color(cmap(norm(c[:frame])))\n",
+    "    ax.set_title(pd.to_datetime(t[frame]).strftime('%Y-%m-%dT%H:%M:%SZ'))\n",
+    "    \n",
+    "    return pscat,\n",
+    "\n",
+    "ani = FuncAnimation(fig=fig, func=update, frames=len(t), interval=1, blit = False)\n",
+    "plt.show()"
+   ],
+   "id": "704b79bcf5881c52",
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<IPython.core.display.Javascript object>"
+      ],
+      "application/javascript": "/* Put everything inside the global mpl namespace */\n/* global mpl */\nwindow.mpl = {};\n\nmpl.get_websocket_type = function () {\n    if (typeof WebSocket !== 'undefined') {\n        return WebSocket;\n    } else if (typeof MozWebSocket !== 'undefined') {\n        return MozWebSocket;\n    } else {\n        alert(\n            'Your browser does not have WebSocket support. ' +\n                'Please try Chrome, Safari or Firefox ≥ 6. ' +\n                'Firefox 4 and 5 are also supported but you ' +\n                'have to enable WebSockets in about:config.'\n        );\n    }\n};\n\nmpl.figure = function (figure_id, websocket, ondownload, parent_element) {\n    this.id = figure_id;\n\n    this.ws = websocket;\n\n    this.supports_binary = this.ws.binaryType !== undefined;\n\n    if (!this.supports_binary) {\n        var warnings = document.getElementById('mpl-warnings');\n        if (warnings) {\n            warnings.style.display = 'block';\n            warnings.textContent =\n                'This browser does not support binary websocket messages. ' +\n                'Performance may be slow.';\n        }\n    }\n\n    this.imageObj = new Image();\n\n    this.context = undefined;\n    this.message = undefined;\n    this.canvas = undefined;\n    this.rubberband_canvas = undefined;\n    this.rubberband_context = undefined;\n    this.format_dropdown = undefined;\n\n    this.image_mode = 'full';\n\n    this.root = document.createElement('div');\n    this.root.setAttribute('style', 'display: inline-block');\n    this._root_extra_style(this.root);\n\n    parent_element.appendChild(this.root);\n\n    this._init_header(this);\n    this._init_canvas(this);\n    this._init_toolbar(this);\n\n    var fig = this;\n\n    this.waiting = false;\n\n    this.ws.onopen = function () {\n        fig.send_message('supports_binary', { value: fig.supports_binary });\n        fig.send_message('send_image_mode', {});\n        if (fig.ratio !== 1) {\n            fig.send_message('set_device_pixel_ratio', {\n                device_pixel_ratio: fig.ratio,\n            });\n        }\n        fig.send_message('refresh', {});\n    };\n\n    this.imageObj.onload = function () {\n        if (fig.image_mode === 'full') {\n            // Full images could contain transparency (where diff images\n            // almost always do), so we need to clear the canvas so that\n            // there is no ghosting.\n            fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n        }\n        fig.context.drawImage(fig.imageObj, 0, 0);\n    };\n\n    this.imageObj.onunload = function () {\n        fig.ws.close();\n    };\n\n    this.ws.onmessage = this._make_on_message_function(this);\n\n    this.ondownload = ondownload;\n};\n\nmpl.figure.prototype._init_header = function () {\n    var titlebar = document.createElement('div');\n    titlebar.classList =\n        'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n    var titletext = document.createElement('div');\n    titletext.classList = 'ui-dialog-title';\n    titletext.setAttribute(\n        'style',\n        'width: 100%; text-align: center; padding: 3px;'\n    );\n    titlebar.appendChild(titletext);\n    this.root.appendChild(titlebar);\n    this.header = titletext;\n};\n\nmpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n\nmpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n\nmpl.figure.prototype._init_canvas = function () {\n    var fig = this;\n\n    var canvas_div = (this.canvas_div = document.createElement('div'));\n    canvas_div.setAttribute('tabindex', '0');\n    canvas_div.setAttribute(\n        'style',\n        'border: 1px solid #ddd;' +\n            'box-sizing: content-box;' +\n            'clear: both;' +\n            'min-height: 1px;' +\n            'min-width: 1px;' +\n            'outline: 0;' +\n            'overflow: hidden;' +\n            'position: relative;' +\n            'resize: both;' +\n            'z-index: 2;'\n    );\n\n    function on_keyboard_event_closure(name) {\n        return function (event) {\n            return fig.key_event(event, name);\n        };\n    }\n\n    canvas_div.addEventListener(\n        'keydown',\n        on_keyboard_event_closure('key_press')\n    );\n    canvas_div.addEventListener(\n        'keyup',\n        on_keyboard_event_closure('key_release')\n    );\n\n    this._canvas_extra_style(canvas_div);\n    this.root.appendChild(canvas_div);\n\n    var canvas = (this.canvas = document.createElement('canvas'));\n    canvas.classList.add('mpl-canvas');\n    canvas.setAttribute(\n        'style',\n        'box-sizing: content-box;' +\n            'pointer-events: none;' +\n            'position: relative;' +\n            'z-index: 0;'\n    );\n\n    this.context = canvas.getContext('2d');\n\n    var backingStore =\n        this.context.backingStorePixelRatio ||\n        this.context.webkitBackingStorePixelRatio ||\n        this.context.mozBackingStorePixelRatio ||\n        this.context.msBackingStorePixelRatio ||\n        this.context.oBackingStorePixelRatio ||\n        this.context.backingStorePixelRatio ||\n        1;\n\n    this.ratio = (window.devicePixelRatio || 1) / backingStore;\n\n    var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n        'canvas'\n    ));\n    rubberband_canvas.setAttribute(\n        'style',\n        'box-sizing: content-box;' +\n            'left: 0;' +\n            'pointer-events: none;' +\n            'position: absolute;' +\n            'top: 0;' +\n            'z-index: 1;'\n    );\n\n    // Apply a ponyfill if ResizeObserver is not implemented by browser.\n    if (this.ResizeObserver === undefined) {\n        if (window.ResizeObserver !== undefined) {\n            this.ResizeObserver = window.ResizeObserver;\n        } else {\n            var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n            this.ResizeObserver = obs.ResizeObserver;\n        }\n    }\n\n    this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n        // There's no need to resize if the WebSocket is not connected:\n        // - If it is still connecting, then we will get an initial resize from\n        //   Python once it connects.\n        // - If it has disconnected, then resizing will clear the canvas and\n        //   never get anything back to refill it, so better to not resize and\n        //   keep something visible.\n        if (fig.ws.readyState != 1) {\n            return;\n        }\n        var nentries = entries.length;\n        for (var i = 0; i < nentries; i++) {\n            var entry = entries[i];\n            var width, height;\n            if (entry.contentBoxSize) {\n                if (entry.contentBoxSize instanceof Array) {\n                    // Chrome 84 implements new version of spec.\n                    width = entry.contentBoxSize[0].inlineSize;\n                    height = entry.contentBoxSize[0].blockSize;\n                } else {\n                    // Firefox implements old version of spec.\n                    width = entry.contentBoxSize.inlineSize;\n                    height = entry.contentBoxSize.blockSize;\n                }\n            } else {\n                // Chrome <84 implements even older version of spec.\n                width = entry.contentRect.width;\n                height = entry.contentRect.height;\n            }\n\n            // Keep the size of the canvas and rubber band canvas in sync with\n            // the canvas container.\n            if (entry.devicePixelContentBoxSize) {\n                // Chrome 84 implements new version of spec.\n                canvas.setAttribute(\n                    'width',\n                    entry.devicePixelContentBoxSize[0].inlineSize\n                );\n                canvas.setAttribute(\n                    'height',\n                    entry.devicePixelContentBoxSize[0].blockSize\n                );\n            } else {\n                canvas.setAttribute('width', width * fig.ratio);\n                canvas.setAttribute('height', height * fig.ratio);\n            }\n            /* This rescales the canvas back to display pixels, so that it\n             * appears correct on HiDPI screens. */\n            canvas.style.width = width + 'px';\n            canvas.style.height = height + 'px';\n\n            rubberband_canvas.setAttribute('width', width);\n            rubberband_canvas.setAttribute('height', height);\n\n            // And update the size in Python. We ignore the initial 0/0 size\n            // that occurs as the element is placed into the DOM, which should\n            // otherwise not happen due to the minimum size styling.\n            if (width != 0 && height != 0) {\n                fig.request_resize(width, height);\n            }\n        }\n    });\n    this.resizeObserverInstance.observe(canvas_div);\n\n    function on_mouse_event_closure(name) {\n        /* User Agent sniffing is bad, but WebKit is busted:\n         * https://bugs.webkit.org/show_bug.cgi?id=144526\n         * https://bugs.webkit.org/show_bug.cgi?id=181818\n         * The worst that happens here is that they get an extra browser\n         * selection when dragging, if this check fails to catch them.\n         */\n        var UA = navigator.userAgent;\n        var isWebKit = /AppleWebKit/.test(UA) && !/Chrome/.test(UA);\n        if(isWebKit) {\n            return function (event) {\n                /* This prevents the web browser from automatically changing to\n                 * the text insertion cursor when the button is pressed. We\n                 * want to control all of the cursor setting manually through\n                 * the 'cursor' event from matplotlib */\n                event.preventDefault()\n                return fig.mouse_event(event, name);\n            };\n        } else {\n            return function (event) {\n                return fig.mouse_event(event, name);\n            };\n        }\n    }\n\n    canvas_div.addEventListener(\n        'mousedown',\n        on_mouse_event_closure('button_press')\n    );\n    canvas_div.addEventListener(\n        'mouseup',\n        on_mouse_event_closure('button_release')\n    );\n    canvas_div.addEventListener(\n        'dblclick',\n        on_mouse_event_closure('dblclick')\n    );\n    // Throttle sequential mouse events to 1 every 20ms.\n    canvas_div.addEventListener(\n        'mousemove',\n        on_mouse_event_closure('motion_notify')\n    );\n\n    canvas_div.addEventListener(\n        'mouseenter',\n        on_mouse_event_closure('figure_enter')\n    );\n    canvas_div.addEventListener(\n        'mouseleave',\n        on_mouse_event_closure('figure_leave')\n    );\n\n    canvas_div.addEventListener('wheel', function (event) {\n        if (event.deltaY < 0) {\n            event.step = 1;\n        } else {\n            event.step = -1;\n        }\n        on_mouse_event_closure('scroll')(event);\n    });\n\n    canvas_div.appendChild(canvas);\n    canvas_div.appendChild(rubberband_canvas);\n\n    this.rubberband_context = rubberband_canvas.getContext('2d');\n    this.rubberband_context.strokeStyle = '#000000';\n\n    this._resize_canvas = function (width, height, forward) {\n        if (forward) {\n            canvas_div.style.width = width + 'px';\n            canvas_div.style.height = height + 'px';\n        }\n    };\n\n    // Disable right mouse context menu.\n    canvas_div.addEventListener('contextmenu', function (_e) {\n        event.preventDefault();\n        return false;\n    });\n\n    function set_focus() {\n        canvas.focus();\n        canvas_div.focus();\n    }\n\n    window.setTimeout(set_focus, 100);\n};\n\nmpl.figure.prototype._init_toolbar = function () {\n    var fig = this;\n\n    var toolbar = document.createElement('div');\n    toolbar.classList = 'mpl-toolbar';\n    this.root.appendChild(toolbar);\n\n    function on_click_closure(name) {\n        return function (_event) {\n            return fig.toolbar_button_onclick(name);\n        };\n    }\n\n    function on_mouseover_closure(tooltip) {\n        return function (event) {\n            if (!event.currentTarget.disabled) {\n                return fig.toolbar_button_onmouseover(tooltip);\n            }\n        };\n    }\n\n    fig.buttons = {};\n    var buttonGroup = document.createElement('div');\n    buttonGroup.classList = 'mpl-button-group';\n    for (var toolbar_ind in mpl.toolbar_items) {\n        var name = mpl.toolbar_items[toolbar_ind][0];\n        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n        var image = mpl.toolbar_items[toolbar_ind][2];\n        var method_name = mpl.toolbar_items[toolbar_ind][3];\n\n        if (!name) {\n            /* Instead of a spacer, we start a new button group. */\n            if (buttonGroup.hasChildNodes()) {\n                toolbar.appendChild(buttonGroup);\n            }\n            buttonGroup = document.createElement('div');\n            buttonGroup.classList = 'mpl-button-group';\n            continue;\n        }\n\n        var button = (fig.buttons[name] = document.createElement('button'));\n        button.classList = 'mpl-widget';\n        button.setAttribute('role', 'button');\n        button.setAttribute('aria-disabled', 'false');\n        button.addEventListener('click', on_click_closure(method_name));\n        button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n\n        var icon_img = document.createElement('img');\n        icon_img.src = '_images/' + image + '.png';\n        icon_img.srcset = '_images/' + image + '_large.png 2x';\n        icon_img.alt = tooltip;\n        button.appendChild(icon_img);\n\n        buttonGroup.appendChild(button);\n    }\n\n    if (buttonGroup.hasChildNodes()) {\n        toolbar.appendChild(buttonGroup);\n    }\n\n    var fmt_picker = document.createElement('select');\n    fmt_picker.classList = 'mpl-widget';\n    toolbar.appendChild(fmt_picker);\n    this.format_dropdown = fmt_picker;\n\n    for (var ind in mpl.extensions) {\n        var fmt = mpl.extensions[ind];\n        var option = document.createElement('option');\n        option.selected = fmt === mpl.default_extension;\n        option.innerHTML = fmt;\n        fmt_picker.appendChild(option);\n    }\n\n    var status_bar = document.createElement('span');\n    status_bar.classList = 'mpl-message';\n    toolbar.appendChild(status_bar);\n    this.message = status_bar;\n};\n\nmpl.figure.prototype.request_resize = function (x_pixels, y_pixels) {\n    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n    // which will in turn request a refresh of the image.\n    this.send_message('resize', { width: x_pixels, height: y_pixels });\n};\n\nmpl.figure.prototype.send_message = function (type, properties) {\n    properties['type'] = type;\n    properties['figure_id'] = this.id;\n    this.ws.send(JSON.stringify(properties));\n};\n\nmpl.figure.prototype.send_draw_message = function () {\n    if (!this.waiting) {\n        this.waiting = true;\n        this.ws.send(JSON.stringify({ type: 'draw', figure_id: this.id }));\n    }\n};\n\nmpl.figure.prototype.handle_save = function (fig, _msg) {\n    var format_dropdown = fig.format_dropdown;\n    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n    fig.ondownload(fig, format);\n};\n\nmpl.figure.prototype.handle_resize = function (fig, msg) {\n    var size = msg['size'];\n    if (size[0] !== fig.canvas.width || size[1] !== fig.canvas.height) {\n        fig._resize_canvas(size[0], size[1], msg['forward']);\n        fig.send_message('refresh', {});\n    }\n};\n\nmpl.figure.prototype.handle_rubberband = function (fig, msg) {\n    var x0 = msg['x0'] / fig.ratio;\n    var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n    var x1 = msg['x1'] / fig.ratio;\n    var y1 = (fig.canvas.height - msg['y1']) / fig.ratio;\n    x0 = Math.floor(x0) + 0.5;\n    y0 = Math.floor(y0) + 0.5;\n    x1 = Math.floor(x1) + 0.5;\n    y1 = Math.floor(y1) + 0.5;\n    var min_x = Math.min(x0, x1);\n    var min_y = Math.min(y0, y1);\n    var width = Math.abs(x1 - x0);\n    var height = Math.abs(y1 - y0);\n\n    fig.rubberband_context.clearRect(\n        0,\n        0,\n        fig.canvas.width / fig.ratio,\n        fig.canvas.height / fig.ratio\n    );\n\n    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n};\n\nmpl.figure.prototype.handle_figure_label = function (fig, msg) {\n    // Updates the figure title.\n    fig.header.textContent = msg['label'];\n};\n\nmpl.figure.prototype.handle_cursor = function (fig, msg) {\n    fig.canvas_div.style.cursor = msg['cursor'];\n};\n\nmpl.figure.prototype.handle_message = function (fig, msg) {\n    fig.message.textContent = msg['message'];\n};\n\nmpl.figure.prototype.handle_draw = function (fig, _msg) {\n    // Request the server to send over a new figure.\n    fig.send_draw_message();\n};\n\nmpl.figure.prototype.handle_image_mode = function (fig, msg) {\n    fig.image_mode = msg['mode'];\n};\n\nmpl.figure.prototype.handle_history_buttons = function (fig, msg) {\n    for (var key in msg) {\n        if (!(key in fig.buttons)) {\n            continue;\n        }\n        fig.buttons[key].disabled = !msg[key];\n        fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n    }\n};\n\nmpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n    if (msg['mode'] === 'PAN') {\n        fig.buttons['Pan'].classList.add('active');\n        fig.buttons['Zoom'].classList.remove('active');\n    } else if (msg['mode'] === 'ZOOM') {\n        fig.buttons['Pan'].classList.remove('active');\n        fig.buttons['Zoom'].classList.add('active');\n    } else {\n        fig.buttons['Pan'].classList.remove('active');\n        fig.buttons['Zoom'].classList.remove('active');\n    }\n};\n\nmpl.figure.prototype.updated_canvas_event = function () {\n    // Called whenever the canvas gets updated.\n    this.send_message('ack', {});\n};\n\n// A function to construct a web socket function for onmessage handling.\n// Called in the figure constructor.\nmpl.figure.prototype._make_on_message_function = function (fig) {\n    return function socket_on_message(evt) {\n        if (evt.data instanceof Blob) {\n            var img = evt.data;\n            if (img.type !== 'image/png') {\n                /* FIXME: We get \"Resource interpreted as Image but\n                 * transferred with MIME type text/plain:\" errors on\n                 * Chrome.  But how to set the MIME type?  It doesn't seem\n                 * to be part of the websocket stream */\n                img.type = 'image/png';\n            }\n\n            /* Free the memory for the previous frames */\n            if (fig.imageObj.src) {\n                (window.URL || window.webkitURL).revokeObjectURL(\n                    fig.imageObj.src\n                );\n            }\n\n            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n                img\n            );\n            fig.updated_canvas_event();\n            fig.waiting = false;\n            return;\n        } else if (\n            typeof evt.data === 'string' &&\n            evt.data.slice(0, 21) === 'data:image/png;base64'\n        ) {\n            fig.imageObj.src = evt.data;\n            fig.updated_canvas_event();\n            fig.waiting = false;\n            return;\n        }\n\n        var msg = JSON.parse(evt.data);\n        var msg_type = msg['type'];\n\n        // Call the  \"handle_{type}\" callback, which takes\n        // the figure and JSON message as its only arguments.\n        try {\n            var callback = fig['handle_' + msg_type];\n        } catch (e) {\n            console.log(\n                \"No handler for the '%s' message type: \",\n                msg_type,\n                msg\n            );\n            return;\n        }\n\n        if (callback) {\n            try {\n                // console.log(\"Handling '%s' message: \", msg_type, msg);\n                callback(fig, msg);\n            } catch (e) {\n                console.log(\n                    \"Exception inside the 'handler_%s' callback:\",\n                    msg_type,\n                    e,\n                    e.stack,\n                    msg\n                );\n            }\n        }\n    };\n};\n\nfunction getModifiers(event) {\n    var mods = [];\n    if (event.ctrlKey) {\n        mods.push('ctrl');\n    }\n    if (event.altKey) {\n        mods.push('alt');\n    }\n    if (event.shiftKey) {\n        mods.push('shift');\n    }\n    if (event.metaKey) {\n        mods.push('meta');\n    }\n    return mods;\n}\n\n/*\n * return a copy of an object with only non-object keys\n * we need this to avoid circular references\n * https://stackoverflow.com/a/24161582/3208463\n */\nfunction simpleKeys(original) {\n    return Object.keys(original).reduce(function (obj, key) {\n        if (typeof original[key] !== 'object') {\n            obj[key] = original[key];\n        }\n        return obj;\n    }, {});\n}\n\nmpl.figure.prototype.mouse_event = function (event, name) {\n    if (name === 'button_press') {\n        this.canvas.focus();\n        this.canvas_div.focus();\n    }\n\n    // from https://stackoverflow.com/q/1114465\n    var boundingRect = this.canvas.getBoundingClientRect();\n    var x = (event.clientX - boundingRect.left) * this.ratio;\n    var y = (event.clientY - boundingRect.top) * this.ratio;\n\n    this.send_message(name, {\n        x: x,\n        y: y,\n        button: event.button,\n        step: event.step,\n        buttons: event.buttons,\n        modifiers: getModifiers(event),\n        guiEvent: simpleKeys(event),\n    });\n\n    return false;\n};\n\nmpl.figure.prototype._key_event_extra = function (_event, _name) {\n    // Handle any extra behaviour associated with a key event\n};\n\nmpl.figure.prototype.key_event = function (event, name) {\n    // Prevent repeat events\n    if (name === 'key_press') {\n        if (event.key === this._key) {\n            return;\n        } else {\n            this._key = event.key;\n        }\n    }\n    if (name === 'key_release') {\n        this._key = null;\n    }\n\n    var value = '';\n    if (event.ctrlKey && event.key !== 'Control') {\n        value += 'ctrl+';\n    }\n    else if (event.altKey && event.key !== 'Alt') {\n        value += 'alt+';\n    }\n    else if (event.shiftKey && event.key !== 'Shift') {\n        value += 'shift+';\n    }\n\n    value += 'k' + event.key;\n\n    this._key_event_extra(event, name);\n\n    this.send_message(name, { key: value, guiEvent: simpleKeys(event) });\n    return false;\n};\n\nmpl.figure.prototype.toolbar_button_onclick = function (name) {\n    if (name === 'download') {\n        this.handle_save(this, null);\n    } else {\n        this.send_message('toolbar_button', { name: name });\n    }\n};\n\nmpl.figure.prototype.toolbar_button_onmouseover = function (tooltip) {\n    this.message.textContent = tooltip;\n};\n\n///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n// prettier-ignore\nvar _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\nmpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis\", \"fa fa-square-o\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o\", \"download\"]];\n\nmpl.extensions = [\"eps\", \"jpeg\", \"pgf\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\", \"webp\"];\n\nmpl.default_extension = \"png\";/* global mpl */\n\nvar comm_websocket_adapter = function (comm) {\n    // Create a \"websocket\"-like object which calls the given IPython comm\n    // object with the appropriate methods. Currently this is a non binary\n    // socket, so there is still some room for performance tuning.\n    var ws = {};\n\n    ws.binaryType = comm.kernel.ws.binaryType;\n    ws.readyState = comm.kernel.ws.readyState;\n    function updateReadyState(_event) {\n        if (comm.kernel.ws) {\n            ws.readyState = comm.kernel.ws.readyState;\n        } else {\n            ws.readyState = 3; // Closed state.\n        }\n    }\n    comm.kernel.ws.addEventListener('open', updateReadyState);\n    comm.kernel.ws.addEventListener('close', updateReadyState);\n    comm.kernel.ws.addEventListener('error', updateReadyState);\n\n    ws.close = function () {\n        comm.close();\n    };\n    ws.send = function (m) {\n        //console.log('sending', m);\n        comm.send(m);\n    };\n    // Register the callback with on_msg.\n    comm.on_msg(function (msg) {\n        //console.log('receiving', msg['content']['data'], msg);\n        var data = msg['content']['data'];\n        if (data['blob'] !== undefined) {\n            data = {\n                data: new Blob(msg['buffers'], { type: data['blob'] }),\n            };\n        }\n        // Pass the mpl event to the overridden (by mpl) onmessage function.\n        ws.onmessage(data);\n    });\n    return ws;\n};\n\nmpl.mpl_figure_comm = function (comm, msg) {\n    // This is the function which gets called when the mpl process\n    // starts-up an IPython Comm through the \"matplotlib\" channel.\n\n    var id = msg.content.data.id;\n    // Get hold of the div created by the display call when the Comm\n    // socket was opened in Python.\n    var element = document.getElementById(id);\n    var ws_proxy = comm_websocket_adapter(comm);\n\n    function ondownload(figure, _format) {\n        window.open(figure.canvas.toDataURL());\n    }\n\n    var fig = new mpl.figure(id, ws_proxy, ondownload, element);\n\n    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n    // web socket which is closed, not our websocket->open comm proxy.\n    ws_proxy.onopen();\n\n    fig.parent_element = element;\n    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n    if (!fig.cell_info) {\n        console.error('Failed to find cell for figure', id, fig);\n        return;\n    }\n    fig.cell_info[0].output_area.element.on(\n        'cleared',\n        { fig: fig },\n        fig._remove_fig_handler\n    );\n};\n\nmpl.figure.prototype.handle_close = function (fig, msg) {\n    var width = fig.canvas.width / fig.ratio;\n    fig.cell_info[0].output_area.element.off(\n        'cleared',\n        fig._remove_fig_handler\n    );\n    fig.resizeObserverInstance.unobserve(fig.canvas_div);\n\n    // Update the output cell to use the data from the current canvas.\n    fig.push_to_output();\n    var dataURL = fig.canvas.toDataURL();\n    // Re-enable the keyboard manager in IPython - without this line, in FF,\n    // the notebook keyboard shortcuts fail.\n    IPython.keyboard_manager.enable();\n    fig.parent_element.innerHTML =\n        '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n    fig.close_ws(fig, msg);\n};\n\nmpl.figure.prototype.close_ws = function (fig, msg) {\n    fig.send_message('closing', msg);\n    // fig.ws.close()\n};\n\nmpl.figure.prototype.push_to_output = function (_remove_interactive) {\n    // Turn the data on the canvas into data in the output cell.\n    var width = this.canvas.width / this.ratio;\n    var dataURL = this.canvas.toDataURL();\n    this.cell_info[1]['text/html'] =\n        '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n};\n\nmpl.figure.prototype.updated_canvas_event = function () {\n    // Tell IPython that the notebook contents must change.\n    IPython.notebook.set_dirty(true);\n    this.send_message('ack', {});\n    var fig = this;\n    // Wait a second, then push the new image to the DOM so\n    // that it is saved nicely (might be nice to debounce this).\n    setTimeout(function () {\n        fig.push_to_output();\n    }, 1000);\n};\n\nmpl.figure.prototype._init_toolbar = function () {\n    var fig = this;\n\n    var toolbar = document.createElement('div');\n    toolbar.classList = 'btn-toolbar';\n    this.root.appendChild(toolbar);\n\n    function on_click_closure(name) {\n        return function (_event) {\n            return fig.toolbar_button_onclick(name);\n        };\n    }\n\n    function on_mouseover_closure(tooltip) {\n        return function (event) {\n            if (!event.currentTarget.disabled) {\n                return fig.toolbar_button_onmouseover(tooltip);\n            }\n        };\n    }\n\n    fig.buttons = {};\n    var buttonGroup = document.createElement('div');\n    buttonGroup.classList = 'btn-group';\n    var button;\n    for (var toolbar_ind in mpl.toolbar_items) {\n        var name = mpl.toolbar_items[toolbar_ind][0];\n        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n        var image = mpl.toolbar_items[toolbar_ind][2];\n        var method_name = mpl.toolbar_items[toolbar_ind][3];\n\n        if (!name) {\n            /* Instead of a spacer, we start a new button group. */\n            if (buttonGroup.hasChildNodes()) {\n                toolbar.appendChild(buttonGroup);\n            }\n            buttonGroup = document.createElement('div');\n            buttonGroup.classList = 'btn-group';\n            continue;\n        }\n\n        button = fig.buttons[name] = document.createElement('button');\n        button.classList = 'btn btn-default';\n        button.href = '#';\n        button.title = name;\n        button.innerHTML = '<i class=\"fa ' + image + ' fa-lg\"></i>';\n        button.addEventListener('click', on_click_closure(method_name));\n        button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n        buttonGroup.appendChild(button);\n    }\n\n    if (buttonGroup.hasChildNodes()) {\n        toolbar.appendChild(buttonGroup);\n    }\n\n    // Add the status bar.\n    var status_bar = document.createElement('span');\n    status_bar.classList = 'mpl-message pull-right';\n    toolbar.appendChild(status_bar);\n    this.message = status_bar;\n\n    // Add the close button to the window.\n    var buttongrp = document.createElement('div');\n    buttongrp.classList = 'btn-group inline pull-right';\n    button = document.createElement('button');\n    button.classList = 'btn btn-mini btn-primary';\n    button.href = '#';\n    button.title = 'Stop Interaction';\n    button.innerHTML = '<i class=\"fa fa-power-off icon-remove icon-large\"></i>';\n    button.addEventListener('click', function (_evt) {\n        fig.handle_close(fig, {});\n    });\n    button.addEventListener(\n        'mouseover',\n        on_mouseover_closure('Stop Interaction')\n    );\n    buttongrp.appendChild(button);\n    var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n    titlebar.insertBefore(buttongrp, titlebar.firstChild);\n};\n\nmpl.figure.prototype._remove_fig_handler = function (event) {\n    var fig = event.data.fig;\n    if (event.target !== this) {\n        // Ignore bubbled events from children.\n        return;\n    }\n    fig.close_ws(fig, {});\n};\n\nmpl.figure.prototype._root_extra_style = function (el) {\n    el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n};\n\nmpl.figure.prototype._canvas_extra_style = function (el) {\n    // this is important to make the div 'focusable\n    el.setAttribute('tabindex', 0);\n    // reach out to IPython and tell the keyboard manager to turn it's self\n    // off when our div gets focus\n\n    // location in version 3\n    if (IPython.notebook.keyboard_manager) {\n        IPython.notebook.keyboard_manager.register_events(el);\n    } else {\n        // location in version 2\n        IPython.keyboard_manager.register_events(el);\n    }\n};\n\nmpl.figure.prototype._key_event_extra = function (event, _name) {\n    // Check for shift+enter\n    if (event.shiftKey && event.which === 13) {\n        this.canvas_div.blur();\n        // select the cell after this one\n        var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n        IPython.notebook.select(index + 1);\n    }\n};\n\nmpl.figure.prototype.handle_save = function (fig, _msg) {\n    fig.ondownload(fig, null);\n};\n\nmpl.find_output_cell = function (html_output) {\n    // Return the cell and output element which can be found *uniquely* in the notebook.\n    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n    // IPython event is triggered only after the cells have been serialised, which for\n    // our purposes (turning an active figure into a static one), is too late.\n    var cells = IPython.notebook.get_cells();\n    var ncells = cells.length;\n    for (var i = 0; i < ncells; i++) {\n        var cell = cells[i];\n        if (cell.cell_type === 'code') {\n            for (var j = 0; j < cell.output_area.outputs.length; j++) {\n                var data = cell.output_area.outputs[j];\n                if (data.data) {\n                    // IPython >= 3 moved mimebundle to data attribute of output\n                    data = data.data;\n                }\n                if (data['text/html'] === html_output) {\n                    return [cell, data, j];\n                }\n            }\n        }\n    }\n};\n\n// Register the function which deals with the matplotlib target/channel.\n// The kernel may be null if the page has been refreshed.\nif (IPython.notebook.kernel !== null) {\n    IPython.notebook.kernel.comm_manager.register_target(\n        'matplotlib',\n        mpl.mpl_figure_comm\n    );\n}\n"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ],
+      "text/html": [
+       "<div id='d47f9d00-1f3c-4b41-b2c0-71af2d4d025a'></div>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "execution_count": 15
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-09-05T19:30:25.527396Z",
+     "start_time": "2025-09-05T19:30:25.524283Z"
+    }
+   },
+   "cell_type": "code",
+   "source": "",
+   "id": "c6a7ec169a6956eb",
+   "outputs": [],
+   "execution_count": 15
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 2
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython2",
+   "version": "2.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/hf_radar/sog_hf.ipynb b/examples/hf_radar/sog_hf.ipynb
new file mode 100644
index 0000000..0419918
--- /dev/null
+++ b/examples/hf_radar/sog_hf.ipynb
@@ -0,0 +1,252 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "id": "initial_id",
+   "metadata": {
+    "collapsed": true,
+    "ExecuteTime": {
+     "end_time": "2025-09-08T16:32:59.965786Z",
+     "start_time": "2025-09-08T16:32:58.923732Z"
+    }
+   },
+   "source": [
+    "import cartopy.crs as ccrs\n",
+    "from datetime import datetime\n",
+    "import matplotlib\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "import xarray as xr\n",
+    "\n",
+    "from onc import ONC\n",
+    "from onc.util import get_onc_token, dt2str"
+   ],
+   "outputs": [],
+   "execution_count": 1
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-09-08T16:32:59.971477Z",
+     "start_time": "2025-09-08T16:32:59.966324Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "save_dir = '../data/hf'\n",
+    "onc = ONC(token = get_onc_token(),outPath = save_dir)"
+   ],
+   "id": "3ac5a7b4400485c6",
+   "outputs": [],
+   "execution_count": 2
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-09-08T16:33:00.574689Z",
+     "start_time": "2025-09-08T16:32:59.971477Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "products = onc.getDataProducts({'locationCode': 'SOGCS', 'extension': 'nc'})\n",
+    "products"
+   ],
+   "id": "6ecbbdc5b639d2d8",
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[{'dataProductCode': 'CODARQCSC',\n",
+       "  'dataProductName': 'CODAR Quality Controlled Surface Currents',\n",
+       "  'dataProductOptions': [{'allowableRange': None,\n",
+       "    'allowableValues': ['0', '1'],\n",
+       "    'defaultValue': '1',\n",
+       "    'documentation': ['https://wiki.oceannetworks.ca/pages/viewpage.action?pageId=81887426'],\n",
+       "    'option': 'dpo_IncludeRadials',\n",
+       "    'suboptions': None}],\n",
+       "  'extension': 'nc',\n",
+       "  'hasDeviceData': True,\n",
+       "  'hasPropertyData': False,\n",
+       "  'helpDocument': 'https://wiki.oceannetworks.ca/display/DP/148'}]"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "execution_count": 3
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-09-08T16:34:02.425190Z",
+     "start_time": "2025-09-08T16:33:00.574689Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "%%time\n",
+    "date_from = datetime(2016,3,30,0,0,0,0) # Start of the data request.\n",
+    "date_to = datetime(2016,3,30,11,59,59,999999) # End of the data request.\n",
+    "\n",
+    "loc_code = 'SOGCS'\n",
+    "dev_cat_code = 'OCEANOGRAPHICRADAR'\n",
+    "data_product_code = 'CODARQCSC' # Quality Controlled Surface Currents\n",
+    "extension = 'nc'  # NetCDF output format.\n",
+    "\n",
+    "params = {'locationCode': loc_code,\n",
+    "          'deviceCategoryCode': dev_cat_code,\n",
+    "          'dateFrom': dt2str(date_from),\n",
+    "          'dateTo': dt2str(date_to),\n",
+    "          'extension': extension,\n",
+    "          'dataProductCode': data_product_code}\n",
+    "\n",
+    "req = onc.requestDataProduct(filters = params)\n",
+    "status = onc.runDataProduct(req['dpRequestId'])\n",
+    "for run_id in status['runIds']:\n",
+    "    down = onc.downloadDataProduct(run_id)"
+   ],
+   "id": "b85c3615c8a6166e",
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Request Id: 27101716\n",
+      "Estimated File Size: 433 kB\n",
+      "Estimated Processing Time: 45 s\n",
+      "To cancel the running data product, run 'onc.cancelDataProduct(27101716)'\n",
+      "\n",
+      "   queued\n",
+      "   data product running...............\n",
+      "   1 files generated for this data product\n",
+      "   metadata product running\n",
+      "   complete\n",
+      "\n",
+      "Downloading data product files with runId 53590563...\n",
+      "\n",
+      "   Search complete, waiting on the file system to synchronize (StraitofGeorgia_StraitofGeorgiaCODARSystem_OceanographicRadarSystem_20160330T000000.000Z_20160330T110000.000Z-Totals_Clean.nc).........................CPU times: total: 10.3 s\n",
+      "Wall time: 1min 1s\n"
+     ]
+    }
+   ],
+   "execution_count": 4
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-09-08T16:34:02.504390Z",
+     "start_time": "2025-09-08T16:34:02.426933Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "fp = '../data/hf/StraitofGeorgia_StraitofGeorgiaCODARSystem_OceanographicRadarSystem_20160330T000000.000Z_20160330T110000.000Z-Totals_Clean.nc'\n",
+    "ds = xr.open_dataset(fp)\n",
+    "\n",
+    "ds = ds.sel(time = datetime(2016,3,30,11), method = 'nearest') # Select a single pass timestamp.\n",
+    "\n",
+    "ds['spd'] = np.sqrt(ds.u**2 + ds.v**2)  # Calculate speed for colormap."
+   ],
+   "id": "bab6b0c4c953be8b",
+   "outputs": [],
+   "execution_count": 5
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-09-08T16:34:03.367025Z",
+     "start_time": "2025-09-08T16:34:02.504390Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "hfcmap = matplotlib.colormaps.get_cmap('gist_yarg')\n",
+    "hfnorm = matplotlib.colors.Normalize(vmin = 0 , vmax = 80) \n",
+    "\n",
+    "xmin = ds.lon.min()-0.03\n",
+    "xmax = ds.lon.max()+0.03\n",
+    "ymin = ds.lat.min()-0.03\n",
+    "ymax = ds.lat.max()+0.03\n",
+    "x_major_locator = 0.2\n",
+    "y_major_locator = 0.2\n",
+    "\n",
+    "fig, ax = plt.subplots(1,1, figsize = (6,5), constrained_layout = True, subplot_kw = {'projection': ccrs.PlateCarree()})\n",
+    "ax.set_extent([xmin, xmax, ymin, ymax])\n",
+    "ax.coastlines(zorder = 0)\n",
+    "\n",
+    "ax.set_xticks(np.arange(xmin, xmax,x_major_locator))\n",
+    "ax.set_xlabel(r'Longitude ($^{\\circ}E$)')\n",
+    "\n",
+    "ax.set_yticks(np.arange(ymin, ymax,y_major_locator))\n",
+    "ax.set_ylabel(r'Latitude ($^{\\circ}N$)')\n",
+    "\n",
+    "ax.set_title('Strait of Georgia: ' + str(ds.time.min().values)[:-10] + 'Z')\n",
+    "\n",
+    "\n",
+    "quiv = ax.quiver(ds.lon, ds.lat, ds.u, ds.v, ds.spd, angles = 'uv', pivot = 'mid', cmap = hfcmap, norm = hfnorm)\n",
+    "fig.colorbar(quiv, ax = ax, shrink = 0.5, label = 'Surface Current Speed (cm/s)')\n"
+   ],
+   "id": "34dd1bad97eaaed",
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.colorbar.Colorbar at 0x2b334aa77a0>"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 600x500 with 2 Axes>"
+      ],
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "execution_count": 6
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-09-08T16:34:03.371180Z",
+     "start_time": "2025-09-08T16:34:03.367025Z"
+    }
+   },
+   "cell_type": "code",
+   "source": "",
+   "id": "f71d9e290cdcee5f",
+   "outputs": [],
+   "execution_count": 6
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 2
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython2",
+   "version": "2.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/pyproject.toml b/pyproject.toml
index 8079a3c..038701b 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -16,6 +16,9 @@ dependencies = [
     "requests",
     'python-dateutil',
     "humanize",
+    "numpy",
+    "pandas",
+    "xarray",
 ]
 classifiers = [
     'Development Status :: 5 - Production/Stable',
diff --git a/src/onc/util/__init__.py b/src/onc/util/__init__.py
index e69de29..716fa2f 100644
--- a/src/onc/util/__init__.py
+++ b/src/onc/util/__init__.py
@@ -0,0 +1,2 @@
+from .util import (get_onc_token,
+                   dt2str)
diff --git a/src/onc/util/util.py b/src/onc/util/util.py
index b66b5e8..70f245c 100644
--- a/src/onc/util/util.py
+++ b/src/onc/util/util.py
@@ -12,11 +12,14 @@
 
 import json
 import math
-from datetime import datetime, timedelta
-
 from dateutil.relativedelta import SU, relativedelta
+import os
+from datetime import datetime, timedelta
+from netrc import netrc
+import pandas as pd
 
 datetimeFormat = "%Y-%m-%dT%H:%M:%S.%f"
+FlagTerm = 'flag'  # String that prepends in pandas/xarray to indicate a flag variable.
 
 
 def printErrorMessage(response, parameters, showUrl=False, showValue=False):
@@ -348,3 +351,61 @@ def copyFieldIfExists(fromDic, toDic, keys):
     for key in keys:
         if key in fromDic:
             toDic[key] = fromDic[key]
+
+
+def dt2str(dt: datetime) -> str:
+    """
+    Convert a Pythonic datetime object to a string that is compatible
+    with the ONC Oceans 3.0 API dateFrom and dateTo API query parameters.
+
+
+    Parameters
+    ----------
+    dt: datetime
+        A Python datetime object.
+
+    Returns
+    -------
+    str
+
+    Examples
+    ----------
+    >>> dtstr = dt2str(datetime.now()) # doctest: +SKIP
+    """
+
+    dt = pd.to_datetime(dt)
+    dtstr = dt.strftime('%Y-%m-%dT%H:%M:%S.%f')[:-3] + 'Z'
+    return dtstr
+
+
+def get_onc_token(netrc_path: os.PathLike | None = None) -> str:
+    """
+    Retrieve an ONC token from the password portion of a .netrc file entry.
+
+    machine data.oceannetworks.ca
+    login <username>
+    password <onc_token>
+
+    Parameters
+    ----------
+    netrc_path: os.PathLike | None
+        The path to the .netrc file.
+        If left as the default value of None, the netrc module looks for a
+        .netrc file in the user directory. If None, the netrc module looks for a
+        .netrc file in the user directory.
+
+
+    Returns
+    -------
+    str
+
+    Examples
+    ----------
+    >>> token = get_onc_token() # doctest: +SKIP
+    """
+
+    if netrc_path is None:
+        _, __, onc_token = netrc().authenticators("data.oceannetworks.ca")
+    else:
+        _, __, onc_token = netrc(netrc_path).authenticators("data.oceannetworks.ca")
+    return onc_token
diff --git a/src/onc/util/xarray.py b/src/onc/util/xarray.py
new file mode 100644
index 0000000..114d9a5
--- /dev/null
+++ b/src/onc/util/xarray.py
@@ -0,0 +1,164 @@
+import numpy as np
+import pandas as pd
+import xarray as xr
+
+from .util import FlagTerm
+
+
+def nan_onc_flags(ds: xr.Dataset, flags_to_nan: list[int] = [4]) -> xr.Dataset:
+    """
+    Set corresponding data values to NaN if the flag is in flags_to_nan.
+
+    Parameters
+    ----------
+    ds: xr.Dataset
+        The input xarray Dataset. The dataset must contain data variables and matching
+        flag variables prepended with FlagTerm (defined in util.util).
+    flags_to_nan: list[int]
+        A list of integer flag values to set to NaN if they are present in a variable.
+        By default, only the flag for bad data (4) is supplied.
+
+    Returns
+    -------
+    xr.Dataset
+
+    Examples
+    ----------
+    >>> data = nan_onc_flags(data, flags_to_nan = [3,4]) # doctest: +SKIP
+    """
+
+    flag_vars = [v for v in ds.data_vars if v.startswith(FlagTerm)]
+    if len(flag_vars) != 0:
+        for fv in flag_vars:
+            dv = fv.replace(FlagTerm + '_', '')
+            if dv in ds.data_vars:
+                ds[dv] = ds[dv].where(~ds[fv].isin([flags_to_nan]), np.nan)
+    return ds
+
+
+def remove_onc_flag_vars(ds: xr.Dataset) -> xr.Dataset:
+    """
+    Remove all flag variables from an xarray Dataset.
+    Usually this can be implemented after using nan_onc_flags to set bad data to NaN,
+    or if you don't care about the flag output.
+
+    Parameters
+    ----------
+    ds: xr.Dataset
+        The input xarray Dataset.
+
+    Returns
+    -------
+    xr.Dataset
+
+    Examples
+    ----------
+    >>> data = remove_onc_flag_vars(data) # doctest: +SKIP
+    """
+
+    flag_vars = [v for v in ds.data_vars if v.startswith(FlagTerm)]
+    if len(flag_vars) != 0:
+        ds = ds.drop_vars(flag_vars, errors='ignore')
+    return ds
+
+
+def json2xarray(json_response_data: dict, join_method: str = 'outer') -> xr.Dataset:
+    """
+    Convert a getScalarData JSON response to an xarray Dataset.
+    This function only supports use of 'array' outputFormat and 'full' metadata
+    query parameters.
+
+    Parameters
+    ----------
+    json_response_data: dict
+        A json object returned from an ONC getScalarData request.
+    join_method: str
+        The method to combine variables on. Options are the same as
+        xr.combine_by_coords join options.
+
+    Returns
+    -------
+    xr.Dataset
+
+    Examples
+    ----------
+    >>> data = json2xarray(json_response_data) # doctest: +SKIP
+    """
+
+    # Light checks because this function only handles certain conditions.
+    if json_response_data['parameters']['outputFormat'].lower() != 'array':
+        raise NotImplementedError("Only 'array' outputFormat is currently supported.")
+    elif json_response_data['parameters']['metaData'].lower() != 'full':
+        raise NotImplementedError("Only 'full' metadata is currently supported.")
+
+    loc_code = json_response_data['parameters']['locationCode'].upper()
+
+    cit = json_response_data['citations']
+    doi_info = [c['citations'] for c in cit] if len(cit) > 1 else cit[0]['citation']
+
+    metadata = json_response_data['metadata']
+    depth = metadata['depth']
+    dev_cat_code = metadata['deviceCategoryCode']
+    loc_name = metadata['locationName']
+
+    qaqc_flag_info = '\n'.join([f"{k}:{v}" for k, v in
+                                json_response_data['qaqcFlagInfo'].items()])
+
+    device_data = json_response_data['sensorData']
+
+    vds_list = []
+    for var_data in device_data:  # This could probably be parallelized in the future.
+
+        # The sensorName is more descriptive than the propertyCode.
+        var_name = var_data['sensorName'].replace(' ', '_')
+        var_name = var_name.replace('-', '_')
+        var_name = var_name.replace('(', '')
+        var_name = var_name.replace(')', '')
+        var_name = var_name.lower()
+
+        flag_var_name = f"{FlagTerm}_{var_name}"
+
+        var_times = var_data['data']['sampleTimes']
+        var_values = var_data['data']['values']
+        var_flags = var_data['data']['qaqcFlags']
+
+        vds = xr.Dataset()
+        vds = vds.assign_coords({'time': pd.to_datetime(var_times).tz_localize(None)})
+        vds[var_name] = (('time'), var_values)
+        vds[flag_var_name] = (('time'), var_flags)
+
+        # Fill any potential NaNs with a flag indicating no QAQC performed (0).
+        vds[flag_var_name] = vds[flag_var_name].fillna(0)
+
+        # Convert time dtypes to reduce object size.
+        vds['time'] = vds['time'].astype('datetime64[ms]')
+        vds[flag_var_name] = vds[flag_var_name].astype('int8')
+
+        # Assign variable level attributes.
+        vds[var_name].attrs['units'] = var_data['unitOfMeasure']
+        vds[var_name].attrs['long_name'] = var_data['sensorName']
+        vds[var_name].attrs['propertyCode'] = var_data['propertyCode']
+        vds[var_name].attrs['sensorCategoryCode'] = var_data['sensorCategoryCode']
+        vds[var_name].attrs['sensorName'] = var_data['sensorName']
+        vds[var_name].attrs['sensorCode'] = var_data['sensorCode']
+        vds[var_name].attrs['deviceCategoryCode'] = dev_cat_code
+
+        vds[flag_var_name].attrs['variable'] = var_name
+        vds[flag_var_name].attrs['qaqcFlagInfo'] = qaqc_flag_info
+
+        vds['time'].attrs['timezone'] = 'UTC'
+
+        vds_list.append(vds)
+
+    ds = xr.combine_by_coords(vds_list, join=join_method)
+    ds = ds[sorted(ds.data_vars)]
+
+    # Assign root level attributes.
+    ds.attrs['locationCode'] = loc_code
+    ds.attrs['locationName'] = loc_name
+    ds.attrs['deviceCategoryCode'] = dev_cat_code
+    ds.attrs['citations'] = doi_info
+    ds.attrs['qaqcFlagInfo'] = qaqc_flag_info
+    if 'depth' not in ds.data_vars:
+        ds.attrs['depth'] = depth
+    return ds