python-data/solutions/ex09a_weather_api.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# Exercise 9a: Weather API\n",
    "\n",
    "## Aim: Use a Weather API to create and graph NetCDF files\n",
    "\n",
    "### Issues covered:\n",
    "\n",
    "- Request and get data from a weather API service\n",
    "- Read and retrieve information from a JSON response\n",
    "- Write contents to a NetCDF file\n",
    "- Read a collection of NetCDF files and plot a time series graph\n",
    "\n",
    "## 1. Let's get data from a web API on the internet\n",
    "\n",
    "We will use the NOAA National Weather Service in the US as our data source:\n",
    "\n",
    "![](https://www.weather.gov/css/images/header.png)\n",
    "\n",
    "The service has a web API that allows you to request forecast data for a given grid point in the USA. Details of the API are documented at:\n",
    "\n",
    "https://www.weather.gov/documentation/services-web-api\n",
    "\n",
    "Use the endpoint `https://api.weather.gov/` as the base URL.\n",
    "\n",
    "Firstly, we want to get a grid ID and based on some latitude/longitude coordinates. To do so we will use the `points/{latitude,longitude}` endpoint of the API.\n",
    "\n",
    "**Choose the latitude and longitude of your favourite US location (this API is US only and in latitude North, longitude East). The extent of the USA is approximately:**\n",
    "- Longitude: -120, -80\n",
    "- Latitude:  30, 48\n",
    "\n",
    "Once you have queried the `points` API you will get back a `grid ID` (`GridId`). The `grid ID` can be used to get a weather forecast for your location of interest, using the `gridpoints/{grid ID}/{grid co-ordinates}` endpoint."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Import the `requests` library which is great for downloading content from external URLs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2024-11-07T10:48:23.639772Z",
     "iopub.status.busy": "2024-11-07T10:48:23.639460Z",
     "iopub.status.idle": "2024-11-07T10:48:23.970841Z",
     "shell.execute_reply": "2024-11-07T10:48:23.970287Z"
    },
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "import requests"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "You can use the requests library to access the web API. Fill in the elipses with the `latitude` (degrees North) and `longitude` (degrees East, so use negative value) of a location in the US. \n",
    "If successful, the response code should be 200."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-11-07T10:48:23.973493Z",
     "iopub.status.busy": "2024-11-07T10:48:23.973226Z",
     "iopub.status.idle": "2024-11-07T10:48:24.289901Z",
     "shell.execute_reply": "2024-11-07T10:48:24.289294Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "200"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "url = 'https://api.weather.gov/'\n",
    "latitude, longitude = 39.7456, -97.0892\n",
    "\n",
    "# Hint: use the requests library to GET from the url: https://api.weather.gov/points/{LAT},{LON}\n",
    "response = requests.get(f'{url}points/{latitude},{longitude}')\n",
    "response.status_code"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With the requests library, the results from the webAPI can be extracted into in JSON format. A JSON document behaves exactly like a dictionary.\n",
    "\n",
    "Use dictionary indexing to extract the values of the grid ID and the X/Y coordinates:\n",
    "\n",
    "- get `gridID`\n",
    "- get `gridX`\n",
    "- get `gridY`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2024-11-07T10:48:24.292507Z",
     "iopub.status.busy": "2024-11-07T10:48:24.292277Z",
     "iopub.status.idle": "2024-11-07T10:48:24.296347Z",
     "shell.execute_reply": "2024-11-07T10:48:24.295747Z"
    },
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# hint: you can view the JSON by pasting the URL directly into your browser address bar\n",
    "\n",
    "response = response.json()\n",
    "\n",
    "gridID = response['properties']['gridId']\n",
    "gridX = response['properties']['gridX']\n",
    "gridY = response['properties']['gridY']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With your `gridID`, `gridX`, and `gridY`, use the `gridpoints` API endpoint to request a weather forecast for that location. Print the status code.\n",
    "If everything is working, you should get another 200 status code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2024-11-07T10:48:24.298707Z",
     "iopub.status.busy": "2024-11-07T10:48:24.298234Z",
     "iopub.status.idle": "2024-11-07T10:48:24.714917Z",
     "shell.execute_reply": "2024-11-07T10:48:24.714298Z"
    },
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "200"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "response = requests.get(f'{url}gridpoints/{gridID}/{gridX},{gridY}')\n",
    "response.status_code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Can you use the JSON response data to get the forecast temperature values? Use dictionary indexing to get the `values` from `temperature` in `properties`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-11-07T10:48:24.717368Z",
     "iopub.status.busy": "2024-11-07T10:48:24.717137Z",
     "iopub.status.idle": "2024-11-07T10:48:24.722908Z",
     "shell.execute_reply": "2024-11-07T10:48:24.722196Z"
    }
   },
   "outputs": [],
   "source": [
    "data = response.json()\n",
    "forecast = data['properties']['temperature']['values']"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The below code extracts the coordinates of the grid box you have chosen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-11-07T10:48:24.725229Z",
     "iopub.status.busy": "2024-11-07T10:48:24.724728Z",
     "iopub.status.idle": "2024-11-07T10:48:24.734799Z",
     "shell.execute_reply": "2024-11-07T10:48:24.734239Z"
    }
   },
   "outputs": [],
   "source": [
    "coords = data['geometry']['coordinates'][0][0]\n",
    "x = coords[1]\n",
    "y = coords[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Let's format that data and write it to NetCDF\n",
    "\n",
    "### Formatting the data\n",
    "\n",
    "First, format your forecast data to get the datetime and air temperature as separate\n",
    "lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2024-11-07T10:48:24.737247Z",
     "iopub.status.busy": "2024-11-07T10:48:24.736739Z",
     "iopub.status.idle": "2024-11-07T10:48:24.747003Z",
     "shell.execute_reply": "2024-11-07T10:48:24.746444Z"
    },
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "from datetime import datetime as dt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Loop through your `forecast` values and get the temperatures (`value`) and datetimes (`validTime`) into a list.\n",
    "`forecast` is a list of dictionaries, where each dictionary is of one time instance.\n",
    "Fill in the ellipses to format each `validTime` string to a python `datetime` object and assign and set to the variable `date`. Get each `value` and assign to the variable `temp`. These values will then be appended to the `temps` and `timeseries` lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-11-07T10:48:24.749454Z",
     "iopub.status.busy": "2024-11-07T10:48:24.748973Z",
     "iopub.status.idle": "2024-11-07T10:48:24.762072Z",
     "shell.execute_reply": "2024-11-07T10:48:24.761418Z"
    },
    "pycharm": {
     "name": "#%%\n"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Use the datetime module to convert the times from the data to a datetime object.\n",
    "# Hint: look at the validTime string and see how you can turn the string to datetime\n",
    "# using strptime, the format of the datetime is: '%Y-%m-%dT%H:%M:%Sz'.\n",
    "\n",
    "timeseries = []\n",
    "temps = []\n",
    "\n",
    "for item in forecast:\n",
    "    \n",
    "    date = item['validTime']\n",
    "    date = dt.strptime(date.split('/')[0], '%Y-%m-%dT%H:%M:%S%z')\n",
    "    timeseries.append(date)\n",
    "    \n",
    "    temp = item['value']\n",
    "    temps.append(temp)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Format the `timeseries` list and convert it to relative time in seconds from the start of the timeseries. When using NetCDF and the CF Metadata Conventions time is stored as an offset from a base time rather than an absolute times.\n",
    "\n",
    "If you are stuck, take look at the 'Time series' slide in the [logging data from serial ports](https://github.com/ncasuk/ncas-isc/raw/68abbfd3a573e576c32fc127fafc874bfff98b1e/python/presentations/logging-data-from-serial-ports/LDFSP_Slides.pdf) presentation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2024-11-07T10:48:24.764352Z",
     "iopub.status.busy": "2024-11-07T10:48:24.763860Z",
     "iopub.status.idle": "2024-11-07T10:48:24.774832Z",
     "shell.execute_reply": "2024-11-07T10:48:24.774256Z"
    },
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "base_time = timeseries[0]\n",
    "time_values = []\n",
    "\n",
    "for t in timeseries:\n",
    "    value = t - base_time\n",
    "    ts = value.total_seconds()\n",
    "    time_values.append(ts)\n",
    "\n",
    "time_units = \"seconds since \" + base_time.strftime('%Y-%m-%d %H:%M:%S')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "Convert the `temps` list from degrees C to Kelvin. As per the CF Conventions, the canonical units for Air Temperature is K. Create a new list, called `temp_values`, which is the temperature in Kelvin."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2024-11-07T10:48:24.777212Z",
     "iopub.status.busy": "2024-11-07T10:48:24.776808Z",
     "iopub.status.idle": "2024-11-07T10:48:24.787224Z",
     "shell.execute_reply": "2024-11-07T10:48:24.786657Z"
    },
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "temp_values = []\n",
    "\n",
    "for t in temps:\n",
    "    t = t + 273.15\n",
    "    temp_values.append(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create a netCDF4 Dataset and write the contents to a file\n",
    "\n",
    "Import the `Dataset` class from the `netCDF4` library. You can go on to create an *instance* of this class which will contain:\n",
    "- variables\n",
    "- coordinate variables\n",
    "- dimensions\n",
    "- global attributes\n",
    "\n",
    "When you create the instance of `Dataset`, you will give it a file name which will be written to when you close the `Dataset`.\n",
    "\n",
    "Also import `numpy` as `np`. This will be used to construct the data arrays from the existing lists that currently hold the weather data and coordinate information.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2024-11-07T10:48:24.789287Z",
     "iopub.status.busy": "2024-11-07T10:48:24.789090Z",
     "iopub.status.idle": "2024-11-07T10:48:25.298859Z",
     "shell.execute_reply": "2024-11-07T10:48:25.298154Z"
    },
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "from netCDF4 import Dataset\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Quick aside, let's make sure we have a `DATA_DIR` to write to\n",
    "\n",
    "Since this is a group exercise, everyone should be writing to the same output directory. Let's set some python variables that can be used below:\n",
    "1. `USER` - used in the output file names to ensure every NetCDF file is unique.\n",
    "2. `HOME_DIR` - your `$HOME` directory\n",
    "2. `MY_DATA_DIR` - the directory where you will write your NetCDF file.\n",
    "3. `GROUP_DATA_DIR` - the directory where all the NetCDF files will eventually be collected/available.\n",
    "\n",
    "Since `GROUP_DATA_DIR` is not writeable directly from the Notebook Service, we have set up a job to replicate files from `MY_DATA_DIR` to `GROUP_DATA_DIR` (which runs once per minute)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-11-07T10:48:25.301843Z",
     "iopub.status.busy": "2024-11-07T10:48:25.301474Z",
     "iopub.status.idle": "2024-11-07T10:48:25.308753Z",
     "shell.execute_reply": "2024-11-07T10:48:25.308289Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'/home/users/nfarmer/TOP-nfarmer-temps.nc'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import os\n",
    "USER = os.environ[\"JUPYTERHUB_USER\"]\n",
    "\n",
    "HOME_DIR = f\"/home/users/{USER}\"\n",
    "MY_DATA_DIR = os.path.join(HOME_DIR, \"weather-api-outputs\")\n",
    "\n",
    "# Create MY_DATA_DIR if it doesn't exist\n",
    "if not os.path.isdir(MY_DATA_DIR):\n",
    "    os.mkdir(MY_DATA_DIR)\n",
    "\n",
    "# All NetCDF will be automatically copied here (once per minute)\n",
    "GROUP_DATA_DIR = \"/gws/pw/j07/workshop/weather-api-data\"\n",
    "\n",
    "# The output file will initially be written here (then you will move it when complete)\n",
    "filename = f\"{gridID}-{USER}-temps.nc\"\n",
    "outfile = f\"{HOME_DIR}/{filename}\"\n",
    "outfile"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Back to our NetCDF file\n",
    "\n",
    "Create the output file, as a `netCDF4 Dataset` instance, using the `outfile` defined above.\n",
    "\n",
    "If you need help, have a look at the 'Create the NetCDF dimensions & variables' slide in the [logging data from serial ports](https://github.com/ncasuk/ncas-isc/raw/68abbfd3a573e576c32fc127fafc874bfff98b1e/python/presentations/logging-data-from-serial-ports/LDFSP_Slides.pdf) presentation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2024-11-07T10:48:25.311034Z",
     "iopub.status.busy": "2024-11-07T10:48:25.310615Z",
     "iopub.status.idle": "2024-11-07T10:48:25.325229Z",
     "shell.execute_reply": "2024-11-07T10:48:25.324753Z"
    },
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "dataset = Dataset(outfile, \"w\", format=\"NETCDF4_CLASSIC\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Start by defining some dimensions\n",
    "\n",
    "Create NetCDF *dimensions*:\n",
    "- `time_dim`: *unlimited* length\n",
    "- `lat_dim`: length 1\n",
    "- `lon_dim`: length 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-11-07T10:48:25.327305Z",
     "iopub.status.busy": "2024-11-07T10:48:25.327068Z",
     "iopub.status.idle": "2024-11-07T10:48:25.382604Z",
     "shell.execute_reply": "2024-11-07T10:48:25.382108Z"
    }
   },
   "outputs": [],
   "source": [
    "time_dim = dataset.createDimension('time', None) # None means \"UNLIMITED\"\n",
    "lat_dim = dataset.createDimension('lat', 1)\n",
    "lon_dim = dataset.createDimension('lon', 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Now define the coordinate variables and then temperature variable\n",
    "\n",
    "Create the `time` *variable* with the following properties:\n",
    "- type: numpy float (`np.float64`)\n",
    "- variable id: `time`\n",
    "- dimensions: (`time`,)\n",
    "- set the array using the `time_values` list\n",
    "- `units`: `time_units` defined earlier\n",
    "- `standard_name`: `time`\n",
    "- `calendar`: `standard`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-11-07T10:48:25.384711Z",
     "iopub.status.busy": "2024-11-07T10:48:25.384481Z",
     "iopub.status.idle": "2024-11-07T10:48:25.451883Z",
     "shell.execute_reply": "2024-11-07T10:48:25.451133Z"
    }
   },
   "outputs": [],
   "source": [
    "time_var = dataset.createVariable('time', np.float64, ('time',))\n",
    "time_var[:] = time_values\n",
    "time_var.units = time_units\n",
    "time_var.standard_name = 'time'\n",
    "time_var.calendar = 'standard'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create the `lat` *variable* with the following properties:\n",
    "- type: numpy float (`np.float64`)\n",
    "- variable id: `lat`\n",
    "- dimensions: (`lat`,)\n",
    "- set the array of length 1 using the `gridY` value\n",
    "- `units`: `degrees_north`\n",
    "- `standard_name`: `latitude`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-11-07T10:48:25.454013Z",
     "iopub.status.busy": "2024-11-07T10:48:25.453784Z",
     "iopub.status.idle": "2024-11-07T10:48:25.470005Z",
     "shell.execute_reply": "2024-11-07T10:48:25.469530Z"
    }
   },
   "outputs": [],
   "source": [
    "lat_var = dataset.createVariable('lat', np.float64, ('lat',))\n",
    "lat_var[:] = [gridY]\n",
    "lat_var.units = 'degrees_north'\n",
    "lat_var.standard_name = 'latitude'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create the `lon` *variable* with the following properties:\n",
    "- type: numpy float (`np.float64`)\n",
    "- variable id: `lon`\n",
    "- dimensions: (`lon`,)\n",
    "- set the array of length 1 using the `gridX` value\n",
    "- `units`: `degrees_east`\n",
    "- `standard_name`: `longitude`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-11-07T10:48:25.472228Z",
     "iopub.status.busy": "2024-11-07T10:48:25.471822Z",
     "iopub.status.idle": "2024-11-07T10:48:25.487128Z",
     "shell.execute_reply": "2024-11-07T10:48:25.486646Z"
    }
   },
   "outputs": [],
   "source": [
    "lon_var = dataset.createVariable('lon', np.float64, ('lon',))\n",
    "lon_var[:] = [gridX]\n",
    "lon_var.units = 'degrees_east'\n",
    "lon_var.standard_name = 'longitude'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create the `temp` *variable* with the following properties:\n",
    "- type: numpy float (`np.float64`)\n",
    "- variable id: `temp`\n",
    "- dimensions: (`time`,)\n",
    "- set the array using the `temp_values` list\n",
    "- `long_name`: `air temperature (K)`\n",
    "- `units`: `K`\n",
    "- `standard_name`: `air_temperature`\n",
    "- `coordinates`: `lon lat` - to relate the longitude and latitude to this variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-11-07T10:48:25.489353Z",
     "iopub.status.busy": "2024-11-07T10:48:25.488955Z",
     "iopub.status.idle": "2024-11-07T10:48:25.505378Z",
     "shell.execute_reply": "2024-11-07T10:48:25.504896Z"
    }
   },
   "outputs": [],
   "source": [
    "temp_var = dataset.createVariable('temp', np.float32, ('time',))\n",
    "temp_var[:] = temp_values\n",
    "temp_var.var_id = 'temp'\n",
    "temp_var.long_name = 'Air Temperature (K)'\n",
    "temp_var.units = 'K'\n",
    "temp_var.standard_name = 'air_temperature'\n",
    "temp_var.coordinates = 'lon lat'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Add some global attributes\n",
    "\n",
    "The [CF Metadata Conventions](https://cfconventions.org/cf-conventions/cf-conventions.html#_overview) recommends a set of global attributes to \"provide human readable documentation of the file contents\":\n",
    "- title\n",
    "- history\n",
    "- institution\n",
    "- source\n",
    "- references\n",
    "- comment\n",
    "\n",
    "Add each of the above to your `Dataset` instance. Here are some suggested values (but you can say whatever you like):\n",
    "- title: Air Temperature forecasts for `<gridID>`\n",
    "- history: File created on: `<YYYY-MM-DD>`\n",
    "- institution: NCAS-ISC\n",
    "- source: NOAA Weather API Service\n",
    "- references: https://www.weather.gov/documentation/services-web-api\n",
    "- comment: The ISC course is teaching me about Python and NetCDF!\n",
    "\n",
    "You can add any other global attributes that you wish to."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-11-07T10:48:25.507475Z",
     "iopub.status.busy": "2024-11-07T10:48:25.507257Z",
     "iopub.status.idle": "2024-11-07T10:48:25.521485Z",
     "shell.execute_reply": "2024-11-07T10:48:25.521015Z"
    }
   },
   "outputs": [],
   "source": [
    "dataset.title = f'Air Temperature forecasts for {gridID}'\n",
    "dataset.history = f'File created on: {dt.now().strftime(\"%Y-%m-%d\")}'\n",
    "dataset.institution = 'NCAS-ISC'\n",
    "dataset.source = 'NOAA Weather API Service'\n",
    "dataset.references = 'https://www.weather.gov/documentation/services-web-api'\n",
    "dataset.comment = 'This course is OK!'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Finally, close the `Dataset` to save the file\n",
    "\n",
    "Save your NetCDF file by closing the dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-11-07T10:48:25.523545Z",
     "iopub.status.busy": "2024-11-07T10:48:25.523320Z",
     "iopub.status.idle": "2024-11-07T10:48:25.538816Z",
     "shell.execute_reply": "2024-11-07T10:48:25.538355Z"
    }
   },
   "outputs": [],
   "source": [
    "dataset.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can check it is there using `os.path.isfile(...)`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-11-07T10:48:25.540844Z",
     "iopub.status.busy": "2024-11-07T10:48:25.540627Z",
     "iopub.status.idle": "2024-11-07T10:48:25.556761Z",
     "shell.execute_reply": "2024-11-07T10:48:25.556311Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.path.isfile(outfile)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### IMPORTANT: Move the file to your MY_DATA_DIR so it gets copied to the GROUP_DATA_DIR\n",
    "\n",
    "Since we cannot write directly to the `GROUP_DATA_DIR`, move the file from your `HOME_DIR` to your `MY_DATA_DIR`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-11-07T10:48:25.561683Z",
     "iopub.status.busy": "2024-11-07T10:48:25.561311Z",
     "iopub.status.idle": "2024-11-07T10:48:25.575170Z",
     "shell.execute_reply": "2024-11-07T10:48:25.574700Z"
    }
   },
   "outputs": [],
   "source": [
    "os.rename(outfile, f\"{MY_DATA_DIR}/{filename}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 3. Find all the NetCDF files written during this exercise\n",
    "\n",
    "To find all the `.nc` files in a group workspace, we will use the glob module in Python.\n",
    "Glob let's us find all files matching a pattern, in our case:\n",
    "\n",
    "`{GROUP_DATA_DIR}/*.nc`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2024-11-07T10:48:25.577733Z",
     "iopub.status.busy": "2024-11-07T10:48:25.577374Z",
     "iopub.status.idle": "2024-11-07T10:48:25.592760Z",
     "shell.execute_reply": "2024-11-07T10:48:25.592293Z"
    },
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "from glob import glob"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "Can you use glob to make a list of file paths of all NetCDF files in the\n",
    "group workspace?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2024-11-07T10:48:25.594899Z",
     "iopub.status.busy": "2024-11-07T10:48:25.594683Z",
     "iopub.status.idle": "2024-11-07T10:48:25.621671Z",
     "shell.execute_reply": "2024-11-07T10:48:25.621201Z"
    },
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "filepaths = glob(f\"{GROUP_DATA_DIR}/*temps.nc\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 4. Create a time-series graph of all the forecasts\n",
    "\n",
    "Now that we have a list of NetCDF file paths, we can open them and extract their data.\n",
    "\n",
    "To start, let us make the a plot using matplotlib."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2024-11-07T10:48:25.623846Z",
     "iopub.status.busy": "2024-11-07T10:48:25.623613Z",
     "iopub.status.idle": "2024-11-07T10:48:26.669125Z",
     "shell.execute_reply": "2024-11-07T10:48:26.668507Z"
    },
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "from netCDF4 import num2date\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.dates as mdates\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "Create a subplots figure with figure and axis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2024-11-07T10:48:26.671966Z",
     "iopub.status.busy": "2024-11-07T10:48:26.671577Z",
     "iopub.status.idle": "2024-11-07T10:48:26.829764Z",
     "shell.execute_reply": "2024-11-07T10:48:26.829269Z"
    },
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "Can you set the x-axis locator (ticks) using dates class from matplotlib?\n",
    "- set the major locator to days.\n",
    "- set the minor locator to every 6 hours.\n",
    "- set the x-axis formatter to Day-Month for each day."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2024-11-07T10:48:26.832380Z",
     "iopub.status.busy": "2024-11-07T10:48:26.832123Z",
     "iopub.status.idle": "2024-11-07T10:48:26.835757Z",
     "shell.execute_reply": "2024-11-07T10:48:26.835281Z"
    },
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# In the matplotlib.dates module, as mdates, look at the DayLocator and HourLocator.\n",
    "fmt_day = mdates.DayLocator()\n",
    "fmt_six_hours = mdates.HourLocator(interval=6)\n",
    "\n",
    "ax.xaxis.set_major_locator(fmt_day)\n",
    "ax.xaxis.set_minor_locator(fmt_six_hours)\n",
    "ax.xaxis.set_major_formatter(mdates.DateFormatter('%d-%m'))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "Label the axis, `ax`, on the plot:\n",
    "- label the x-axis as `Date`\n",
    "- label the y-axis as `Air Temperature (K)`\n",
    "- set a title on your plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2024-11-07T10:48:26.838128Z",
     "iopub.status.busy": "2024-11-07T10:48:26.837773Z",
     "iopub.status.idle": "2024-11-07T10:48:26.855334Z",
     "shell.execute_reply": "2024-11-07T10:48:26.854875Z"
    },
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Air temperature Forecast')"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ax.set_xlabel(\"Date\")\n",
    "ax.set_ylabel(\"Air Temperature (K)\")\n",
    "ax.set_title(\"Air temperature Forecast\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "Open each NetCDF file and extract the `temp`, `time`, `lat` and `lon` variables from the file. Then use the matplotlib `plot_date` function to plot the graph.\n",
    "\n",
    "- set the label of plot to the `<lat>, <lon>` coordinates attribute of the `temp` variable.\n",
    "\n",
    "Replace the elipses with your plotting, the `for` loop works through all the shared NetCDF files in the workspace, where `f` is the file path and `filepaths` is a list of data files.\n",
    "\n",
    "If you need help, look at the 'Plotting data with matplotlib' slide in the [logging data from serial ports](https://github.com/ncasuk/ncas-isc/raw/68abbfd3a573e576c32fc127fafc874bfff98b1e/python/presentations/logging-data-from-serial-ports/LDFSP_Slides.pdf) presentation.\n",
    "\n",
    "Plot a line graph using matplotlib: \n",
    "\n",
    "- you will need to set the marker to `-` otherwise you will get a scatter graph.\n",
    "- set the label of the plot to a string: `<lat>, <lon>`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2024-11-07T10:48:26.857437Z",
     "iopub.status.busy": "2024-11-07T10:48:26.857215Z",
     "iopub.status.idle": "2024-11-07T10:48:26.881944Z",
     "shell.execute_reply": "2024-11-07T10:48:26.881476Z"
    },
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "for f in filepaths:\n",
    "    \n",
    "    dset = Dataset(f, mode='r')\n",
    "    \n",
    "    temp = dset.variables['temp']\n",
    "    time = dset.variables['time']\n",
    "    lat = dset.variables['lat'][0]\n",
    "    lon = dset.variables['lon'][0]\n",
    "\n",
    "    times = num2date(time[:], units=time.units, calendar=time.calendar)\n",
    "    ax.plot_date(times, temp[:], '-', label=f\"{lat:.3f}, {lon:.3f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "Finally, show the plot with a legend, you might want to enable tight layout,\n",
    "and save the plot to your `MY_DATA_DIR` directory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2024-11-07T10:48:26.884223Z",
     "iopub.status.busy": "2024-11-07T10:48:26.883813Z",
     "iopub.status.idle": "2024-11-07T10:48:27.060981Z",
     "shell.execute_reply": "2024-11-07T10:48:27.060496Z"
    },
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "No artists with labels found to put in legend.  Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ax.grid(True)\n",
    "fig.tight_layout()\n",
    "ax.legend()\n",
    "fig"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Save the graph to a PNG file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-11-07T10:48:27.063247Z",
     "iopub.status.busy": "2024-11-07T10:48:27.062989Z",
     "iopub.status.idle": "2024-11-07T10:48:27.141299Z",
     "shell.execute_reply": "2024-11-07T10:48:27.140782Z"
    }
   },
   "outputs": [],
   "source": [
    "fig.savefig(f\"{MY_DATA_DIR}/{gridID}-{USER}-temps.png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 + Jaspy",
   "language": "python",
   "name": "jaspy"
  },
  "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.11.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}