{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "cb836184-31c3-4113-a89d-d93548f8bded",
   "metadata": {},
   "source": [
    "# Building Intake-ESM datastores of ACCESS model output\n",
    "\n",
    "This tutorial will demonstrate how users can build Intake-ESM datastores for their ACCESS model runs using the `access-nri-intake` Python package.\n",
    "\n",
    "The ACCESS-NRI Intake Catalog consists of a set of intake-esm datastores, where a datastore has the result for one experiment. This tutorial focusses on <b>building one datastore for one experiment</b>. In general, it's assumed most user's wont build their own intake catalog, but could have several datastores for several experiments.\n",
    "\n",
    "Note: The ACCESS-NRI Intake Catalog is curated by ACCESS-NRI with further information on its <a href=\"https://access-nri-intake-catalog.readthedocs.io/en/latest/index.html\" target=\"_blank\">documentation website</a> and <a href=\"https://access-hive.org.au/model_evaluation/model_evaluation_model_catalogs\" target=\"_blank\">this ACCESS-Hive page</a>. It contains a set of model output shared amongst the ACCESS-NRI working groups, including CMIP6 results and ACCESS-OM2 (as typically used in Cosima Recipes). \n",
    "\n",
    "We demonstrate two methods here - first, the more involved method, which was the only way of building a datastore prior to the `access-nri-intake v1.1.1` release, and secondly, the convenience method added with that release.\n",
    "\n",
    "In most cases, the convenience method will be preferable, but the more involved method can be useful as it affords a greater degree of control over the process.\n",
    "\n",
    "----\n",
    "# 1. The more involved method"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4bb64c0d-bb8f-4989-9002-44d5518b7cae",
   "metadata": {},
   "source": [
    "A builder class is used for creating Intake-ESM datastores for each flavour of model output.  Classes for ACCESS model outputs are available in the `builders` submodule of the `access_nri_intake` Python package. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7af029b-68e1-4b43-993e-5dc13de4fdc7",
   "metadata": {},
   "source": [
    "We can list the available builders:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "a89c7407-8fa7-4021-81e0-487ff8fbbf82",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['AccessOm2Builder',\n",
       " 'AccessOm3Builder',\n",
       " 'Mom6Builder',\n",
       " 'AccessEsm15Builder',\n",
       " 'AccessCm2Builder',\n",
       " 'ROMSBuilder',\n",
       " 'WoaBuilder']"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from access_nri_intake.source import builders\n",
    "\n",
    "builders.__all__"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a372ba48-2ac3-4c5e-86f7-564fd6c01b69",
   "metadata": {},
   "source": [
    "Because we're looking at ACCESS-OM2 output, we'll typically use the `AccessOm2Builder` class. For other models, use the correct Builder"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc200ca9-5cba-4413-a550-bd0a4f1b54bd",
   "metadata": {},
   "source": [
    "## Building the datastore"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54ab0f35-68b2-40dc-a298-407bd7adc700",
   "metadata": {},
   "source": [
    "Building the Intake-ESM catalog should be as simple as passing the model run base output directory to the Builder and calling `.build()`. The build is parallelized (without dask) so will be faster if you throw more resources at it. The following was run using an Large `normal` ARE instance (12 cpus)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "db2a83f3-501d-48df-944d-67ba306bbfa5",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 5.91 s, sys: 957 ms, total: 6.87 s\n",
      "Wall time: 1min 11s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "PATH = \"/g/data/ik11/outputs/access-om2/1deg_jra55_iaf_omip2_cycle6\" #Some example ACCESS-OM2 output\n",
    "\n",
    "builder = builders.AccessOm2Builder(\n",
    "    path=PATH\n",
    ").build()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d2510acd-931a-4d0a-b91a-9426190f4e57",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "source": [
    "If using MOM6 standalone, just change the Builder used, e.g.:\n",
    "``` python\n",
    "PATH = \"/g/data/ol01/outputs/mom6-panan/panant-01-zstar-ACCESSyr2\" #Some example MOM6-SIS2 output\n",
    "\n",
    "builder = builders.Mom6Builder(\n",
    "    path=PATH\n",
    ").build()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e61775ac-a973-4cb0-a87f-b6a695b9e00d",
   "metadata": {},
   "source": [
    "The previous cell builds the Intake-ESM datastore in memory. We'll want to save it somewhere so we can reuse and share it. The following cell will create two new files (a `.json` and `.csv` file) in your current work directory. These files are how Intake-ESM datastores are stored on disk."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "7f4ed770-df35-4467-ab5e-ce9f8b8ec075",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Successfully wrote ESM catalog json file to: file:///home/603/as2285/mydatastore.json\n"
     ]
    }
   ],
   "source": [
    "builder.save(\n",
    "    name=\"mydatastore\", \n",
    "    description=\"An example datastore for ACCESS-OM2 ryf9091\",\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1acbbe16-04a3-4a7c-bc30-3f2a4ec81fc9",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Using your datastore"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e01ccb09-1783-4856-9648-f8ddcd863a80",
   "metadata": {},
   "source": [
    "Now we can use our Intake-ESM datastore to query and load the model data - see also the Intake-ESM documentation [here](https://intake-esm.readthedocs.io/en/stable/index.html).\n",
    "\n",
    "We can load the datastore directly using `intake`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "029dd740-fa73-4403-b756-2dff8fd0a32f",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<p><strong>mydatastore catalog with 11 dataset(s) from 2013 asset(s)</strong>:</p> <div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>unique</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>filename</th>\n",
       "      <td>1473</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>path</th>\n",
       "      <td>2013</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>file_id</th>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>frequency</th>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>start_date</th>\n",
       "      <td>855</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>end_date</th>\n",
       "      <td>854</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>variable</th>\n",
       "      <td>338</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>variable_long_name</th>\n",
       "      <td>306</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>variable_standard_name</th>\n",
       "      <td>57</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>variable_cell_methods</th>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>variable_units</th>\n",
       "      <td>128</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>realm</th>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>derived_variable</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import intake\n",
    "\n",
    "esm_datastore = intake.open_esm_datastore(\n",
    "    \"./mydatastore.json\", \n",
    "    columns_with_iterables=[\n",
    "            \"variable\",\n",
    "            \"variable_long_name\",\n",
    "            \"variable_standard_name\",\n",
    "            \"variable_cell_methods\",\n",
    "            \"variable_units\",\n",
    "    ] # This is important\n",
    ")\n",
    "\n",
    "esm_datastore"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9667b60-639b-4eb4-abf0-cb198ab2a9a0",
   "metadata": {},
   "source": [
    "It's easy to search for datasets in the datastore containing a particular variable and load them as xarray Datasets. (Note for analysing large datasets, you may want to first start a dask cluster)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f7377e3c-19db-4732-9da2-6e3d3460de71",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/intake_esm/core.py:301: FutureWarning: When grouping with a length-1 list-like, you will need to pass a length-1 tuple to get_group in a future version of pandas. Pass `(name,)` instead of `name` to silence this warning.\n",
      "  records = grouped.get_group(internal_key).to_dict(orient='records')\n"
     ]
    }
   ],
   "source": [
    "ds = esm_datastore.search(variable=\"temp\", frequency=\"1mon\").to_dask()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "896a9cc5-ac81-4fcb-a70f-3d4ee6d59682",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.QuadMesh at 0x14a2dd0e1850>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ds[\"temp\"].isel(time=-1, st_ocean=0).plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0fcbcf73-42ed-4920-88a0-5a7b5f07f11c",
   "metadata": {},
   "source": [
    "If you think your ACCESS model data is worth sharing more widely, it might be a good idea to include it in the ACCESS-NRI Intake catalog. Please open an issue here to discuss: https://github.com/ACCESS-NRI/access-nri-intake-catalog/issues/new/choose"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39e4246a-1494-4145-9280-3152325f56b9",
   "metadata": {},
   "source": [
    "# 2. The convenience method: `use_datastore`\n",
    "\n",
    "\n",
    "With the `access-nri-intake` v1.1.1 release, it is now possible to build and load datastores, all in a single step.\n",
    "To do so, we use the `use_datastore` function.\n",
    "\n",
    "The `use_datastore` function will check for a datastore in the directory you specify to place the catalog: `catalog_dir`. If one is found, it will verify whether it needs updating - for example, if a model run has been updated with new outputs. If so, the datastore will be updated and opened - if not, the existing datastore will be opened."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "00b47f8d-bc68-4801-9a30-4d1aa26176d8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function use_datastore in module access_nri_intake.experiment.main:\n",
      "\n",
      "use_datastore(experiment_dir: pathlib.Path | str, builder: ecgtools.builder.Builder | None = None, catalog_dir: pathlib.Path | str | None = None, builder_kwargs: dict | None = None, open_ds: bool = True, datastore_name: str = 'experiment_datastore', description: str | None = None) -> intake_esm.core.esm_datastore | None\n",
      "    Specify a builder and an experiment directory in order to build and/or open\n",
      "    an esm-datastore in place for that experiment. Valid and up to date datastores\n",
      "    will not be overwritten.\n",
      "    \n",
      "    Further configuration can be done by passing additional keyword arguments\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    builder : Builder\n",
      "        The builder object that will be used to build the datastore.\n",
      "    experiment_dir : Path | str\n",
      "        The directory containing the experiment. If a string is passed, it will be\n",
      "        converted to a Path object.\n",
      "    catalog_dir : Path | str, optional\n",
      "        The directory containing/to write the catalog to, if it differs from the\n",
      "        experiment directory. If None, the catalog will be written to the experiment\n",
      "        directory. If a string is passed, it will be converted to a Path object.\n",
      "    open_ds : bool\n",
      "        Whether to open the datastore after building it. Typically set to false\n",
      "        when called from a console script.\n",
      "    builder_kwargs : dict, optional\n",
      "        Any additional keyword arguments to pass to the builder if needed - for\n",
      "        example, AccessEsm15Builder additionally takes an `ensemble` argument\n",
      "    datastore_name : str, optional\n",
      "        The name of the datastore to be written. Defaults to 'experiment_datastore'.\n",
      "        Datastores are written as `catalog_dir / datastore_name.json`.\n",
      "    description : str, optional\n",
      "        A description of the datastore. If None, a default description will be used.\n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    esm_datastore | None\n",
      "        The datastore object, if it was requested to be opened. Otherwise, None.\n",
      "    \n",
      "    Raises\n",
      "    ------\n",
      "    TBC\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from access_nri_intake.experiment import use_datastore\n",
    "\n",
    "help(use_datastore)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5fe00ef5-601d-438e-bb30-4a2ff5ea068d",
   "metadata": {},
   "source": [
    "When calling `use_datastore`, you can:\n",
    "1. Not specify `catalog_dir`. If you do so, the catalog will be built in the `experiment_dir`. \n",
    "   - If you follow this approach, we recommend *not* configuring `datastore_name` - this will default to `experiment_datastore`(`.json`). This can be handy if you want to build an esm-datastore that you want to add to the main access-nri intake catalog easily.\n",
    "2. Specify `catalog_dir`. If you do so, we recommend:\n",
    "    - Creating a directory somewhere that you wish to keep these esm-datastores - likely a subdirectory within your home directory.\n",
    "    - Specifying `datastore_name` - all esm-datastores in the same directory must have unique names.\n",
    "\n",
    "\n",
    "Approach 1. may be more useful if you a. know where the experiment output is located, and b. would like to add your output to the main catalog eventually.\n",
    "\n",
    "Approach 2. may be more useful if you want to a. create a throwaway datastore, and b. have it be easily accessible whilst you work on it - and especially if you want to create multiple throwaway datastores. It may also be useful if you do not have write permissions to the directory where the model output is saved.\n",
    "\n",
    "Note that in Approach 2, you will still require the experiment output path if you want to update the datastore - however, you can use the `intake.open_esm_datastore` method above to open it without checking for updates.\n",
    "\n",
    "___\n",
    "\n",
    "In this tutorial, we follow Approach 2, demonstrating how to build and update the same datastore above, saving it to a subdirectory within our home directory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "80d141df-4f69-459a-9e33-ed9da45777d6",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[32m\u001b[22mGenerating esm-datastore for /g/data/ik11/outputs/access-om2/1deg_jra55_iaf_omip2_cycle6\u001b[0m\n",
      "\u001b[34m\u001b[22mBuilding esm-datastore...\u001b[0m\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n",
      "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.08/lib/python3.11/site-packages/access_nri_intake/source/utils.py:241: UserWarning: Time coordinate does not include bounds information. Guessing start and end times.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[32m\u001b[22mSucessfully built esm-datastore!\u001b[0m\n",
      "\u001b[34m\u001b[22mSaving esm-datastore to \u001b[36m\u001b[1m/home/603/as2285/catalog_dir\u001b[0m\n",
      "Successfully wrote ESM catalog json file to: file:///home/603/as2285/catalog_dir/demo_datastore.json\n",
      "\u001b[34m\u001b[22mHashing catalog to prevent unnecessary rebuilds.\n",
      "This may take some time...\u001b[0m\n",
      "\u001b[32m\u001b[22mCatalog sucessfully hashed!\u001b[0m\n",
      "\u001b[32m\u001b[22mDatastore sucessfully written to \u001b[36m\u001b[1m/home/603/as2285/catalog_dir/demo_datastore.json\u001b[32m\u001b[22m!\n",
      "\u001b[34m\u001b[22mPlease note that this has not added the datastore to the access-nri-intake catalog.\n",
      "To add to catalog, please run '\u001b[37m\u001b[1mscaffold_catalog_entry\u001b[34m\u001b[22m' for help on how to do so.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<p><strong>demo_datastore catalog with 11 dataset(s) from 2013 asset(s)</strong>:</p> <div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>unique</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>filename</th>\n",
       "      <td>1473</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>path</th>\n",
       "      <td>2013</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>file_id</th>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>frequency</th>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>start_date</th>\n",
       "      <td>855</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>end_date</th>\n",
       "      <td>854</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>variable</th>\n",
       "      <td>338</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>variable_long_name</th>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>variable_standard_name</th>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>variable_cell_methods</th>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>variable_units</th>\n",
       "      <td>131</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>realm</th>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>derived_variable</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from pathlib import Path\n",
    "\n",
    "EXPERIMENT_DIR = PATH # Path to experiment to catalog\n",
    "BUILDER = builders.AccessOm2Builder # Builder for the model type run\n",
    "CATALOG_DIR = Path(\"~/catalog_dir\").expanduser() # We'll save our datastore in a directory called catalog_dir in our home dir\n",
    "DATASTORE_NAME = \"demo_datastore\"\n",
    "\n",
    "# If catalog_dir doesn't exist, make it. If there is a file called `catalog_dir`, we'll need to delete it.\n",
    "if not CATALOG_DIR.exists() and not CATALOG_DIR.is_file():\n",
    "    CATALOG_DIR.mkdir() \n",
    "elif CATALOG_DIR.exists() and CATALOG_DIR.is_file():\n",
    "    raise RuntimeError(\"Please remove the file named 'catalog_dir' in your home directory\")\n",
    "\n",
    "\n",
    "esm_ds = use_datastore(\n",
    "    builder=BUILDER,\n",
    "    experiment_dir=EXPERIMENT_DIR,\n",
    "    catalog_dir=CATALOG_DIR,\n",
    "    datastore_name=DATASTORE_NAME\n",
    ")\n",
    "\n",
    "esm_ds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "23f498b7-a2a7-4bc4-ac9b-ba5fda58b74b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[34m\u001b[22mDatastore found in \u001b[36m\u001b[1m/home/603/as2285/catalog_dir\u001b[34m\u001b[22m, verifying datastore integrity...\u001b[0m\n",
      "\u001b[34m\u001b[22mParsing experiment dir...\u001b[0m\n",
      "\u001b[32m\u001b[22mDatastore integrity verified!\u001b[0m\n",
      "\u001b[32m\u001b[22mDatastore found in \u001b[36m\u001b[1m/home/603/as2285/catalog_dir/demo_datastore.json\u001b[32m\u001b[22m!\n",
      "\u001b[34m\u001b[22mPlease note that this has not added the datastore to the access-nri-intake catalog.\n",
      "To add to catalog, please run '\u001b[37m\u001b[1mscaffold_catalog_entry\u001b[34m\u001b[22m' for help on how to do so.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<p><strong>demo_datastore catalog with 11 dataset(s) from 2013 asset(s)</strong>:</p> <div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>unique</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>filename</th>\n",
       "      <td>1473</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>path</th>\n",
       "      <td>2013</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>file_id</th>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>frequency</th>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>start_date</th>\n",
       "      <td>855</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>end_date</th>\n",
       "      <td>854</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>variable</th>\n",
       "      <td>338</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>variable_long_name</th>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>variable_standard_name</th>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>variable_cell_methods</th>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>variable_units</th>\n",
       "      <td>131</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>realm</th>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>derived_variable</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# If we run the function again, it should pick up our existing datastore - and not rebuild it, saving time! \n",
    "esm_ds = use_datastore(\n",
    "    builder=BUILDER,\n",
    "    experiment_dir=EXPERIMENT_DIR,\n",
    "    catalog_dir=CATALOG_DIR,\n",
    "    datastore_name=DATASTORE_NAME\n",
    ")\n",
    "\n",
    "esm_ds"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a7ea305-5105-4005-950b-0e3b29903e91",
   "metadata": {},
   "source": [
    "Note that you can additionally access this functionality from the terminal, using the `build-esm-datastore` tool:\n",
    "___\n",
    "```bash\n",
    "$ module use /g/data/xp65/public/modules\n",
    "$ module load conda/analysis3-25.02\n",
    "$ build-esm-datastore --help\n",
    "usage: build-esm-datastore [-h] [--builder BUILDER] [--builder-kwargs [BUILDER_KWARGS ...]] [--expt-dir EXPT_DIR] [--cat-dir CAT_DIR] [--datastore-name DATASTORE_NAME]\n",
    "                           [--description DESCRIPTION]\n",
    "\n",
    "Build an esm-datastore by inspecting a directory containing model outputs. If no datastore exists, a new one will be created. If a datastore exists, its integrity will be\n",
    "verified, and the datastore regenerated if necessary.\n",
    "\n",
    "options:\n",
    "  -h, --help            show this help message and exit\n",
    "  --builder BUILDER     Builder to use to create the esm-datastore. Builders are defined the source.builders module. Currently available options are: AccessOm2Builder,\n",
    "                        AccessOm3Builder, Mom6Builder, AccessEsm15Builder, AccessCm2Builder. To build a datastore for a new model, please contact the ACCESS-NRI team.\n",
    "  --builder-kwargs [BUILDER_KWARGS ...]\n",
    "                        Additional keyword arguments to pass to the builder. Should be in the form of key=value.\n",
    "  --expt-dir EXPT_DIR   Directory containing the model outputs to be added to the esm-datastore. Defaults to the current working directory. Although builders support adding\n",
    "                        multiple directories, this tool only supports one directory at a time - at present.\n",
    "  --cat-dir CAT_DIR     Directory in which to place the catalog.json file. Defaults to the value of --expt-dir if not set.\n",
    "  --datastore-name DATASTORE_NAME\n",
    "                        Name of the datastore to use. If not provided, this will default to 'experiment_datastore'.\n",
    "  --description DESCRIPTION\n",
    "                        Description of the datastore. If not provided, a default description will be used: 'esm_datastore for the model output in {--expt-dir}'\n",
    "\n",
    "# Lets build the same datastore as above, but from the terminal\n",
    "\n",
    "$ build-esm-datastore --builder AccessOm2Builder --expt-dir /g/data/ik11/outputs/access-om2/1deg_jra55_iaf_omip2_cycle6 --cat-dir ~/catalog_dir\n",
    "\n",
    "Datastore found in /home/189/ct1163/catalog_dir, verifying datastore integrity...\n",
    "Parsing experiment dir...\n",
    "Datastore integrity verified!\n",
    "Datastore found in /home/189/ct1163/catalog_dir/experiment_datastore.json!\n",
    "Please note that this has not added the datastore to the access-nri-intake catalog.\n",
    "To add to catalog, please run 'scaffold-catalog-entry' for help on how to do so.\n",
    "To open the datastore, run `intake.open_esm_datastore('/home/189/ct1163/catalog_dir/experiment_datastore.json', columns_with_iterables=['variable'])` in a Python session.\n",
    "   \n",
    "```\n",
    "___\n",
    "\n",
    "Note that we only know *for sure, for every datastore* that the `variable` column has iterables in it - hence the instruction above. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bcbfc90d-1ca5-45d1-a5d7-5c76dbb3e9e8",
   "metadata": {},
   "source": [
    "You can additionally use `qsub` to submit a build-esm-datastore job to the compute nodes: if you wish to build datastores from the terminal, this is the preferred way to do so. The sample PBS script below shows how to do this:\n",
    "\n",
    "```bash\n",
    "$ cat build_my_datastore.sh\n",
    "\n",
    "#!/bin/bash -l\n",
    "\n",
    "#PBS -P iq82\n",
    "#PBS -l storage=gdata/xp65+gdata/ik11+gdata/cj50+gdata/p73+gdata/dk92+gdata/al33+gdata/rr3+gdata/fs38+gdata/oi10+gdata/hq89+gdata/py18+gdata/ig45+gdata/zz63+gdata/rt52 # Change these as necessary.\n",
    "#PBS -q normal\n",
    "#PBS -W block=true\n",
    "#PBS -l walltime=00:10:00\n",
    "#PBS -l mem=32gb\n",
    "#PBS -l ncpus=7\n",
    "#PBS -l wd\n",
    "#PBS -j oe\n",
    "#PBS -W umask=0022\n",
    "\n",
    "# These PBS flags should give us resources comparable to a large ARE instance. You may need to change storage flags - these are the storage resources necessary to run end-to-end build tests for the catalog, so *should* cover your use case \n",
    "\n",
    "\n",
    "\n",
    "########################################################################################### \n",
    "# Copyright 2022 ACCESS-NRI and contributors. See the top-level COPYRIGHT file for details.\n",
    "# SPDX-License-Identifier: Apache-2.0\n",
    "\n",
    "# Description:\n",
    "#   Generate access-nri intake datastore for a single experiment\n",
    "\n",
    "###########################################################################################\n",
    "\n",
    "set -e\n",
    "\n",
    "module use /g/data/xp65/public/modules\n",
    "module load conda/analysis3-25.02 \n",
    "module load openmpi\n",
    "\n",
    "build-esm-datastore --builder AccessOm2Builder --expt-dir /g/data/ik11/outputs/access-om2/1deg_jra55_iaf_omip2_cycle6 --cat-dir ~/catalog_dir\n",
    "\n",
    "$ qsub build_my_datastore.sh\n",
    "```"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:analysis3-25.08]",
   "language": "python",
   "name": "conda-env-analysis3-25.08-py"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}