docs/notebooks/extendxclim.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Extending xclim\n",
    "\n",
    "xclim tries to make it easy for users to add their own indices and indicators. The following goes into details on how to create _indices_ and document them so that xclim can parse most of the metadata directly. We then explain the multiple ways new _Indicators_ can be created and, finally, how we can regroup and structure them in virtual submodules.\n",
    "\n",
    "Central to xclim are the **Indicators**, objects computating indices over climate variables, but xclim also provides other modules:\n",
    "\n",
    "![modules](./Modules.svg)\n",
    "\n",
    "Where `subset` is a phantom module, kept for legacy code, as it only redirects the calls to `clisops.core.subset`.\n",
    "\n",
    "This introduction will focus on the Indicator/Indice part of xclim and how one can extend it by implementing new ones.\n",
    "\n",
    "\n",
    "## Indices vs Indicators\n",
    "\n",
    "Internally and in the documentation, xclim makes a distinction between \"indices\" and \"indicators\".\n",
    " \n",
    "### indice\n",
    "\n",
    " * A python function accepting DataArrays and other parameters (usually bultin types)\n",
    " * Returns one or several DataArrays. \n",
    " * Handles the units : checks input units and set proper CF-compliant output units. But doesn't usually prescribe specific units, the output will at minimum have the proper dimensionality.\n",
    " * Performs **no** other checks or set any (non-unit) metadata.\n",
    " * Accessible through [xclim.indices](../indices.rst).\n",
    " \n",
    "### indicator\n",
    "\n",
    " * An instance of a subclass of `xclim.core.indicator.Indicator` that wraps around an `indice` (stored in its `compute` property). \n",
    " * Returns one or several DataArrays.\n",
    " * Handles missing values, performs input data and metadata checks (see [usage](usage.ipynb#Health-checks-and-metadata-attributes)).\n",
    " * Always ouputs data in the same units.\n",
    " * Adds dynamically generated metadata to the output after computation.\n",
    " * Accessible through [xclim.indicators](../indicators_api.rst)\n",
    "\n",
    "Most metadata stored in the Indicators is parsed from the underlying indice documentation, so defining indices with complete documentation and an appropriate signature helps the process. The two next sections go into details on the definition of both objects.\n",
    "\n",
    "#### Call sequence\n",
    "\n",
    "The following graph shows the steps done when calling an Indicator. Attributes and methods of the Indicator object relating to those steps are listed on the right side.\n",
    "\n",
    "![indicator](Indicator.svg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Defining new indices\n",
    "\n",
    "The annotated example below shows the general template to be followed when defining proper _indices_. In the comments `Ind` is the indicator instance that would be created from this function.\n",
    "\n",
    "<div class=\"alert alert-info\">\n",
    "\n",
    "Note that it is not _needed_ to follow these standards when writing indices that will be wrapped in indicators. Problems in parsing will not raise errors at runtime, but might raise warnings and will result in Indicators with poorer metadata than expected by most users, especially those that dynamically use indicators in other applications where the code is inaccessible, like web services.\n",
    "    \n",
    "</div>\n",
    "\n",
    "![indice doc](Indice.svg)\n",
    "\n",
    "The following code is another example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import annotations\n",
    "\n",
    "import xarray as xr\n",
    "\n",
    "import xclim as xc\n",
    "from xclim.core.units import convert_units_to, declare_units\n",
    "from xclim.indices.generic import threshold_count\n",
    "\n",
    "\n",
    "@declare_units(tasmax=\"[temperature]\", thresh=\"[temperature]\")\n",
    "def tx_days_compare(\n",
    "    tasmax: xr.DataArray, thresh: str = \"0 degC\", op: str = \">\", freq: str = \"YS\"\n",
    "):\n",
    "    r\"\"\"Number of days where maximum daily temperature. is above or under a threshold.\n",
    "\n",
    "    The daily maximum temperature is compared to a threshold using a given operator and the number\n",
    "    of days where the condition is true is returned.\n",
    "\n",
    "    It assumes a daily input.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    tasmax : xarray.DataArray\n",
    "      Maximum daily temperature.\n",
    "    thresh : str\n",
    "      Threshold temperature to compare to.\n",
    "    op : {'>', '<'}\n",
    "      The operator to use.\n",
    "      # A fixed set of choices can be imposed. Only strings, numbers, booleans or None are accepted.\n",
    "    freq : str\n",
    "      Resampling frequency.\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    xarray.DataArray, [temperature]\n",
    "      Maximum value of daily maximum temperature.\n",
    "\n",
    "    Notes\n",
    "    -----\n",
    "    Let :math:`TX_{ij}` be the maximum temperature at day :math:`i` of period :math:`j`. Then the maximum\n",
    "    daily maximum temperature for period :math:`j` is:\n",
    "\n",
    "    .. math::\n",
    "\n",
    "        TXx_j = max(TX_{ij})\n",
    "\n",
    "    References\n",
    "    ----------\n",
    "    Smith, John and Tremblay, Robert, An dummy citation for examples in documentation. J. RTD. (2020).\n",
    "    \"\"\"\n",
    "    thresh = convert_units_to(thresh, tasmax)\n",
    "    out = threshold_count(tasmax, op, thresh, freq)\n",
    "    out.attrs[\"units\"] = \"days\"\n",
    "    return out"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Naming and conventions\n",
    "\n",
    "Variable names should correspond to CMIP6 variables, whenever possible. The file `xclim/data/variables.yml` lists all variables that xclim can use when generating indicators from yaml files (see below), and new indices should try to reflect these also. For new variables, the  `xclim.testing.get_all_CMIP6_variables` function downloads the official table of CMIP6 variables and puts everything in a dictionary. If possible, use variables names from this list, add them to `variables.yml` as needed.\n",
    "\n",
    "### Generic functions for common operations\n",
    "\n",
    "The [xclim.indices.generic](../indices.rst#generic-indices-submodule) submodule contains useful functions for common computations (like `threshold_count` or `select_resample_op`) and many basic indice functions, as defined by [clix-meta](https://github.com/clix-meta/clix-meta). In order to reduce duplicate code, their use is recommended for xclim's indices. As previously said, the units handling has to be made explicitly when non trivial, [xclim.core.units](../api.rst#unit-handling-module) also exposes a few helpers for that (like `convert_units_to`, `to_agg_units` or `rate2amount`).\n",
    "\n",
    "## Defining new indicators\n",
    "\n",
    "xclim's Indicators are instances of (subclasses of) `xclim.core.indicator.Indicator`. While they are the central to xclim, their construction can be somewhat tricky as a lot happens backstage. Essentially, they act as self-aware functions, taking a set of input variables (DataArrays) and parameters (usually strings, integers or floats), performing some health checks on them and returning one or multiple DataArrays, with CF-compliant (and potentially translated) metadata attributes, masked according to a given missing value set of rules.\n",
    "They define the following key attributes:\n",
    "\n",
    "* the `identifier`, as string that uniquely identifies the indicator, usually all caps.\n",
    "* the `realm`, one of \"atmos\", \"land\", \"seaIce\" or \"ocean\", classifying the domain of use of the indicator.\n",
    "* the `compute` function that returns one or more DataArrays, the \"indice\",\n",
    "* the `cfcheck` and `datacheck` methods that make sure the inputs are appropriate and valid.\n",
    "* the `missing` function that masks elements based on null values in the input.\n",
    "* all metadata attributes that will be attributed to the output and that document the indicator:\n",
    "    - Indicator-level attribute are : `title`, `abstract`, `keywords`, `references` and `notes`.\n",
    "    - Ouput variables attributes (respecting CF conventions) are: `var_name`, `standard_name`, `long_name`, `units`, `cell_methods`, `description` and `comment`. \n",
    "\n",
    "Output variables attributes are regrouped in `Indicator.cf_attrs` and input parameters are documented in `Indicator.parameters`.\n",
    "\n",
    "A particularity of Indicators is that each instance corresponds to a single class: when creating a new indicator, a new class is automatically created. This is done for easy construction of indicators based on others, like shown further down.\n",
    "\n",
    "See the [class documentation](../api.rst#indicator-tools) for more info on the meaning of each attribute. The [indicators](https://github.com/Ouranosinc/xclim/tree/master/xclim/indicators) module contains over 50 examples of indicators to draw inspiration from.\n",
    "\n",
    "### Identifier vs python name\n",
    "\n",
    "An indicator's identifier is **not** the same as the name it has within the python module. For example, `xc.atmos.relative_humidity` has `hurs` as its identifier. As explained below, indicator _classes_ can be accessed through `xc.core.indicator.registry` with their _identifier_.\n",
    "\n",
    "### Metadata parsing vs explicit setting\n",
    "\n",
    "As explained above, most metadata can be parsed from the indice's signature and docstring. Otherwise, it can always be set when creating a new Indicator instance *or* a new subclass. When _creating_ an indicator, output metadata attributes can be given as strings, or list of strings in the case of indicator returning multiple outputs. However, they are stored in the `cf_attrs` list of dictionaries on the instance.\n",
    "\n",
    "### Internationalization of metadata\n",
    "\n",
    "xclim offers the possibility to translate the main Indicator metadata field and automatically add the translations to the outputs. The mechnanic is explained in the [Internationalization](../internationalization.rst) page.\n",
    "\n",
    "### Inputs and checks\n",
    "\n",
    "xclim decides which input arguments of the indicator's call function are considered _variables_ and which are _parameters_ using the annotations of the underlying indice (the `compute` method). Arguments annotated with the `xarray.DataArray` type are considered _variables_ and can be read from the dataset passed in `ds`.\n",
    "\n",
    "### Indicator creation\n",
    "\n",
    "There a two ways for creating indicators:\n",
    "\n",
    "1) By initializing an existing indicator (sub)class\n",
    "2) From a dictionary\n",
    "\n",
    "The first method is best when defining indicators in scripts of external modules and are explained here. The second is best used when building virtual modules through YAML files, and is explained further down and in the [submodule doc](../api.rst#indicator-tools).\n",
    "\n",
    "Creating a new indicator that simply modifies a few metadata output of an existing one is a simple call like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from xclim.core.indicator import registry\n",
    "from xclim.core.utils import wrapped_partial\n",
    "\n",
    "# An indicator based on tg_mean, but returning Celsius and fixed on annual resampling\n",
    "tg_mean_c = registry[\"TG_MEAN\"](\n",
    "    identifier=\"tg_mean_c\",\n",
    "    units=\"degC\",\n",
    "    title=\"Mean daily mean temperature but in degC\",\n",
    "    parameters=dict(freq=\"YS\"),  # We inject the freq arg.\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(tg_mean_c.__doc__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The registry is a dictionary mapping indicator identifiers (in uppercase) to their class. This way, we could subclass `tg_mean` to create our new indicator. `tg_mean_c` is the exact same as `atmos.tg_mean`, but outputs the result in Celsius instead of Kelvins, has a different title and removes control over the `freq` argument, resampling to \"YS\". The `identifier` keyword is here needed in order to differentiate the new indicator from `tg_mean` itself. If it wasn't given, a warning would have been raised and further subclassing of  `tg_mean` would have in fact subclassed `tg_mean_c`, which is not wanted!\n",
    "\n",
    "By default, indicator classes are registered in `xclim.core.indicator.registry`, using their identifier which is prepended by the indicator's module **if** that indicator is declared outisde xclim. An \"child\" indicator inherits it's module from its parent:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tg_mean_c.__module__ == xc.atmos.tg_mean.__module__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To create indicators with a different module, for example, in a goal to differentiate them in the registry, two methods can be used : passing `module` to the constructor, or using conventional class inheritance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Passing module\n",
    "tg_mean_c2 = registry[\"TG_MEAN_C\"](module=\"test\")  # we didn't change the identifier!\n",
    "print(tg_mean_c2.__module__)\n",
    "\"test.TG_MEAN_C\" in registry"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Conventionnal class inheritance, uses the current module name\n",
    "class TG_MEAN_C3(registry[\"TG_MEAN_C\"]):\n",
    "    pass  # nothing to change really\n",
    "\n",
    "\n",
    "tg_mean_c3 = TG_MEAN_C3()\n",
    "\n",
    "print(tg_mean_c3.__module__)\n",
    "\"__main__.TG_MEAN_C\" in registry"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While the former method is shorter, the latter is what xclim uses internally as it provides some clean code structure. See [the code in the github repo](https://github.com/Ouranosinc/xclim/tree/master/xclim/indicators).\n",
    "\n",
    "## Virtual modules\n",
    "\n",
    "`xclim` gives users the ability to generate their own modules from existing indices library. These mappings can help in emulating existing libraries (such as ICCLIM), with the added benefit of CF-compliant metadata, multilingual metadata support, and optimized calculations using federated resources (using Dask). This can be used for example to tailor existing indices with predefined thresholds without having to rewrite indices.\n",
    "\n",
    "Presently, xclim is capable of approximating the indices developed in [ICCLIM](https://icclim.readthedocs.io/en/stable/explanation/climate_indices.html), [ANUCLIM](https://fennerschool.anu.edu.au/files/anuclim61.pdf) and [clix-meta](https://github.com/clix-meta/clix-meta) and is open to contributions of new indices and library mappings.\n",
    "\n",
    "This notebook serves as an example of how one might go about creating their own library of mapped indices. Two ways are possible:\n",
    "\n",
    "1. From a YAML file (recommended way)\n",
    "2. From a mapping (dictionary) of indicators\n",
    "\n",
    "### YAML file\n",
    "\n",
    "The first method is based on the YAML syntax proposed by `clix-meta`, expanded to xclim's needs. The full documentation on that syntax is [here](../api.rst#indicator-tools). This notebook shows an example different complexities of indicator creation. It creates a minimal python module defining a indice, creates a YAML file with the metadata for several indicators and then parses it into xclim."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbsphinx": "hidden"
   },
   "outputs": [],
   "source": [
    "from pygments import highlight\n",
    "\n",
    "# Workaround absence of syntax highlighting in notebooks\n",
    "from pygments.formatters import Terminal256Formatter\n",
    "from pygments.lexers import JsonLexer, PythonLexer, YamlLexer\n",
    "\n",
    "with open(\"example.py\") as f:\n",
    "    pydata = f.read()\n",
    "\n",
    "with open(\"example.yml\") as f:\n",
    "    ymldata = f.read()\n",
    "\n",
    "with open(\"example.fr.json\") as f:\n",
    "    jsondata = f.read()\n",
    "\n",
    "highlighted_py = highlight(pydata, PythonLexer(), Terminal256Formatter(style=\"manni\"))\n",
    "highlighted_yaml = highlight(ymldata, YamlLexer(), Terminal256Formatter(style=\"manni\"))\n",
    "highlighted_json = highlight(jsondata, JsonLexer(), Terminal256Formatter(style=\"manni\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# These variables were generated by a hidden cell above that syntax-colored them.\n",
    "print(\"Content of example.py :\")\n",
    "print(highlighted_py)\n",
    "print(\"\\n\\nContent of example.yml :\")\n",
    "print(highlighted_yaml)\n",
    "print(\"\\n\\nContent of example.fr.json :\")\n",
    "print(highlighted_json)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`example.yml` created a module of 4 indicators. \n",
    "\n",
    "<div class=\"alert alert-info\">\n",
    "    \n",
    "Values of the `base` arguments are the **identifier** of the associated indicators, and those can be different than their name within the python modules. For example, `xc.atmos.relative_humidity` has `HURS` as identifier. One can always access `xc.atmos.relative_humidity.identifier` to get the correct name to use.\n",
    "    \n",
    "</div>\n",
    "\n",
    "- `RX1day` is simply the same as  `registry['RX1DAY']`, but with an updated `long_name`.\n",
    "- `RX5day` is based on `registry['MAX_N_DAY_PRECIPITATION_AMOUNT']`, changed the `long_name` and injects the `window` and `freq` arguments.\n",
    "- `R75pdays` is based on `registry['DAYS_OVER_PRECIP_THRESH']`, injects the `thresh` argument and changes the description of the `per` argument.\n",
    "- `fd` is a more complex example. As there were no `base:` entry, the `Daily` class serves as a base. As it is pretty much empty, a lot has to be given explicitly:\n",
    "    * Many output metadata fields are given\n",
    "    * A compute function name if given (here it refers to a function in `xclim.indices.generic`).\n",
    "    * Some parameters are injected, the default for `freq` is modified.\n",
    "    * The input variable `data` is mapped to a known variable. Functions in `xclim.indices.generic` are indeed generic. Here we tell xclim that the `data` argument is minimum daily temperature. This will set the proper units check, default value and CF-compliance checks.\n",
    "- `R95p` is similar to `fd` but here the `compute` is not defined in `xclim` but rather in  `example.py`. Also, the custom function returns two outputs, so the `output` section is a list of mappings rather than a mapping directly.\n",
    "- `R99p` is the same as `R95p` but changes the injected value. In order to avoid rewriting the output metadata, and allowed periods, we based it on `R95p` : as the latter was defined within the current yaml file, the identifier is prefixed by a dot (.).\n",
    "\n",
    "\n",
    "Additionnaly, the yaml specified a `realm` and `references` to be used on all indices and provided a submodule docstring. Creating the module is then simply:\n",
    "\n",
    "Finally, french translations for the main attributes and the new indicaters are given in `example.fr.json`. Even though new indicator objects are created for each yaml entry, non-specified translations are taken from the base classes if missing in the `json` file.\n",
    "\n",
    "Note that all files are named the same way : `example.<ext>`, with the translations having an additionnal suffix giving the locale name. In the next cell, we build the module by passing only the path without extension. This absence of extension is what tells xclim to try to parse a module (`*.py`) and custom translations (`*.<locale>.json`). Those two could also be read beforehand and passed through the  `indices=` and `translations=` arguments.\n",
    "\n",
    "\n",
    "#### Validation of the YAML file\n",
    "Using [yamale](https://github.com/23andMe/Yamale), it is possible to check if the yaml file is valid. xclim ships with a schema (in `xclim/data/schema.yml`) file. The file can be located with:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from importlib.resources import path\n",
    "\n",
    "with path(\"xclim.data\", \"schema.yml\") as f:\n",
    "    print(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And the validation can be executed either in a python session:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import yamale\n",
    "\n",
    "with path(\"xclim.data\", \"schema.yml\") as f:\n",
    "    schema = yamale.make_schema(f)\n",
    "    data = yamale.make_data(\"example.yml\")  # in the current folder\n",
    "yamale.validate(schema, data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No errors means it passed. The validation can also be run through the command line with:\n",
    "\n",
    "```bash\n",
    "yamale -s path/to/schema.yml path/to/module.yml\n",
    "```\n",
    "\n",
    "#### Loading the module and computating of the indices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import xclim as xc\n",
    "\n",
    "example = xc.core.indicator.build_indicator_module_from_yaml(\"example\", mode=\"raise\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(example.__doc__)\n",
    "print(\"--\")\n",
    "print(xc.indicators.example.R99p.__doc__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Useful for using this technique in large projects, we can iterate over the indicators like so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from xclim.testing import open_dataset\n",
    "\n",
    "ds = open_dataset(\"ERA5/daily_surface_cancities_1990-1993.nc\")\n",
    "ds2 = ds.assign(\n",
    "    pr_per=xc.core.calendar.percentile_doy(ds.pr, window=5, per=75).isel(\n",
    "        percentiles=0, drop=True\n",
    "    )\n",
    ")\n",
    "\n",
    "outs = []\n",
    "with xc.set_options(metadata_locales=\"fr\"):\n",
    "    for name, ind in example.iter_indicators():\n",
    "        print(f\"Indicator: {name}\")\n",
    "        print(f\"\\tIdentifier: {ind.identifier}\")\n",
    "        print(f\"\\tTitle: {ind.title}\")\n",
    "        out = ind(ds=ds2)  # Use all default arguments and variables from the dataset\n",
    "        if isinstance(out, tuple):\n",
    "            outs.extend(out)\n",
    "        else:\n",
    "            outs.append(out)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`out` contains all the computed indices, with translated metadata.\n",
    "Note that this merge doesn't make much sense with the current list of indicators since they have different frequencies (`freq`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "out = xr.merge(outs)\n",
    "out.attrs = {\n",
    "    \"title\": \"Indicators computed from the example module.\"\n",
    "}  # Merge puts the attributes of the first variable, we don't want that.\n",
    "out"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mapping of indicators\n",
    "\n",
    "For more complex mappings, submodules can be constructed from Indicators directly. This is not the recommended way, but can sometimes be a workaround when the YAML version is lacking features."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from xclim.core.indicator import build_indicator_module, registry\n",
    "from xclim.core.utils import wrapped_partial\n",
    "\n",
    "mapping = dict(\n",
    "    egg_cooking_season=registry[\"MAXIMUM_CONSECUTIVE_WARM_DAYS\"](\n",
    "        module=\"awesome\",\n",
    "        compute=xc.indices.maximum_consecutive_tx_days,\n",
    "        parameters=dict(thresh=\"35 degC\"),\n",
    "        long_name=\"Season for outdoor egg cooking.\",\n",
    "    ),\n",
    "    fish_feeling_days=registry[\"WETDAYS\"](\n",
    "        module=\"awesome\",\n",
    "        compute=xc.indices.wetdays,\n",
    "        parameters=dict(thresh=\"14.0 mm/day\"),\n",
    "        long_name=\"Days where we feel we are fishes\",\n",
    "    ),\n",
    "    sweater_weather=xc.atmos.tg_min.__class__(module=\"awesome\"),\n",
    ")\n",
    "\n",
    "awesome = build_indicator_module(\n",
    "    name=\"awesome\",\n",
    "    objs=mapping,\n",
    "    doc=\"\"\"\n",
    "        =========================\n",
    "        My Awesome Custom indices\n",
    "        =========================\n",
    "        There are only 3 indices that really matter when you come down to brass tacks.\n",
    "        This mapping library exposes them to users who want to perform real deal \n",
    "        climate science.\n",
    "        \"\"\",\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(xc.indicators.awesome.__doc__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's look at our new awesome module\n",
    "print(awesome.__doc__)\n",
    "for name, ind in awesome.iter_indicators():\n",
    "    print(f\"{name} : {ind}\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.4"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}