diff --git a/docs/src/3_minutes.md b/docs/src/3_minutes.md
index a17f0a732..918fd2702 100644
--- a/docs/src/3_minutes.md
+++ b/docs/src/3_minutes.md
@@ -6,9 +6,13 @@ This is a _very_ quick introduction to how Temporian works. For a complete tour
 
 The most basic unit of data in Temporian is an **event**. An event consists of a timestamp and a set of feature values.
 
-Events are not handled individually. Instead, events are grouped together into an **[EventSet][temporian.EventSet]**.
+Events are not handled individually. Instead, events are grouped together into an **[`EventSet`][temporian.EventSet]**.
 
-[`EventSets`][temporian.EventSet] are the main data structure in Temporian, and represent **[multivariate time sequences](../user_guide/#what-is-temporal-data)**. Note that "multivariate" indicates that each event in the time sequence holds several feature values, and "sequence" indicates that the events are not necessarily sampled at a uniform rate (in which case we would call it a time "series").
+[`EventSets`][temporian.EventSet] are the main data structure in Temporian, and represent **[multivariate and multi-index time sequences](../user_guide/#what-is-temporal-data)**. Let's break that down:
+
+- "multivariate" indicates that each event in the time sequence holds several feature values.
+- "multi-index" indicates that the events can represent hierarchical data, and be therefore grouped by one or more of their features' values.
+- "sequence" indicates that the events are not necessarily sampled at a uniform rate (in which case we would call it a time "series").
 
 You can create an [`EventSet`][temporian.EventSet] from a pandas DataFrame, NumPy arrays, CSV files, and more. Here is an example of an [`EventSet`][temporian.EventSet] containing four events and three features:
 
@@ -27,40 +31,38 @@ You can create an [`EventSet`][temporian.EventSet] from a pandas DataFrame, NumP
 
 An [`EventSet`][temporian.EventSet] can hold one or several time sequences, depending on what its **[index](../user_guide/#index-horizontal-and-vertical-operators)** is.
 
-If the [`EventSet`][temporian.EventSet] has no index, it will hold a single time sequence, which means that all events will be considered part of the same group and will interact with each other when operators are applied to the [`EventSet`][temporian.EventSet].
+If the [`EventSet`][temporian.EventSet] has no index, it will hold a single multivariate time sequence, which means that all events will be considered part of the same group and will interact with each other when operators are applied to the [`EventSet`][temporian.EventSet].
 
-If the [`EventSet`][temporian.EventSet] has one (or many) indexes, it will hold one time sequence for each unique value (or unique combination of values) of the indexes, the events will be grouped by their index key, and operators applied to the [`EventSet`][temporian.EventSet] will be applied to each time sequence independently.
+If the [`EventSet`][temporian.EventSet] has one (or many) indexes, its events will be grouped by their indexes' values, so it will hold one multivariate time sequence for each unique value (or unique combination of values) of its indexes, and most operators applied to the [`EventSet`][temporian.EventSet] will be applied to each time sequence independently.
 
-## Graph, EventSetNodes, and Operators
+## Operators
 
-There are two big phases in any Temporian script: graph **definition** and **evaluation**. This is a common pattern in computing libraries, and it allows us to perform optimizations before the graph is run, share Temporian programs across different platforms, and more.
+Processing operations are performed by **operators**. For instance, the `tp.simple_moving_average()` operator computes the [simple moving average](https://en.wikipedia.org/wiki/Moving_average) of each feature in an [`EventSet`][temporian.EventSet].
 
-A graph is created by using **operators**. For example, the [`tp.simple_moving_average()`][temporian.simple_moving_average] operator computes the [simple moving average](https://en.wikipedia.org/wiki/Moving_average) of each feature in an [`EventSet`][temporian.EventSet]. You can find documentation for all available operators [here](../reference/).
+The list of all available operators is available in the [API Reference](./reference/).
 
-Note that when calling operators you are only defining the graph - i.e., you are telling Temporian what operations you want to perform on your data, but those operations are not yet being performed.
+```python
+>>> # Compute the 2-day simple moving average of the EventSet defined above
+>>> sma = tp.simple_moving_average(evset, window_length=tp.duration.days(2))
 
-Operators are not applied directly to [`EventSets`][temporian.EventSet], but to **[EventSetNodes][temporian.EventSetNode]**. You can think of an [`EventSetNode`][temporian.EventSetNode] as the placeholder for an [`EventSet`][temporian.EventSet] in the graph. When applying operators to [`EventSetNodes`][temporian.EventSetNode], you get back new [`EventSetNodes`][temporian.EventSetNode] that are placeholders for the results of those operations. You can create arbitrarily complex graphs by combining operators and [`EventSetNodes`][temporian.EventSetNode].
+>>> # Remove index to get a flat EventSet
+>>> reindexed = tp.drop_index(sma)
 
-```python
->>> # Obtain the EventSetNode corresponding to the EventSet we created above
->>> source = evset.node()
->>>
->>> # Apply operators to existing EventSetNodes to generate new EventSetNodes
->>> addition = source["feature_1"] + source["feature_3"]
->>> addition_lagged = tp.lag(addition, duration=tp.duration.days(7))
+>>> # Subtract feature_1 from feature_3
+>>> sub = reindexed["feature_3"] - reindexed["feature_1"]
 
-```
+>>> # Plot the resulting EventSet
+>>> sub.plot()
 
-<!-- TODO: add image of the generated graph -->
+```
 
-Your graph can now be run by calling [`.run()`][temporian.EventSetNode.run] on any [`EventSetNode`][temporian.EventSetNode] in the graph, which will perform all necessary operations and return the resulting [`EventSet`][temporian.EventSet].
+## Graph mode
 
-```python
->>> result = addition_lagged.run(evset)
+Temporian works in **eager mode** out of the box, which means that when you call an operator on an [`EventSet`][temporian.EventSet] you get back the result of that operation immediately as a new [`EventSet`][temporian.EventSet].
 
-```
+Eager execution is easy to grasp, and fits most small data use cases. However, for big data, **graph mode** allows Temporian to perform optimizations on the computation graph that is defined when operators are applied on [`EventSets`][temporian.EventSet]. Graph mode also enables the serialization of Temporian programs, for later use in other platforms or distributed compute environments.
 
-Note that you need to pass the [`EventSets`][temporian.EventSet] that correspond to the source [`EventSetNodes`][temporian.EventSetNode] in the graph to [`.run()`][temporian.EventSetNode.run] (since those are not part of the graph definition). Also, several [`EventSetNodes`][temporian.EventSetNode] can be run at the same time by calling [`tp.run()`][temporian.run] directly.
+To learn how graph mode works, check out **[Eager mode vs Graph mode](./user_guide.ipynb#eager-mode-vs-graph-mode)** in the User Guide.
 
 🥳 Congratulations! You're all set to write your first pieces of Temporian code.
 
diff --git a/docs/src/user_guide.ipynb b/docs/src/user_guide.ipynb
index c2ccc4ed4..8b068e5f0 100644
--- a/docs/src/user_guide.ipynb
+++ b/docs/src/user_guide.ipynb
@@ -1,3119 +1,3119 @@
 {
- "cells": [
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "4e767688-0f90-47a7-baf0-b8042e282746",
-   "metadata": {},
-   "source": [
-    "# User Guide\n",
-    "\n",
-    "This is a complete tour of Temporian's capabilities. For a brief introduction to how the library works, please refer to [3 minutes to Temporian](./3_minutes).\n"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "d2b71b95-5268-46ca-98e3-83b473f9b518",
-   "metadata": {},
-   "source": [
-    "## What is temporal data?\n",
-    "\n",
-    "In Temporian, there is only one type of data: **multivariate multi-index time sequences** (MMITS). MMITS extends many commonly used data formats such as time-series and transactions to allow multi-variate data, non-uniform sampling, non-aligned sampling, and hierarchically-structured data. In that, MMITSs are particularly well suited to represent classical time-series, but also transactions, logs, sparse events, asynchronous measurements, and hierarchical records.\n",
-    "\n",
-    "<!-- TODO: add plot -->"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "d64627bf",
-   "metadata": {
-    "cell_marker": "\"\"\"",
-    "lines_to_next_cell": 0
-   },
-   "source": [
-    "## Events and EventSets\n",
-    "\n",
-    "The unit of data in Temporian is referred to as an _event_. An event consists of a timestamp and a set of feature values.\n",
-    "\n",
-    "Here is an example of an event:\n",
-    "\n",
-    "```\n",
-    "timestamp: 2023-02-05\n",
-    "feature_1: 0.5\n",
-    "feature_2: \"red\"\n",
-    "feature_3: 10\n",
-    "```\n",
-    "\n",
-    "Events are not handled individually. Instead, events are grouped together into [EventSet][temporian.EventSet]s. When representing an `EventSet`, it is convenient to group similar features together and to sort them according to the timestamps in increasing order.\n",
-    "\n",
-    "Here is an example of an `EventSet` containing four events and three features:\n",
-    "\n",
-    "```\n",
-    "timestamp: [04-02-2023, 06-02-2023, 07-02-2023, 07-02-2023]\n",
-    "feature_1: [0.5, 0.6, NaN, 0.9]\n",
-    "feature_2: [\"red\", \"blue\", \"red\", \"blue\"]\n",
-    "feature_3:  [10, -1, 5, 5]\n",
-    "```\n",
-    "\n",
-    "**Remarks:**\n",
-    "\n",
-    "- All values for a given feature are of the same data type. For instance, `feature_1` is float64 while `feature_2` is a string.\n",
-    "- Many operators interpret the value NaN (for _not a number_) as missing.\n",
-    "- Timestamps are not necessarily uniformly sampled.\n",
-    "- The same timestamp can be repeated.\n",
-    "- The events withing an EventSet are sampled synchronously. However, different EventSets might be sampled differently.\n",
-    "\n",
-    "In the next code examples, variables with names like `evset` refer to an `EventSet`.\n",
-    "\n",
-    "You can create an `EventSet` as follows:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "1d23b4c0",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-07-12T19:18:35.767580Z",
-     "iopub.status.busy": "2023-07-12T19:18:35.767381Z",
-     "iopub.status.idle": "2023-07-12T19:18:44.015701Z",
-     "shell.execute_reply": "2023-07-12T19:18:44.014530Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "import temporian as tp\n",
-    "import pandas as pd\n",
-    "import numpy as np\n",
-    "\n",
-    "evset = tp.event_set(\n",
-    "\ttimestamps=[\"2023-02-04\",\"2023-02-06\",\"2023-02-07\",\"2023-02-07\"],\n",
-    "\tfeatures={\n",
-    "        \"feature_1\": [0.5, 0.6, np.nan, 0.9],\n",
-    "        \"feature_2\": [\"red\", \"blue\", \"red\", \"blue\"],\n",
-    "        \"feature_3\":  [10, -1, 5, 5],\n",
-    "\t}\n",
-    ")"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "3678cc72",
-   "metadata": {
-    "cell_marker": "\"\"\"",
-    "lines_to_next_cell": 0
-   },
-   "source": [
-    "\n",
-    "`EventSets` can be printed."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "17c712f6",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-07-12T19:18:44.019104Z",
-     "iopub.status.busy": "2023-07-12T19:18:44.018296Z",
-     "iopub.status.idle": "2023-07-12T19:18:44.023020Z",
-     "shell.execute_reply": "2023-07-12T19:18:44.022309Z"
-    }
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "indexes: []\n",
-      "features: [('feature_1', float64), ('feature_2', str_), ('feature_3', int64)]\n",
-      "events:\n",
-      "     (4 events):\n",
-      "        timestamps: [1.6755e+09 1.6756e+09 1.6757e+09 1.6757e+09]\n",
-      "        'feature_1': [0.5 0.6 nan 0.9]\n",
-      "        'feature_2': [b'red' b'blue' b'red' b'blue']\n",
-      "        'feature_3': [10 -1  5  5]\n",
-      "memory usage: 0.8 kB\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(evset)"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "a09dfdad",
-   "metadata": {
-    "cell_marker": "\"\"\"",
-    "lines_to_next_cell": 0
-   },
-   "source": [
-    "`EventSets` can be plotted."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "e3f29b64",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-07-12T19:18:44.025430Z",
-     "iopub.status.busy": "2023-07-12T19:18:44.025215Z",
-     "iopub.status.idle": "2023-07-12T19:18:44.686537Z",
-     "shell.execute_reply": "2023-07-12T19:18:44.685455Z"
-    }
-   },
-   "outputs": [
+  "cells": [
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "4e767688-0f90-47a7-baf0-b8042e282746",
+      "metadata": {},
+      "source": [
+        "# User Guide\n",
+        "\n",
+        "This is a complete tour of Temporian's capabilities. For a brief introduction to how the library works, please refer to [3 minutes to Temporian](./3_minutes).\n"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "d2b71b95-5268-46ca-98e3-83b473f9b518",
+      "metadata": {},
+      "source": [
+        "## What is temporal data?\n",
+        "\n",
+        "In Temporian, there is only one type of data: **multivariate multi-index time sequences** (MMITS). MMITS extends many commonly used data formats such as time-series and transactions to allow multi-variate data, non-uniform sampling, non-aligned sampling, and hierarchically-structured data. In that, MMITSs are particularly well suited to represent classical time-series, but also transactions, logs, sparse events, asynchronous measurements, and hierarchical records.\n",
+        "\n",
+        "<!-- TODO: add plot -->"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "d64627bf",
+      "metadata": {
+        "cell_marker": "\"\"\"",
+        "lines_to_next_cell": 0
+      },
+      "source": [
+        "## Events and EventSets\n",
+        "\n",
+        "The unit of data in Temporian is referred to as an _event_. An event consists of a timestamp and a set of feature values.\n",
+        "\n",
+        "Here is an example of an event:\n",
+        "\n",
+        "```\n",
+        "timestamp: 2023-02-05\n",
+        "feature_1: 0.5\n",
+        "feature_2: \"red\"\n",
+        "feature_3: 10\n",
+        "```\n",
+        "\n",
+        "Events are not handled individually. Instead, events are grouped together into [EventSet][temporian.EventSet]s. When representing an `EventSet`, it is convenient to group similar features together and to sort them according to the timestamps in increasing order.\n",
+        "\n",
+        "Here is an example of an `EventSet` containing four events and three features:\n",
+        "\n",
+        "```\n",
+        "timestamp: [04-02-2023, 06-02-2023, 07-02-2023, 07-02-2023]\n",
+        "feature_1: [0.5, 0.6, NaN, 0.9]\n",
+        "feature_2: [\"red\", \"blue\", \"red\", \"blue\"]\n",
+        "feature_3:  [10, -1, 5, 5]\n",
+        "```\n",
+        "\n",
+        "**Remarks:**\n",
+        "\n",
+        "- All values for a given feature are of the same data type. For instance, `feature_1` is float64 while `feature_2` is a string.\n",
+        "- Many operators interpret the value NaN (for _not a number_) as missing.\n",
+        "- Timestamps are not necessarily uniformly sampled.\n",
+        "- The same timestamp can be repeated.\n",
+        "- The events withing an EventSet are sampled synchronously. However, different EventSets might be sampled differently.\n",
+        "\n",
+        "In the next code examples, variables with names like `evset` refer to an `EventSet`.\n",
+        "\n",
+        "You can create an `EventSet` as follows:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "id": "1d23b4c0",
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2023-07-12T19:18:35.767580Z",
+          "iopub.status.busy": "2023-07-12T19:18:35.767381Z",
+          "iopub.status.idle": "2023-07-12T19:18:44.015701Z",
+          "shell.execute_reply": "2023-07-12T19:18:44.014530Z"
+        }
+      },
+      "outputs": [],
+      "source": [
+        "import temporian as tp\n",
+        "import pandas as pd\n",
+        "import numpy as np\n",
+        "\n",
+        "evset = tp.event_set(\n",
+        "\ttimestamps=[\"2023-02-04\",\"2023-02-06\",\"2023-02-07\",\"2023-02-07\"],\n",
+        "\tfeatures={\n",
+        "        \"feature_1\": [0.5, 0.6, np.nan, 0.9],\n",
+        "        \"feature_2\": [\"red\", \"blue\", \"red\", \"blue\"],\n",
+        "        \"feature_3\":  [10, -1, 5, 5],\n",
+        "\t}\n",
+        ")"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "3678cc72",
+      "metadata": {
+        "cell_marker": "\"\"\"",
+        "lines_to_next_cell": 0
+      },
+      "source": [
+        "\n",
+        "`EventSets` can be printed."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 2,
+      "id": "17c712f6",
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2023-07-12T19:18:44.019104Z",
+          "iopub.status.busy": "2023-07-12T19:18:44.018296Z",
+          "iopub.status.idle": "2023-07-12T19:18:44.023020Z",
+          "shell.execute_reply": "2023-07-12T19:18:44.022309Z"
+        }
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "indexes: []\n",
+            "features: [('feature_1', float64), ('feature_2', str_), ('feature_3', int64)]\n",
+            "events:\n",
+            "     (4 events):\n",
+            "        timestamps: [1.6755e+09 1.6756e+09 1.6757e+09 1.6757e+09]\n",
+            "        'feature_1': [0.5 0.6 nan 0.9]\n",
+            "        'feature_2': [b'red' b'blue' b'red' b'blue']\n",
+            "        'feature_3': [10 -1  5  5]\n",
+            "memory usage: 0.8 kB\n",
+            "\n"
+          ]
+        }
+      ],
+      "source": [
+        "print(evset)"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "a09dfdad",
+      "metadata": {
+        "cell_marker": "\"\"\"",
+        "lines_to_next_cell": 0
+      },
+      "source": [
+        "`EventSets` can be plotted."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 3,
+      "id": "e3f29b64",
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2023-07-12T19:18:44.025430Z",
+          "iopub.status.busy": "2023-07-12T19:18:44.025215Z",
+          "iopub.status.idle": "2023-07-12T19:18:44.686537Z",
+          "shell.execute_reply": "2023-07-12T19:18:44.685455Z"
+        }
+      },
+      "outputs": [
+        {
+          "data": {
+            "image/png": "iVBORw0KGgoAAAANSUhEUgAAA/UAAAG4CAYAAAAE4sdiAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABmKElEQVR4nO3de3xU9Z3/8ffAYADJpAjGgCRgDOBCMBeFnz/vl2V1rRtSqaIrykUutta26touWovUFqzVWqtbAbGoi6Uo2BZXa70h4IoChUAFRSOERCEEYswEQmIu398f/JyaEiCXA2fOJ6/n4zEPyWTmzIe8GnY/yclJyDnnBAAAAAAAAqeT3wMAAAAAAIC2YakHAAAAACCgWOoBAAAAAAgolnoAAAAAAAKKpR4AAAAAgIBiqQcAAAAAIKBY6gEAAAAACCiWegAAAAAAAirs9wDHWmNjo3bs2KHExESFQiG/xwEAAAAA4CDOOVVVValv377q1OnQ34/vcEv9jh07lJqa6vcYAAAAAAAcUUlJifr163fI98fVUv/RRx9p3Lhx2rNnj5KSkvTkk09q6NChTR7T2NioH/zgB3r55ZdVX1+vc845R4899piOO+64Fr1GYmKipAMfmEgk4vnfwWulpaVKSUnxewy0Ex1toKMdtLSBjjbQ0Q5a2mC94+5ojZ5d+4muPrOfTox09Xucw4pGo0pNTY3tsIcSV0v91KlTNWXKFI0fP16LFy/W+PHjtWbNmiaPeeKJJ7Ru3TqtW7dOXbp00ZQpU/Twww/rjjvuaNFrfHnKfSQSCcRSv2/fvkDMicOjow10tIOWNtDRBjraQUsbrHcsrnKa885O/dvwUwPz9zzSj43HzYXyysrKtHbtWo0dO1aSNHr0aJWUlKiwsLDJ4zZs2KB//ud/1nHHHadQKKR//dd/1X//93/7MfIxUV5e7vcI8AAdbaCjHbS0gY420NEOWtpAx+CJm6W+pKREffr0UTh84OSBUCiktLQ0FRcXN3ncGWecoaVLlyoajaqurk7PPvusioqKDnnc2tpaRaPRJrcgSU5O9nsEeICONtDRDlraQEcb6GgHLW2w3tG5pv+1IG6W+pYaP368LrvsMl1wwQW64IILNGjQoNgXApoza9YsJSUlxW5Bu0heXV2d3yPAA3S0gY520NIGOtpARztoaYPljnv21uqeFzZJku55YZP27K31eSJvxM1Sn5qaqp07d6q+vl7Sgcv3FxcXKy0trcnjQqGQ7rnnHq1fv15vv/22hgwZctDF9L5q2rRpqqysjN1KSkqO6t/DaxUVFX6PAA/Q0QY62kFLG+hoAx3toKUNVju+uHGnRv5yubbt2aevn95H2/bs08hfLteLG3f6PVq7xc1Sn5ycrNzcXC1YsECStGTJEvXr108ZGRlNHldTUxP7H9qePXt033336Qc/+MEhj5uQkBC7KF5QLo73VZavPNmR0NEGOtpBSxvoaAMd7aClDVY7btlVpbPSe+mVW8/Xf/17rl659Xydld5LH+6q8nu0dourq9/PmTNH48eP18yZMxWJRDR//nxJ0qRJk5SXl6e8vDxVVlbqwgsvVKdOndTY2Kjvfe97+rd/+zefJz96qqur/R4BHqCjDXS0g5Y20NEGOtpBSxusdvz+JQPVqdPfryLfu0eCHht7hhobg//D9XG11A8ePFirVq066P558+bF/nzSSSfp/fffP5Zj+SpoF/ZD8+hoAx3toKUNdLSBjnbQ0garHb+60Lfk/iCJm9Pv0by+ffv6PQI8QEcb6GgHLW2gow10tIOWNtAxeFjq45zVr5R1NHS0gY520NIGOtpARztoaQMdg4elPs7t3bvX7xHgATraQEc7aGkDHW2gox20tIGOwcNSH+dSU1P9HgEeoKMNdLSDljbQ0QY62kFLG+gYPCz1cW7Pnj1+jwAP0NEGOtpBSxvoaAMd7aClDXQMHpb6OLd//36/R4AH6GgDHe2gpQ10tIGOdtDSBjoGD0t9nOvfv7/fI8ADdLSBjnbQ0gY62kBHO2hpAx2Dh6U+zpWWlvo9AjxARxvoaActbaCjDXS0g5Y20DF4WOrjXG1trd8jwAN0tIGOdtDSBjraQEc7aGkDHYOHpT7Opaen+z0CPEBHG+hoBy1toKMNdLSDljbQMXhY6uNccXGx3yPAA3S0gY520NIGOtpARztoaQMdg4elPs7V19f7PQI8QEcb6GgHLW2gow10tIOWNtAxeELOOef3EMdSNBpVUlKSKisrFYlE/B7niGpqatS1a1e/x0A70dEGOtpBSxvoaAMd7aClDXSMHy3dXflOfZzbunWr3yPAA3S0gY520NIGOtpARztoaQMdg4elPs41Njb6PQI8QEcb6GgHLW2gow10tIOWNtAxeDj9Ps7V1dWpS5cufo+BdqKjDXS0g5Y20NEGOtpBSxvoGD8Cefr9Rx99pLPPPluDBg3S8OHDtWnTpoMe09jYqNtuu01DhgzR6aefrosuukiFhYU+THtsbNmyxe8R4AE62kBHO2hpAx1toKMdtLSBjsETV0v91KlTNWXKFH344Yf64Q9/qPHjxx/0mKVLl+p///d/tWHDBm3cuFGXXHKJ7rzzzmM/LAAAAAAAPoubpb6srExr167V2LFjJUmjR49WSUnJQd+FD4VCqq2tVU1NjZxzikaj6tevnx8jHxODBw/2ewR4gI420NEOWtpARxvoaActbaBj8MTNUl9SUqI+ffooHA5LOrC8p6Wlqbi4uMnj/u3f/k0XXnihUlJS1KdPH73++uv6yU9+csjj1tbWKhqNNrkFCae/2EBHG+hoBy1toKMNdLSDljbQMXjiZqlvqbVr1+q9997Tp59+qh07duiSSy7RTTfddMjHz5o1S0lJSbFbamrqMZwWAAAAAICj56hf/b68vFy9evU64uPKysqUkZGhzz77TOFwWM459enTR2+99ZYyMjJij/vOd76jvn37xn6OftOmTfqXf/kXffrpp80et7a2VrW1tbG3o9GoUlNTufo9jik62kBHO2hpAx1toKMdtLSBjvEjbq5+n5OT06LHJScnKzc3VwsWLJAkLVmyRP369Wuy0EtSenq63njjDX3xxReSpP/5n/9RZmbmIY+bkJCgSCTS5BYknP5iAx1toKMdtLSBjjbQ0Q5a2kDH4Al7cZClS5ce8n01NTUtPs6cOXM0fvx4zZw5U5FIRPPnz5ckTZo0SXl5ecrLy9PNN9+s999/X1lZWerSpYtSUlI0e/bsdv8d4lWnToH7CQk0g4420NEOWtpARxvoaActbaBj8Hhy+n3nzp11wQUXqLlDvfPOO9q/f397X8IzLT2FIV7U1NSoa9eufo+BdqKjDXS0g5Y20NEGOtpBSxvoGD+O6en3AwcO1G9/+1stW7bsoFvv3r29eIkO6x9/pR+CiY420NEOWtpARxvoaActbaBj8Hiy1I8bN0579uxp9n2HuzI9juzLX/GHYKOjDXS0g5Y20NEGOtpBSxvoGDxH/er3X7Vt2zadcsopx+rlmhW00++rq6vVvXt3v8dAO9HRBjraQUsb6GgDHe2gpQ10jB9xc/X7rxo9evSxfDkTtm7d6vcI8AAdbaCjHbS0gY420NEOWtpAx+A5pkv9MTwpwIyEhAS/R4AH6GgDHe2gpQ10tIGOdtDSBjoGzzFd6kOh0LF8ORNSUlL8HgEeoKMNdLSDljbQ0QY62kFLG+gYPPwSwji3fft2v0eAB+hoAx3toKUNdLSBjnbQ0gY6Bg+n38e5bt26+T0CPEBHG+hoBy1toKMNdLSDljbQMXiO6VJ/5ZVXHsuXM6F3795+jwAP0NEGOtpBSxvoaAMd7aClDXQMHk+X+pKSEl1xxRXKzs6WJBUUFOihhx6Kvf/uu+/28uU6hJKSEr9HgAfoaAMd7aClDXS0gY520NIGOgaPp0v91KlTdc0118ROs8/MzNRvf/tbL1+iw+nRo4ffI8ADdLSBjnbQ0gY62kBHO2hpAx2Dx9OlvqysTGPHjlWnTgcOGw6HFQ6HvXyJDicSifg9AjxARxvoaActbaCjDXS0g5Y20DF4PF3qw+Fwk4vhVVRUcHG8dtqxY4ffI8ADdLSBjnbQ0gY62kBHO2hpAx2Dx9Ol/qqrrtLUqVMVjUY1b948jRw5UpMmTfLyJTocvlJmAx1toKMdtLSBjjbQ0Q5a2kDH4PH03Pjbb79dCxcuVGVlpV555RXddttt+vd//3cvX6LD6d69u98jwAN0tIGOdtDSBjraQEc7aGkDHYPHs6W+oaFBl156qV577TVde+21Xh22wystLeXXShhARxvoaActbaCjDXS0g5Y20DF4PDv9vnPnzqqurlZjY2Obj/HRRx/p7LPP1qBBgzR8+HBt2rTpoMfMnz9f2dnZsVvv3r115ZVXtmf0uNazZ0+/R4AH6GgDHe2gpQ10tIGOdtDSBjoGj6en3w8fPlxXXHGFxo4d2+RXIeTl5bXo+VOnTtWUKVM0fvx4LV68WOPHj9eaNWuaPGbChAmaMGFC7O3MzExdd9113vwF4lCXLl38HgEeoKMNdLSDljbQ0QY62kFLG+gYPJ5eKG/jxo3av3+/Hn/8cT300EN66KGH9Ktf/apFzy0rK9PatWs1duxYSdLo0aNVUlKiwsLCQz7n3XffVVlZWYu/aBBEZWVlfo8AD9DRBjraQUsb6GgDHe2gpQ10DB5Pv1O/bNmyNj+3pKREffr0if1e+1AopLS0NBUXFysjI6PZ5zzxxBO6/vrrD/vVpNraWtXW1sbejkajbZ7RD7169fJ7BHiAjjbQ0Q5a2kBHG+hoBy1toGPweLrUr1ixotn7zz//fC9fRpK0b98+/f73v9c777xz2MfNmjVLM2bM8Pz1AQAAAADwm+e/0u5LNTU12rJlizIzM7Vu3bojPjc1NVU7d+5UfX29wuGwnHMqLi5WWlpas49/7rnnNHToUA0ZMuSwx502bZpuu+222NvRaFSpqakt/Bv5r7y8XH369PF7DLQTHW2gox20tIGONtDRDlraQMfg8XSp/8eL2q1evVpPPvlki56bnJys3NxcLViwQOPHj9eSJUvUr1+/w556f+ONNx7xuAkJCUpISGjRDPEoOTnZ7xHgATraQEc7aGkDHW2gox20tIGOwePphfL+0YgRI7Rq1aoWP37OnDmaM2eOBg0apPvuu0/z58+XJE2aNElLly6NPW7Lli0qKCjQmDFjPJ853tTV1fk9AjxARxvoaActbaCjDXS0g5Y20DF4PP1O/caNG2N/bmho0Lvvvtuq/1EMHjy42S8CzJs376DHVVVVtX3QAKmoqNDJJ5/s9xhoJzraQEc7aGkDHW2gox20tIGOwePpUj9q1Ki/Hzgc1sCBA/XUU095+RIdTkpKit8jwAN0tIGOdtDSBjraQEc7aGkDHYPH06V+27ZtXh4Okqqrq/0eAR6gow10tIOWNtDRBjraQUsb6Bg8nv5MfX5+fovuQ8tFo1G/R4AH6GgDHe2gpQ10tIGOdtDSBjoGj6dLfXFx8UH3ffzxx16+RIfTt29fv0eAB+hoAx3toKUNdLSBjnbQ0gY6Bo8nS/2cOXOUk5OjLVu2KDc3N3Y79dRTdcopp3jxEh0WXymzgY420NEOWtpARxvoaActbaBj8HjyM/WXXXaZBg8erG9961t66KGHYvdHIhGdfvrpXrxEh7V3716/R4AH6GgDHe2gpQ10tIGOdtDSBjoGjydLff/+/dW/f3+9//77XhwOX5Gamur3CPAAHW2gox20tIGONtDRDlraQMfg8fTq9/v379cjjzyigoIC1dTUxO5//vnnvXyZDmXPnj1KSkryewy0Ex1toKMdtLSBjjbQ0Q5a2kDH4PH0QnmTJ09WUVGR3n77bV100UXavn27+vfv7+VLdDj79+/3ewR4gI420NEOWtpARxvoaActbaBj8Hi61G/YsEG/+c1vFIlEdMstt+jNN9/UX//6Vy9fosPhiyI20NEGOtpBSxvoaAMd7aClDXQMHk+X+m7dukmSwuGw9u3bp8TERO3evdvLl+hwSktL/R4BHqCjDXS0g5Y20NEGOtpBSxvoGDye/kz9CSecoIqKCl1++eW69NJL1bt3b/Xr18/Ll+hwamtr/R4BHqCjDXS0g5Y20NEGOtpBSxvoGDwh55zz6mANDQ3q3LmznHP63e9+p4qKCt1www2KRCJevUS7RaNRJSUlqbKyMq7mOpTq6mp1797d7zHQTnS0gY520NIGOtpARztoaQMd40dLd1dPT7/v3Lmzdu7cqeXLl+u6667T1KlT1bVrVy9fosMpLi72ewR4gI420NEOWtpARxvoaActbaBj8Hi61C9evFhnnXWWxo8fL0navHmz8vPzvXyJDqe+vt7vEeABOtpARztoaQMdbaCjHbS0gY7B4+lSP2vWLK1bt049e/aUJGVlZWn79u1evkSHk5GR4fcI8AAdbaCjHbS0gY420NEOWtpAx+Dx/PT7Xr16NbnvuOOOa/HzP/roI5199tkaNGiQhg8frk2bNjX7uL/97W+68MIL9U//9E/6p3/6Jz3//PPtmjuebd261e8R4AE62kBHO2hpAx2Dryxao588/1eVRWv8HgUe4HPSBjoGj6dLfWJionbt2qVQKCRJev3113XCCSe0+PlTp07VlClT9OGHH+qHP/xh7DT+r6qurtaoUaP005/+VO+//77ee+89nXfeeV79FeJOY2Oj3yPAA3S0gY520NIGOgZfWVWtfrfxc5VVcbVtC/ictIGOwePJ1e83bdqkoUOHau3atZoyZYq2bt2qzMxMbdu2TS+++KKys7OPeIyysjJlZGTos88+UzgclnNOffr00VtvvdXkFJB58+bpjTfe0O9+97s2zRq0q9/X1dWpS5cufo+BdqKjDXS0g5Y20DH43vu0Ulc88pb+55ZzlXlykt/joJ34nLSBjvHjmF79/vrrr5ckff/739eyZcu0cOFC3Xnnndq0aVOLFnpJKikpUZ8+fRQOhyVJoVBIaWlpB119cfPmzUpISNAVV1yh7Oxs3XDDDdq9e/chj1tbW6toNNrkFiRbtmzxewR4gI420NEOWtpAx+D78ltL3v2CZfiJz0kb6Bg8niz1NTU1WrRokXbu3KkVK1aorq5O9fX1WrFihZYuXerFS8TU19frtdde05w5c7R+/XqdfPLJ+ta3vnXIx8+aNUtJSUmxW2pqqqfzAAAAoPX27K3VPS8cuH7SPS9s0p69nIIPAG3hyen3S5cu1ezZs7Vy5UqdeeaZTV8gFNIbb7xxxGO09PT7Bx54QBs3btTTTz8t6cCp/5deeqk++eSTZo9bW1ur2tq//x+JaDSq1NRUTr/HMUVHG+hoBy1toGNwvbhxp370x78pFArprFN66p1tFXLO6af5w/T10/v4PR7aiM9JG+gYP47p6fd5eXl66aWXNHHiRC1btqzJrSULvSQlJycrNzdXCxYskCQtWbJE/fr1O+hXKlx99dVas2ZN7DT6l156SVlZWYc8bkJCgiKRSJNbkHD6iw10tIGOdtDSBjoG15ZdVTorvZdeufV8fTu7q1659Xydld5LH+6q8ns0tAOfkzbQMXjCXh7s4Ycfbtfz58yZo/Hjx2vmzJmKRCKaP3++JGnSpEnKy8tTXl6e0tLSdOedd+rss89Wp06ddPLJJ2vu3LlejA8AAIBj4PuXDFSnTgd+W1KppN49EvTY2DPU2MgP1wNAa3ly+n2QcPV7+IGONtDRDlraQEcb6GgHLW2gY/w4pqff4+jh9Bcb6GgDHe2gpQ10tIGOdtDSBjoGD0t9nOvUiUQW0NEGOtpBSxvoaAMd7aClDXQMHk6/j3M1NTXq2rWr32OgnehoAx3toKUNdLSBjnbQ0gY6xg9OvzeisLDQ7xHgATraQEc7aGkDHW2gox20tIGOwcNSH+fCYU9/QQF8Qkcb6GgHLW2gow10tIOWNtAxeFjq41xaWprfI8ADdLSBjnbQ0gY62kBHO2hpAx2Dh6U+zm3dutXvEeABOtpARztoaQMdbaCjHbS0gY7Bw1If5xISEvweAR6gow10tIOWNtDRBjraQUsb6Bg8LPVxLiUlxe8R4AE62kBHO2hpAx1toKMdtLSBjsHDUh/ntm/f7vcI8AAdbaCjHbS0gY420NEOWtpAx+BhqY9z3bp183sEeICONtDRDlraQEcb6GgHLW2gY/Cw1Me53r17+z0CPEBHG+hoBy1toKMNdLSDljbQMXhY6uNcSUmJ3yPAA3S0gY520NIGOtpARztoaQMdg4elPs716NHD7xHgATraQEc7aGkDHW2gox20tIGOwcNSH+cikYjfI8ADdLSBjnbQ0gY62kBHO2hpAx2Dh6U+zu3YscPvEeABOtpARztoaQMdbaCjHbS0gY7BE1dL/UcffaSzzz5bgwYN0vDhw7Vp06aDHvPmm2+qW7duys7Ojt3279/vw7RHX1m0Ros/2K+yaI3fo6Cd+IqnDXS0g5Y20NEGOtpBSxvoGDxxtdRPnTpVU6ZM0Ycffqgf/vCHGj9+fLOPGzx4sAoKCmI3q792oayqVk+uLVNZVa3fo6Cdunfv7vcI8AAd7aClDXS0gY520NIGOgZP3Cz1ZWVlWrt2rcaOHStJGj16tEpKSlRYWOjzZED7lZaW+j0CPEBHO2hpAx1toKMdtLSBjsETN0t9SUmJ+vTpo3A4LEkKhUJKS0tTcXHxQY/9+OOPlZubq+HDh+s3v/nNYY9bW1uraDTa5BYUzjX9L4KrZ8+efo8AD9DRDlraQEcb6GgHLW2gY/DEzVLfUrm5ufrkk0+0bt06/eEPf9Ds2bP17LPPHvLxs2bNUlJSUuyWmpp6DKdtuz17a3XPCweuKXDPC5u0Zy+n4AdZly5d/B4BHqCjHbS0gY420NEOWtpAx+CJm6U+NTVVO3fuVH19vSTJOafi4mKlpaU1eVwkElFSUpIkqV+/frr22mu1cuXKQx532rRpqqysjN1KSkqO3l/CIy9u3KmRv1yubXv26bz+3bVtzz6N/OVyvbhxp9+joY3Kysr8HgEeoKMdtLSBjjbQ0Q5a2kDH4ImbpT45OVm5ublasGCBJGnJkiXq16+fMjIymjxu586damxslCRVVVXpf/7nf5STk3PI4yYkJCgSiTS5xbstu6p0VnovvXLr+bo//zS9cuv5Oiu9lz7cVeX3aGijXr16+T0CPEBHO2hpAx1toKMdtLSBjsET9nuAr5ozZ47Gjx+vmTNnKhKJaP78+ZKkSZMmKS8vT3l5eVqyZIkee+wxhcNh1dfX66qrrtKECRN8ntxb379koDp1CkmSdlZJvXsk6LGxZ6ixkR+uBwAAAAD8XVwt9YMHD9aqVasOun/evHmxP3/nO9/Rd77znTa/hvv/V50LygXztm/fruOPP97vMdBOdLSBjnbQ0gY62kBHO2hpAx3jx5c7qzvCldPjaqk/FqqqDpzCHpQL5gEAAAAAOq6qqqrYdeWaE3JHWvuNaWxs1I4dO5SYmKhQKOT3OIcVjUaVmpqqkpKSQFwLAM2jow10tIOWNtDRBjraQUsb6BhfnHOqqqpS37591anToS+H1+G+U9+pUyf169fP7zFaJSgX+MPh0dEGOtpBSxvoaAMd7aClDXSMH4f7Dv2X4ubq9wAAAAAAoHVY6gEAAAAACCiW+jiWkJCg6dOnKyEhwe9R0A50tIGOdtDSBjraQEc7aGkDHYOpw10oDwAAAAAAK/hOPQAAAAAAAcVSDwAAAABAQLHUAwAAAAAQUCz1R1BTU6P8/HwNGjRIWVlZGjlypAoLCyVJZWVluuyyyzRw4EBlZmZqxYoVsedNmDAh9pxzzjlHa9asib3vrrvu0rBhw5Sdna3s7Gz9/ve/P+TrV1dX69prr1VGRoYGDRqkxYsXx95355136rTTTlNWVpbOPPNM/eUvfznkcRobG3XLLbfo1FNPVUZGhh599NGDHlNWVqaTTjpJ+fn5rfkQBQYtbaCjDR2h4z333KMTTzwxNs91113Xpo9VvKOlDR2hoyQtWbJEw4YNU2ZmpjIzM1VUVNTaD1Vco6MdtESrOBzW/v373YsvvugaGxudc8498sgj7oILLnDOOTdhwgQ3ffp055xzq1evdieffLL74osvnHPO/elPf3J1dXXOOedeeOEF179//9gxKyoqYn/+5JNPXGJiotu9e3ezrz9jxgw3btw455xzW7dudSeeeKLbs2ePc865l156yVVXVzvnnCsoKHCRSMTt3bu32eM89dRT7uKLL3b19fWuvLzcpaWluffee6/JY/Lz893EiRPdqFGjWvSxCRpa2kBHGzpCx+nTp7vvfe97rfq4BBEtbegIHdetW+cGDx7sPv30U+ecc9Fo1O3bt68VH6X4R0c7aInWYKlvpTVr1sQ+OY4//ni3c+fO2PuGDx/uXn311YOes3v3bhcOh2OfYF/1wQcfuB49erhdu3Y1+3pDhgxxq1atir191VVXuccff/ygxzU0NLjExES3bdu2Zo9z+eWXu4ULF8bevuOOO9xdd90Ve3vevHnu1ltvdfPnzze5QDSHljbQ0QaLHTvCItgcWtpgseN1113n5syZ0+zzrKKjHbTE4XD6fSs9/PDDGjVqlMrLy1VXV6eUlJTY+wYMGKDi4uJmn3P55ZcrHA7H7vv1r3+twYMHKzc3V3PnzlVycnKzr1dcXKz+/fsf8TXmz5+v9PT0Jo9t6XG2bdum2bNn62c/+9kR/va20NIGOtpgsaMkPffcc8rKytLFF1+sZcuWHeYjYActbbDYcfPmzSouLtYFF1ygnJwc3X333WpoaDjCRyLY6GgHLXE4LPWtMHPmTBUWFmrWrFktfs6CBQv07LPPau7cuU3u/+53v6stW7bo7bff1syZM1VeXt7muV5//XXNmDFDixYtUigUatVznXOaOHGiHn30UXXr1q3NMwQNLW2gow0WO0rSTTfdpKKiIm3YsEH33nuvxowZo+3bt7d5niCgpQ1WO9bX12v9+vV6+eWX9dZbb+ntt9/WY4891uZ54h0d7aAljoSlvoUeeOABPf/88/rzn/+s7t27q1evXgqHwyotLY09pqioSGlpabG3Fy1apBkzZujVV1/VSSed1Oxxs7KydPLJJ+vNN9/U5s2bYxeuuPnmmyVJaWlpTf4fh398jeXLl2vChAl64YUXNHjwYEnS559/HjvON77xjcMeJxqNauPGjRozZowGDBig//iP/9Arr7yiSy65xIOPWnyipQ10tMFqR0lKSUlRly5dJEnnnHOOcnJytHbt2nZ9vOIZLW2w3DEtLU2jR49Wt27ddPzxx+vKK6/UO++8094PWVyiox20RIv4fPp/IDz44IMuNzfXffbZZ03uHzduXJOLVPTt2zd2kYpFixa5jIwMV1RUdNDxNm3aFPtzYWGhS05Odps3b272tadPn37QRSq+vKDF8uXLXWpqqlu3bt0R/w7z588/6CIVGzdubPZxln9+l5Y20NEG6x1LSkpij/vwww9dcnKy27JlyxGPGUS0tMF6x2eeecaNGTPGNTQ0uLq6OpeXl+fuv//+Ix4zaOhoBy3RUiz1R1BSUuIkufT0dJeVleWysrLciBEjnHPOlZaWupEjR7qMjAw3ZMgQ98Ybb8SeFw6HXb9+/WLPycrKil0x8utf/7obMmSIy8rKcmeccYZ79tlnD/n6e/fudVdffbVLT093AwcOdIsWLYq9LyMjwyUnJzd5jeaWAuecq6+vd9/+9rfdKaec4tLT092vfvWrZh9neYGgpQ10tKEjdLzhhhvc0KFDXVZWlsvNzXXPPfdcuz5m8YqWNnSEjg0NDe722293p512mhs6dKi76aabXG1tbbs+bvGGjnbQEq0Rcs45/84TAAAAAAAAbcXP1AMAAAAAEFAs9QAAAAAABBRLPQAAAAAAAcVSDwAAAABAQLHUAwAAAAAQUCz1AAAAAAAEFEs9AAAAAAABxVIPAAAAAEBAsdQDAAAAABBQLPUAAAAAAAQUSz0AAAAAAAHFUg8AAAAAQECx1AMAAAAAEFAs9QAAAAAABBRLPQAAAAAAARX2e4BjrbGxUTt27FBiYqJCoZDf4wAAAAAAcBDnnKqqqtS3b1916nTo78d3uKV+x44dSk1N9XsMAAAAAACOqKSkRP369Tvk+4/5Uh8KhVRRUaGvfe1rrXqfVxITEyUd+MBEIpGj9jpeKS0tVUpKit9joJ3oaAMd7aClDXQ0oGqXqt6arcRzb5IST/J7GrQTn5M2mO9YtUtav0DKGRv3/+5Eo1GlpqbGdthD6XDfqf/ylPtIJBKIpX7fvn2BmBOHR0cb6GgHLW2gowF7tyry/jzpvOslWgYen5M2mO+4d6u09ldS7jcC8+/OkX5s3JcL5T3wwAPKycnRoEGD9MwzzzT7mAEDBqigoCD29plnnqk333xT0oGvHl199dUaMWKEhg0bph/96EfHYGp/lJeX+z0CPEBHG+hoBy1toCMQX/ictIGOwePLUh8KhbR+/Xq9/PLLuuWWW1RUVNSq548bN04333yzVq9erfXr12vt2rV67rnnmn1sbW2totFok1uQJCcn+z0CPEBHG+hoBy1toKMF7h/+iyDjc9IG+x3t/bvjy+n3kyZNkiSlp6fr/PPP14oVKzRgwIAWPXffvn16/fXXtWvXrth9e/fu1ZYtW5p9/KxZszRjxox2z+yXuro6v0eAB+hoAx3toKUNdAy4vbulP//wwJ///ENpzDNSjxP9nQntwuekDaY7Gv13Jy5+T31zPyMQDofV0NAQe7umpkbSgcv6S9I777yjgoICFRQUqLCw8JCn4E+bNk2VlZWxW0lJyVH4Gxw9FRUVfo8AD9DRBjraQUsb6Bhgm/4g/dcIqbxQlf0ulsoLD7y96Q9+T4Z24HPSBrMdv/LvjoZ+w9S/O74s9fPnz5ckFRUVaeXKlTrvvPMOekxGRobeffddSdLq1atj34nv0aOHLrroIt13332xx+7YsUOffPJJs6+VkJAQuyheUC6O91WmrzzZgdDRBjraQUsb6BhgZe9LA86Vvv2u6vIfl7797oG3yz7wezK0A5+TNpjt+JV/d3TVk6b+3fHl9PuGhgbl5ORo3759+vWvf93sqfc//elPNW7cOM2ZM0f/9//+Xw0dOjT2vmeeeUa33XabMjMzFQqFdPzxx2vOnDmH/d19QVVdXe33CPAAHW2gox20tIGOAXbBf0qdDnxvqfqzYql3mjTmv6XGRp8HQ3vwOWmD2Y5f+XdH0oHT7o38u3PMl/ovT5+/9957D/k+6cDV7jdt2tTsMZKTk7VgwYKjM2CcCdqF/dA8OtpARztoaQMdA+wr/491k46d4uInQ9FGfE7aYLbjof59MfDvTvD/Bsb17dvX7xHgATraQEc7aGkDHW2gox20tIGOwcNSH+fMfqWsg6GjDXS0g5Y20NEGOtpBSxvoGDws9XFu7969fo8AD9DRBjraQUsb6GgDHe2gpQ10DB6W+jiXmprq9wjwAB1toKMdtLSBjjbQ0Q5a2kDH4GGpj3N79uzxewR4gI420NEOWtpARxvoaActbaBj8LDUx7n9+/f7PQI8QEcb6GgHLW2gow10tIOWNtAxeFjq41z//v39HgEeoKMNdLSDljbQ0QY62kFLG+gYPCz1ca60tNTvEeABOtpARztoaQMdbaCjHbS0gY7Bw1If52pra/0eAR6gow10tIOWNtDRBjraQUsb6Bg8LPVxLj093e8R4AE62kBHO2hpAx1toKMdtLSBjsHDUh/niouL/R4BHqCjDXS0g5Y20NEGOtpBSxvoGDws9XGuvr7e7xHgATraQEc7aGkDHW2gox20tIGOwRNyzjm/hziWotGokpKSVFlZqUgk4vc4R1RTU6OuXbv6PQbaiY420NEOWtpARxvoaActbaBj/Gjp7sp36uPc1q1b/R4BHqCjDXS0g5Y20NEGOtpBSxvoGDws9XGusbHR7xHgATraQEc7aGkDHW2gox20tIGOwcPp93Gurq5OXbp08XsMtBMdbaCjHbS0gY420NEOWtpAx/gRt6ffh0Ihff75561+X0e1ZcsWv0eAB+hoAx3toKUNdLSBjnbQ0gY6Bg+n3wMAAAAAEFC+LPUPPPCAcnJyNGjQID3zzDPNPmbAgAEqKCiIvX3mmWfqzTfflCSVlpbq6quv1ogRIzRs2DD96Ec/OgZT+2Pw4MF+jwAP0NEGOtpBSxvoaAMd7aClDXQMHl+W+lAopPXr1+vll1/WLbfcoqKiolY9f9y4cbr55pu1evVqrV+/XmvXrtVzzz3X7GNra2sVjUab3IKE019soKMNdLSDljbQ0QY62kFLG+gYPGE/XnTSpEmSpPT0dJ1//vlasWKFBgwY0KLn7tu3T6+//rp27doVu2/v3r2H/B/frFmzNGPGjHbPDAAAAABAvGnTUt/Y2KhOnZp+k7+iokI9e/Zs0xChUOjgwcJhNTQ0xN6uqamRJH15sf533nlHXbt2PeKxp02bpttuuy32djQaVWpqapvm9AOnv9hARxvoaActbaCjDXS0g5Y20DF4WnX6/dq1a3XKKaeoW7du+sY3vqHdu3fH3nfJJZe0+Djz58+XJBUVFWnlypU677zzDnpMRkaG3n33XUnS6tWrY9+J79Gjhy666CLdd999scfu2LFDn3zySbOvlZCQoEgk0uQWJJz+YgMdbaCjHbS0gY420NEOWtpAx+Bp1VJ/66236tFHH9WOHTuUmZmp888/X59++qmkv38HvSUaGhqUk5Ojf/mXf9Gvf/3rZk+9/+lPf6r/+q//UlZWln77299q6NChsfc988wzKiwsVGZmpoYNG6Yrr7xS5eXlrfmrBMY/nhGBYKKjDXS0g5Y20NEGOtpBSxvoGDwh14ptPCcnR+vXr4+9vWDBAt1777167bXXNGrUKK1bt+6oDOmlaDSqpKQkVVZWBuK79jU1NS36MQPENzraQEc7aGkDHW2gox20tIGO8aOlu2urvgxTXV2txsbG2Ntjx47VT37yE11yySVmv1Put8LCQr9HgAfoaAMd7aClDXS0gY520NIGOgZPq5b6c845Ry+99FKT+8aMGaOf/vSn2rlzp6eD4YBw2JdfUACP0dEGOtpBSxvoaAMd7aClDXQMnladft9S27Zt0ymnnOL1YT0RtNPvq6ur1b17d7/HQDvR0QY62kFLG+hoAx3toKUNdIwfR+X0+5YaPXr00Thsh7R161a/R4AH6GgDHe2gpQ10tIGOdtDSBjoGz1FZ6o/CN/87rISEBL9HgAfoaAMd7aClDXS0gY520NIGOgbPUVnqQ6HQ0Thsh5SSkuL3CPAAHW2gox20tIGONtDRDlraQMfg4ZcQxrnt27f7PQI8QEcb6GgHLW2gow10tIOWNtAxeDj9Ps5169bN7xHgATraQEc7aGkDHW2gox20tIGOwXNUlvorr7zyaBy2Q+rdu7ffI8ADdLSBjnbQ0gY62kBHO2hpAx2Dp01LfUlJia644gplZ2dLkgoKCvTQQw/F3n/33Xd7MhwOfKwRfHS0gY520NIGOtpARztoaQMdg6dNS/3UqVN1zTXXxE6zz8zM1G9/+1tPB8MBPXr08HsEeICONtDRDlraQEcb6GgHLW2gY/C0aakvKyvT2LFj1anTgaeHw2GFw2FPB8MBkUjE7xHgATraQEc7aGkDHW2gox20tIGOwdOmpT4cDje5GF5FRQUXxztKduzY4fcI8AAdbaCjHbS0gY420NEOWtpAx+Bp01J/1VVXaerUqYpGo5o3b55GjhypSZMmeT0bxFfKrKCjDXS0g5Y20NEGOtpBSxvoGDxtOmf+9ttv18KFC1VZWalXXnlFt912m/793//d69kgqXv37n6PAA/Q0QY62kFLG+hoAx3toKUNdAyeVi/1DQ0NuvTSS/Xaa6/p2muvPRoz4StKS0v5tRIG0NEGOtpBSxvoaAMd7aClDXQMnlafft+5c2dVV1ersbHxaMzTJt/85jf15JNP+j3GUdGzZ0+/R4AH6GgDHe2gpQ10tIGOdtDSBjoGT5tOvx8+fLiuuOIKjR07tsmvPMjLy/NkqPr6eq6m//916dLF7xHgATraQEc7aGkDHW2gox20tIGOwdOmzXnjxo2SpMcffzx2XygUatdSHwqF9OMf/1gvvfSSLrzwQv34xz/Wbbfdpg0bNqimpkZnnXWWHn30UR133HH64IMPNHHiRFVWVmrgwIGqrq5u8+vGu7KyMiUnJ/s9BtqJjjbQ0Q5a2kBHG+hoBy1toGPwtGmpX7ZsmddzSDpwav+aNWskSVOmTNF5552nxx9/XM45TZ48WQ8//LDuuOMOXX/99brpppt044036m9/+5vOPPPMQ16or7a2VrW1tbG3o9HoUZn9aOnVq5ffI8ADdLSBjnbQ0gY62kBHO2hpAx2Dp01L/YoVK5q9//zzz2/XMBMnToz9+Y9//KNWrVqlX/7yl5Kk/fv3q3PnzopGoyooKND48eMlScOGDdO55557yGPOmjVLM2bMaNdcAAAAAADEozb/Srsv1dTUaMuWLcrMzNS6devaNcxXfz7fOaclS5Zo0KBBTR7T3HfaQ6HQIY85bdo03XbbbU2en5qa2q45j6Xy8nL16dPH7zHQTnS0gY520NIGOtpARztoaQMdg6fVV7+XpDVr1sRuf/vb3/TWW2/prLPO8nSw/Px8/fznP1d9fb0kqaKiQoWFhYpEIsrJydHTTz8tSdq0aZPeeuutQx4nISFBkUikyS1I+HkWG+hoAx3toKUNdLSBjnbQ0gY6Bk+blvp/NGLECK1atcqLQ8U89NBD6tatm7Kzs3X66afrkksuUVFRkSTp6aef1ty5c5WZmakf/ehH7T7tP57V1dX5PQI8QEcb6GgHLW2gow10tIOWNtAxeNp19XtJamho0Lvvvtvu+M65Jm/36NFDjz76aLOPPe200zz/IkK8qqio0Mknn+z3GGgnOtpARztoaQMdbaCjHbS0gY7B06alftSoUX8/QDisgQMH6qmnnvJsKPxdSkqK3yPAA3S0gY520NIGOtpARztoaQMdg6dNS/22bdu8ngOHUF1d7fcI8AAdbaCjHbS0gY420NEOWtpAx+Bp08/U5+fnt+g+tF9zV/tH8NDRBjraQUsb6GgDHe2gpQ10DJ42LfXFxcUH3ffxxx+3exgcrG/fvn6PAA/Q0QY62kFLG+hoAx3toKUNdAyeVi31c+bMUU5OjrZs2aLc3NzY7dRTT9Upp5xytGbs0PhKmQ10tIGOdtDSBjraQEc7aGkDHYOnVT9Tf9lll2nw4MH61re+pYceeih2fyQS0emnn+75cJD27t3r9wjwAB1toKMdtLSBjjbQ0Q5a2kDH4GnVUt+/f3/1799f77///tGaB/8gNTXV7xHgATraQEc7aGkDHW2gox20tIGOwdOmq9/v379fjzzyiAoKClRTUxO7//nnn/dsMBywZ88eJSUl+T0G2omONtDRDlraQEcb6GgHLW2gY/C06UJ5kydPVlFRkd5++21ddNFF2r59u/r37+/1bNCBL6Ag+OhoAx3toKUNdLSBjnbQ0gY6Bk+blvoNGzboN7/5jSKRiG655Ra9+eab+utf/+r1bJD4YokRdLSBjnbQ0gY62kBHO2hpAx2Dp01Lfbdu3SRJ4XBY+/btU2Jionbv3u3pYDigtLTU7xHgATraQEc7aGkDHW2gox20tIGOwdOmn6k/4YQTVFFRocsvv1yXXnqpevfurX79+nk9GyTV1tb6PQI8QEcb6GgHLW2gow10tIOWNtAxeELOOdfaJzU0NKhz585yzul3v/udKioqdMMNNygSiRyNGT0VjUaVlJSkysrKQMxbXV2t7t27+z0G2omONtDRDlraQEcb6GgHLW2gY/xo6e7aptPvO3furJ07d2r58uW67rrrNHXqVHXt2rXNw+LQiouL/R4BHqCjDXS0g5Y20NEGOtpBSxvoGDxtWuoXL16ss846S+PHj5ckbd68Wfn5+R6OhS/V19f7PQI8QEcb6GgHLW2gow10tIOWNtAxeNq01M+aNUvr1q1Tz549JUlZWVnavn27p4PhgIyMDL9HgAfoaAMd7aClDXS0gY520NIGOgZPm0+/79WrV5P7jjvuOE8GaotvfvObevLJJ317/aNp69atfo8AD9DRBjraQUsb6GgDHe2gpQ10DJ42LfWJiYnatWuXQqGQJOn111/XCSec4NlQnPLxd42NjX6PAA/Q0QY62kFLG+hoAx3toKUNdAyeVi31mzZtkiT9/Oc/17/+679q69atOvfcc3XDDTfowQcfbNcgoVBI06dP1/DhwzVt2jRVVVVp8uTJGjFihE4//XRNmTJFX3zxhSTpgw8+0Nlnn62hQ4cqPz9f0Wi0Xa8dzwYPHuz3CPAAHW2gox20tIGONtDRDlraQMfgadVSf/3110uSvv/972vZsmVauHCh7rzzTm3atEnZ2dntHqZz585as2aNfvGLX+j222/Xeeedp9WrV2vDhg1qbGzUww8/HJvjxhtv1KZNm3Tvvfdq+fLlhzxmbW2totFok1uQbNmyxe8R4AE62kBHO2hpAx1toKMdtLSBjsETbs2Da2pqtGjRIu3cuVMrVqzQl7/ifsWKFZKkvLy8dg0zceLE2J//+Mc/atWqVfrlL38pSdq/f786d+6saDSqgoKC2JX3hw0bpnPPPfeQx5w1a5ZmzJjRrrkAAAAAAIhHIfflZt4CS5cu1ezZs7Vy5UqdeeaZTQ8UCumNN95o+yChkCoqKvS1r31NknTiiSfqf//3fzVo0KAmj4tGo+rVq5dqamrUuXNnSdI///M/a+zYsbFF/6tqa2tVW1vb5PmpqamqrKxUJBJp87zHSl1dnbp06eL3GGgnOtpARztoaQMdbaCjHbS0gY7xIxqNKikp6Yi7a6tOv8/Ly9NLL72kiRMnatmyZU1u7Vnom5Ofn6+f//znsYvmVVRUqLCwUJFIRDk5OXr66aclHfg5/7feeuuQx0lISFAkEmlyCxJOf7GBjjbQ0Q5a2kBHG+hoBy1toGPwtOnq91/+bPvR9NBDD6lbt27Kzs7W6aefrksuuURFRUWSpKefflpz585VZmamfvSjH+n8888/6vMAAAAAABBvWnX6vQUtPYUhXnD6iw10tIGOdtDSBjraQEc7aGkDHePHUTn9Hscep7/YQEcb6GgHLW2gow10tIOWNtAxeFjq41ynTiSygI420NEOWtpARxvoaActbaBj8HD6fZyrqalR165d/R4D7URHG+hoBy1toKMNdLSDljbQMX5w+r0RhYWFfo8AD9DRBjraQUsb6GgDHe2gpQ10DB6W+jgXDof9HgEeoKMNdLSDljbQ0QY62kFLG+gYPCz1cS4tLc3vEeABOtpARztoaQMdbaCjHbS0gY7Bw1If57Zu3er3CPAAHW2gox20tIGONtDRDlraQMfgYamPcwkJCX6PAA/Q0QY62kFLG+hoAx3toKUNdAwelvo4l5KS4vcI8AAdbaCjHbS0gY420NEOWtpAx+BhqY9z27dv93sEeICONtDRDlraQEcb6GgHLW2gY/Cw1Me5bt26+T0CPEBHG+hoBy1toKMNdLSDljbQMXhY6uNc7969/R4BHqCjDXS0g5Y20NEGOtpBSxvoGDws9XGupKTE7xHgATraQEc7aGkDHW2gox20tIGOwcNSH+d69Ojh9wjwAB1toKMdtLSBjjbQ0Q5a2kDH4GGpj3ORSMTvEeABOtpARztoaQMdbaCjHbS0gY7Bw1If53bs2OH3CPAAHW2gox20tIGONtDRDlraQMfgMbHUf/Ob39STTz7p9xjeqypVauECqarU70nQTnzF0wY62kFLG+hoAx3toKUN5jtWlUrLZpnaseJyqa+vr/d7hPhQVaqkgsdM/Q+uo+revbvfI8ADdLSDljbQ0QY62kFLG8x3rCqVlt9naseKm6U+FApp+vTpGj58uKZNm6aqqipNnjxZI0aM0Omnn64pU6boiy++kCR98MEHOvvsszV06FDl5+crGo36PD1weKWldv7R6MjoaActbaCjDXS0g5Y20DF44mapl6TOnTtrzZo1+sUvfqHbb79d5513nlavXq0NGzaosbFRDz/8sCTp+uuv14033qhNmzbp3nvv1fLlyw95zNraWkWj0Sa34HD/8F8EVc+ePf0eAR6gox20tIGONtDRDlraYL+jvR0rrpb6iRMnxv78xz/+Ub/4xS+UnZ2tnJwcrVy5UoWFhYpGoyooKND48eMlScOGDdO55557yGPOmjVLSUlJsVtqaurR/mt4Y+9u6c8/PPDnP//wwNsIrC5duvg9AjxARztoaQMdbaCjHbS0wXRHoztWXC31X/2diM45LVmyRAUFBSooKNCWLVs0Z86cZp8XCoUOecxp06apsrIydispKfF8bs9t+oP0XyOk8kJV9rtYKi888PamP/g9GdqorKzM7xHgATraQUsb6GgDHe2gpQ1mO35lx9LQb5jaseJqqf+q/Px8/fznP49dNK+iokKFhYWKRCLKycnR008/LUnatGmT3nrrrUMeJyEhQZFIpMkt7pW9Lw04V/r2u6r++m+kb7974O2yD/yeDG3Uq1cvv0eAB+hoBy1toKMNdLSDljaY7fiVHUtXPWlqxwr7PcChPPTQQ/rP//xPZWdnq1OnTgqHw7r//vuVkZGhp59+WhMmTNCDDz6ogQMH6vzzz/d7XG9d8J9Sp///9ZaqnVKPE6Ux/y01Nvo7FwAAAAAE0Vd3LMnUjhU3S71zTS9U0KNHDz366KPNPva0007TqlWr2vU6Qblg3vbt23X88cf7PQbaiY420NEOWtpARxvoaActbaBj/PhyZ/3HXfkfxc1Sf6xUVVVJUnAumAcAAAAA6LCqqqqUlJR0yPeH3JHWfmMaGxu1Y8cOJSYmHvYCe/EgGo0qNTVVJSUlwbgWAJpFRxvoaActbaCjDXS0g5Y20DG+OOdUVVWlvn37qlOnQ18Or8N9p75Tp07q16+f32O0SmAu8IfDoqMNdLSDljbQ0QY62kFLG+gYPw73Hfovxe3V7wEAAAAAwOGx1AMAAAAAEFAs9XEsISFB06dPV0JCgt+joB3oaAMd7aClDXS0gY520NIGOgZTh7tQHgAAAAAAVvCdegAAAAAAAoqlHgAAAACAgGKpBwAAAAAgoFjqj6Cmpkb5+fkaNGiQsrKyNHLkSBUWFkqSysrKdNlll2ngwIHKzMzUihUrYs+bMGFC7DnnnHOO1qxZE3vfXXfdpWHDhik7O1vZ2dn6/e9/f8jXr66u1rXXXquMjAwNGjRIixcvjr3vzjvv1GmnnaasrCydeeaZ+stf/nLI4zQ2NuqWW27RqaeeqoyMDD366KMHPaasrEwnnXSS8vPzW/MhCgxa2kBHGzpCx3vuuUcnnnhibJ7rrruuTR+reEdLGzpCR0lasmSJhg0bpszMTGVmZqqoqKi1H6q4Rkc7aIlWcTis/fv3uxdffNE1NjY655x75JFH3AUXXOCcc27ChAlu+vTpzjnnVq9e7U4++WT3xRdfOOec+9Of/uTq6uqcc8698MILrn///rFjVlRUxP78ySefuMTERLd79+5mX3/GjBlu3Lhxzjnntm7d6k488US3Z88e55xzL730kquurnbOOVdQUOAikYjbu3dvs8d56qmn3MUXX+zq6+tdeXm5S0tLc++9916Tx+Tn57uJEye6UaNGtehjEzS0tIGONnSEjtOnT3ff+973WvVxCSJa2tAROq5bt84NHjzYffrpp84556LRqNu3b18rPkrxj4520BKtwVLfSmvWrIl9chx//PFu586dsfcNHz7cvfrqqwc9Z/fu3S4cDsc+wb7qgw8+cD169HC7du1q9vWGDBniVq1aFXv7qquuco8//vhBj2toaHCJiYlu27ZtzR7n8ssvdwsXLoy9fccdd7i77ror9va8efPcrbfe6ubPn29ygWgOLW2gow0WO3aERbA5tLTBYsfrrrvOzZkzp9nnWUVHO2iJw+H0+1Z6+OGHNWrUKJWXl6uurk4pKSmx9w0YMEDFxcXNPufyyy9XOByO3ffrX/9agwcPVm5urubOnavk5ORmX6+4uFj9+/c/4mvMnz9f6enpTR7b0uNs27ZNs2fP1s9+9rMj/O1toaUNdLTBYkdJeu6555SVlaWLL75Yy5YtO8xHwA5a2mCx4+bNm1VcXKwLLrhAOTk5uvvuu9XQ0HCEj0Sw0dEOWuJwWOpbYebMmSosLNSsWbNa/JwFCxbo2Wef1dy5c5vc/93vfldbtmzR22+/rZkzZ6q8vLzNc73++uuaMWOGFi1apFAo1KrnOuc0ceJEPfroo+rWrVubZwgaWtpARxssdpSkm266SUVFRdqwYYPuvfdejRkzRtu3b2/zPEFASxusdqyvr9f69ev18ssv66233tLbb7+txx57rM3zxDs62kFLHAlLfQs98MADev755/XnP/9Z3bt3V69evRQOh1VaWhp7TFFRkdLS0mJvL1q0SDNmzNCrr76qk046qdnjZmVl6eSTT9abb76pzZs3xy5ccfPNN0uS0tLSmvw/Dv/4GsuXL9eECRP0wgsvaPDgwZKkzz//PHacb3zjG4c9TjQa1caNGzVmzBgNGDBA//Ef/6FXXnlFl1xyiQcftfhESxvoaIPVjpKUkpKiLl26SJLOOecc5eTkaO3ate36eMUzWtpguWNaWppGjx6tbt266fjjj9eVV16pd955p70fsrhERztoiRbx+fT/QHjwwQddbm6u++yzz5rcP27cuCYXqejbt2/sIhWLFi1yGRkZrqio6KDjbdq0KfbnwsJCl5yc7DZv3tzsa0+fPv2gi1R8eUGL5cuXu9TUVLdu3boj/h3mz59/0EUqNm7c2OzjLP/8Li1toKMN1juWlJTEHvfhhx+65ORkt2XLliMeM4hoaYP1js8884wbM2aMa2hocHV1dS4vL8/df//9Rzxm0NDRDlqipVjqj6CkpMRJcunp6S4rK8tlZWW5ESNGOOecKy0tdSNHjnQZGRluyJAh7o033og9LxwOu379+sWek5WVFbti5Ne//nU3ZMgQl5WV5c444wz37LPPHvL19+7d666++mqXnp7uBg4c6BYtWhR7X0ZGhktOTm7yGs0tBc45V19f77797W+7U045xaWnp7tf/epXzT7O8gJBSxvoaENH6HjDDTe4oUOHuqysLJebm+uee+65dn3M4hUtbegIHRsaGtztt9/uTjvtNDd06FB30003udra2nZ93OINHe2gJVoj5Jxz/p0nAAAAAAAA2oqfqQcAAAAAIKBY6gEAAAAACCiWegAAAAAAAoqlHgAAAACAgGKpBwAAAAAgoFjqAQAAAAAIKJZ6AAAAAAACiqUeAAAAAICAYqkHAAAAACCgWOoBAAAAAAgolnoAAAAAAAKKpR4AAAAAgIBiqQcAAAAAIKBY6gEAAAAACCiWegAAAAAAAirs9wDHWmNjo3bs2KHExESFQiG/xwEAAAAA4CDOOVVVValv377q1OnQ34/vcEv9jh07lJqa6vcYAAAAAAAcUUlJifr163fI9x/zpf673/2uli5dqu3bt2v9+vXKzs6WJH300UcaN26c9uzZo6SkJD355JMaOnRos8d44okndN9996mxsVEXX3yxfvOb36hLly4tev3ExERJBz4wkUjEk7/T0bKneo/+u+C/dX329erdvbff46AdSktLlZKS4vcYaCc62kFLG+hoAx3toKUNdIwf0WhUqampsR32UI75Uv/Nb35TP/jBD3Tuuec2uX/q1KmaMmWKxo8fr8WLF2v8+PFas2bNQc/ftm2b7r77bq1bt04nnXSSRo0apblz5+rmm29u0et/ecp9JBKJ+6X+k7pPtHjXYl3V5aq4nxWHt2/fPhoaQEc7aGkDHW2gox20tIGO8edIPzZ+zC+Ud/755x906kBZWZnWrl2rsWPHSpJGjx6tkpISFRYWHvT8xYsXKy8vTykpKQqFQrrpppu0cOHCYzI70Fbl5eV+jwAP0NEOWtpARxvoaActbaBj8MTF1e9LSkrUp08fhcMHThwIhUJKS0tTcXHxQY8tLi5W//79Y28PGDCg2cd9qba2VtFotMktKJxck/8iuJKTk/0eAR6gox20tIGONtDRDlraQMfgiYul/miaNWuWkpKSYregXCSvfH+57nv3PknSfe/ep/L9fMUsyOrq6vweAR6gox20tIGONtDRDlraQMfgiYulPjU1VTt37lR9fb2kA5fuLy4uVlpa2kGPTUtL0/bt22NvFxUVNfu4L02bNk2VlZWxW0lJifd/AY/9pegvyv9TvrZHt+usnmdpe3S78v+Ur78U/cXv0dBGFRUVfo8AD9DRDlraQEcb6GgHLW2gY/DExVKfnJys3NxcLViwQJK0ZMkS9evXTxkZGQc9dvTo0Vq6dKlKS0vlnNPs2bN1zTXXHPLYCQkJsYviBeHieJJU+HmhhqcM1x9G/UGzzp6lP4z6g4anDNfHn3/s92hoI64gagMd7aClDXS0gY520NIGOgbPMb/6/dSpU/Xiiy+qtLRUl156qRITE1VYWKg5c+Zo/PjxmjlzpiKRiObPnx97zqRJk5SXl6e8vDylp6drxowZOueccyRJF154oaZOnXqs/xpH1beyvqVOoQNfbyneXay03mn65YW/VKNr9HkytFV1dbXfI8ADdLSDljbQ0QY62kFLG+gYPMd8qZ8zZ06z9w8ePFirVq1q9n3z5s1r8vbkyZM1efJkz2eLF18u9JKaXNjvq/cjWIJ0gUYcGh3toKUNdLSBjnbQ0gY6Bg9bYpzr27ev3yPAA3S0gY520NIGOtpARztoaQMdg4elPs7xlTIb6GgDHe2gpQ10tIGOdtDSBjoGD0t9nNu7d6/fI8ADdLSBjnbQ0gY62kBHO2hpAx2Dh6U+zqWmpvo9AjxARxvoaActbaCjDXS0g5Y20DF4WOrj3J49e/weAR6gow10tIOWNtDRBjraQUsb6Bg8LPVxbv/+/X6PAA/Q0QY62kFLG+hoAx3toKUNdAwelvo4179/f79HgAfoaAMd7aClDXS0gY520NIGOgYPS32cKy0t9XsEeICONtDRDlraQEcb6GgHLW2gY/Cw1Me52tpav0eAB+hoAx3toKUNdLSBjnbQ0gY6Bg9LfZxLT0/3ewR4gI420NEOWtpARxvoaActbaBj8LDUx7ni4mK/R4AH6GgDHe2gpQ10tIGOdtDSBjoGD0t9nKuvr/d7BHiAjjbQ0Q5a2kBHG+hoBy1toGPwhJxzzu8hjqVoNKqkpCRVVlYqEon4Pc4R1dTUqGvXrn6PgXaiow10tIOWNtDRBjraQUsb6Bg/Wrq78p36OLd161a/R4AH6GgDHe2gpQ10tIGOdtDSBjoGT9jvAb5UXl6uSy65JPZ2dXW1tm7dqrKyMp1wwgmx+4uKinTqqadq2LBhsfuWLFmiU0899ZjOe6w0Njb6PQI8QEcb6GgHLW2gow10tIOWNtAxeOL29PsHHnhAy5cv1wsvvNDk/qKiImVnZ+vzzz9v03GDdvp9XV2dunTp4vcYaCc62kBHO2hpAx1toKMdtLSBjvEj8KffP/HEE7rxxhv9HsN3W7Zs8XsEeICONtDRDlraQEcb6GgHLW2gY/DEzen3X/X222+roqJCV1xxRbPv37dvn4YPH66Ghgbl5+frrrvuUufOnZt9bG1trWpra2NvR6PRozIzAAAAAADHWlyefn/jjTeqV69euv/++w96X21trSorK5WcnKzPPvtMY8aM0ciRI/WDH/yg2WPdc889mjFjxkH3c/o9jiU62kBHO2hpAx1toKMdtLSBjvEjsKff7927V88++6wmTpzY7PsTEhKUnJwsSTrhhBM0ceJErVy58pDHmzZtmiorK2O3kpKSozL30cLpLzbQ0QY62kFLG+hoAx3toKUNdAyeuDv9ftGiRcrKytJpp53W7PvLysrUs2dPdenSRbW1tXr++eeVk5NzyOMlJCQoISHhaI0LAAAAAIBv2vyd+vr6eq1fv16VlZVeztPsBfJ+/OMfa/bs2ZKkt956Szk5OcrKylJubq5SUlJ01113eTpDPBk8eLDfI8ADdLSBjnbQ0gY62kBHO2hpAx2Dp8U/U//GG2/oqquuUigU0pIlS3THHXeoqqpKu3fv1pIlS3TBBRcc7Vk9EbRfaffee+8pMzPT7zHQTnS0gY520NIGOtpARztoaQMd40dLd9cWn34/bdo0vf766/r88881evRoPfvss7r44ou1evVq3X777Yf9uXa0XadOcXfZA7QBHW2gox20tIGONtDRDlraQMfgafFS/8UXXyg7O1uS9LWvfU0XX3yxJGnEiBHau3fvURkOUnp6ut8jwAN0tIGOdtDSBjraQEc7aGkDHYOnxV+GaWxsjP35qquuavK+hoYG7yZCE4WFhX6PAA/Q0QY62kFLG+hoAx3toKUNdAyeFi/1Z5xxhqLRqCRp1qxZsfs//vjjQPxselCFw3H3CwrQBnS0gY520NIGOtpARztoaQMdg6fFF8o7lPr6etXV1albt26SpG3btumUU07xZLijIWgXyquurlb37t39HgPtREcb6GgHLW2gow10tIOWNtAxfrR0d233VRDC4XBsoZek0aNHt/eQ+IqtW7f6PQI8QEcb6GgHLW2gow10tIOWNtAxeDy/tGE7v/GPf5CQkOD3CPAAHW2gox20tIGONtDRDlraQMfg8XypD4VCXh+yQ0tJSfF7BHiAjjbQ0Q5a2kBHG+hoBy1toGPw8EsI49z27dv9HgEeoKMNdLSDljbQ0QY62kFLG+gYPJx+H+e+er0CBBcdbaCjHbS0gY420NEOWtpAx+DxfKm/8sorvT5kh9a7d2+/R4AH6GgDHe2gpQ10tIGOdtDSBjoGT6uX+pKSEl1xxRXKzs6WJBUUFOihhx6Kvf/uu+/2bDgc+Hgj+OhoAx3toKUNdLSBjnbQ0gY6Bk+rl/qpU6fqmmuuiZ1mn5mZqd/+9reeD4YDevTo4fcI8AAdbaCjHbS0gY420NEOWtpAx+Bp9VJfVlamsWPHqlOnA08Nh8MKh8OeD4YDIpGI3yPAA3S0gY520NIGOtpARztoaQMdg6fVS304HG5yMbyKigrPLo43YMAADR48WNnZ2crOztaiRYuafdwTTzyhgQMH6tRTT9XkyZNVV1fnyevHox07dvg9AjxARxvoaActbaCjDXS0g5Y2WO/4QfkHmvDyBH1Q/oHfo3im1Uv9VVddpalTpyoajWrevHkaOXKkJk2a5NlAixYtUkFBgQoKCjRmzJiD3r9t2zbdfffdWrlypQoLC7Vr1y7NnTvXs9ePN3ylzAY62kBHO2hpAx1toKMdtLTBesfCykKt3bVWhZWFfo/imVYv9bfffrsuuuginXnmmXrllVd022236Tvf+c7RmK1ZixcvVl5enlJSUhQKhXTTTTdp4cKFx+z1j7Xu3bv7PQI8QEcb6GgHLW2gow10tIOWNtAxeFr1w/ANDQ269NJL9dprr+naa689KgPdcMMNcs5pxIgRuu+++3TiiSc2eX9xcbH69+8fe3vAgAEqLi4+5PFqa2tVW1sbezsajXo/9FFUWlrKr5UwgI420NEOWtpARxvoaActbbDe8csfHffqR8jjQau+U9+5c2dVV1ersbHxqAyzYsUKbdy4UevWrVPv3r01bty4dh9z1qxZSkpKit1SU1M9mPTY6dmzp98jwAN0tIGOdtDSBjraQEc7aGmD5Y6FFYX62Ts/kyT97J2fqbDCxin4rb5s/fDhw3XFFVdo7NixTX7dQV5eXruHSUtLkyR16dJF3//+9zVo0KBmH/Pxxx/H3i4qKoo9rznTpk3TbbfdFns7Go0GarHv0qWL3yPAA3S0gY520NIGOtpARztoaYPVjvevuV8LNi+QJKV0T9Gu6l26cumVGjtkrH4w/Ac+T9c+rV7qN27cKEl6/PHHY/eFQqF2L/X79u1TXV2dvva1r0mSFi5cqJycnIMeN3r0aJ177rm65557dNJJJ2n27Nm65pprDnnchIQEJSQktGs2P5WVlSk5OdnvMdBOdLSBjnbQ0gY62kBHO2hpg9WOm8s368TuJ2rOP89RRs8MFVYUauprU/V++ft+j9ZurV7qly1bdjTm0K5duzR69Gg1NDTIOaf09HQ9/fTTkqRJkyYpLy9PeXl5Sk9P14wZM3TOOedIki688EJNnTr1qMwUD3r16uX3CPAAHW2gox20tIGONtDRDlraYLXjvH+Zp3Cnv6+/GT0z9PpVr6u+sd7HqbzR6qV+xYoVzd5//vnnt2uQ9PR0rV+/vtn3zZs3r8nbkydP1uTJk9v1egAAAACAjuGrC31L7g+SVv8Nbr/99tifa2pqtGXLFmVmZmrdunWeDoYDysvL1adPH7/HQDvR0QY62kFLG+hoAx3toKUNdAyeVi/1a9asafL26tWr9eSTT3o1D/6BxZ9n6YjoaAMd7aClDXS0gY520NIGOgZPq36lXXNGjBihVatWeTELmlFXV+f3CPAAHW2gox20tIGONtDRDlraQMfgafVSv3Hjxtht/fr1mj17NuGPooqKCr9HgAfoaAMd7aClDXS0gY520NIGOgZPq0+/HzVq1N+fHA5r4MCBeuqppzwdCn+XkpLi9wjwAB1toKMdtLSBjjbQ0Q5a2kDH4Gn1Ur9t27ajMQcOobq62u8R4AE62kBHO2hpAx1toKMdtLSBjsHT6tPv8/PzW3QfvBGNRv0eAR6gow10tIOWNtDRBjraQUsb6Bg8rV7qi4uLD7rv448/9mQYHKxv375+jwAP0NEGOtpBSxvoaAMd7aClDXQMnhYv9XPmzFFOTo62bNmi3Nzc2O3UU0/VKaeccjRn7ND4SpkNdLSBjnbQ0gY62kBHO2hpAx2Dp8U/U3/ZZZdp8ODB+ta3vqWHHnoodn8kEtHpp59+VIaDtHfvXr9HgAfoaAMd7aClDXS0gY520NIGOgZPi5f6/v37q3///nr//feP5jz4B6mpqX6PAA/Q0QY62kFLG+hoAx3toKUNdAyeVl/9fv/+/XrkkUdUUFCgmpqa2P3PP/+8p4PhgD179igpKcnvMdBOdLSBjnbQ0gY62kBHO2hpAx2Dp9UXyps8ebKKior09ttv66KLLtL27dvVv3//ozEbdOCLKAg+OtpARztoaQMdbaCjHbS0gY7B0+qlfsOGDfrNb36jSCSiW265RW+++ab++te/tnuQmpoa5efna9CgQcrKytLIkSNVWFh40OOKiorUuXNnZWdnx26Wr77PF0xsoKMNdLSDljbQ0QY62kFLG+gYPK1e6rt16yZJCofD2rdvnxITE7V7925PhpkyZYq2bNmiDRs2aNSoUZo0aVKzj0tMTFRBQUHsduqpp3ry+vGotLTU7xHgATraQEc7aGkDHW2gox20tIGOwdPqpf6EE05QRUWFLr/8cl166aXKz89Xv3792j1I165ddfnllysUCkmSzjrrLBUVFbX7uEFXW1vr9wjwAB1toKMdtLSBjjbQ0Q5a2kDH4Ak551xrntDQ0KDOnTvLOaff/e53qqio0A033KBIJOLpYNdff71OOOEEPfzww03uLyoq0sCBA5Wdna2Ghgbl5+frrrvuUufOnZs9Tm1tbZP/YUajUaWmpqqystLzmY+G6upqde/e3e8x0E50tIGOdtDSBjraQEc7aGkDHeNHNBpVUlLSEXfXVn+nvnPnztq5c6eWL1+u6667TlOnTlXXrl3bNew/mjlzpgoLCzVr1qyD3tenTx99+umnWrNmjV577TWtXLlSDz744CGPNWvWLCUlJcVuQfsVDcXFxX6PAA/Q0QY62kFLG+hoAx3toKUNdAyeVi/1ixcv1llnnaXx48dLkjZv3qz8/HzPBnrggQf0/PPP689//nOzXyFKSEhQcnKypAM/CjBx4kStXLnykMebNm2aKisrY7eSkhLPZj0W6uvr/R4BHqCjDXS0g5Y20NEGOtpBSxvoGDytXupnzZqldevWqWfPnpKkrKwsbd++3ZNhfvnLX2rhwoV69dVX9bWvfa3Zx5SVlamurk7SgVPrn3/+eeXk5BzymAkJCYpEIk1uQZKRkeH3CPAAHW2gox20tIGONtDRDlraQMfgadPp97169Wpy33HHHdfuQT755BPdfvvt+vzzz3XRRRcpOztb/+f//B9J0o9//GPNnj1bkvTWW28pJydHWVlZys3NVUpKiu666652v3682rp1q98jwAN0tIGOdtDSBjraQEc7aGkDHYMn3NonJCYmateuXbGr1L/++us64YQT2j1Iv379dKhr9v3kJz+J/fnKK6/UlVde2e7XC4rGxka/R4AH6GgDHe2gpQ10tIGOdtDSBjoGT4uvfr9p0yYNHTpUa9eu1ZQpU7R161ZlZmZq27ZtevHFF5WdnX2UR/VGS68gGC/q6urUpUsXv8dAO9HRBjraQUsb6GgDHe2gpQ10jB+eX/3++uuvlyR9//vf17Jly7Rw4ULdeeed2rRpU2AW+iDasmWL3yPAA3S0gY520NIGOtpARztoaQMdg6fFp9/X1NRo0aJF2rlzp1asWBE7VX7FihWSpLy8vKMzIQAAAAAAaFaLT79funSpZs+erZUrV+rMM89sepBQSG+88cZRGdBrnH4PP9DRBjraQUsb6GgDHe2gpQ10jB+en36fl5enl156SRMnTtSyZcua3IKy0AcRp7/YQEcb6GgHLW2gow10tIOWNtAxeFr9K+0efvjhozEHAAAAAABopRaffm8Fp9/DD3S0gY520NIGOtpARztoaQMd44fnp9/DH5z+YgMdbaCjHbS0gY420NEOWtpAx+BhqY9znTqRyAI62kBHO2hpAx1toKMdtLSBjsHD6fdxrqamRl27dvV7DLQTHW2gox20tIGONtDRDlraQMf4wen3RhQWFvo9AjxARxvoaActbaCjDXS0g5Y20DF4WOrjXDgc9nsEeICONtDRDlraQEcb6GgHLW2gY/Cw1Me5tLQ0v0eAB+hoAx3toKUNdLSBjnbQ0gY6Bg9LfZzbunWr3yPAA3S0gY520NIGOtpARztoaQMdgyeulvqPPvpIZ599tgYNGqThw4dr06ZNzT7uiSee0MCBA3Xqqadq8uTJqqurO8aTHjsJCQl+jwAP0NEGOtpBSxvoaAMd7aClDXQMnrha6qdOnaopU6boww8/1A9/+EONHz/+oMds27ZNd999t1auXKnCwkLt2rVLc+fOPfbDHiMpKSl+jwAP0NEGOtpBSxvoaAMd7aClDXQMnrhZ6svKyrR27VqNHTtWkjR69GiVlJQcdPXFxYsXKy8vTykpKQqFQrrpppu0cOFCP0Y+JrZv3+73CPAAHW2gox20tIGONtDRDlraQMfgiZulvqSkRH369IldbTEUCiktLU3FxcVNHldcXKz+/fvH3h4wYMBBj/mq2tpaRaPRJrcg6datm98jwAN0tIGOdtDSBjraQEc7aGkDHYMnbpb6o2XWrFlKSkqK3VJTU/0eqVV69+7t9wjwAB1toKMdtLSBjjbQ0Q5a2kDH4ImbpT41NVU7d+5UfX29JMk5p+Li4oN+pUJaWlqTU0KKiooO+2sXpk2bpsrKytitpKTk6PwFjpKgzYvm0dEGOtpBSxvoaAMd7aClDXQMnrhZ6pOTk5Wbm6sFCxZIkpYsWaJ+/fopIyOjyeNGjx6tpUuXqrS0VM45zZ49W9dcc80hj5uQkKBIJNLkFiQ9evTwewR4gI420NEOWtpARxvoaActbaBj8MTNUi9Jc+bM0Zw5czRo0CDdd999mj9/viRp0qRJWrp0qSQpPT1dM2bM0DnnnKOMjAydeOKJmjp1qp9jH1VB+yIEmkdHG+hoBy1toKMNdLSDljbQMXjCfg/wVYMHD9aqVasOun/evHlN3p48ebImT558rMby1Y4dO3TCCSf4PQbaiY420NEOWtpARxvoaActbaBj8MTVd+pxML5SZgMdbaCjHbS0gY7Bt7t6t14of0G7q3f7PQo8wOekDXQMHpb6ONe9e3e/R4AH6GgDHe2gpQ10DL7d+3frd0W/0+79LPUW8DlpAx2Dh6U+zpWWlvo9AjxARxvoaActbaAjEF/4nLSBjsHDUh/nevbs6fcI8AAdbaCjHbS0gY7B5+Sa/BfBxuekDXQMHpb6ONelSxe/R4AH6GgDHe2gpQ10DLby/eW67937JEn3vXufyveX+zwR2ovPSRvoGDws9XGurKzM7xHgATraQEc7aGkDHYPrL0V/Uf6f8rU9ul1n9TxL26Pblf+nfP2l6C9+j4Z24HPSBjoGT1z9SjscrFevXn6PAA/Q0QY62kFLG+gYXIWfF2p4ynDd9X/u0heff6Hjvnacfvbuz/Tx5x/7PRragc9JG+gYPCz1AAAAOKa+lfUtdQodOGF05+c71atbL/3ywl+q0TX6PBkABE+HW+qdO3Ahlmg06vMkLbN9+3Ydf/zxfo+BdqKjDXS0g5Y20NEGOtpBSxvoGD++3Fm/3GEPpcMt9VVVVZKk1NRUnycBAAAAAODwqqqqlJSUdMj3h9yR1n5jGhsbtWPHDiUmJioUCvk9zmFFo1GlpqaqpKREkUjE73HQRnS0gY520NIGOtpARztoaQMd44tzTlVVVerbt686dTr0Ne473HfqO3XqpH79+vk9RqtEIhE+qQygow10tIOWNtDRBjraQUsb6Bg/Dvcd+i/xK+0AAAAAAAgolnoAAAAAAAKKpT6OJSQkaPr06UpISPB7FLQDHW2gox20tIGONtDRDlraQMdg6nAXygMAAAAAwAq+Uw8AAAAAQECx1AMAAAAAEFAs9QAAAAAABBRL/RHU1NQoPz9fgwYNUlZWlkaOHKnCwkJJUllZmS677DINHDhQmZmZWrFiRex5EyZMiD3nnHPO0Zo1a2Lvu+uuuzRs2DBlZ2crOztbv//97w/5+tXV1br22muVkZGhQYMGafHixbH33XnnnTrttNOUlZWlM888U3/5y18OeZzGxkbdcsstOvXUU5WRkaFHH330oMeUlZXppJNOUn5+fms+RIFBSxvoaENH6HjPPffoxBNPjM1z3XXXteljFe9oaUNH6ChJS5Ys0bBhw5SZmanMzEwVFRW19kMV1+hoBy3RKg6HtX//fvfiiy+6xsZG55xzjzzyiLvgggucc85NmDDBTZ8+3Tnn3OrVq93JJ5/svvjiC+ecc3/6059cXV2dc865F154wfXv3z92zIqKitifP/nkE5eYmOh2797d7OvPmDHDjRs3zjnn3NatW92JJ57o9uzZ45xz7qWXXnLV1dXOOecKCgpcJBJxe/fubfY4Tz31lLv44otdfX29Ky8vd2lpae69995r8pj8/Hw3ceJEN2rUqBZ9bIKGljbQ0YaO0HH69Onue9/7Xqs+LkFESxs6Qsd169a5wYMHu08//dQ551w0GnX79u1rxUcp/tHRDlqiNVjqW2nNmjWxT47jjz/e7dy5M/a+4cOHu1dfffWg5+zevduFw+HYJ9hXffDBB65Hjx5u165dzb7ekCFD3KpVq2JvX3XVVe7xxx8/6HENDQ0uMTHRbdu2rdnjXH755W7hwoWxt++44w531113xd6eN2+eu/XWW938+fNNLhDNoaUNdLTBYseOsAg2h5Y2WOx43XXXuTlz5jT7PKvoaActcTicft9KDz/8sEaNGqXy8nLV1dUpJSUl9r4BAwaouLi42edcfvnlCofDsft+/etfa/DgwcrNzdXcuXOVnJzc7OsVFxerf//+R3yN+fPnKz09vcljW3qcbdu2afbs2frZz352hL+9LbS0gY42WOwoSc8995yysrJ08cUXa9myZYf5CNhBSxssdty8ebOKi4t1wQUXKCcnR3fffbcaGhqO8JEINjraQUscDkt9K8ycOVOFhYWaNWtWi5+zYMECPfvss5o7d26T+7/73e9qy5YtevvttzVz5kyVl5e3ea7XX39dM2bM0KJFixQKhVr1XOecJk6cqEcffVTdunVr8wxBQ0sb6GiDxY6SdNNNN6moqEgbNmzQvffeqzFjxmj79u1tnicIaGmD1Y719fVav369Xn75Zb311lt6++239dhjj7V5nnhHRztoiSNhqW+hBx54QM8//7z+/Oc/q3v37urVq5fC4bBKS0tjjykqKlJaWlrs7UWLFmnGjBl69dVXddJJJzV73KysLJ188sl68803tXnz5tiFK26++WZJUlpaWpP/x+EfX2P58uWaMGGCXnjhBQ0ePFiS9Pnnn8eO841vfOOwx4lGo9q4caPGjBmjAQMG6D/+4z/0yiuv6JJLLvHgoxafaGkDHW2w2lGSUlJS1KVLF0nSOeeco5ycHK1du7ZdH694RksbLHdMS0vT6NGj1a1bNx1//PG68sor9c4777T3QxaX6GgHLdEiPp/+HwgPPvigy83NdZ999lmT+8eNG9fkIhV9+/aNXaRi0aJFLiMjwxUVFR10vE2bNsX+XFhY6JKTk93mzZubfe3p06cfdJGKLy9osXz5cpeamurWrVt3xL/D/PnzD7pIxcaNG5t9nOWf36WlDXS0wXrHkpKS2OM+/PBDl5yc7LZs2XLEYwYRLW2w3vGZZ55xY8aMcQ0NDa6urs7l5eW5+++//4jHDBo62kFLtBRL/RGUlJQ4SS49Pd1lZWW5rKwsN2LECOecc6WlpW7kyJEuIyPDDRkyxL3xxhux54XDYdevX7/Yc7KysmJXjPz617/uhgwZ4rKystwZZ5zhnn322UO+/t69e93VV1/t0tPT3cCBA92iRYti78vIyHDJyclNXqO5pcA55+rr6923v/1td8opp7j09HT3q1/9qtnHWV4gaGkDHW3oCB1vuOEGN3ToUJeVleVyc3Pdc889166PWbyipQ0doWNDQ4O7/fbb3WmnneaGDh3qbrrpJldbW9uuj1u8oaMdtERrhJxzzr/zBAAAAAAAQFvxM/UAAAAAAAQUSz0AAAAAAAHFUg8AAAAAQECx1AMAAAAAEFAs9QAAAAAABBRLPQAAAAAAAcVSDwAAAABAQLHUAwAAAAAQUCz1AAAAAAAEFEs9AAAAAAABxVIPAAAAAEBA/T9B7L+x4MlUtwAAAABJRU5ErkJggg==",
+            "text/plain": [
+              "<Figure size 1024x450 with 3 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "evset.plot()"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "fe507137-0c0f-4533-a75d-008352a2566b",
+      "metadata": {},
+      "source": [
+        "\n",
+        "**Note:** You'll learn how to create an `EventSet` using other data sources such as pandas DataFrames later.\n",
+        "\n",
+        "Events can carry various meanings. For instance, events can represent **regular measurements**. Suppose an electronic thermometer that generates temperature measurements every minute. This could be an `EventSet` with one feature called `temperature`. In this scenario, the temperature can change between two measurements. However, for most practical uses, the most recent measurement will be considered the current temperature.\n",
+        "\n",
+        "<!-- TODO: Temperature plot -->\n",
+        "\n",
+        "Events can also represent the _occurrence_ of sporadic phenomena. Suppose a sales recording system that records client purchases. Each time a client makes a purchase (i.e., each transaction), a new event is created.\n",
+        "\n",
+        "<!-- TODO: Sales plot -->\n",
+        "\n",
+        "You will see that Temporian is agnostic to the semantics of events, and that often, you will mix together measurements and occurrences. For instance, given the _occurrence_ of sales from the previous example, you can compute daily sales (which is a _measurement_).\n"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "e7a88b45-bef7-46ac-88b8-f376cc14ee88",
+      "metadata": {},
+      "source": [
+        "## Operators and eager mode\n",
+        "\n",
+        "Processing operations are performed by **Operators**. For instance, the `tp.simple_moving_average()` operator computes the [simple moving average](https://en.wikipedia.org/wiki/Moving_average) of each feature in an `EventSet`.\n",
+        "\n",
+        "The list of all operators is available in the [API Reference](../reference/)."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 4,
+      "id": "f0c059c3-1412-47d5-8f21-8c034f16a551",
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2023-07-12T19:18:44.689781Z",
+          "iopub.status.busy": "2023-07-12T19:18:44.688990Z",
+          "iopub.status.idle": "2023-07-12T19:18:44.920401Z",
+          "shell.execute_reply": "2023-07-12T19:18:44.919687Z"
+        }
+      },
+      "outputs": [
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 1024x300 with 2 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "# Create an event set with a random walk\n",
+        "np.random.seed(1)\n",
+        "random_walk = np.cumsum(np.random.choice([-1.0, 0.0, 1.0], size=1000))\n",
+        "\n",
+        "evset = tp.event_set(\n",
+        "\ttimestamps=np.linspace(0,10, num=1000),\n",
+        "\tfeatures={\"value\": random_walk}\n",
+        ")\n",
+        "\n",
+        "# Compute a simple moving average\n",
+        "result = tp.simple_moving_average(evset, window_length=1)\n",
+        "\n",
+        "# Plot the results\n",
+        "tp.plot([evset, result]) "
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "0dd8a9a5-19b4-4898-b5af-794dbd4ac1eb",
+      "metadata": {},
+      "source": [
+        "## Eager mode vs Graph mode\n",
+        "\n",
+        "Temporian has two execution modes: **eager** and **graph**. In eager mode, operators are applied immediately. This mode is useful for learning Temporian, for iterative and interactive development, and for lightweight/small data use cases where performance isn't a priority.\n",
+        "\n",
+        "In graph mode, operators are combined together into \"Temporian programs\" before being executed. Graph mode is more efficient and it consumes less memory. Temporian programs can be saved, inspected, and distributed by users.\n",
+        "\n",
+        "Migrating a Temporian program from eager to graph mode is easy and requires little work. Most of the time, adding a `@tp.compile` annotation is enough. Therefore, it is recommended to develop programs in eager mode and then to productize them in graph mode.\n",
+        "\n",
+        "Next, we see a the same program written three times: First, in eager mode, then in graph mode using `@tp.compile`, and finally in graph mode without `@tp.compile`."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 5,
+      "id": "d5405837-c801-40e9-8b41-4d4dc901d429",
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2023-07-12T19:18:44.922893Z",
+          "iopub.status.busy": "2023-07-12T19:18:44.922680Z",
+          "iopub.status.idle": "2023-07-12T19:18:45.058522Z",
+          "shell.execute_reply": "2023-07-12T19:18:45.057820Z"
+        }
+      },
+      "outputs": [
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 1024x150 with 1 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "# Eager mode\n",
+        "#\n",
+        "# Note: This Temporian program contains three operators: two \"simple_moving_average\" and one \"tp.substract\" operators.\n",
+        "result = tp.simple_moving_average(evset, window_length=0.5) - tp.simple_moving_average(evset, window_length=1.0)\n",
+        "result.plot()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 6,
+      "id": "9c854408-0804-4435-8d44-f521ef1b379e",
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2023-07-12T19:18:45.060873Z",
+          "iopub.status.busy": "2023-07-12T19:18:45.060668Z",
+          "iopub.status.idle": "2023-07-12T19:18:45.188317Z",
+          "shell.execute_reply": "2023-07-12T19:18:45.187603Z"
+        }
+      },
+      "outputs": [
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 1024x150 with 1 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "# Graph mode with @tp.compile\n",
+        "\n",
+        "@tp.compile\n",
+        "def my_function(x):\n",
+        "    return tp.simple_moving_average(x, window_length=0.5) - tp.simple_moving_average(x, window_length=1.0)\n",
+        "\n",
+        "result = my_function(evset)\n",
+        "    \n",
+        "result.plot()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 7,
+      "id": "e4aa008f-aa8e-486f-a96c-854fb5b2bd83",
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2023-07-12T19:18:45.190989Z",
+          "iopub.status.busy": "2023-07-12T19:18:45.190568Z",
+          "iopub.status.idle": "2023-07-12T19:18:45.330304Z",
+          "shell.execute_reply": "2023-07-12T19:18:45.329427Z"
+        }
+      },
+      "outputs": [
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "Build schedule\n",
+            "Run 3 operators\n",
+            "    1 / 3: SIMPLE_MOVING_AVERAGE [0.00007 s]\n",
+            "    2 / 3: SIMPLE_MOVING_AVERAGE [0.00004 s]\n",
+            "    3 / 3: SUBTRACTION [0.00007 s]\n",
+            "Execution in 0.00050 s\n"
+          ]
+        },
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 1024x150 with 1 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "# Graph model without @tp.compile\n",
+        "\n",
+        "input_node = tp.input_node([(\"value\", tp.float64)])\n",
+        "# Or input_node = tp.input_node(evset.schema.features)\n",
+        "\n",
+        "result_node = tp.simple_moving_average(input_node, window_length=0.5) - tp.simple_moving_average(input_node, window_length=1.0)\n",
+        "result = tp.run(result_node, {input_node: evset}, verbose=1)\n",
+        "    \n",
+        "result.plot()"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "a6a5a017-9dbe-4782-bc73-9b278ec622b0",
+      "metadata": {},
+      "source": [
+        "## More on graph mode\n",
+        "\n",
+        "**Remark:** While you will likely use the graph mode with `@tp.compile` , it is useful for you to understand the graph model without `@tp.compile`.\n",
+        "\n",
+        "A Temporian program is a graph of [EventSetNode][temporian.EventSetNodes]s connecting operators. A graph is executed with the function `tp.run(<outputs>, <inputs>)`.\n",
+        "\n",
+        "<img src=\"https://github.com/google/temporian/blob/main/docs/src/assets/eager_and_graph.svg\" width=\"100%\" alt=\"eager vs graph mode\">\n",
+        "\n",
+        "The `<outputs>` can be specified as an `EventSetNode`, a list of `EventSetNodes`, or a dictionary of names to `EventSetNodes`, and the result of `tp.run()` will be of the same type. For example, if `<outputs>` is a list of three `EventSetNodes`, the result will be a list of the three corresponding `EventSets`.\n",
+        "\n",
+        "The `<inputs>` can be specified as:\n",
+        "\n",
+        "- A dictionary of `EventSetNodes` to `EventSets`, or \n",
+        "- A dictionary of names to `EventSets`, or,\n",
+        "- A list of `EventSets`, or\n",
+        "- A single `EventSet`\n",
+        "\n",
+        "This lets Temporian know the `EventSetNodes` of the graph that each input `EventSet` corresponds to. If `<inputs>` is a dictionary of names to `EventSets`, the names must match the names of `EventSetNodes` in the graph.  If `<inputs>` is a list or a single `EventSet`, the names of those `EventSets` must do the same. If we specify the inputs as a dictionary, we could skip passing a name to `a_evset`."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 8,
+      "id": "dd4142a0-df47-4ca3-aafe-7a105b4f2deb",
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2023-07-12T19:18:45.332924Z",
+          "iopub.status.busy": "2023-07-12T19:18:45.332468Z",
+          "iopub.status.idle": "2023-07-12T19:18:45.342998Z",
+          "shell.execute_reply": "2023-07-12T19:18:45.342153Z"
+        }
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "[indexes: []\n",
+            "features: [('value', float64)]\n",
+            "events:\n",
+            "     (1000 events):\n",
+            "        timestamps: [ 0.    0.01  0.02 ...  9.98  9.99 10.  ]\n",
+            "        'value': [ 0.   -0.5  -1.   ...  3.74  3.76  3.76]\n",
+            "memory usage: 8.5 kB\n",
+            ", indexes: []\n",
+            "features: [('value', float64)]\n",
+            "events:\n",
+            "     (1000 events):\n",
+            "        timestamps: [ 0.    0.01  0.02 ...  9.98  9.99 10.  ]\n",
+            "        'value': [ 0.   -0.5  -1.   ...  1.04  1.09  1.14]\n",
+            "memory usage: 8.5 kB\n",
+            ", indexes: []\n",
+            "features: [('sub_value_value', float64)]\n",
+            "events:\n",
+            "     (1000 events):\n",
+            "        timestamps: [ 0.    0.01  0.02 ...  9.98  9.99 10.  ]\n",
+            "        'sub_value_value': [0.   0.   0.   ... 2.7  2.67 2.62]\n",
+            "memory usage: 8.5 kB\n",
+            "]\n"
+          ]
+        }
+      ],
+      "source": [
+        "input_node = tp.input_node([(\"value\", tp.float64)])\n",
+        "result_1_node = tp.simple_moving_average(input_node, window_length=0.5)\n",
+        "result_2_node = tp.simple_moving_average(input_node, window_length=1.0)\n",
+        "result_3_node = result_1_node - result_2_node\n",
+        "\n",
+        "result = tp.run([result_1_node,result_2_node, result_3_node], {input_node: evset})\n",
+        "    \n",
+        "print(result)"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "32dd49a8-8847-4df1-be17-b844b92f4211",
+      "metadata": {},
+      "source": [
+        "**Remarks:**\n",
+        "\n",
+        "- It's important to distinguish between a `tp.EventSet`, such as `evset`, that contains data, and a `tp.EventSetNode`, like `input_node`, that connect operators together and compose the computation graph, but do not contain data.\n",
+        "- No computation is performed when defining the graph (i.e., when calling the operator functions). All computation is done during `tp.run()`.\n",
+        "- In `tp.run()`, the second argument defines a mapping between input `EventSetNodes` and `EventSets`. If all necessary input `EventSetNodes` are not fed, an error will be raised.\n",
+        "- In most cases you will only pass `EventSets` that correspond to the graph's input `EventSetNodes`, but Temporian also supports passing `EventSets` to intermediate `EventSetNodes` in the graph."
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "c7e808b2-4091-447a-a6a5-66fcf5f037a9",
+      "metadata": {},
+      "source": [
+        "The `@tp.compile` annotation takes a function inputing and outputing `tp.EventSetNode`, and automatically calls `tp.run` on the result of the function if a `tp.EventSet` is provided as input."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 9,
+      "id": "b0b0220b-9869-454c-8f3b-afeabaca06bc",
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2023-07-12T19:18:45.345745Z",
+          "iopub.status.busy": "2023-07-12T19:18:45.345069Z",
+          "iopub.status.idle": "2023-07-12T19:18:45.350527Z",
+          "shell.execute_reply": "2023-07-12T19:18:45.349823Z"
+        }
+      },
+      "outputs": [],
+      "source": [
+        "@tp.compile\n",
+        "def my_function(x : tp.EventSetNode) -> tp.EventSetNode:\n",
+        "    return tp.simple_moving_average(x, window_length=0.5)\n",
+        "\n",
+        "# Feeding an EventSet\n",
+        "input_evset = tp.event_set(timestamps=[1, 2, 3],features={\"value\": [5., 6., 7.]})\n",
+        "assert isinstance(my_function(input_evset), tp.EventSet)\n",
+        "\n",
+        "# Feeding an EventSetNode\n",
+        "input_node = tp.input_node([(\"value\", tp.float64)])\n",
+        "assert isinstance(my_function(input_node), tp.EventSetNode)"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "c0f02853-718f-4c9e-8945-b25e74b548ae",
+      "metadata": {},
+      "source": [
+        "Importantly, variables in a `tp.compile` function are `EventSetNode` and not `EventSet`. Therefore, you cannot directly access the event set data.\n",
+        "\n",
+        "In addition, the compiled function execution first generates the graph. The graph is then executed. In the next example, the compiled function generates a graph with 10 operators."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 10,
+      "id": "945d8f39-18ad-44df-a4d2-9d8986e7825b",
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2023-07-12T19:18:45.353329Z",
+          "iopub.status.busy": "2023-07-12T19:18:45.353112Z",
+          "iopub.status.idle": "2023-07-12T19:18:45.358949Z",
+          "shell.execute_reply": "2023-07-12T19:18:45.357662Z"
+        }
+      },
+      "outputs": [],
+      "source": [
+        "@tp.compile\n",
+        "def my_function(x : tp.EventSetNode) -> tp.EventSetNode:\n",
+        "    for i in range(10):\n",
+        "        x = tp.simple_moving_average(x, window_length=i+1)\n",
+        "    return x"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "4c46c4ee-a8ff-4b9b-9ced-acbee202d0a3",
+      "metadata": {},
+      "source": [
+        "You can create a compiled function with a `if`. However, the condition of the `if` cannot depend on the EventSet data."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 11,
+      "id": "941a5fc4-edfc-4fba-8bc8-22f3a7387e91",
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2023-07-12T19:18:45.362130Z",
+          "iopub.status.busy": "2023-07-12T19:18:45.361815Z",
+          "iopub.status.idle": "2023-07-12T19:18:45.367314Z",
+          "shell.execute_reply": "2023-07-12T19:18:45.366603Z"
+        }
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "[('a_branch', float64)]\n",
+            "[('non_a_branch', float64)]\n"
+          ]
+        }
+      ],
+      "source": [
+        "@tp.compile\n",
+        "def my_function(x : tp.EventSetNode, a:bool) -> tp.EventSetNode:\n",
+        "    if a:\n",
+        "        return tp.rename(x, \"a_branch\")\n",
+        "    else:\n",
+        "        return tp.rename(x, \"non_a_branch\")\n",
+        "\n",
+        "print(my_function(input_evset, a=True).schema.features)\n",
+        "\n",
+        "print(my_function(input_evset, a=False).schema.features)"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "3bf624e6-6b1c-4806-8024-8beebd30fc0b",
+      "metadata": {},
+      "source": [
+        "If you want to create a program conditional on EventSet data, you can use a `tp.filter`."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 12,
+      "id": "a9ab68f3-91a6-445e-99c2-7f2379185f21",
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2023-07-12T19:18:45.369918Z",
+          "iopub.status.busy": "2023-07-12T19:18:45.369624Z",
+          "iopub.status.idle": "2023-07-12T19:18:45.376649Z",
+          "shell.execute_reply": "2023-07-12T19:18:45.375861Z"
+        }
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "indexes: []\n",
+              "features: [('value', int64)]\n",
+              "events:\n",
+              "     (2 events):\n",
+              "        timestamps: [1. 2.]\n",
+              "        'value': [10 11]\n",
+              "memory usage: 0.5 kB"
+            ]
+          },
+          "execution_count": 12,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "@tp.compile\n",
+        "def my_function(x : tp.EventSetNode) -> tp.EventSetNode:\n",
+        "    return tp.filter(x[\"value\"], x[\"condition\"])\n",
+        "\n",
+        "my_function(tp.event_set(\n",
+        "\ttimestamps=[1,2,3],\n",
+        "\tfeatures={\n",
+        "        \"value\": [10, 11, 12],\n",
+        "        \"condition\":[True, True, False]}\n",
+        "))"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "c7ef8b32-a08d-46e2-aa8e-5cad3d5421e0",
+      "metadata": {},
+      "source": [
+        "To simplify its usage when the graph contains a single output `EventSetNode`, `node.run(...)` is equivalent to `tp.run(node, ...)`."
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "afa9c5d2-1efe-440d-bf45-366c0b389b5a",
+      "metadata": {},
+      "source": [
+        "\n",
+        "<!-- TODO\n",
+        "# Not implemented yet:\n",
+        "# d_evset = tp.run(d_node, {\"a\": a_evset})\n",
+        "# d_evset = tp.run(d_node, [a_evset])\n",
+        "# d_evset = tp.run(d_node, a_evset)\n",
+        "# d_evset = d_node.run({\"a\": a_evset})\n",
+        "# d_evset = d_node.run([a_evset])\n",
+        "# d_evset = d_node.run(a_evset)\n",
+        "-->\n",
+        "\n",
+        "**Warning:** It is more efficient to run multiple output `EventSetNodes` together with `tp.run()` than to run them separately with `node_1.run(...)`, `node_2.run(...)`, etc."
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "d78f320b",
+      "metadata": {
+        "cell_marker": "\"\"\"",
+        "lines_to_next_cell": 0
+      },
+      "source": [
+        "Previously, we defined the input of the graph with `tp.input_node()`. This way of listing features manually and their respective data type is cumbersome.\n",
+        "\n",
+        "If an `EventSet` is available (i.e., data is available) this step can be changed to use `evset.node()` instead, which will return an `EventSetNode` that is compatible with it. This is especially useful when creating `EventSets` from existing data, such as pandas DataFrames or CSV files."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 13,
+      "id": "d4fc33b0",
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2023-07-12T19:18:45.379097Z",
+          "iopub.status.busy": "2023-07-12T19:18:45.378892Z",
+          "iopub.status.idle": "2023-07-12T19:18:45.383530Z",
+          "shell.execute_reply": "2023-07-12T19:18:45.382775Z"
+        },
+        "lines_to_next_cell": 0
+      },
+      "outputs": [],
+      "source": [
+        "# Define an EventSet.\n",
+        "a_evset = tp.event_set(\n",
+        "\ttimestamps=[0, 1, 2],\n",
+        "\tfeatures={\n",
+        "        \"feature_1\": [1.0, 2.0, 3.0],\n",
+        "        \"feature_2\": [\"hello\", \"little\", \"dog\"],\n",
+        "        \"feature_3\": [\"A\", \"A\", \"B\"],\n",
+        "\t}\n",
+        ")\n",
+        "\n",
+        "# The following three statements are (almost) equivalent.\n",
+        "a_node = tp.input_node(\n",
+        "    features=[\n",
+        "        (\"feature_1\", tp.float64),\n",
+        "        (\"feature_2\", tp.str_),\n",
+        "    ],\n",
+        "    indexes=[(\"feature_3\", tp.str_)])\n",
+        "\n",
+        "a_node = tp.input_node(features=a_evset.schema.features,\n",
+        "                       indexes=a_evset.schema.indexes)\n",
+        "    \n",
+        "a_node = a_evset.node()"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "b73d3011",
+      "metadata": {
+        "cell_marker": "\"\"\"",
+        "lines_to_next_cell": 0
+      },
+      "source": [
+        "\n",
+        "## Time units\n",
+        "\n",
+        "In Temporian, times are always represented by a float64 value. Users have the freedom to choose the semantic to this value. For example, the time can be the number of nanoseconds since the start of the day, the number of cycles of a process, the number of years since the big bang, or the number of seconds since January 1, 1970, at 00:00:00 UTC, also known as Unix or POSIX time.\n",
+        "\n",
+        "To ease the feature engineering of dates, Temporian contains a set of _calendar operators_. These operators specialize in creating features from dates and datetimes. For instance, the `tp.calendar_hour()` operator returns the hour of the date in the range `0-23`.\n",
+        "\n",
+        "Calendar operators require the time in their inputs to be Unix time, so applying them on non-Unix timestamps will raise errors. Temporian can sometimes automatically recognize if input timestamps correspond to Unix time (e.g. when an `EventSet` is created from a pandas DataFrame with a datetime column, or when passing a list of datetime objects as timestamps in `EventSet`'s constructor). If creating `EventSets` manually and passing floats directly to `timestamps`, you need to explicitly specify whether they correspond to Unix times or not via the `is_unix_timestamp` argument."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 14,
+      "id": "92ec9711",
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2023-07-12T19:18:45.386117Z",
+          "iopub.status.busy": "2023-07-12T19:18:45.385905Z",
+          "iopub.status.idle": "2023-07-12T19:18:45.394646Z",
+          "shell.execute_reply": "2023-07-12T19:18:45.393913Z"
+        },
+        "lines_to_next_cell": 0
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "indexes: []\n",
+              "features: [('feature_1', int64), ('feature_2', str_), ('calendar_day_of_week', int32)]\n",
+              "events:\n",
+              "     (3 events):\n",
+              "        timestamps: [1.6787e+09 1.6788e+09 1.6790e+09]\n",
+              "        'feature_1': [1 2 3]\n",
+              "        'feature_2': [b'a' b'b' b'c']\n",
+              "        'calendar_day_of_week': [0 1 4]\n",
+              "memory usage: 0.8 kB"
+            ]
+          },
+          "execution_count": 14,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "a_evset = tp.event_set(\n",
+        "    timestamps=[\n",
+        "        pd.to_datetime(\"Monday Mar 13 12:00:00 2023\", utc=True),\n",
+        "        pd.to_datetime(\"Tuesday Mar 14 12:00:00 2023\", utc=True),\n",
+        "        pd.to_datetime(\"Friday Mar 17 00:00:01 2023\", utc=True),\n",
+        "    ],\n",
+        "    features={\n",
+        "        \"feature_1\": [1, 2, 3],\n",
+        "        \"feature_2\": [\"a\", \"b\", \"c\"],\n",
+        "    },\n",
+        ")\n",
+        "a_node = a_evset.node()\n",
+        "b_node = tp.glue(a_node, tp.calendar_day_of_week(a_node))\n",
+        "b_node.run(a_evset)"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "7380c9c7",
+      "metadata": {
+        "cell_marker": "\"\"\"",
+        "lines_to_next_cell": 0
+      },
+      "source": [
+        "\n",
+        "Temporian accepts time inputs in various formats, including integer, float, Python date or datetime, NumPy datetime, and pandas datetime. Date and datetime objects are internally converted to floats as Unix time in seconds, compatible with the calendar operators.\n",
+        "\n",
+        "Operators can take _durations_ as input arguments. For example, the simple moving average operator takes a `window_length` argument. Temporian exposes several utility functions to help creating those duration arguments when using Unix timestamps:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 15,
+      "id": "508c3f0c",
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2023-07-12T19:18:45.396932Z",
+          "iopub.status.busy": "2023-07-12T19:18:45.396715Z",
+          "iopub.status.idle": "2023-07-12T19:18:45.401047Z",
+          "shell.execute_reply": "2023-07-12T19:18:45.400244Z"
+        }
+      },
+      "outputs": [],
+      "source": [
+        "a = tp.input_node(features=[(\"feature_1\", tp.float64)])\n",
+        "\n",
+        "# Define a 1-day moving average.\n",
+        "b = tp.simple_moving_average(a, window_length=tp.duration.days(1))\n",
+        "\n",
+        "# Equivalent.\n",
+        "b = tp.simple_moving_average(a, window_length=24 * 60 * 60)"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "6c99993c",
+      "metadata": {
+        "cell_marker": "\"\"\"",
+        "lines_to_next_cell": 0
+      },
+      "source": [
+        "\n",
+        "## Plotting\n",
+        "\n",
+        "Data visualization is crucial for gaining insights into data and the system it represents. It also helps in detecting unexpected behavior and issues, making debugging and iterative development easier.\n",
+        "\n",
+        "Temporian provides two plotting functions for data visualization: `evset.plot()` and `tp.plot()`.\n",
+        "\n",
+        "The `evset.plot()` function is shorter to write and is used for displaying a single `EventSet`, while the `tp.plot()` function is used for displaying multiple `EventSets` together. This function is particularly useful when `EventSets` are indexed (see [Index, horizontal and vertical operators](#indexes-horizontal-and-vertical-operators)) or have different samplings (see [Sampling](#sampling)).\n",
+        "\n",
+        "Here's an example of using the `evset.plot()` function:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 16,
+      "id": "cbf42f42",
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2023-07-12T19:18:45.403996Z",
+          "iopub.status.busy": "2023-07-12T19:18:45.403771Z",
+          "iopub.status.idle": "2023-07-12T19:18:45.643643Z",
+          "shell.execute_reply": "2023-07-12T19:18:45.643082Z"
+        }
+      },
+      "outputs": [
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 1024x300 with 2 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "evset = tp.event_set(\n",
+        "\ttimestamps=[1, 2, 3, 4, 5],\n",
+        "\tfeatures={\n",
+        "        \"feature_1\": [0.5, 0.6, 0.4, 0.4, 0.9],\n",
+        "        \"feature_2\": [\"red\", \"blue\", \"red\", \"blue\", \"green\"]\n",
+        "    }\n",
+        ")\n",
+        "evset.plot()"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "39dc9a92",
+      "metadata": {
+        "cell_marker": "\"\"\"",
+        "lines_to_next_cell": 0
+      },
+      "source": [
+        "\n",
+        "By default, the plotting style is selected automatically based on the data.\n",
+        "\n",
+        "For example, uniformly sampled numerical features (i.e., time series) are plotted with a continuous line, while non-uniformly sampled values are plotted with markers. Those and other behaviors can be controlled via the function's arguments.\n",
+        "\n",
+        "Here's an example of using the `evset.plot()` function with options:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 17,
+      "id": "82552e04",
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2023-07-12T19:18:45.647386Z",
+          "iopub.status.busy": "2023-07-12T19:18:45.647153Z",
+          "iopub.status.idle": "2023-07-12T19:18:45.925838Z",
+          "shell.execute_reply": "2023-07-12T19:18:45.925123Z"
+        }
+      },
+      "outputs": [
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 400x300 with 2 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "figure = evset.plot(\n",
+        "    style=\"marker\",\n",
+        "    width_px=400,\n",
+        "    min_time=2,\n",
+        "    max_time=10,\n",
+        "    return_fig=True,\n",
+        ")"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "37bd0475",
+      "metadata": {
+        "cell_marker": "\"\"\"",
+        "lines_to_next_cell": 0
+      },
+      "source": [
+        "\n",
+        "The plots are static images by default. However, interactive plotting can be very powerful. To enable interactive plotting, use `interactive=True`. Note that interactive plotting requires the `bokeh` Python library to be installed."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 18,
+      "id": "37feddd0",
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2023-07-12T19:18:45.928391Z",
+          "iopub.status.busy": "2023-07-12T19:18:45.928187Z",
+          "iopub.status.idle": "2023-07-12T19:18:48.039131Z",
+          "shell.execute_reply": "2023-07-12T19:18:48.038008Z"
+        }
+      },
+      "outputs": [
+        {
+          "data": {
+            "application/javascript": [
+              "(function(root) {\n",
+              "  function now() {\n",
+              "    return new Date();\n",
+              "  }\n",
+              "\n",
+              "  const force = true;\n",
+              "\n",
+              "  if (typeof root._bokeh_onload_callbacks === \"undefined\" || force === true) {\n",
+              "    root._bokeh_onload_callbacks = [];\n",
+              "    root._bokeh_is_loading = undefined;\n",
+              "  }\n",
+              "\n",
+              "const JS_MIME_TYPE = 'application/javascript';\n",
+              "  const HTML_MIME_TYPE = 'text/html';\n",
+              "  const EXEC_MIME_TYPE = 'application/vnd.bokehjs_exec.v0+json';\n",
+              "  const CLASS_NAME = 'output_bokeh rendered_html';\n",
+              "\n",
+              "  /**\n",
+              "   * Render data to the DOM node\n",
+              "   */\n",
+              "  function render(props, node) {\n",
+              "    const script = document.createElement(\"script\");\n",
+              "    node.appendChild(script);\n",
+              "  }\n",
+              "\n",
+              "  /**\n",
+              "   * Handle when an output is cleared or removed\n",
+              "   */\n",
+              "  function handleClearOutput(event, handle) {\n",
+              "    const cell = handle.cell;\n",
+              "\n",
+              "    const id = cell.output_area._bokeh_element_id;\n",
+              "    const server_id = cell.output_area._bokeh_server_id;\n",
+              "    // Clean up Bokeh references\n",
+              "    if (id != null && id in Bokeh.index) {\n",
+              "      Bokeh.index[id].model.document.clear();\n",
+              "      delete Bokeh.index[id];\n",
+              "    }\n",
+              "\n",
+              "    if (server_id !== undefined) {\n",
+              "      // Clean up Bokeh references\n",
+              "      const cmd_clean = \"from bokeh.io.state import curstate; print(curstate().uuid_to_server['\" + server_id + \"'].get_sessions()[0].document.roots[0]._id)\";\n",
+              "      cell.notebook.kernel.execute(cmd_clean, {\n",
+              "        iopub: {\n",
+              "          output: function(msg) {\n",
+              "            const id = msg.content.text.trim();\n",
+              "            if (id in Bokeh.index) {\n",
+              "              Bokeh.index[id].model.document.clear();\n",
+              "              delete Bokeh.index[id];\n",
+              "            }\n",
+              "          }\n",
+              "        }\n",
+              "      });\n",
+              "      // Destroy server and session\n",
+              "      const cmd_destroy = \"import bokeh.io.notebook as ion; ion.destroy_server('\" + server_id + \"')\";\n",
+              "      cell.notebook.kernel.execute(cmd_destroy);\n",
+              "    }\n",
+              "  }\n",
+              "\n",
+              "  /**\n",
+              "   * Handle when a new output is added\n",
+              "   */\n",
+              "  function handleAddOutput(event, handle) {\n",
+              "    const output_area = handle.output_area;\n",
+              "    const output = handle.output;\n",
+              "\n",
+              "    // limit handleAddOutput to display_data with EXEC_MIME_TYPE content only\n",
+              "    if ((output.output_type != \"display_data\") || (!Object.prototype.hasOwnProperty.call(output.data, EXEC_MIME_TYPE))) {\n",
+              "      return\n",
+              "    }\n",
+              "\n",
+              "    const toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n",
+              "\n",
+              "    if (output.metadata[EXEC_MIME_TYPE][\"id\"] !== undefined) {\n",
+              "      toinsert[toinsert.length - 1].firstChild.textContent = output.data[JS_MIME_TYPE];\n",
+              "      // store reference to embed id on output_area\n",
+              "      output_area._bokeh_element_id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n",
+              "    }\n",
+              "    if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n",
+              "      const bk_div = document.createElement(\"div\");\n",
+              "      bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n",
+              "      const script_attrs = bk_div.children[0].attributes;\n",
+              "      for (let i = 0; i < script_attrs.length; i++) {\n",
+              "        toinsert[toinsert.length - 1].firstChild.setAttribute(script_attrs[i].name, script_attrs[i].value);\n",
+              "        toinsert[toinsert.length - 1].firstChild.textContent = bk_div.children[0].textContent\n",
+              "      }\n",
+              "      // store reference to server id on output_area\n",
+              "      output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n",
+              "    }\n",
+              "  }\n",
+              "\n",
+              "  function register_renderer(events, OutputArea) {\n",
+              "\n",
+              "    function append_mime(data, metadata, element) {\n",
+              "      // create a DOM node to render to\n",
+              "      const toinsert = this.create_output_subarea(\n",
+              "        metadata,\n",
+              "        CLASS_NAME,\n",
+              "        EXEC_MIME_TYPE\n",
+              "      );\n",
+              "      this.keyboard_manager.register_events(toinsert);\n",
+              "      // Render to node\n",
+              "      const props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n",
+              "      render(props, toinsert[toinsert.length - 1]);\n",
+              "      element.append(toinsert);\n",
+              "      return toinsert\n",
+              "    }\n",
+              "\n",
+              "    /* Handle when an output is cleared or removed */\n",
+              "    events.on('clear_output.CodeCell', handleClearOutput);\n",
+              "    events.on('delete.Cell', handleClearOutput);\n",
+              "\n",
+              "    /* Handle when a new output is added */\n",
+              "    events.on('output_added.OutputArea', handleAddOutput);\n",
+              "\n",
+              "    /**\n",
+              "     * Register the mime type and append_mime function with output_area\n",
+              "     */\n",
+              "    OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n",
+              "      /* Is output safe? */\n",
+              "      safe: true,\n",
+              "      /* Index of renderer in `output_area.display_order` */\n",
+              "      index: 0\n",
+              "    });\n",
+              "  }\n",
+              "\n",
+              "  // register the mime type if in Jupyter Notebook environment and previously unregistered\n",
+              "  if (root.Jupyter !== undefined) {\n",
+              "    const events = require('base/js/events');\n",
+              "    const OutputArea = require('notebook/js/outputarea').OutputArea;\n",
+              "\n",
+              "    if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n",
+              "      register_renderer(events, OutputArea);\n",
+              "    }\n",
+              "  }\n",
+              "  if (typeof (root._bokeh_timeout) === \"undefined\" || force === true) {\n",
+              "    root._bokeh_timeout = Date.now() + 5000;\n",
+              "    root._bokeh_failed_load = false;\n",
+              "  }\n",
+              "\n",
+              "  const NB_LOAD_WARNING = {'data': {'text/html':\n",
+              "     \"<div style='background-color: #fdd'>\\n\"+\n",
+              "     \"<p>\\n\"+\n",
+              "     \"BokehJS does not appear to have successfully loaded. If loading BokehJS from CDN, this \\n\"+\n",
+              "     \"may be due to a slow or bad network connection. Possible fixes:\\n\"+\n",
+              "     \"</p>\\n\"+\n",
+              "     \"<ul>\\n\"+\n",
+              "     \"<li>re-rerun `output_notebook()` to attempt to load from CDN again, or</li>\\n\"+\n",
+              "     \"<li>use INLINE resources instead, as so:</li>\\n\"+\n",
+              "     \"</ul>\\n\"+\n",
+              "     \"<code>\\n\"+\n",
+              "     \"from bokeh.resources import INLINE\\n\"+\n",
+              "     \"output_notebook(resources=INLINE)\\n\"+\n",
+              "     \"</code>\\n\"+\n",
+              "     \"</div>\"}};\n",
+              "\n",
+              "  function display_loaded() {\n",
+              "    const el = document.getElementById(null);\n",
+              "    if (el != null) {\n",
+              "      el.textContent = \"BokehJS is loading...\";\n",
+              "    }\n",
+              "    if (root.Bokeh !== undefined) {\n",
+              "      if (el != null) {\n",
+              "        el.textContent = \"BokehJS \" + root.Bokeh.version + \" successfully loaded.\";\n",
+              "      }\n",
+              "    } else if (Date.now() < root._bokeh_timeout) {\n",
+              "      setTimeout(display_loaded, 100)\n",
+              "    }\n",
+              "  }\n",
+              "\n",
+              "  function run_callbacks() {\n",
+              "    try {\n",
+              "      root._bokeh_onload_callbacks.forEach(function(callback) {\n",
+              "        if (callback != null)\n",
+              "          callback();\n",
+              "      });\n",
+              "    } finally {\n",
+              "      delete root._bokeh_onload_callbacks\n",
+              "    }\n",
+              "    console.debug(\"Bokeh: all callbacks have finished\");\n",
+              "  }\n",
+              "\n",
+              "  function load_libs(css_urls, js_urls, callback) {\n",
+              "    if (css_urls == null) css_urls = [];\n",
+              "    if (js_urls == null) js_urls = [];\n",
+              "\n",
+              "    root._bokeh_onload_callbacks.push(callback);\n",
+              "    if (root._bokeh_is_loading > 0) {\n",
+              "      console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n",
+              "      return null;\n",
+              "    }\n",
+              "    if (js_urls == null || js_urls.length === 0) {\n",
+              "      run_callbacks();\n",
+              "      return null;\n",
+              "    }\n",
+              "    console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n",
+              "    root._bokeh_is_loading = css_urls.length + js_urls.length;\n",
+              "\n",
+              "    function on_load() {\n",
+              "      root._bokeh_is_loading--;\n",
+              "      if (root._bokeh_is_loading === 0) {\n",
+              "        console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n",
+              "        run_callbacks()\n",
+              "      }\n",
+              "    }\n",
+              "\n",
+              "    function on_error(url) {\n",
+              "      console.error(\"failed to load \" + url);\n",
+              "    }\n",
+              "\n",
+              "    for (let i = 0; i < css_urls.length; i++) {\n",
+              "      const url = css_urls[i];\n",
+              "      const element = document.createElement(\"link\");\n",
+              "      element.onload = on_load;\n",
+              "      element.onerror = on_error.bind(null, url);\n",
+              "      element.rel = \"stylesheet\";\n",
+              "      element.type = \"text/css\";\n",
+              "      element.href = url;\n",
+              "      console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n",
+              "      document.body.appendChild(element);\n",
+              "    }\n",
+              "\n",
+              "    for (let i = 0; i < js_urls.length; i++) {\n",
+              "      const url = js_urls[i];\n",
+              "      const element = document.createElement('script');\n",
+              "      element.onload = on_load;\n",
+              "      element.onerror = on_error.bind(null, url);\n",
+              "      element.async = false;\n",
+              "      element.src = url;\n",
+              "      console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n",
+              "      document.head.appendChild(element);\n",
+              "    }\n",
+              "  };\n",
+              "\n",
+              "  function inject_raw_css(css) {\n",
+              "    const element = document.createElement(\"style\");\n",
+              "    element.appendChild(document.createTextNode(css));\n",
+              "    document.body.appendChild(element);\n",
+              "  }\n",
+              "\n",
+              "  const js_urls = [\"https://cdn.bokeh.org/bokeh/release/bokeh-3.1.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.1.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.1.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.1.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-mathjax-3.1.1.min.js\"];\n",
+              "  const css_urls = [];\n",
+              "\n",
+              "  const inline_js = [    function(Bokeh) {\n",
+              "      Bokeh.set_log_level(\"info\");\n",
+              "    },\n",
+              "function(Bokeh) {\n",
+              "    }\n",
+              "  ];\n",
+              "\n",
+              "  function run_inline_js() {\n",
+              "    if (root.Bokeh !== undefined || force === true) {\n",
+              "          for (let i = 0; i < inline_js.length; i++) {\n",
+              "      inline_js[i].call(root, root.Bokeh);\n",
+              "    }\n",
+              "} else if (Date.now() < root._bokeh_timeout) {\n",
+              "      setTimeout(run_inline_js, 100);\n",
+              "    } else if (!root._bokeh_failed_load) {\n",
+              "      console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n",
+              "      root._bokeh_failed_load = true;\n",
+              "    } else if (force !== true) {\n",
+              "      const cell = $(document.getElementById(null)).parents('.cell').data().cell;\n",
+              "      cell.output_area.append_execute_result(NB_LOAD_WARNING)\n",
+              "    }\n",
+              "  }\n",
+              "\n",
+              "  if (root._bokeh_is_loading === 0) {\n",
+              "    console.debug(\"Bokeh: BokehJS loaded, going straight to plotting\");\n",
+              "    run_inline_js();\n",
+              "  } else {\n",
+              "    load_libs(css_urls, js_urls, function() {\n",
+              "      console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n",
+              "      run_inline_js();\n",
+              "    });\n",
+              "  }\n",
+              "}(window));"
+            ],
+            "application/vnd.bokehjs_load.v0+json": "(function(root) {\n  function now() {\n    return new Date();\n  }\n\n  const force = true;\n\n  if (typeof root._bokeh_onload_callbacks === \"undefined\" || force === true) {\n    root._bokeh_onload_callbacks = [];\n    root._bokeh_is_loading = undefined;\n  }\n\n\n  if (typeof (root._bokeh_timeout) === \"undefined\" || force === true) {\n    root._bokeh_timeout = Date.now() + 5000;\n    root._bokeh_failed_load = false;\n  }\n\n  const NB_LOAD_WARNING = {'data': {'text/html':\n     \"<div style='background-color: #fdd'>\\n\"+\n     \"<p>\\n\"+\n     \"BokehJS does not appear to have successfully loaded. If loading BokehJS from CDN, this \\n\"+\n     \"may be due to a slow or bad network connection. Possible fixes:\\n\"+\n     \"</p>\\n\"+\n     \"<ul>\\n\"+\n     \"<li>re-rerun `output_notebook()` to attempt to load from CDN again, or</li>\\n\"+\n     \"<li>use INLINE resources instead, as so:</li>\\n\"+\n     \"</ul>\\n\"+\n     \"<code>\\n\"+\n     \"from bokeh.resources import INLINE\\n\"+\n     \"output_notebook(resources=INLINE)\\n\"+\n     \"</code>\\n\"+\n     \"</div>\"}};\n\n  function display_loaded() {\n    const el = document.getElementById(null);\n    if (el != null) {\n      el.textContent = \"BokehJS is loading...\";\n    }\n    if (root.Bokeh !== undefined) {\n      if (el != null) {\n        el.textContent = \"BokehJS \" + root.Bokeh.version + \" successfully loaded.\";\n      }\n    } else if (Date.now() < root._bokeh_timeout) {\n      setTimeout(display_loaded, 100)\n    }\n  }\n\n  function run_callbacks() {\n    try {\n      root._bokeh_onload_callbacks.forEach(function(callback) {\n        if (callback != null)\n          callback();\n      });\n    } finally {\n      delete root._bokeh_onload_callbacks\n    }\n    console.debug(\"Bokeh: all callbacks have finished\");\n  }\n\n  function load_libs(css_urls, js_urls, callback) {\n    if (css_urls == null) css_urls = [];\n    if (js_urls == null) js_urls = [];\n\n    root._bokeh_onload_callbacks.push(callback);\n    if (root._bokeh_is_loading > 0) {\n      console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n      return null;\n    }\n    if (js_urls == null || js_urls.length === 0) {\n      run_callbacks();\n      return null;\n    }\n    console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n    root._bokeh_is_loading = css_urls.length + js_urls.length;\n\n    function on_load() {\n      root._bokeh_is_loading--;\n      if (root._bokeh_is_loading === 0) {\n        console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n        run_callbacks()\n      }\n    }\n\n    function on_error(url) {\n      console.error(\"failed to load \" + url);\n    }\n\n    for (let i = 0; i < css_urls.length; i++) {\n      const url = css_urls[i];\n      const element = document.createElement(\"link\");\n      element.onload = on_load;\n      element.onerror = on_error.bind(null, url);\n      element.rel = \"stylesheet\";\n      element.type = \"text/css\";\n      element.href = url;\n      console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n      document.body.appendChild(element);\n    }\n\n    for (let i = 0; i < js_urls.length; i++) {\n      const url = js_urls[i];\n      const element = document.createElement('script');\n      element.onload = on_load;\n      element.onerror = on_error.bind(null, url);\n      element.async = false;\n      element.src = url;\n      console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n      document.head.appendChild(element);\n    }\n  };\n\n  function inject_raw_css(css) {\n    const element = document.createElement(\"style\");\n    element.appendChild(document.createTextNode(css));\n    document.body.appendChild(element);\n  }\n\n  const js_urls = [\"https://cdn.bokeh.org/bokeh/release/bokeh-3.1.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.1.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.1.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.1.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-mathjax-3.1.1.min.js\"];\n  const css_urls = [];\n\n  const inline_js = [    function(Bokeh) {\n      Bokeh.set_log_level(\"info\");\n    },\nfunction(Bokeh) {\n    }\n  ];\n\n  function run_inline_js() {\n    if (root.Bokeh !== undefined || force === true) {\n          for (let i = 0; i < inline_js.length; i++) {\n      inline_js[i].call(root, root.Bokeh);\n    }\n} else if (Date.now() < root._bokeh_timeout) {\n      setTimeout(run_inline_js, 100);\n    } else if (!root._bokeh_failed_load) {\n      console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n      root._bokeh_failed_load = true;\n    } else if (force !== true) {\n      const cell = $(document.getElementById(null)).parents('.cell').data().cell;\n      cell.output_area.append_execute_result(NB_LOAD_WARNING)\n    }\n  }\n\n  if (root._bokeh_is_loading === 0) {\n    console.debug(\"Bokeh: BokehJS loaded, going straight to plotting\");\n    run_inline_js();\n  } else {\n    load_libs(css_urls, js_urls, function() {\n      console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n      run_inline_js();\n    });\n  }\n}(window));"
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "text/html": [
+              "\n",
+              "  <div id=\"cee9bf9c-702c-47ab-8463-acce41621d85\" data-root-id=\"p1165\" style=\"display: contents;\"></div>\n"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "application/javascript": [
+              "(function(root) {\n",
+              "  function embed_document(root) {\n",
+              "  const docs_json = {\"bf595bed-9875-4d3a-97fe-79acda08d25a\":{\"version\":\"3.1.1\",\"title\":\"Bokeh Application\",\"defs\":[],\"roots\":[{\"type\":\"object\",\"name\":\"GridPlot\",\"id\":\"p1165\",\"attributes\":{\"rows\":null,\"cols\":null,\"toolbar\":{\"type\":\"object\",\"name\":\"Toolbar\",\"id\":\"p1164\",\"attributes\":{\"logo\":null,\"tools\":[{\"type\":\"object\",\"name\":\"ToolProxy\",\"id\":\"p1155\",\"attributes\":{\"tools\":[{\"type\":\"object\",\"name\":\"PanTool\",\"id\":\"p1032\",\"attributes\":{\"dimensions\":\"width\"}},{\"type\":\"object\",\"name\":\"PanTool\",\"id\":\"p1092\",\"attributes\":{\"dimensions\":\"width\"}}]}},{\"type\":\"object\",\"name\":\"ToolProxy\",\"id\":\"p1156\",\"attributes\":{\"tools\":[{\"type\":\"object\",\"name\":\"PanTool\",\"id\":\"p1033\"},{\"type\":\"object\",\"name\":\"PanTool\",\"id\":\"p1093\"}]}},{\"type\":\"object\",\"name\":\"ToolProxy\",\"id\":\"p1157\",\"attributes\":{\"tools\":[{\"type\":\"object\",\"name\":\"WheelZoomTool\",\"id\":\"p1034\",\"attributes\":{\"dimensions\":\"width\"}},{\"type\":\"object\",\"name\":\"WheelZoomTool\",\"id\":\"p1094\",\"attributes\":{\"dimensions\":\"width\"}}]}},{\"type\":\"object\",\"name\":\"ToolProxy\",\"id\":\"p1158\",\"attributes\":{\"tools\":[{\"type\":\"object\",\"name\":\"WheelZoomTool\",\"id\":\"p1035\",\"attributes\":{\"dimensions\":\"height\"}},{\"type\":\"object\",\"name\":\"WheelZoomTool\",\"id\":\"p1095\",\"attributes\":{\"dimensions\":\"height\"}}]}},{\"type\":\"object\",\"name\":\"ToolProxy\",\"id\":\"p1159\",\"attributes\":{\"tools\":[{\"type\":\"object\",\"name\":\"BoxZoomTool\",\"id\":\"p1036\",\"attributes\":{\"overlay\":{\"type\":\"object\",\"name\":\"BoxAnnotation\",\"id\":\"p1037\",\"attributes\":{\"syncable\":false,\"level\":\"overlay\",\"visible\":false,\"left_units\":\"canvas\",\"right_units\":\"canvas\",\"bottom_units\":\"canvas\",\"top_units\":\"canvas\",\"line_color\":\"black\",\"line_alpha\":1.0,\"line_width\":2,\"line_dash\":[4,4],\"fill_color\":\"lightgrey\",\"fill_alpha\":0.5}}}},{\"type\":\"object\",\"name\":\"BoxZoomTool\",\"id\":\"p1096\",\"attributes\":{\"overlay\":{\"type\":\"object\",\"name\":\"BoxAnnotation\",\"id\":\"p1097\",\"attributes\":{\"syncable\":false,\"level\":\"overlay\",\"visible\":false,\"left_units\":\"canvas\",\"right_units\":\"canvas\",\"bottom_units\":\"canvas\",\"top_units\":\"canvas\",\"line_color\":\"black\",\"line_alpha\":1.0,\"line_width\":2,\"line_dash\":[4,4],\"fill_color\":\"lightgrey\",\"fill_alpha\":0.5}}}}]}},{\"type\":\"object\",\"name\":\"ToolProxy\",\"id\":\"p1160\",\"attributes\":{\"tools\":[{\"type\":\"object\",\"name\":\"ResetTool\",\"id\":\"p1038\"},{\"type\":\"object\",\"name\":\"ResetTool\",\"id\":\"p1098\"}]}},{\"type\":\"object\",\"name\":\"ToolProxy\",\"id\":\"p1161\",\"attributes\":{\"tools\":[{\"type\":\"object\",\"name\":\"UndoTool\",\"id\":\"p1039\"},{\"type\":\"object\",\"name\":\"UndoTool\",\"id\":\"p1099\"}]}},{\"type\":\"object\",\"name\":\"SaveTool\",\"id\":\"p1162\"},{\"type\":\"object\",\"name\":\"ToolProxy\",\"id\":\"p1163\",\"attributes\":{\"tools\":[{\"type\":\"object\",\"name\":\"HoverTool\",\"id\":\"p1041\",\"attributes\":{\"renderers\":\"auto\"}},{\"type\":\"object\",\"name\":\"HoverTool\",\"id\":\"p1101\",\"attributes\":{\"renderers\":\"auto\"}}]}}]}},\"toolbar_location\":\"right\",\"children\":[[{\"type\":\"object\",\"name\":\"Figure\",\"id\":\"p1001\",\"attributes\":{\"width\":1024,\"height\":150,\"x_range\":{\"type\":\"object\",\"name\":\"DataRange1d\",\"id\":\"p1003\",\"attributes\":{\"js_property_callbacks\":{\"type\":\"map\",\"entries\":[[\"change:start\",[{\"type\":\"object\",\"name\":\"CustomJS\",\"id\":\"p1122\",\"attributes\":{\"args\":{\"type\":\"map\",\"entries\":[[\"p1_x_range\",{\"id\":\"p1003\"}],[\"p2_x_range\",{\"type\":\"object\",\"name\":\"DataRange1d\",\"id\":\"p1064\",\"attributes\":{\"js_property_callbacks\":{\"type\":\"map\",\"entries\":[[\"change:start\",[{\"id\":\"p1122\"}]],[\"change:end\",[{\"id\":\"p1122\"}]]]}}}]]},\"code\":\"\\n            if (cb_obj == p1_x_range) {\\n                const start =  p1_x_range.start;\\n                const end =  p1_x_range.end;\\n                \\n            p2_x_range.start = start;\\n            p2_x_range.end = end;\\n            \\n            }\\n            \\n            if (cb_obj == p2_x_range) {\\n                const start =  p2_x_range.start;\\n                const end =  p2_x_range.end;\\n                \\n            p1_x_range.start = start;\\n            p1_x_range.end = end;\\n            \\n            }\\n            \"}}]],[\"change:end\",[{\"id\":\"p1122\"}]]]}}},\"y_range\":{\"type\":\"object\",\"name\":\"DataRange1d\",\"id\":\"p1002\"},\"x_scale\":{\"type\":\"object\",\"name\":\"LinearScale\",\"id\":\"p1014\"},\"y_scale\":{\"type\":\"object\",\"name\":\"LinearScale\",\"id\":\"p1016\"},\"title\":{\"type\":\"object\",\"name\":\"Title\",\"id\":\"p1005\"},\"renderers\":[{\"type\":\"object\",\"name\":\"GlyphRenderer\",\"id\":\"p1059\",\"attributes\":{\"data_source\":{\"type\":\"object\",\"name\":\"ColumnDataSource\",\"id\":\"p1053\",\"attributes\":{\"selected\":{\"type\":\"object\",\"name\":\"Selection\",\"id\":\"p1054\",\"attributes\":{\"indices\":[],\"line_indices\":[]}},\"selection_policy\":{\"type\":\"object\",\"name\":\"UnionRenderers\",\"id\":\"p1055\"},\"data\":{\"type\":\"map\",\"entries\":[[\"x\",{\"type\":\"ndarray\",\"array\":{\"type\":\"bytes\",\"data\":\"AAAAAAAA8D8AAAAAAAAAQAAAAAAAAAhAAAAAAAAAEEAAAAAAAAAUQA==\"},\"shape\":[5],\"dtype\":\"float64\",\"order\":\"little\"}],[\"y\",{\"type\":\"ndarray\",\"array\":{\"type\":\"bytes\",\"data\":\"AAAAAAAA4D8zMzMzMzPjP5qZmZmZmdk/mpmZmZmZ2T/NzMzMzMzsPw==\"},\"shape\":[5],\"dtype\":\"float64\",\"order\":\"little\"}]]}}},\"view\":{\"type\":\"object\",\"name\":\"CDSView\",\"id\":\"p1060\",\"attributes\":{\"filter\":{\"type\":\"object\",\"name\":\"AllIndices\",\"id\":\"p1061\"}}},\"glyph\":{\"type\":\"object\",\"name\":\"Line\",\"id\":\"p1056\",\"attributes\":{\"x\":{\"type\":\"field\",\"field\":\"x\"},\"y\":{\"type\":\"field\",\"field\":\"y\"},\"line_color\":\"#1b9e77\"}},\"nonselection_glyph\":{\"type\":\"object\",\"name\":\"Line\",\"id\":\"p1057\",\"attributes\":{\"x\":{\"type\":\"field\",\"field\":\"x\"},\"y\":{\"type\":\"field\",\"field\":\"y\"},\"line_color\":\"#1b9e77\",\"line_alpha\":0.1}},\"muted_glyph\":{\"type\":\"object\",\"name\":\"Line\",\"id\":\"p1058\",\"attributes\":{\"x\":{\"type\":\"field\",\"field\":\"x\"},\"y\":{\"type\":\"field\",\"field\":\"y\"},\"line_color\":\"#1b9e77\",\"line_alpha\":0.2}}}}],\"toolbar\":{\"type\":\"object\",\"name\":\"Toolbar\",\"id\":\"p1006\",\"attributes\":{\"tools\":[{\"id\":\"p1032\"},{\"id\":\"p1033\"},{\"id\":\"p1034\"},{\"id\":\"p1035\"},{\"id\":\"p1036\"},{\"id\":\"p1038\"},{\"id\":\"p1039\"},{\"type\":\"object\",\"name\":\"SaveTool\",\"id\":\"p1040\"},{\"id\":\"p1041\"}]}},\"toolbar_location\":null,\"left\":[{\"type\":\"object\",\"name\":\"LinearAxis\",\"id\":\"p1025\",\"attributes\":{\"ticker\":{\"type\":\"object\",\"name\":\"BasicTicker\",\"id\":\"p1028\",\"attributes\":{\"mantissas\":[1,2,5]}},\"formatter\":{\"type\":\"object\",\"name\":\"BasicTickFormatter\",\"id\":\"p1026\"},\"axis_label\":\"feature_1\",\"major_label_policy\":{\"type\":\"object\",\"name\":\"AllLabels\",\"id\":\"p1027\"}}}],\"below\":[{\"type\":\"object\",\"name\":\"LinearAxis\",\"id\":\"p1018\",\"attributes\":{\"ticker\":{\"type\":\"object\",\"name\":\"BasicTicker\",\"id\":\"p1021\",\"attributes\":{\"mantissas\":[1,2,5]}},\"formatter\":{\"type\":\"object\",\"name\":\"BasicTickFormatter\",\"id\":\"p1019\"},\"major_label_policy\":{\"type\":\"object\",\"name\":\"AllLabels\",\"id\":\"p1020\"}}}],\"center\":[{\"type\":\"object\",\"name\":\"Grid\",\"id\":\"p1024\",\"attributes\":{\"axis\":{\"id\":\"p1018\"}}},{\"type\":\"object\",\"name\":\"Grid\",\"id\":\"p1031\",\"attributes\":{\"dimension\":1,\"axis\":{\"id\":\"p1025\"}}}]}},0,0],[{\"type\":\"object\",\"name\":\"Figure\",\"id\":\"p1062\",\"attributes\":{\"width\":1024,\"height\":150,\"x_range\":{\"id\":\"p1064\"},\"y_range\":{\"type\":\"object\",\"name\":\"FactorRange\",\"id\":\"p1073\",\"attributes\":{\"factors\":[\"red\",\"green\",\"blue\"]}},\"x_scale\":{\"type\":\"object\",\"name\":\"LinearScale\",\"id\":\"p1075\"},\"y_scale\":{\"type\":\"object\",\"name\":\"CategoricalScale\",\"id\":\"p1077\"},\"title\":{\"type\":\"object\",\"name\":\"Title\",\"id\":\"p1066\"},\"renderers\":[{\"type\":\"object\",\"name\":\"GlyphRenderer\",\"id\":\"p1119\",\"attributes\":{\"data_source\":{\"type\":\"object\",\"name\":\"ColumnDataSource\",\"id\":\"p1113\",\"attributes\":{\"selected\":{\"type\":\"object\",\"name\":\"Selection\",\"id\":\"p1114\",\"attributes\":{\"indices\":[],\"line_indices\":[]}},\"selection_policy\":{\"type\":\"object\",\"name\":\"UnionRenderers\",\"id\":\"p1115\"},\"data\":{\"type\":\"map\",\"entries\":[[\"x\",{\"type\":\"ndarray\",\"array\":{\"type\":\"bytes\",\"data\":\"AAAAAAAA8D8AAAAAAAAAQAAAAAAAAAhAAAAAAAAAEEAAAAAAAAAUQA==\"},\"shape\":[5],\"dtype\":\"float64\",\"order\":\"little\"}],[\"y\",{\"type\":\"ndarray\",\"array\":[\"red\",\"blue\",\"red\",\"blue\",\"green\"],\"shape\":[5],\"dtype\":\"object\",\"order\":\"little\"}]]}}},\"view\":{\"type\":\"object\",\"name\":\"CDSView\",\"id\":\"p1120\",\"attributes\":{\"filter\":{\"type\":\"object\",\"name\":\"AllIndices\",\"id\":\"p1121\"}}},\"glyph\":{\"type\":\"object\",\"name\":\"Circle\",\"id\":\"p1116\",\"attributes\":{\"x\":{\"type\":\"field\",\"field\":\"x\"},\"y\":{\"type\":\"field\",\"field\":\"y\"},\"line_color\":{\"type\":\"value\",\"value\":\"#1f77b4\"},\"fill_color\":{\"type\":\"value\",\"value\":\"#1f77b4\"}}},\"nonselection_glyph\":{\"type\":\"object\",\"name\":\"Circle\",\"id\":\"p1117\",\"attributes\":{\"x\":{\"type\":\"field\",\"field\":\"x\"},\"y\":{\"type\":\"field\",\"field\":\"y\"},\"line_color\":{\"type\":\"value\",\"value\":\"#1f77b4\"},\"line_alpha\":{\"type\":\"value\",\"value\":0.1},\"fill_color\":{\"type\":\"value\",\"value\":\"#1f77b4\"},\"fill_alpha\":{\"type\":\"value\",\"value\":0.1},\"hatch_alpha\":{\"type\":\"value\",\"value\":0.1}}},\"muted_glyph\":{\"type\":\"object\",\"name\":\"Circle\",\"id\":\"p1118\",\"attributes\":{\"x\":{\"type\":\"field\",\"field\":\"x\"},\"y\":{\"type\":\"field\",\"field\":\"y\"},\"line_color\":{\"type\":\"value\",\"value\":\"#1f77b4\"},\"line_alpha\":{\"type\":\"value\",\"value\":0.2},\"fill_color\":{\"type\":\"value\",\"value\":\"#1f77b4\"},\"fill_alpha\":{\"type\":\"value\",\"value\":0.2},\"hatch_alpha\":{\"type\":\"value\",\"value\":0.2}}}}}],\"toolbar\":{\"type\":\"object\",\"name\":\"Toolbar\",\"id\":\"p1067\",\"attributes\":{\"tools\":[{\"id\":\"p1092\"},{\"id\":\"p1093\"},{\"id\":\"p1094\"},{\"id\":\"p1095\"},{\"id\":\"p1096\"},{\"id\":\"p1098\"},{\"id\":\"p1099\"},{\"type\":\"object\",\"name\":\"SaveTool\",\"id\":\"p1100\"},{\"id\":\"p1101\"}]}},\"toolbar_location\":null,\"left\":[{\"type\":\"object\",\"name\":\"CategoricalAxis\",\"id\":\"p1086\",\"attributes\":{\"ticker\":{\"type\":\"object\",\"name\":\"CategoricalTicker\",\"id\":\"p1089\"},\"formatter\":{\"type\":\"object\",\"name\":\"CategoricalTickFormatter\",\"id\":\"p1087\"},\"axis_label\":\"feature_2\",\"major_label_policy\":{\"type\":\"object\",\"name\":\"AllLabels\",\"id\":\"p1088\"}}}],\"below\":[{\"type\":\"object\",\"name\":\"LinearAxis\",\"id\":\"p1079\",\"attributes\":{\"ticker\":{\"type\":\"object\",\"name\":\"BasicTicker\",\"id\":\"p1082\",\"attributes\":{\"mantissas\":[1,2,5]}},\"formatter\":{\"type\":\"object\",\"name\":\"BasicTickFormatter\",\"id\":\"p1080\"},\"major_label_policy\":{\"type\":\"object\",\"name\":\"AllLabels\",\"id\":\"p1081\"}}}],\"center\":[{\"type\":\"object\",\"name\":\"Grid\",\"id\":\"p1085\",\"attributes\":{\"axis\":{\"id\":\"p1079\"}}},{\"type\":\"object\",\"name\":\"Grid\",\"id\":\"p1091\",\"attributes\":{\"dimension\":1,\"axis\":{\"id\":\"p1086\"}}}]}},1,0]]}}],\"callbacks\":{\"type\":\"map\"}}};\n",
+              "  const render_items = [{\"docid\":\"bf595bed-9875-4d3a-97fe-79acda08d25a\",\"roots\":{\"p1165\":\"cee9bf9c-702c-47ab-8463-acce41621d85\"},\"root_ids\":[\"p1165\"]}];\n",
+              "  root.Bokeh.embed.embed_items_notebook(docs_json, render_items);\n",
+              "  }\n",
+              "  if (root.Bokeh !== undefined) {\n",
+              "    embed_document(root);\n",
+              "  } else {\n",
+              "    let attempts = 0;\n",
+              "    const timer = setInterval(function(root) {\n",
+              "      if (root.Bokeh !== undefined) {\n",
+              "        clearInterval(timer);\n",
+              "        embed_document(root);\n",
+              "      } else {\n",
+              "        attempts++;\n",
+              "        if (attempts > 100) {\n",
+              "          clearInterval(timer);\n",
+              "          console.log(\"Bokeh: ERROR: Unable to run BokehJS code because BokehJS library is missing\");\n",
+              "        }\n",
+              "      }\n",
+              "    }, 10, root)\n",
+              "  }\n",
+              "})(window);"
+            ],
+            "application/vnd.bokehjs_exec.v0+json": ""
+          },
+          "metadata": {
+            "application/vnd.bokehjs_exec.v0+json": {
+              "id": "p1165"
+            }
+          },
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "!pip install bokeh -q\n",
+        "\n",
+        "evset.plot(interactive=True)"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "cf4d0c27",
+      "metadata": {
+        "cell_marker": "\"\"\"",
+        "lines_to_next_cell": 0
+      },
+      "source": [
+        "\n",
+        "## Feature naming\n",
+        "\n",
+        "Each feature is identified by a name, and the list of features is available through the `features` property of an `EventSetNode`."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 19,
+      "id": "38ff0e20",
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2023-07-12T19:18:48.041769Z",
+          "iopub.status.busy": "2023-07-12T19:18:48.041511Z",
+          "iopub.status.idle": "2023-07-12T19:18:48.045989Z",
+          "shell.execute_reply": "2023-07-12T19:18:48.045296Z"
+        }
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "[('feature_1', float64), ('feature_2', float64)]\n"
+          ]
+        }
+      ],
+      "source": [
+        "events = tp.event_set(\n",
+        "\ttimestamps=[1,2,3,4,5],\n",
+        "\tfeatures={\n",
+        "\t    \"feature_1\": [0.5, 0.6, 0.4, 0.4, 0.9],\n",
+        "\t    \"feature_2\": [1.0, 2.0, 3.0, 2.0, 1.0]}\n",
+        "    )\n",
+        "node = events.node()\n",
+        "print(node.features)"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "2cd29020",
+      "metadata": {
+        "cell_marker": "\"\"\"",
+        "lines_to_next_cell": 0
+      },
+      "source": [
+        "\n",
+        "Most operators do not change the input feature's names."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 20,
+      "id": "838449d4",
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2023-07-12T19:18:48.048381Z",
+          "iopub.status.busy": "2023-07-12T19:18:48.048173Z",
+          "iopub.status.idle": "2023-07-12T19:18:48.053544Z",
+          "shell.execute_reply": "2023-07-12T19:18:48.052749Z"
+        }
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "[('feature_1', float64), ('feature_2', float64)]"
+            ]
+          },
+          "execution_count": 20,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "tp.moving_sum(node, window_length=10).features"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "b70cc298",
+      "metadata": {
+        "cell_marker": "\"\"\"",
+        "lines_to_next_cell": 0
+      },
+      "source": [
+        "\n",
+        "Some operators combine two input features with different names, in which case the output name is also combined."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 21,
+      "id": "b10fdec3",
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2023-07-12T19:18:48.056033Z",
+          "iopub.status.busy": "2023-07-12T19:18:48.055834Z",
+          "iopub.status.idle": "2023-07-12T19:18:48.060788Z",
+          "shell.execute_reply": "2023-07-12T19:18:48.060000Z"
+        }
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "[('mult_feature_1_feature_2', float64)]"
+            ]
+          },
+          "execution_count": 21,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "result = node[\"feature_1\"] * node[\"feature_2\"]\n",
+        "result.features"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "87731369",
+      "metadata": {
+        "cell_marker": "\"\"\"",
+        "lines_to_next_cell": 0
+      },
+      "source": [
+        "\n",
+        "The calendar operators don't depend on input features but on the timestamps, so the output feature name doesn't\n",
+        "relate to the input feature names."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 22,
+      "id": "4182d3f8",
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2023-07-12T19:18:48.063351Z",
+          "iopub.status.busy": "2023-07-12T19:18:48.063139Z",
+          "iopub.status.idle": "2023-07-12T19:18:48.067737Z",
+          "shell.execute_reply": "2023-07-12T19:18:48.066977Z"
+        }
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "[('calendar_month', int32)]\n"
+          ]
+        }
+      ],
+      "source": [
+        "date_events = tp.event_set(\n",
+        "\ttimestamps=[\"2020-02-15\", \"2020-06-20\"],\n",
+        "\tfeatures={\"some_feature\": [10, 20]}\n",
+        "    )\n",
+        "date_node = date_events.node()\n",
+        "print(tp.calendar_month(date_node).features)"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "61127d7f",
+      "metadata": {
+        "cell_marker": "\"\"\"",
+        "lines_to_next_cell": 0
+      },
+      "source": [
+        "\n",
+        "You can modify feature names using the `tp.rename()` and `tp.prefix()` operators. `tp.rename()` changes the name of features, while `tp.prefix()` adds a prefix in front of existing feature names. Note that they do not modify the content of the input `EventSetNode`, but return a new `EventSetNode` with the modified feature names."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 23,
+      "id": "bc36bc1f",
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2023-07-12T19:18:48.070434Z",
+          "iopub.status.busy": "2023-07-12T19:18:48.070178Z",
+          "iopub.status.idle": "2023-07-12T19:18:48.074287Z",
+          "shell.execute_reply": "2023-07-12T19:18:48.073625Z"
+        }
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "[('renamed_1', float64)]\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Rename a single feature.\n",
+        "renamed_f1 = tp.rename(node[\"feature_1\"], \"renamed_1\")\n",
+        "print(renamed_f1.features)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 24,
+      "id": "a44f6e7a",
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2023-07-12T19:18:48.076479Z",
+          "iopub.status.busy": "2023-07-12T19:18:48.076270Z",
+          "iopub.status.idle": "2023-07-12T19:18:48.080087Z",
+          "shell.execute_reply": "2023-07-12T19:18:48.079462Z"
+        }
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "[('renamed_1', float64), ('renamed_2', float64)]\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Rename all features.\n",
+        "renamed_node = tp.rename(node,\n",
+        "    {\"feature_1\": \"renamed_1\", \"feature_2\": \"renamed_2\"}\n",
+        ")\n",
+        "print(renamed_node.features)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 25,
+      "id": "af6103fc",
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2023-07-12T19:18:48.082268Z",
+          "iopub.status.busy": "2023-07-12T19:18:48.082077Z",
+          "iopub.status.idle": "2023-07-12T19:18:48.086119Z",
+          "shell.execute_reply": "2023-07-12T19:18:48.085424Z"
+        }
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "[('prefixed.feature_1', float64)]\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Prefix a single feature.\n",
+        "prefixed_f1 = tp.prefix(\"prefixed.\", node[\"feature_1\"])\n",
+        "print(prefixed_f1.features)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 26,
+      "id": "3126cbed",
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2023-07-12T19:18:48.088498Z",
+          "iopub.status.busy": "2023-07-12T19:18:48.088287Z",
+          "iopub.status.idle": "2023-07-12T19:18:48.092046Z",
+          "shell.execute_reply": "2023-07-12T19:18:48.091363Z"
+        }
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "[('prefixed.feature_1', float64), ('prefixed.feature_2', float64)]\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Prefix all features.\n",
+        "prefixed_node = tp.prefix(\"prefixed.\", node)\n",
+        "print(prefixed_node.features)"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "085e79c3",
+      "metadata": {
+        "cell_marker": "\"\"\"",
+        "lines_to_next_cell": 0
+      },
+      "source": [
+        "\n",
+        "It is recommended to use `tp.rename()` and `tp.prefix()` to organize your data, and avoid duplicated feature names."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 27,
+      "id": "852abbdd",
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2023-07-12T19:18:48.094459Z",
+          "iopub.status.busy": "2023-07-12T19:18:48.094263Z",
+          "iopub.status.idle": "2023-07-12T19:18:48.098192Z",
+          "shell.execute_reply": "2023-07-12T19:18:48.097520Z"
+        }
+      },
+      "outputs": [],
+      "source": [
+        "sma_7_node = tp.prefix(\"sma_7.\", tp.simple_moving_average(node, tp.duration.days(7)))\n",
+        "sma_14_node = tp.prefix(\"sma_14.\", tp.simple_moving_average(node, tp.duration.days(14)))"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "ac25eb4a",
+      "metadata": {
+        "cell_marker": "\"\"\"",
+        "lines_to_next_cell": 0
+      },
+      "source": [
+        "\n",
+        "The `tp.glue()` operator can be used to concatenate different features into a single `EventSetNode`, but it will fail if two features with the same name are provided. The following pattern is commonly used in Temporian programs."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 28,
+      "id": "f7d85e33",
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2023-07-12T19:18:48.100474Z",
+          "iopub.status.busy": "2023-07-12T19:18:48.100285Z",
+          "iopub.status.idle": "2023-07-12T19:18:48.104973Z",
+          "shell.execute_reply": "2023-07-12T19:18:48.104296Z"
+        }
+      },
+      "outputs": [],
+      "source": [
+        "result = tp.glue(\n",
+        "    tp.prefix(\"sma_7.\", tp.simple_moving_average(node, tp.duration.days(7))),\n",
+        "    tp.prefix(\"sma_14.\", tp.simple_moving_average(node, tp.duration.days(14))),\n",
+        ")"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "749df3cc",
+      "metadata": {
+        "cell_marker": "\"\"\"",
+        "lines_to_next_cell": 0
+      },
+      "source": [
+        "\n",
+        "## Casting\n",
+        "\n",
+        "Temporian is strict on feature data types (also called dtype). This means that often, you cannot perform operations between features of different types. For example, you cannot subtract a `tp.float32` and a `tp.float64`. Instead, you must manually cast the features to the same type before performing the operation."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 29,
+      "id": "e1276be1",
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2023-07-12T19:18:48.107140Z",
+          "iopub.status.busy": "2023-07-12T19:18:48.106948Z",
+          "iopub.status.idle": "2023-07-12T19:18:48.110638Z",
+          "shell.execute_reply": "2023-07-12T19:18:48.109910Z"
+        }
+      },
+      "outputs": [],
+      "source": [
+        "node = tp.input_node(features=[(\"f1\", tp.float32), (\"f2\", tp.float64)])\n",
+        "added = tp.cast(node[\"f1\"], tp.float64) + node[\"f2\"]"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "d45a37bb",
+      "metadata": {
+        "lines_to_next_cell": 0
+      },
+      "source": [
+        "\n",
+        "Casting is especially useful to reduce memory usage. For example, if a feature only contains values between 0 and 10000, using `tp.int32` instead of `tp.int64` will halve memory usage. These optimizations are critical when working with large datasets.\n",
+        "\n",
+        "Casting can also be a necessary step before calling operators that only accept certain input data types.\n",
+        "\n",
+        "Note that in Python, the values `1.0` and `1` are respectively `float64` and `int64`.\n",
+        "\n",
+        "Temporian supports data type casting through the `tp.cast()` operator. Destination data types can be specified in three different ways:\n",
+        "\n",
+        "1. Single data type: converts all input features to the same destination data type.\n",
+        "\n",
+        "   "
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 30,
+      "id": "3e3ee4c4",
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2023-07-12T19:18:48.112858Z",
+          "iopub.status.busy": "2023-07-12T19:18:48.112669Z",
+          "iopub.status.idle": "2023-07-12T19:18:48.117232Z",
+          "shell.execute_reply": "2023-07-12T19:18:48.116444Z"
+        },
+        "lines_to_next_cell": 0
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "[('f1', float32), ('f2', float64)]"
+            ]
+          },
+          "execution_count": 30,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "node.features"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 31,
+      "id": "6c2444ba",
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2023-07-12T19:18:48.119467Z",
+          "iopub.status.busy": "2023-07-12T19:18:48.119269Z",
+          "iopub.status.idle": "2023-07-12T19:18:48.122662Z",
+          "shell.execute_reply": "2023-07-12T19:18:48.122171Z"
+        }
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "[('f1', str_), ('f2', str_)]\n"
+          ]
+        }
+      ],
+      "source": [
+        "print(tp.cast(node, tp.str_).features)"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "59c449d9",
+      "metadata": {
+        "cell_marker": "\"\"\"",
+        "lines_to_next_cell": 0
+      },
+      "source": [
+        "\n",
+        "2. Feature name to data type mapping: converts each feature (specified by name) to a specific data type."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 32,
+      "id": "05ee00a7",
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2023-07-12T19:18:48.124843Z",
+          "iopub.status.busy": "2023-07-12T19:18:48.124658Z",
+          "iopub.status.idle": "2023-07-12T19:18:48.128444Z",
+          "shell.execute_reply": "2023-07-12T19:18:48.127834Z"
+        }
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "[('f1', str_), ('f2', int64)]\n"
+          ]
+        }
+      ],
+      "source": [
+        "print(tp.cast(node, {\"f1\": tp.str_, \"f2\": tp.int64}).features)"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "3f85a531",
+      "metadata": {
+        "cell_marker": "\"\"\"",
+        "lines_to_next_cell": 0
+      },
+      "source": [
+        "\n",
+        "3. Data type to data type mapping: converts all features of a specific data type to another data type."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 33,
+      "id": "6deaff88",
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2023-07-12T19:18:48.130815Z",
+          "iopub.status.busy": "2023-07-12T19:18:48.130616Z",
+          "iopub.status.idle": "2023-07-12T19:18:48.134664Z",
+          "shell.execute_reply": "2023-07-12T19:18:48.133974Z"
+        }
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "[('f1', str_), ('f2', int64)]\n"
+          ]
+        }
+      ],
+      "source": [
+        "print(tp.cast(node, {tp.float32: tp.str_, tp.float64: tp.int64}).features)"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "915df6c5",
+      "metadata": {
+        "cell_marker": "\"\"\"",
+        "lines_to_next_cell": 0
+      },
+      "source": [
+        "\n",
+        "Keep in mind that casting may fail when the graph is evaluated. For instance, attempting to cast `\"word\"` to `tp.float64` will result in an error. These errors cannot be caught prior to graph evaluation.\n",
+        "\n",
+        "## Arithmetic operators\n",
+        "\n",
+        "Arithmetic operators can be used between the features of an `EventSetNode`, to perform element-wise calculations.\n",
+        "\n",
+        "Common mathematical and bit operations are supported, such as addition (`+`), subtraction (`-`), product (`*`), division (`/`), floor division (`//`), modulo (`%`), comparisons (`>, >=, <, <=`), and bitwise operators (`&, |, ~`).\n",
+        "\n",
+        "These operators are applied index-wise and timestamp-wise, between features in the same position."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 34,
+      "id": "2c673b17",
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2023-07-12T19:18:48.137323Z",
+          "iopub.status.busy": "2023-07-12T19:18:48.136793Z",
+          "iopub.status.idle": "2023-07-12T19:18:48.142502Z",
+          "shell.execute_reply": "2023-07-12T19:18:48.141727Z"
+        },
+        "lines_to_next_cell": 0
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "indexes: []\n",
+            "features: [('add_f1_f3', int64), ('add_f2_f4', float64)]\n",
+            "events:\n",
+            "     (2 events):\n",
+            "        timestamps: [ 1. 10.]\n",
+            "        'add_f1_f3': [100 101]\n",
+            "        'add_f2_f4': [1010. 1020.]\n",
+            "memory usage: 0.7 kB\n",
+            "\n"
+          ]
+        }
+      ],
+      "source": [
+        "evset = tp.event_set(\n",
+        "    timestamps=[1, 10],\n",
+        "    features={\n",
+        "        \"f1\": [0, 1],\n",
+        "        \"f2\": [10.0, 20.0],\n",
+        "        \"f3\": [100, 100],\n",
+        "        \"f4\": [1000.0, 1000.0],\n",
+        "    },\n",
+        ")\n",
+        "node = evset.node()\n",
+        "\n",
+        "node_added = node[[\"f1\", \"f2\"]] + node[[\"f3\", \"f4\"]]\n",
+        "\n",
+        "evset_added = node_added.run(evset)\n",
+        "print(evset_added)"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "03bd54cc",
+      "metadata": {
+        "cell_marker": "\"\"\"",
+        "lines_to_next_cell": 0
+      },
+      "source": [
+        "\n",
+        "Note that features of type `int64` and `float64` are not mixed above, because otherwise the operation would fail without an explicit type cast."
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "1675fa25",
+      "metadata": {
+        "cell_marker": "\"\"\"",
+        "lines_to_next_cell": 0
+      },
+      "source": [
+        "```python\n",
+        "# Attempt to mix dtypes.\n",
+        ">>> node[\"f1\"] + node[\"f2\"]\n",
+        "Traceback (most recent call last):\n",
+        "    ...\n",
+        "ValueError: corresponding features should have the same dtype. ...\n",
+        "```"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "7b50cf71",
+      "metadata": {
+        "cell_marker": "\"\"\"",
+        "lines_to_next_cell": 0
+      },
+      "source": [
+        "\n",
+        "Refer to the [Casting](#casting) section for more on this.\n",
+        "\n",
+        "All the operators have an equivalent functional form. The example above using `+`, could be rewritten with `tp.add()`."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 35,
+      "id": "3b350c4a",
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2023-07-12T19:18:48.144884Z",
+          "iopub.status.busy": "2023-07-12T19:18:48.144689Z",
+          "iopub.status.idle": "2023-07-12T19:18:48.148299Z",
+          "shell.execute_reply": "2023-07-12T19:18:48.147589Z"
+        }
+      },
+      "outputs": [],
+      "source": [
+        "# Equivalent.\n",
+        "node_added = tp.add(node[[\"f1\", \"f2\"]], node[[\"f3\", \"f4\"]])"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "d65bd8de",
+      "metadata": {
+        "cell_marker": "\"\"\"",
+        "lines_to_next_cell": 0
+      },
+      "source": [
+        "\n",
+        "Other usual comparison and logic operators also work (except `==`, see below)."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 36,
+      "id": "f1462eea",
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2023-07-12T19:18:48.150468Z",
+          "iopub.status.busy": "2023-07-12T19:18:48.150279Z",
+          "iopub.status.idle": "2023-07-12T19:18:48.154461Z",
+          "shell.execute_reply": "2023-07-12T19:18:48.153773Z"
+        }
+      },
+      "outputs": [],
+      "source": [
+        "is_greater = node[[\"f1\", \"f2\"]] > node[[\"f3\", \"f4\"]]\n",
+        "is_less_or_equal = node[[\"f1\", \"f2\"]] <= node[[\"f3\", \"f4\"]]\n",
+        "is_wrong = is_greater & is_less_or_equal"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "9f01eee7",
+      "metadata": {
+        "cell_marker": "\"\"\"",
+        "lines_to_next_cell": 0
+      },
+      "source": [
+        "\n",
+        "**Warning:** The Python equality operator (`==`) does not compute element-wise equality between features. Use the `tp.equal()` operator instead."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 37,
+      "id": "c610a0d0",
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2023-07-12T19:18:48.156702Z",
+          "iopub.status.busy": "2023-07-12T19:18:48.156507Z",
+          "iopub.status.idle": "2023-07-12T19:18:48.161203Z",
+          "shell.execute_reply": "2023-07-12T19:18:48.160516Z"
+        }
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "schema:\n",
+              "    features: [('eq_f1_f3', bool_)]\n",
+              "    indexes: []\n",
+              "    is_unix_timestamp: False\n",
+              "\n",
+              "features: [Feature(id=140558094330624, creator=Operator(key='EQUAL', id=66, attributes={}))]\n",
+              "sampling: Sampling(id=140557545245616, creator=None),\n",
+              "name: None\n",
+              "creator: Operator(key='EQUAL', id=66, attributes={})\n",
+              "id:140558094330240"
+            ]
+          },
+          "execution_count": 37,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "# Works element-wise as expected\n",
+        "tp.equal(node[\"f1\"], node[\"f3\"])"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 38,
+      "id": "abda404b",
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2023-07-12T19:18:48.163464Z",
+          "iopub.status.busy": "2023-07-12T19:18:48.163249Z",
+          "iopub.status.idle": "2023-07-12T19:18:48.168151Z",
+          "shell.execute_reply": "2023-07-12T19:18:48.167430Z"
+        }
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "False"
+            ]
+          },
+          "execution_count": 38,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "# This is just a boolean\n",
+        "(node[\"f1\"] == node[\"f3\"])\n",
+        "False"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "0fa4a2d1",
+      "metadata": {
+        "cell_marker": "\"\"\"",
+        "lines_to_next_cell": 0
+      },
+      "source": [
+        "\n",
+        "All these operators act feature-wise, i.e. they perform index-feature-wise operations (for each feature in each index key). This implies that the input `EventSetNodes` must have the same number of features."
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "0352b9de",
+      "metadata": {
+        "cell_marker": "\"\"\"",
+        "lines_to_next_cell": 0
+      },
+      "source": [
+        "```python\n",
+        "node[[\"f1\", \"f2\"]] + node[\"f3\"]\n",
+        "Traceback (most recent call last):\n",
+        "    ...\n",
+        "ValueError: The left and right arguments should have the same number of features. ...\n",
+        "```"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "8dd1d7f4",
+      "metadata": {
+        "cell_marker": "\"\"\"",
+        "lines_to_next_cell": 0
+      },
+      "source": [
+        "\n",
+        "The input `EventSetNodes` must also have the same sampling and index."
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "00990d1e",
+      "metadata": {
+        "cell_marker": "\"\"\"",
+        "lines_to_next_cell": 0
+      },
+      "source": [
+        "```python\n",
+        "sampling_1 = tp.event_set(\n",
+        "    timestamps=[0, 1],\n",
+        "    features={\"f1\": [1, 2]},\n",
+        ")\n",
+        "sampling_2 = tp.event_set(\n",
+        "    timestamps=[1, 2],\n",
+        "    features={\"f1\": [3, 4]},\n",
+        ")\n",
+        "sampling_1.node() + sampling_2.node()\n",
+        "Traceback (most recent call last):\n",
+        "    ...\n",
+        "ValueError: Arguments should have the same sampling. ...\n",
+        "```"
+      ]
+    },
     {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1024x450 with 3 Axes>"
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "217fa8f5",
+      "metadata": {
+        "cell_marker": "\"\"\"",
+        "lines_to_next_cell": 0
+      },
+      "source": [
+        "\n",
+        "If you want to apply arithmetic operators on `EventSetNodes` with different samplings, take a look at\n",
+        "[Sampling](#sampling) section.\n",
+        "\n",
+        "If you want to apply them on `EventSetNodes` with different indexes, check the\n",
+        "[Vertical operators](#indexes-horizontal-and-vertical-operators) section.\n",
+        "\n",
+        "Operations involving scalars are applied index-feature-element-wise."
       ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "evset.plot()"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "fe507137-0c0f-4533-a75d-008352a2566b",
-   "metadata": {},
-   "source": [
-    "\n",
-    "**Note:** You'll learn how to create an `EventSet` using other data sources such as pandas DataFrames later.\n",
-    "\n",
-    "Events can carry various meanings. For instance, events can represent **regular measurements**. Suppose an electronic thermometer that generates temperature measurements every minute. This could be an `EventSet` with one feature called `temperature`. In this scenario, the temperature can change between two measurements. However, for most practical uses, the most recent measurement will be considered the current temperature.\n",
-    "\n",
-    "<!-- TODO: Temperature plot -->\n",
-    "\n",
-    "Events can also represent the _occurrence_ of sporadic phenomena. Suppose a sales recording system that records client purchases. Each time a client makes a purchase (i.e., each transaction), a new event is created.\n",
-    "\n",
-    "<!-- TODO: Sales plot -->\n",
-    "\n",
-    "You will see that Temporian is agnostic to the semantics of events, and that often, you will mix together measurements and occurrences. For instance, given the _occurrence_ of sales from the previous example, you can compute daily sales (which is a _measurement_).\n"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "e7a88b45-bef7-46ac-88b8-f376cc14ee88",
-   "metadata": {},
-   "source": [
-    "## Operators and eager mode\n",
-    "\n",
-    "Processing operations are performed by **Operators**. For instance, the `tp.simple_moving_average()` operator computes the [simple moving average](https://en.wikipedia.org/wiki/Moving_average) of each feature in an `EventSet`.\n",
-    "\n",
-    "The list of all operators is available in the [API Reference](../reference/)."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "f0c059c3-1412-47d5-8f21-8c034f16a551",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-07-12T19:18:44.689781Z",
-     "iopub.status.busy": "2023-07-12T19:18:44.688990Z",
-     "iopub.status.idle": "2023-07-12T19:18:44.920401Z",
-     "shell.execute_reply": "2023-07-12T19:18:44.919687Z"
-    }
-   },
-   "outputs": [
+    },
     {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1024x300 with 2 Axes>"
+      "cell_type": "code",
+      "execution_count": 39,
+      "id": "58fe7d8e",
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2023-07-12T19:18:48.170667Z",
+          "iopub.status.busy": "2023-07-12T19:18:48.170470Z",
+          "iopub.status.idle": "2023-07-12T19:18:48.174954Z",
+          "shell.execute_reply": "2023-07-12T19:18:48.174165Z"
+        },
+        "lines_to_next_cell": 0
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "indexes: []\n",
+            "features: [('f1', int64), ('f2', float64), ('f3', int64), ('f4', float64)]\n",
+            "events:\n",
+            "     (2 events):\n",
+            "        timestamps: [ 1. 10.]\n",
+            "        'f1': [ 0 10]\n",
+            "        'f2': [100. 200.]\n",
+            "        'f3': [1000 1000]\n",
+            "        'f4': [10000. 10000.]\n",
+            "memory usage: 0.9 kB\n",
+            "\n"
+          ]
+        }
+      ],
+      "source": [
+        "node_scalar = node * 10\n",
+        "print(node_scalar.run(evset))"
       ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# Create an event set with a random walk\n",
-    "np.random.seed(1)\n",
-    "random_walk = np.cumsum(np.random.choice([-1.0, 0.0, 1.0], size=1000))\n",
-    "\n",
-    "evset = tp.event_set(\n",
-    "\ttimestamps=np.linspace(0,10, num=1000),\n",
-    "\tfeatures={\"value\": random_walk}\n",
-    ")\n",
-    "\n",
-    "# Compute a simple moving average\n",
-    "result = tp.simple_moving_average(evset, window_length=1)\n",
-    "\n",
-    "# Plot the results\n",
-    "tp.plot([evset, result]) "
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "0dd8a9a5-19b4-4898-b5af-794dbd4ac1eb",
-   "metadata": {},
-   "source": [
-    "## Eager mode vs Graph mode\n",
-    "\n",
-    "Temporian has two execution modes: **eager** and **graph**. In eager mode, operators are applied immediately. This mode is useful for learning Temporian, for iterative and interactive development, and for lightweight/small data use cases where performance isn't a priority.\n",
-    "\n",
-    "In graph mode, operators are combined together into \"Temporian programs\" before being executed. Graph mode is more efficient and it consumes less memory. Temporian programs can be saved, inspected, and distributed by users.\n",
-    "\n",
-    "Migrating a Temporian program from eager to graph mode is easy and requires little work. Most of the time, adding a `@tp.compile` annotation is enough. Therefore, it is recommended to develop programs in eager mode and then to productize them in graph mode.\n",
-    "\n",
-    "Next, we see a the same program written three times: First, in eager mode, then in graph mode using `@tp.compile`, and finally in graph mode without `@tp.compile`."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "d5405837-c801-40e9-8b41-4d4dc901d429",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-07-12T19:18:44.922893Z",
-     "iopub.status.busy": "2023-07-12T19:18:44.922680Z",
-     "iopub.status.idle": "2023-07-12T19:18:45.058522Z",
-     "shell.execute_reply": "2023-07-12T19:18:45.057820Z"
-    }
-   },
-   "outputs": [
+    },
     {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1024x150 with 1 Axes>"
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "a229408c",
+      "metadata": {
+        "cell_marker": "\"\"\"",
+        "lines_to_next_cell": 0
+      },
+      "source": [
+        "\n",
+        "## Sampling\n",
+        "\n",
+        "Arithmetic operators, such as `tp.add()`, require their input arguments to have the same timestamps and [Index](#indexes-horizontal-and-vertical-operators). The unique combination of timestamps and indexes is called a _sampling_.\n",
+        "\n",
+        "<!-- TODO: example -->\n",
+        "\n",
+        "For example, if `EventSetNodes` `a` and `b` have different samplings, `a[\"feature_1\"] + b[\"feature_2\"]` will fail.\n",
+        "\n",
+        "To use arithmetic operators on `EventSets` with different samplings, one of the `EventSets` needs to be resampled to the sampling of the other `EventSet`. Resampling is done with the `tp.resample()` operator.\n",
+        "\n",
+        "The `tp.resample()` operator takes two `EventSets` called `input` and `sampling`, and returns the resampling of the features of `input` according to the timestamps of `sampling` according to the following rules:\n",
+        "\n",
+        "If a timestamp is present in `input` but not in `sampling`, the timestamp is dropped.\n",
+        "If a timestamp is present in both `input` and `sampling`, the timestamp is kept.\n",
+        "If a timestamp is present in `sampling` but not in `input`, a new timestamp is created using the feature values from the _closest anterior_ (not the closest, as that could induce future leakage) timestamp of `input`. This rule is especially useful for events that represent measurements (see [Events and `EventSets`](#events-and-eventsets)).\n",
+        "\n",
+        "**Note:** Features in `sampling` are ignored. This also happens in some other operators that take a `sampling` argument of type `EventSetNode` - it indicates that only the sampling (a.k.a. the indexes and timestamps) of that `EventSetNode` are being used by that operator.\n",
+        "\n",
+        "Given this example:"
       ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# Eager mode\n",
-    "#\n",
-    "# Note: This Temporian program contains three operators: two \"simple_moving_average\" and one \"tp.substract\" operators.\n",
-    "result = tp.simple_moving_average(evset, window_length=0.5) - tp.simple_moving_average(evset, window_length=1.0)\n",
-    "result.plot()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "9c854408-0804-4435-8d44-f521ef1b379e",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-07-12T19:18:45.060873Z",
-     "iopub.status.busy": "2023-07-12T19:18:45.060668Z",
-     "iopub.status.idle": "2023-07-12T19:18:45.188317Z",
-     "shell.execute_reply": "2023-07-12T19:18:45.187603Z"
-    }
-   },
-   "outputs": [
+    },
     {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1024x150 with 1 Axes>"
+      "cell_type": "code",
+      "execution_count": 40,
+      "id": "087b6fd6",
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2023-07-12T19:18:48.177284Z",
+          "iopub.status.busy": "2023-07-12T19:18:48.177071Z",
+          "iopub.status.idle": "2023-07-12T19:18:48.183612Z",
+          "shell.execute_reply": "2023-07-12T19:18:48.182983Z"
+        },
+        "lines_to_next_cell": 0
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "indexes: []\n",
+              "features: [('x', float64)]\n",
+              "events:\n",
+              "     (7 events):\n",
+              "        timestamps: [ 0.  9. 10. 11. 19. 20. 21.]\n",
+              "        'x': [nan nan  1.  1.  1.  2.  2.]\n",
+              "memory usage: 0.6 kB"
+            ]
+          },
+          "execution_count": 40,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "evset = tp.event_set(\n",
+        "    timestamps=[10, 20, 30],\n",
+        "    features={\n",
+        "        \"x\": [1.0, 2.0, 3.0],\n",
+        "    },\n",
+        ")\n",
+        "node = evset.node()\n",
+        "sampling_evset = tp.event_set(\n",
+        "    timestamps=[0, 9, 10, 11, 19, 20, 21],\n",
+        ")\n",
+        "sampling_node = sampling_evset.node()\n",
+        "resampled = tp.resample(input=node, sampling=sampling_node)\n",
+        "resampled.run({node: evset, sampling_node: sampling_evset})"
       ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# Graph mode with @tp.compile\n",
-    "\n",
-    "@tp.compile\n",
-    "def my_function(x):\n",
-    "    return tp.simple_moving_average(x, window_length=0.5) - tp.simple_moving_average(x, window_length=1.0)\n",
-    "\n",
-    "result = my_function(evset)\n",
-    "    \n",
-    "result.plot()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "e4aa008f-aa8e-486f-a96c-854fb5b2bd83",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-07-12T19:18:45.190989Z",
-     "iopub.status.busy": "2023-07-12T19:18:45.190568Z",
-     "iopub.status.idle": "2023-07-12T19:18:45.330304Z",
-     "shell.execute_reply": "2023-07-12T19:18:45.329427Z"
-    }
-   },
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Build schedule\n",
-      "Run 3 operators\n",
-      "    1 / 3: SIMPLE_MOVING_AVERAGE [0.00007 s]\n",
-      "    2 / 3: SIMPLE_MOVING_AVERAGE [0.00004 s]\n",
-      "    3 / 3: SUBTRACTION [0.00007 s]\n",
-      "Execution in 0.00050 s\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1024x150 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# Graph model without @tp.compile\n",
-    "\n",
-    "input_node = tp.input_node([(\"value\", tp.float64)])\n",
-    "# Or input_node = tp.input_node(evset.schema.features)\n",
-    "\n",
-    "result_node = tp.simple_moving_average(input_node, window_length=0.5) - tp.simple_moving_average(input_node, window_length=1.0)\n",
-    "result = tp.run(result_node, {input_node: evset}, verbose=1)\n",
-    "    \n",
-    "result.plot()"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "a6a5a017-9dbe-4782-bc73-9b278ec622b0",
-   "metadata": {},
-   "source": [
-    "## More on graph mode\n",
-    "\n",
-    "**Remark:** While you will likely use the graph mode with `@tp.compile` , it is useful for you to understand the graph model without `@tp.compile`.\n",
-    "\n",
-    "A Temporian program is a graph of [EventSetNode][temporian.EventSetNodes]s connecting operators. A graph is executed with the function `tp.run(<outputs>, <inputs>)`.\n",
-    "\n",
-    "<img src=\"https://github.com/google/temporian/blob/main/docs/src/assets/eager_and_graph.svg\" width=\"100%\" alt=\"eager vs graph mode\">\n",
-    "\n",
-    "The `<outputs>` can be specified as an `EventSetNode`, a list of `EventSetNodes`, or a dictionary of names to `EventSetNodes`, and the result of `tp.run()` will be of the same type. For example, if `<outputs>` is a list of three `EventSetNodes`, the result will be a list of the three corresponding `EventSets`.\n",
-    "\n",
-    "The `<inputs>` can be specified as:\n",
-    "\n",
-    "- A dictionary of `EventSetNodes` to `EventSets`, or \n",
-    "- A dictionary of names to `EventSets`, or,\n",
-    "- A list of `EventSets`, or\n",
-    "- A single `EventSet`\n",
-    "\n",
-    "This lets Temporian know the `EventSetNodes` of the graph that each input `EventSet` corresponds to. If `<inputs>` is a dictionary of names to `EventSets`, the names must match the names of `EventSetNodes` in the graph.  If `<inputs>` is a list or a single `EventSet`, the names of those `EventSets` must do the same. If we specify the inputs as a dictionary, we could skip passing a name to `a_evset`."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "dd4142a0-df47-4ca3-aafe-7a105b4f2deb",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-07-12T19:18:45.332924Z",
-     "iopub.status.busy": "2023-07-12T19:18:45.332468Z",
-     "iopub.status.idle": "2023-07-12T19:18:45.342998Z",
-     "shell.execute_reply": "2023-07-12T19:18:45.342153Z"
-    }
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[indexes: []\n",
-      "features: [('value', float64)]\n",
-      "events:\n",
-      "     (1000 events):\n",
-      "        timestamps: [ 0.    0.01  0.02 ...  9.98  9.99 10.  ]\n",
-      "        'value': [ 0.   -0.5  -1.   ...  3.74  3.76  3.76]\n",
-      "memory usage: 8.5 kB\n",
-      ", indexes: []\n",
-      "features: [('value', float64)]\n",
-      "events:\n",
-      "     (1000 events):\n",
-      "        timestamps: [ 0.    0.01  0.02 ...  9.98  9.99 10.  ]\n",
-      "        'value': [ 0.   -0.5  -1.   ...  1.04  1.09  1.14]\n",
-      "memory usage: 8.5 kB\n",
-      ", indexes: []\n",
-      "features: [('sub_value_value', float64)]\n",
-      "events:\n",
-      "     (1000 events):\n",
-      "        timestamps: [ 0.    0.01  0.02 ...  9.98  9.99 10.  ]\n",
-      "        'sub_value_value': [0.   0.   0.   ... 2.7  2.67 2.62]\n",
-      "memory usage: 8.5 kB\n",
-      "]\n"
-     ]
-    }
-   ],
-   "source": [
-    "input_node = tp.input_node([(\"value\", tp.float64)])\n",
-    "result_1_node = tp.simple_moving_average(input_node, window_length=0.5)\n",
-    "result_2_node = tp.simple_moving_average(input_node, window_length=1.0)\n",
-    "result_3_node = result_1_node - result_2_node\n",
-    "\n",
-    "result = tp.run([result_1_node,result_2_node, result_3_node], {input_node: evset})\n",
-    "    \n",
-    "print(result)"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "32dd49a8-8847-4df1-be17-b844b92f4211",
-   "metadata": {},
-   "source": [
-    "**Remarks:**\n",
-    "\n",
-    "- It's important to distinguish between a `tp.EventSet`, such as `evset`, that contains data, and a `tp.EventSetNode`, like `input_node`, that connect operators together and compose the computation graph, but do not contain data.\n",
-    "- No computation is performed when defining the graph (i.e., when calling the operator functions). All computation is done during `tp.run()`.\n",
-    "- In `tp.run()`, the second argument defines a mapping between input `EventSetNodes` and `EventSets`. If all necessary input `EventSetNodes` are not fed, an error will be raised.\n",
-    "- In most cases you will only pass `EventSets` that correspond to the graph's input `EventSetNodes`, but Temporian also supports passing `EventSets` to intermediate `EventSetNodes` in the graph."
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "c7e808b2-4091-447a-a6a5-66fcf5f037a9",
-   "metadata": {},
-   "source": [
-    "The `@tp.compile` annotation takes a function inputing and outputing `tp.EventSetNode`, and automatically calls `tp.run` on the result of the function if a `tp.EventSet` is provided as input."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "b0b0220b-9869-454c-8f3b-afeabaca06bc",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-07-12T19:18:45.345745Z",
-     "iopub.status.busy": "2023-07-12T19:18:45.345069Z",
-     "iopub.status.idle": "2023-07-12T19:18:45.350527Z",
-     "shell.execute_reply": "2023-07-12T19:18:45.349823Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "@tp.compile\n",
-    "def my_function(x : tp.EventSetNode) -> tp.EventSetNode:\n",
-    "    return tp.simple_moving_average(x, window_length=0.5)\n",
-    "\n",
-    "# Feeding an EventSet\n",
-    "input_evset = tp.event_set(timestamps=[1, 2, 3],features={\"value\": [5., 6., 7.]})\n",
-    "assert isinstance(my_function(input_evset), tp.EventSet)\n",
-    "\n",
-    "# Feeding an EventSetNode\n",
-    "input_node = tp.input_node([(\"value\", tp.float64)])\n",
-    "assert isinstance(my_function(input_node), tp.EventSetNode)"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "c0f02853-718f-4c9e-8945-b25e74b548ae",
-   "metadata": {},
-   "source": [
-    "Importantly, variables in a `tp.compile` function are `EventSetNode` and not `EventSet`. Therefore, you cannot directly access the event set data.\n",
-    "\n",
-    "In addition, the compiled function execution first generates the graph. The graph is then executed. In the next example, the compiled function generates a graph with 10 operators."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "id": "945d8f39-18ad-44df-a4d2-9d8986e7825b",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-07-12T19:18:45.353329Z",
-     "iopub.status.busy": "2023-07-12T19:18:45.353112Z",
-     "iopub.status.idle": "2023-07-12T19:18:45.358949Z",
-     "shell.execute_reply": "2023-07-12T19:18:45.357662Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "@tp.compile\n",
-    "def my_function(x : tp.EventSetNode) -> tp.EventSetNode:\n",
-    "    for i in range(10):\n",
-    "        x = tp.simple_moving_average(x, window_length=i+1)\n",
-    "    return x"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "4c46c4ee-a8ff-4b9b-9ced-acbee202d0a3",
-   "metadata": {},
-   "source": [
-    "You can create a compiled function with a `if`. However, the condition of the `if` cannot depend on the EventSet data."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "id": "941a5fc4-edfc-4fba-8bc8-22f3a7387e91",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-07-12T19:18:45.362130Z",
-     "iopub.status.busy": "2023-07-12T19:18:45.361815Z",
-     "iopub.status.idle": "2023-07-12T19:18:45.367314Z",
-     "shell.execute_reply": "2023-07-12T19:18:45.366603Z"
-    }
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[('a_branch', float64)]\n",
-      "[('non_a_branch', float64)]\n"
-     ]
-    }
-   ],
-   "source": [
-    "@tp.compile\n",
-    "def my_function(x : tp.EventSetNode, a:bool) -> tp.EventSetNode:\n",
-    "    if a:\n",
-    "        return tp.rename(x, \"a_branch\")\n",
-    "    else:\n",
-    "        return tp.rename(x, \"non_a_branch\")\n",
-    "\n",
-    "print(my_function(input_evset, a=True).schema.features)\n",
-    "\n",
-    "print(my_function(input_evset, a=False).schema.features)"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "3bf624e6-6b1c-4806-8024-8beebd30fc0b",
-   "metadata": {},
-   "source": [
-    "If you want to create a program conditional on EventSet data, you can use a `tp.filter`."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "id": "a9ab68f3-91a6-445e-99c2-7f2379185f21",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-07-12T19:18:45.369918Z",
-     "iopub.status.busy": "2023-07-12T19:18:45.369624Z",
-     "iopub.status.idle": "2023-07-12T19:18:45.376649Z",
-     "shell.execute_reply": "2023-07-12T19:18:45.375861Z"
-    }
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "indexes: []\n",
-       "features: [('value', int64)]\n",
-       "events:\n",
-       "     (2 events):\n",
-       "        timestamps: [1. 2.]\n",
-       "        'value': [10 11]\n",
-       "memory usage: 0.5 kB"
-      ]
-     },
-     "execution_count": 12,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "@tp.compile\n",
-    "def my_function(x : tp.EventSetNode) -> tp.EventSetNode:\n",
-    "    return tp.filter(x[\"value\"], x[\"condition\"])\n",
-    "\n",
-    "my_function(tp.event_set(\n",
-    "\ttimestamps=[1,2,3],\n",
-    "\tfeatures={\n",
-    "        \"value\": [10, 11, 12],\n",
-    "        \"condition\":[True, True, False]}\n",
-    "))"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "c7ef8b32-a08d-46e2-aa8e-5cad3d5421e0",
-   "metadata": {},
-   "source": [
-    "To simplify its usage when the graph contains a single output `EventSetNode`, `node.run(...)` is equivalent to `tp.run(node, ...)`."
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "afa9c5d2-1efe-440d-bf45-366c0b389b5a",
-   "metadata": {},
-   "source": [
-    "\n",
-    "<!-- TODO\n",
-    "# Not implemented yet:\n",
-    "# d_evset = tp.run(d_node, {\"a\": a_evset})\n",
-    "# d_evset = tp.run(d_node, [a_evset])\n",
-    "# d_evset = tp.run(d_node, a_evset)\n",
-    "# d_evset = d_node.run({\"a\": a_evset})\n",
-    "# d_evset = d_node.run([a_evset])\n",
-    "# d_evset = d_node.run(a_evset)\n",
-    "-->\n",
-    "\n",
-    "**Warning:** It is more efficient to run multiple output `EventSetNodes` together with `tp.run()` than to run them separately with `node_1.run(...)`, `node_2.run(...)`, etc."
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "d78f320b",
-   "metadata": {
-    "cell_marker": "\"\"\"",
-    "lines_to_next_cell": 0
-   },
-   "source": [
-    "Previously, we defined the input of the graph with `tp.input_node()`. This way of listing features manually and their respective data type is cumbersome.\n",
-    "\n",
-    "If an `EventSet` is available (i.e., data is available) this step can be changed to use `evset.node()` instead, which will return an `EventSetNode` that is compatible with it. This is especially useful when creating `EventSets` from existing data, such as pandas DataFrames or CSV files."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "id": "d4fc33b0",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-07-12T19:18:45.379097Z",
-     "iopub.status.busy": "2023-07-12T19:18:45.378892Z",
-     "iopub.status.idle": "2023-07-12T19:18:45.383530Z",
-     "shell.execute_reply": "2023-07-12T19:18:45.382775Z"
-    },
-    "lines_to_next_cell": 0
-   },
-   "outputs": [],
-   "source": [
-    "# Define an EventSet.\n",
-    "a_evset = tp.event_set(\n",
-    "\ttimestamps=[0, 1, 2],\n",
-    "\tfeatures={\n",
-    "        \"feature_1\": [1.0, 2.0, 3.0],\n",
-    "        \"feature_2\": [\"hello\", \"little\", \"dog\"],\n",
-    "        \"feature_3\": [\"A\", \"A\", \"B\"],\n",
-    "\t}\n",
-    ")\n",
-    "\n",
-    "# The following three statements are (almost) equivalent.\n",
-    "a_node = tp.input_node(\n",
-    "    features=[\n",
-    "        (\"feature_1\", tp.float64),\n",
-    "        (\"feature_2\", tp.str_),\n",
-    "    ],\n",
-    "    indexes=[(\"feature_3\", tp.str_)])\n",
-    "\n",
-    "a_node = tp.input_node(features=a_evset.schema.features,\n",
-    "                       indexes=a_evset.schema.indexes)\n",
-    "    \n",
-    "a_node = a_evset.node()"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "b73d3011",
-   "metadata": {
-    "cell_marker": "\"\"\"",
-    "lines_to_next_cell": 0
-   },
-   "source": [
-    "\n",
-    "## Time units\n",
-    "\n",
-    "In Temporian, times are always represented by a float64 value. Users have the freedom to choose the semantic to this value. For example, the time can be the number of nanoseconds since the start of the day, the number of cycles of a process, the number of years since the big bang, or the number of seconds since January 1, 1970, at 00:00:00 UTC, also known as Unix or POSIX time.\n",
-    "\n",
-    "To ease the feature engineering of dates, Temporian contains a set of _calendar operators_. These operators specialize in creating features from dates and datetimes. For instance, the `tp.calendar_hour()` operator returns the hour of the date in the range `0-23`.\n",
-    "\n",
-    "Calendar operators require the time in their inputs to be Unix time, so applying them on non-Unix timestamps will raise errors. Temporian can sometimes automatically recognize if input timestamps correspond to Unix time (e.g. when an `EventSet` is created from a pandas DataFrame with a datetime column, or when passing a list of datetime objects as timestamps in `EventSet`'s constructor). If creating `EventSets` manually and passing floats directly to `timestamps`, you need to explicitly specify whether they correspond to Unix times or not via the `is_unix_timestamp` argument."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "id": "92ec9711",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-07-12T19:18:45.386117Z",
-     "iopub.status.busy": "2023-07-12T19:18:45.385905Z",
-     "iopub.status.idle": "2023-07-12T19:18:45.394646Z",
-     "shell.execute_reply": "2023-07-12T19:18:45.393913Z"
-    },
-    "lines_to_next_cell": 0
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "indexes: []\n",
-       "features: [('feature_1', int64), ('feature_2', str_), ('calendar_day_of_week', int32)]\n",
-       "events:\n",
-       "     (3 events):\n",
-       "        timestamps: [1.6787e+09 1.6788e+09 1.6790e+09]\n",
-       "        'feature_1': [1 2 3]\n",
-       "        'feature_2': [b'a' b'b' b'c']\n",
-       "        'calendar_day_of_week': [0 1 4]\n",
-       "memory usage: 0.8 kB"
-      ]
-     },
-     "execution_count": 14,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "a_evset = tp.event_set(\n",
-    "    timestamps=[\n",
-    "        pd.to_datetime(\"Monday Mar 13 12:00:00 2023\", utc=True),\n",
-    "        pd.to_datetime(\"Tuesday Mar 14 12:00:00 2023\", utc=True),\n",
-    "        pd.to_datetime(\"Friday Mar 17 00:00:01 2023\", utc=True),\n",
-    "    ],\n",
-    "    features={\n",
-    "        \"feature_1\": [1, 2, 3],\n",
-    "        \"feature_2\": [\"a\", \"b\", \"c\"],\n",
-    "    },\n",
-    ")\n",
-    "a_node = a_evset.node()\n",
-    "b_node = tp.glue(a_node, tp.calendar_day_of_week(a_node))\n",
-    "b_node.run(a_evset)"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "7380c9c7",
-   "metadata": {
-    "cell_marker": "\"\"\"",
-    "lines_to_next_cell": 0
-   },
-   "source": [
-    "\n",
-    "Temporian accepts time inputs in various formats, including integer, float, Python date or datetime, NumPy datetime, and pandas datetime. Date and datetime objects are internally converted to floats as Unix time in seconds, compatible with the calendar operators.\n",
-    "\n",
-    "Operators can take _durations_ as input arguments. For example, the simple moving average operator takes a `window_length` argument. Temporian exposes several utility functions to help creating those duration arguments when using Unix timestamps:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "id": "508c3f0c",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-07-12T19:18:45.396932Z",
-     "iopub.status.busy": "2023-07-12T19:18:45.396715Z",
-     "iopub.status.idle": "2023-07-12T19:18:45.401047Z",
-     "shell.execute_reply": "2023-07-12T19:18:45.400244Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "a = tp.input_node(features=[(\"feature_1\", tp.float64)])\n",
-    "\n",
-    "# Define a 1-day moving average.\n",
-    "b = tp.simple_moving_average(a, window_length=tp.duration.days(1))\n",
-    "\n",
-    "# Equivalent.\n",
-    "b = tp.simple_moving_average(a, window_length=24 * 60 * 60)"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "6c99993c",
-   "metadata": {
-    "cell_marker": "\"\"\"",
-    "lines_to_next_cell": 0
-   },
-   "source": [
-    "\n",
-    "## Plotting\n",
-    "\n",
-    "Data visualization is crucial for gaining insights into data and the system it represents. It also helps in detecting unexpected behavior and issues, making debugging and iterative development easier.\n",
-    "\n",
-    "Temporian provides two plotting functions for data visualization: `evset.plot()` and `tp.plot()`.\n",
-    "\n",
-    "The `evset.plot()` function is shorter to write and is used for displaying a single `EventSet`, while the `tp.plot()` function is used for displaying multiple `EventSets` together. This function is particularly useful when `EventSets` are indexed (see [Index, horizontal and vertical operators](#indexes-horizontal-and-vertical-operators)) or have different samplings (see [Sampling](#sampling)).\n",
-    "\n",
-    "Here's an example of using the `evset.plot()` function:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "id": "cbf42f42",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-07-12T19:18:45.403996Z",
-     "iopub.status.busy": "2023-07-12T19:18:45.403771Z",
-     "iopub.status.idle": "2023-07-12T19:18:45.643643Z",
-     "shell.execute_reply": "2023-07-12T19:18:45.643082Z"
-    }
-   },
-   "outputs": [
+    },
     {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1024x300 with 2 Axes>"
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "11496f59",
+      "metadata": {
+        "cell_marker": "\"\"\"",
+        "lines_to_next_cell": 0
+      },
+      "source": [
+        "\n",
+        "The following would be the matching between the timestamps of `sampling` and `input`:\n",
+        "\n",
+        "| `sampling` timestamp         | 0   | 9   | 10  | 11  | 19  | 20  | 21  |\n",
+        "| ---------------------------- | --- | --- | --- | --- | --- | --- | --- |\n",
+        "| matching `input` timestamp   | -   | -   | 10  | 10  | 10  | 20  | 20  |\n",
+        "| matching `\"x\"` feature value | NaN | NaN | 1   | 1   | 1   | 2   | 2   |\n",
+        "\n",
+        "If `sampling` contains a timestamp anterior to any timestamp in the `input` (like 0 and 9 in the example above), the feature of the sampled event will be missing. The representation of a missing value depends on its dtype:\n",
+        "\n",
+        "float: `NaN`\n",
+        "integer: `0`\n",
+        "string: `\"\"`\n",
+        "\n",
+        "Back to the example of the `tp.add()` operator, `a` and `b` with different sampling can be added as follows:"
       ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "evset = tp.event_set(\n",
-    "\ttimestamps=[1, 2, 3, 4, 5],\n",
-    "\tfeatures={\n",
-    "        \"feature_1\": [0.5, 0.6, 0.4, 0.4, 0.9],\n",
-    "        \"feature_2\": [\"red\", \"blue\", \"red\", \"blue\", \"green\"]\n",
-    "    }\n",
-    ")\n",
-    "evset.plot()"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "39dc9a92",
-   "metadata": {
-    "cell_marker": "\"\"\"",
-    "lines_to_next_cell": 0
-   },
-   "source": [
-    "\n",
-    "By default, the plotting style is selected automatically based on the data.\n",
-    "\n",
-    "For example, uniformly sampled numerical features (i.e., time series) are plotted with a continuous line, while non-uniformly sampled values are plotted with markers. Those and other behaviors can be controlled via the function's arguments.\n",
-    "\n",
-    "Here's an example of using the `evset.plot()` function with options:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "id": "82552e04",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-07-12T19:18:45.647386Z",
-     "iopub.status.busy": "2023-07-12T19:18:45.647153Z",
-     "iopub.status.idle": "2023-07-12T19:18:45.925838Z",
-     "shell.execute_reply": "2023-07-12T19:18:45.925123Z"
-    }
-   },
-   "outputs": [
+    },
     {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 400x300 with 2 Axes>"
+      "cell_type": "code",
+      "execution_count": 41,
+      "id": "df3bbc7d",
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2023-07-12T19:18:48.185880Z",
+          "iopub.status.busy": "2023-07-12T19:18:48.185684Z",
+          "iopub.status.idle": "2023-07-12T19:18:48.192155Z",
+          "shell.execute_reply": "2023-07-12T19:18:48.191382Z"
+        },
+        "lines_to_next_cell": 0
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "indexes: []\n",
+              "features: [('add_f1_f1', int64)]\n",
+              "events:\n",
+              "     (3 events):\n",
+              "        timestamps: [0. 1. 2.]\n",
+              "        'add_f1_f1': [10 25 34]\n",
+              "memory usage: 0.6 kB"
+            ]
+          },
+          "execution_count": 41,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "sampling_a = tp.event_set(\n",
+        "    timestamps=[0, 1, 2],\n",
+        "    features={\"f1\": [10, 20, 30]},\n",
+        ")\n",
+        "sampling_b = tp.event_set(\n",
+        "    timestamps=[1, 2, 3],\n",
+        "    features={\"f1\": [5, 4, 3]},\n",
+        ")\n",
+        "a = sampling_a.node()\n",
+        "b = sampling_b.node()\n",
+        "result = a + tp.resample(b, a)\n",
+        "result.run({a: sampling_a, b: sampling_b})"
       ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "figure = evset.plot(\n",
-    "    style=\"marker\",\n",
-    "    width_px=400,\n",
-    "    min_time=2,\n",
-    "    max_time=10,\n",
-    "    return_fig=True,\n",
-    ")"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "37bd0475",
-   "metadata": {
-    "cell_marker": "\"\"\"",
-    "lines_to_next_cell": 0
-   },
-   "source": [
-    "\n",
-    "The plots are static images by default. However, interactive plotting can be very powerful. To enable interactive plotting, use `interactive=True`. Note that interactive plotting requires the `bokeh` Python library to be installed."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "id": "37feddd0",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-07-12T19:18:45.928391Z",
-     "iopub.status.busy": "2023-07-12T19:18:45.928187Z",
-     "iopub.status.idle": "2023-07-12T19:18:48.039131Z",
-     "shell.execute_reply": "2023-07-12T19:18:48.038008Z"
-    }
-   },
-   "outputs": [
-    {
-     "data": {
-      "application/javascript": [
-       "(function(root) {\n",
-       "  function now() {\n",
-       "    return new Date();\n",
-       "  }\n",
-       "\n",
-       "  const force = true;\n",
-       "\n",
-       "  if (typeof root._bokeh_onload_callbacks === \"undefined\" || force === true) {\n",
-       "    root._bokeh_onload_callbacks = [];\n",
-       "    root._bokeh_is_loading = undefined;\n",
-       "  }\n",
-       "\n",
-       "const JS_MIME_TYPE = 'application/javascript';\n",
-       "  const HTML_MIME_TYPE = 'text/html';\n",
-       "  const EXEC_MIME_TYPE = 'application/vnd.bokehjs_exec.v0+json';\n",
-       "  const CLASS_NAME = 'output_bokeh rendered_html';\n",
-       "\n",
-       "  /**\n",
-       "   * Render data to the DOM node\n",
-       "   */\n",
-       "  function render(props, node) {\n",
-       "    const script = document.createElement(\"script\");\n",
-       "    node.appendChild(script);\n",
-       "  }\n",
-       "\n",
-       "  /**\n",
-       "   * Handle when an output is cleared or removed\n",
-       "   */\n",
-       "  function handleClearOutput(event, handle) {\n",
-       "    const cell = handle.cell;\n",
-       "\n",
-       "    const id = cell.output_area._bokeh_element_id;\n",
-       "    const server_id = cell.output_area._bokeh_server_id;\n",
-       "    // Clean up Bokeh references\n",
-       "    if (id != null && id in Bokeh.index) {\n",
-       "      Bokeh.index[id].model.document.clear();\n",
-       "      delete Bokeh.index[id];\n",
-       "    }\n",
-       "\n",
-       "    if (server_id !== undefined) {\n",
-       "      // Clean up Bokeh references\n",
-       "      const cmd_clean = \"from bokeh.io.state import curstate; print(curstate().uuid_to_server['\" + server_id + \"'].get_sessions()[0].document.roots[0]._id)\";\n",
-       "      cell.notebook.kernel.execute(cmd_clean, {\n",
-       "        iopub: {\n",
-       "          output: function(msg) {\n",
-       "            const id = msg.content.text.trim();\n",
-       "            if (id in Bokeh.index) {\n",
-       "              Bokeh.index[id].model.document.clear();\n",
-       "              delete Bokeh.index[id];\n",
-       "            }\n",
-       "          }\n",
-       "        }\n",
-       "      });\n",
-       "      // Destroy server and session\n",
-       "      const cmd_destroy = \"import bokeh.io.notebook as ion; ion.destroy_server('\" + server_id + \"')\";\n",
-       "      cell.notebook.kernel.execute(cmd_destroy);\n",
-       "    }\n",
-       "  }\n",
-       "\n",
-       "  /**\n",
-       "   * Handle when a new output is added\n",
-       "   */\n",
-       "  function handleAddOutput(event, handle) {\n",
-       "    const output_area = handle.output_area;\n",
-       "    const output = handle.output;\n",
-       "\n",
-       "    // limit handleAddOutput to display_data with EXEC_MIME_TYPE content only\n",
-       "    if ((output.output_type != \"display_data\") || (!Object.prototype.hasOwnProperty.call(output.data, EXEC_MIME_TYPE))) {\n",
-       "      return\n",
-       "    }\n",
-       "\n",
-       "    const toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n",
-       "\n",
-       "    if (output.metadata[EXEC_MIME_TYPE][\"id\"] !== undefined) {\n",
-       "      toinsert[toinsert.length - 1].firstChild.textContent = output.data[JS_MIME_TYPE];\n",
-       "      // store reference to embed id on output_area\n",
-       "      output_area._bokeh_element_id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n",
-       "    }\n",
-       "    if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n",
-       "      const bk_div = document.createElement(\"div\");\n",
-       "      bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n",
-       "      const script_attrs = bk_div.children[0].attributes;\n",
-       "      for (let i = 0; i < script_attrs.length; i++) {\n",
-       "        toinsert[toinsert.length - 1].firstChild.setAttribute(script_attrs[i].name, script_attrs[i].value);\n",
-       "        toinsert[toinsert.length - 1].firstChild.textContent = bk_div.children[0].textContent\n",
-       "      }\n",
-       "      // store reference to server id on output_area\n",
-       "      output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n",
-       "    }\n",
-       "  }\n",
-       "\n",
-       "  function register_renderer(events, OutputArea) {\n",
-       "\n",
-       "    function append_mime(data, metadata, element) {\n",
-       "      // create a DOM node to render to\n",
-       "      const toinsert = this.create_output_subarea(\n",
-       "        metadata,\n",
-       "        CLASS_NAME,\n",
-       "        EXEC_MIME_TYPE\n",
-       "      );\n",
-       "      this.keyboard_manager.register_events(toinsert);\n",
-       "      // Render to node\n",
-       "      const props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n",
-       "      render(props, toinsert[toinsert.length - 1]);\n",
-       "      element.append(toinsert);\n",
-       "      return toinsert\n",
-       "    }\n",
-       "\n",
-       "    /* Handle when an output is cleared or removed */\n",
-       "    events.on('clear_output.CodeCell', handleClearOutput);\n",
-       "    events.on('delete.Cell', handleClearOutput);\n",
-       "\n",
-       "    /* Handle when a new output is added */\n",
-       "    events.on('output_added.OutputArea', handleAddOutput);\n",
-       "\n",
-       "    /**\n",
-       "     * Register the mime type and append_mime function with output_area\n",
-       "     */\n",
-       "    OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n",
-       "      /* Is output safe? */\n",
-       "      safe: true,\n",
-       "      /* Index of renderer in `output_area.display_order` */\n",
-       "      index: 0\n",
-       "    });\n",
-       "  }\n",
-       "\n",
-       "  // register the mime type if in Jupyter Notebook environment and previously unregistered\n",
-       "  if (root.Jupyter !== undefined) {\n",
-       "    const events = require('base/js/events');\n",
-       "    const OutputArea = require('notebook/js/outputarea').OutputArea;\n",
-       "\n",
-       "    if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n",
-       "      register_renderer(events, OutputArea);\n",
-       "    }\n",
-       "  }\n",
-       "  if (typeof (root._bokeh_timeout) === \"undefined\" || force === true) {\n",
-       "    root._bokeh_timeout = Date.now() + 5000;\n",
-       "    root._bokeh_failed_load = false;\n",
-       "  }\n",
-       "\n",
-       "  const NB_LOAD_WARNING = {'data': {'text/html':\n",
-       "     \"<div style='background-color: #fdd'>\\n\"+\n",
-       "     \"<p>\\n\"+\n",
-       "     \"BokehJS does not appear to have successfully loaded. If loading BokehJS from CDN, this \\n\"+\n",
-       "     \"may be due to a slow or bad network connection. Possible fixes:\\n\"+\n",
-       "     \"</p>\\n\"+\n",
-       "     \"<ul>\\n\"+\n",
-       "     \"<li>re-rerun `output_notebook()` to attempt to load from CDN again, or</li>\\n\"+\n",
-       "     \"<li>use INLINE resources instead, as so:</li>\\n\"+\n",
-       "     \"</ul>\\n\"+\n",
-       "     \"<code>\\n\"+\n",
-       "     \"from bokeh.resources import INLINE\\n\"+\n",
-       "     \"output_notebook(resources=INLINE)\\n\"+\n",
-       "     \"</code>\\n\"+\n",
-       "     \"</div>\"}};\n",
-       "\n",
-       "  function display_loaded() {\n",
-       "    const el = document.getElementById(null);\n",
-       "    if (el != null) {\n",
-       "      el.textContent = \"BokehJS is loading...\";\n",
-       "    }\n",
-       "    if (root.Bokeh !== undefined) {\n",
-       "      if (el != null) {\n",
-       "        el.textContent = \"BokehJS \" + root.Bokeh.version + \" successfully loaded.\";\n",
-       "      }\n",
-       "    } else if (Date.now() < root._bokeh_timeout) {\n",
-       "      setTimeout(display_loaded, 100)\n",
-       "    }\n",
-       "  }\n",
-       "\n",
-       "  function run_callbacks() {\n",
-       "    try {\n",
-       "      root._bokeh_onload_callbacks.forEach(function(callback) {\n",
-       "        if (callback != null)\n",
-       "          callback();\n",
-       "      });\n",
-       "    } finally {\n",
-       "      delete root._bokeh_onload_callbacks\n",
-       "    }\n",
-       "    console.debug(\"Bokeh: all callbacks have finished\");\n",
-       "  }\n",
-       "\n",
-       "  function load_libs(css_urls, js_urls, callback) {\n",
-       "    if (css_urls == null) css_urls = [];\n",
-       "    if (js_urls == null) js_urls = [];\n",
-       "\n",
-       "    root._bokeh_onload_callbacks.push(callback);\n",
-       "    if (root._bokeh_is_loading > 0) {\n",
-       "      console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n",
-       "      return null;\n",
-       "    }\n",
-       "    if (js_urls == null || js_urls.length === 0) {\n",
-       "      run_callbacks();\n",
-       "      return null;\n",
-       "    }\n",
-       "    console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n",
-       "    root._bokeh_is_loading = css_urls.length + js_urls.length;\n",
-       "\n",
-       "    function on_load() {\n",
-       "      root._bokeh_is_loading--;\n",
-       "      if (root._bokeh_is_loading === 0) {\n",
-       "        console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n",
-       "        run_callbacks()\n",
-       "      }\n",
-       "    }\n",
-       "\n",
-       "    function on_error(url) {\n",
-       "      console.error(\"failed to load \" + url);\n",
-       "    }\n",
-       "\n",
-       "    for (let i = 0; i < css_urls.length; i++) {\n",
-       "      const url = css_urls[i];\n",
-       "      const element = document.createElement(\"link\");\n",
-       "      element.onload = on_load;\n",
-       "      element.onerror = on_error.bind(null, url);\n",
-       "      element.rel = \"stylesheet\";\n",
-       "      element.type = \"text/css\";\n",
-       "      element.href = url;\n",
-       "      console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n",
-       "      document.body.appendChild(element);\n",
-       "    }\n",
-       "\n",
-       "    for (let i = 0; i < js_urls.length; i++) {\n",
-       "      const url = js_urls[i];\n",
-       "      const element = document.createElement('script');\n",
-       "      element.onload = on_load;\n",
-       "      element.onerror = on_error.bind(null, url);\n",
-       "      element.async = false;\n",
-       "      element.src = url;\n",
-       "      console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n",
-       "      document.head.appendChild(element);\n",
-       "    }\n",
-       "  };\n",
-       "\n",
-       "  function inject_raw_css(css) {\n",
-       "    const element = document.createElement(\"style\");\n",
-       "    element.appendChild(document.createTextNode(css));\n",
-       "    document.body.appendChild(element);\n",
-       "  }\n",
-       "\n",
-       "  const js_urls = [\"https://cdn.bokeh.org/bokeh/release/bokeh-3.1.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.1.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.1.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.1.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-mathjax-3.1.1.min.js\"];\n",
-       "  const css_urls = [];\n",
-       "\n",
-       "  const inline_js = [    function(Bokeh) {\n",
-       "      Bokeh.set_log_level(\"info\");\n",
-       "    },\n",
-       "function(Bokeh) {\n",
-       "    }\n",
-       "  ];\n",
-       "\n",
-       "  function run_inline_js() {\n",
-       "    if (root.Bokeh !== undefined || force === true) {\n",
-       "          for (let i = 0; i < inline_js.length; i++) {\n",
-       "      inline_js[i].call(root, root.Bokeh);\n",
-       "    }\n",
-       "} else if (Date.now() < root._bokeh_timeout) {\n",
-       "      setTimeout(run_inline_js, 100);\n",
-       "    } else if (!root._bokeh_failed_load) {\n",
-       "      console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n",
-       "      root._bokeh_failed_load = true;\n",
-       "    } else if (force !== true) {\n",
-       "      const cell = $(document.getElementById(null)).parents('.cell').data().cell;\n",
-       "      cell.output_area.append_execute_result(NB_LOAD_WARNING)\n",
-       "    }\n",
-       "  }\n",
-       "\n",
-       "  if (root._bokeh_is_loading === 0) {\n",
-       "    console.debug(\"Bokeh: BokehJS loaded, going straight to plotting\");\n",
-       "    run_inline_js();\n",
-       "  } else {\n",
-       "    load_libs(css_urls, js_urls, function() {\n",
-       "      console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n",
-       "      run_inline_js();\n",
-       "    });\n",
-       "  }\n",
-       "}(window));"
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "56313ff2",
+      "metadata": {
+        "cell_marker": "\"\"\"",
+        "lines_to_next_cell": 0
+      },
+      "source": [
+        "\n",
+        "`tp.resample()` is critical to combine events from different, non-synchronized sources. For example, consider a system with two sensors, a thermometer for temperature and a manometer for pressure. The temperature sensor produces measurements every 1 to 10 minutes, while the pressure sensor returns measurements every second. Additionally assume that both sensors are not synchronized. Finally, assume that you need to combine the temperature and pressure measurements with the equation `temperature / pressure`.\n",
+        "\n",
+        "<!-- TODO: image -->\n",
+        "\n",
+        "Since the temperature and pressure `EventSets` have different sampling, you will need to resample one of them. The pressure sensor has higher resolution. Therefore, resampling the temperature to the pressure yields higher resolution than resampling the pressure to the temperature.\n",
+        "\n",
+        "```python\n",
+        "r = tp.resample(termometer[\"temperature\"], manometer) / manometer[\"pressure\"]\n",
+        "```"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "ae131e37",
+      "metadata": {
+        "cell_marker": "\"\"\"",
+        "lines_to_next_cell": 0
+      },
+      "source": [
+        "\n",
+        "When handling non-uniform timestamps it is also common to have a common resampling source.\n",
+        "\n",
+        "```python\n",
+        "sampling_source = # Uniform timestamps every 10 seconds.\n",
+        "r = tp.resample(termometer[\"temperature\"], sampling_source) / tp.resample(manometer[\"pressure\"], sampling_source)\n",
+        "```\n",
+        "\n",
+        "Moving window operators, such as the `tp.simple_moving_average()` or `tp.moving_count()` operators, have an optional `sampling` argument. For example, the signature of the simple moving average operator is `tp.simple_moving_average()(][temporian.simple_moving_average]input: EventSetNode, window_length: Duration, sampling: Optional[EventSetNode] = None)`. If `sampling`is not set, the result will maintain the sampling of the`input`argument. If`sampling`is set, the moving window will be sampled at each timestamp of`sampling` instead, and the result will have those new ones.\n",
+        "\n",
+        "```python\n",
+        "b = tp.simple_moving_average(input=a, window_length=10)\n",
+        "c = tp.simple_moving_average(input=a, window_length=10, sampling=d)\n",
+        "```\n",
+        "\n",
+        "Note that if planning to resample the result of a moving window operator, passing the `sampling` argument is both more efficient and more accurate than calling `tp.resample()` on the result.\n",
+        "\n",
+        "## Indexes, horizontal and vertical operators\n",
+        "\n",
+        "All operators presented so far work on a sequence of related events. For instance, the simple moving average operator computes the average of events within a specific time window. These types of operators are called _horizontal operators_.\n",
+        "\n",
+        "It is sometimes desirable for events in an `EventSet` not to interact with each other. For example, assume a dataset containing the sum of daily sales of a set of products. The objective is to compute the sum of weekly sales of each product independently. In this scenario, the weekly moving sum should be applied individually to each product. If not, you would compute the weekly sales of all the products together.\n",
+        "\n",
+        "To compute the weekly sales of individual products, you can define the `product` feature as the _index_."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 42,
+      "id": "54a71cae",
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2023-07-12T19:18:48.194474Z",
+          "iopub.status.busy": "2023-07-12T19:18:48.194272Z",
+          "iopub.status.idle": "2023-07-12T19:18:48.199461Z",
+          "shell.execute_reply": "2023-07-12T19:18:48.198635Z"
+        },
+        "lines_to_next_cell": 0
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "indexes: [('product', int64)]\n",
+            "features: [('sale', float64)]\n",
+            "events:\n",
+            "    product=1 (2 events):\n",
+            "        timestamps: [1.5778e+09 1.5779e+09]\n",
+            "        'sale': [100.  90.]\n",
+            "    product=2 (2 events):\n",
+            "        timestamps: [1.5778e+09 1.5779e+09]\n",
+            "        'sale': [300. 400.]\n",
+            "memory usage: 0.9 kB\n",
+            "\n"
+          ]
+        }
       ],
-      "application/vnd.bokehjs_load.v0+json": "(function(root) {\n  function now() {\n    return new Date();\n  }\n\n  const force = true;\n\n  if (typeof root._bokeh_onload_callbacks === \"undefined\" || force === true) {\n    root._bokeh_onload_callbacks = [];\n    root._bokeh_is_loading = undefined;\n  }\n\n\n  if (typeof (root._bokeh_timeout) === \"undefined\" || force === true) {\n    root._bokeh_timeout = Date.now() + 5000;\n    root._bokeh_failed_load = false;\n  }\n\n  const NB_LOAD_WARNING = {'data': {'text/html':\n     \"<div style='background-color: #fdd'>\\n\"+\n     \"<p>\\n\"+\n     \"BokehJS does not appear to have successfully loaded. If loading BokehJS from CDN, this \\n\"+\n     \"may be due to a slow or bad network connection. Possible fixes:\\n\"+\n     \"</p>\\n\"+\n     \"<ul>\\n\"+\n     \"<li>re-rerun `output_notebook()` to attempt to load from CDN again, or</li>\\n\"+\n     \"<li>use INLINE resources instead, as so:</li>\\n\"+\n     \"</ul>\\n\"+\n     \"<code>\\n\"+\n     \"from bokeh.resources import INLINE\\n\"+\n     \"output_notebook(resources=INLINE)\\n\"+\n     \"</code>\\n\"+\n     \"</div>\"}};\n\n  function display_loaded() {\n    const el = document.getElementById(null);\n    if (el != null) {\n      el.textContent = \"BokehJS is loading...\";\n    }\n    if (root.Bokeh !== undefined) {\n      if (el != null) {\n        el.textContent = \"BokehJS \" + root.Bokeh.version + \" successfully loaded.\";\n      }\n    } else if (Date.now() < root._bokeh_timeout) {\n      setTimeout(display_loaded, 100)\n    }\n  }\n\n  function run_callbacks() {\n    try {\n      root._bokeh_onload_callbacks.forEach(function(callback) {\n        if (callback != null)\n          callback();\n      });\n    } finally {\n      delete root._bokeh_onload_callbacks\n    }\n    console.debug(\"Bokeh: all callbacks have finished\");\n  }\n\n  function load_libs(css_urls, js_urls, callback) {\n    if (css_urls == null) css_urls = [];\n    if (js_urls == null) js_urls = [];\n\n    root._bokeh_onload_callbacks.push(callback);\n    if (root._bokeh_is_loading > 0) {\n      console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n      return null;\n    }\n    if (js_urls == null || js_urls.length === 0) {\n      run_callbacks();\n      return null;\n    }\n    console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n    root._bokeh_is_loading = css_urls.length + js_urls.length;\n\n    function on_load() {\n      root._bokeh_is_loading--;\n      if (root._bokeh_is_loading === 0) {\n        console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n        run_callbacks()\n      }\n    }\n\n    function on_error(url) {\n      console.error(\"failed to load \" + url);\n    }\n\n    for (let i = 0; i < css_urls.length; i++) {\n      const url = css_urls[i];\n      const element = document.createElement(\"link\");\n      element.onload = on_load;\n      element.onerror = on_error.bind(null, url);\n      element.rel = \"stylesheet\";\n      element.type = \"text/css\";\n      element.href = url;\n      console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n      document.body.appendChild(element);\n    }\n\n    for (let i = 0; i < js_urls.length; i++) {\n      const url = js_urls[i];\n      const element = document.createElement('script');\n      element.onload = on_load;\n      element.onerror = on_error.bind(null, url);\n      element.async = false;\n      element.src = url;\n      console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n      document.head.appendChild(element);\n    }\n  };\n\n  function inject_raw_css(css) {\n    const element = document.createElement(\"style\");\n    element.appendChild(document.createTextNode(css));\n    document.body.appendChild(element);\n  }\n\n  const js_urls = [\"https://cdn.bokeh.org/bokeh/release/bokeh-3.1.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.1.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.1.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.1.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-mathjax-3.1.1.min.js\"];\n  const css_urls = [];\n\n  const inline_js = [    function(Bokeh) {\n      Bokeh.set_log_level(\"info\");\n    },\nfunction(Bokeh) {\n    }\n  ];\n\n  function run_inline_js() {\n    if (root.Bokeh !== undefined || force === true) {\n          for (let i = 0; i < inline_js.length; i++) {\n      inline_js[i].call(root, root.Bokeh);\n    }\n} else if (Date.now() < root._bokeh_timeout) {\n      setTimeout(run_inline_js, 100);\n    } else if (!root._bokeh_failed_load) {\n      console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n      root._bokeh_failed_load = true;\n    } else if (force !== true) {\n      const cell = $(document.getElementById(null)).parents('.cell').data().cell;\n      cell.output_area.append_execute_result(NB_LOAD_WARNING)\n    }\n  }\n\n  if (root._bokeh_is_loading === 0) {\n    console.debug(\"Bokeh: BokehJS loaded, going straight to plotting\");\n    run_inline_js();\n  } else {\n    load_libs(css_urls, js_urls, function() {\n      console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n      run_inline_js();\n    });\n  }\n}(window));"
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "\n",
-       "  <div id=\"cee9bf9c-702c-47ab-8463-acce41621d85\" data-root-id=\"p1165\" style=\"display: contents;\"></div>\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/javascript": [
-       "(function(root) {\n",
-       "  function embed_document(root) {\n",
-       "  const docs_json = {\"bf595bed-9875-4d3a-97fe-79acda08d25a\":{\"version\":\"3.1.1\",\"title\":\"Bokeh Application\",\"defs\":[],\"roots\":[{\"type\":\"object\",\"name\":\"GridPlot\",\"id\":\"p1165\",\"attributes\":{\"rows\":null,\"cols\":null,\"toolbar\":{\"type\":\"object\",\"name\":\"Toolbar\",\"id\":\"p1164\",\"attributes\":{\"logo\":null,\"tools\":[{\"type\":\"object\",\"name\":\"ToolProxy\",\"id\":\"p1155\",\"attributes\":{\"tools\":[{\"type\":\"object\",\"name\":\"PanTool\",\"id\":\"p1032\",\"attributes\":{\"dimensions\":\"width\"}},{\"type\":\"object\",\"name\":\"PanTool\",\"id\":\"p1092\",\"attributes\":{\"dimensions\":\"width\"}}]}},{\"type\":\"object\",\"name\":\"ToolProxy\",\"id\":\"p1156\",\"attributes\":{\"tools\":[{\"type\":\"object\",\"name\":\"PanTool\",\"id\":\"p1033\"},{\"type\":\"object\",\"name\":\"PanTool\",\"id\":\"p1093\"}]}},{\"type\":\"object\",\"name\":\"ToolProxy\",\"id\":\"p1157\",\"attributes\":{\"tools\":[{\"type\":\"object\",\"name\":\"WheelZoomTool\",\"id\":\"p1034\",\"attributes\":{\"dimensions\":\"width\"}},{\"type\":\"object\",\"name\":\"WheelZoomTool\",\"id\":\"p1094\",\"attributes\":{\"dimensions\":\"width\"}}]}},{\"type\":\"object\",\"name\":\"ToolProxy\",\"id\":\"p1158\",\"attributes\":{\"tools\":[{\"type\":\"object\",\"name\":\"WheelZoomTool\",\"id\":\"p1035\",\"attributes\":{\"dimensions\":\"height\"}},{\"type\":\"object\",\"name\":\"WheelZoomTool\",\"id\":\"p1095\",\"attributes\":{\"dimensions\":\"height\"}}]}},{\"type\":\"object\",\"name\":\"ToolProxy\",\"id\":\"p1159\",\"attributes\":{\"tools\":[{\"type\":\"object\",\"name\":\"BoxZoomTool\",\"id\":\"p1036\",\"attributes\":{\"overlay\":{\"type\":\"object\",\"name\":\"BoxAnnotation\",\"id\":\"p1037\",\"attributes\":{\"syncable\":false,\"level\":\"overlay\",\"visible\":false,\"left_units\":\"canvas\",\"right_units\":\"canvas\",\"bottom_units\":\"canvas\",\"top_units\":\"canvas\",\"line_color\":\"black\",\"line_alpha\":1.0,\"line_width\":2,\"line_dash\":[4,4],\"fill_color\":\"lightgrey\",\"fill_alpha\":0.5}}}},{\"type\":\"object\",\"name\":\"BoxZoomTool\",\"id\":\"p1096\",\"attributes\":{\"overlay\":{\"type\":\"object\",\"name\":\"BoxAnnotation\",\"id\":\"p1097\",\"attributes\":{\"syncable\":false,\"level\":\"overlay\",\"visible\":false,\"left_units\":\"canvas\",\"right_units\":\"canvas\",\"bottom_units\":\"canvas\",\"top_units\":\"canvas\",\"line_color\":\"black\",\"line_alpha\":1.0,\"line_width\":2,\"line_dash\":[4,4],\"fill_color\":\"lightgrey\",\"fill_alpha\":0.5}}}}]}},{\"type\":\"object\",\"name\":\"ToolProxy\",\"id\":\"p1160\",\"attributes\":{\"tools\":[{\"type\":\"object\",\"name\":\"ResetTool\",\"id\":\"p1038\"},{\"type\":\"object\",\"name\":\"ResetTool\",\"id\":\"p1098\"}]}},{\"type\":\"object\",\"name\":\"ToolProxy\",\"id\":\"p1161\",\"attributes\":{\"tools\":[{\"type\":\"object\",\"name\":\"UndoTool\",\"id\":\"p1039\"},{\"type\":\"object\",\"name\":\"UndoTool\",\"id\":\"p1099\"}]}},{\"type\":\"object\",\"name\":\"SaveTool\",\"id\":\"p1162\"},{\"type\":\"object\",\"name\":\"ToolProxy\",\"id\":\"p1163\",\"attributes\":{\"tools\":[{\"type\":\"object\",\"name\":\"HoverTool\",\"id\":\"p1041\",\"attributes\":{\"renderers\":\"auto\"}},{\"type\":\"object\",\"name\":\"HoverTool\",\"id\":\"p1101\",\"attributes\":{\"renderers\":\"auto\"}}]}}]}},\"toolbar_location\":\"right\",\"children\":[[{\"type\":\"object\",\"name\":\"Figure\",\"id\":\"p1001\",\"attributes\":{\"width\":1024,\"height\":150,\"x_range\":{\"type\":\"object\",\"name\":\"DataRange1d\",\"id\":\"p1003\",\"attributes\":{\"js_property_callbacks\":{\"type\":\"map\",\"entries\":[[\"change:start\",[{\"type\":\"object\",\"name\":\"CustomJS\",\"id\":\"p1122\",\"attributes\":{\"args\":{\"type\":\"map\",\"entries\":[[\"p1_x_range\",{\"id\":\"p1003\"}],[\"p2_x_range\",{\"type\":\"object\",\"name\":\"DataRange1d\",\"id\":\"p1064\",\"attributes\":{\"js_property_callbacks\":{\"type\":\"map\",\"entries\":[[\"change:start\",[{\"id\":\"p1122\"}]],[\"change:end\",[{\"id\":\"p1122\"}]]]}}}]]},\"code\":\"\\n            if (cb_obj == p1_x_range) {\\n                const start =  p1_x_range.start;\\n                const end =  p1_x_range.end;\\n                \\n            p2_x_range.start = start;\\n            p2_x_range.end = end;\\n            \\n            }\\n            \\n            if (cb_obj == p2_x_range) {\\n                const start =  p2_x_range.start;\\n                const end =  p2_x_range.end;\\n                \\n            p1_x_range.start = start;\\n            p1_x_range.end = end;\\n            \\n            }\\n            \"}}]],[\"change:end\",[{\"id\":\"p1122\"}]]]}}},\"y_range\":{\"type\":\"object\",\"name\":\"DataRange1d\",\"id\":\"p1002\"},\"x_scale\":{\"type\":\"object\",\"name\":\"LinearScale\",\"id\":\"p1014\"},\"y_scale\":{\"type\":\"object\",\"name\":\"LinearScale\",\"id\":\"p1016\"},\"title\":{\"type\":\"object\",\"name\":\"Title\",\"id\":\"p1005\"},\"renderers\":[{\"type\":\"object\",\"name\":\"GlyphRenderer\",\"id\":\"p1059\",\"attributes\":{\"data_source\":{\"type\":\"object\",\"name\":\"ColumnDataSource\",\"id\":\"p1053\",\"attributes\":{\"selected\":{\"type\":\"object\",\"name\":\"Selection\",\"id\":\"p1054\",\"attributes\":{\"indices\":[],\"line_indices\":[]}},\"selection_policy\":{\"type\":\"object\",\"name\":\"UnionRenderers\",\"id\":\"p1055\"},\"data\":{\"type\":\"map\",\"entries\":[[\"x\",{\"type\":\"ndarray\",\"array\":{\"type\":\"bytes\",\"data\":\"AAAAAAAA8D8AAAAAAAAAQAAAAAAAAAhAAAAAAAAAEEAAAAAAAAAUQA==\"},\"shape\":[5],\"dtype\":\"float64\",\"order\":\"little\"}],[\"y\",{\"type\":\"ndarray\",\"array\":{\"type\":\"bytes\",\"data\":\"AAAAAAAA4D8zMzMzMzPjP5qZmZmZmdk/mpmZmZmZ2T/NzMzMzMzsPw==\"},\"shape\":[5],\"dtype\":\"float64\",\"order\":\"little\"}]]}}},\"view\":{\"type\":\"object\",\"name\":\"CDSView\",\"id\":\"p1060\",\"attributes\":{\"filter\":{\"type\":\"object\",\"name\":\"AllIndices\",\"id\":\"p1061\"}}},\"glyph\":{\"type\":\"object\",\"name\":\"Line\",\"id\":\"p1056\",\"attributes\":{\"x\":{\"type\":\"field\",\"field\":\"x\"},\"y\":{\"type\":\"field\",\"field\":\"y\"},\"line_color\":\"#1b9e77\"}},\"nonselection_glyph\":{\"type\":\"object\",\"name\":\"Line\",\"id\":\"p1057\",\"attributes\":{\"x\":{\"type\":\"field\",\"field\":\"x\"},\"y\":{\"type\":\"field\",\"field\":\"y\"},\"line_color\":\"#1b9e77\",\"line_alpha\":0.1}},\"muted_glyph\":{\"type\":\"object\",\"name\":\"Line\",\"id\":\"p1058\",\"attributes\":{\"x\":{\"type\":\"field\",\"field\":\"x\"},\"y\":{\"type\":\"field\",\"field\":\"y\"},\"line_color\":\"#1b9e77\",\"line_alpha\":0.2}}}}],\"toolbar\":{\"type\":\"object\",\"name\":\"Toolbar\",\"id\":\"p1006\",\"attributes\":{\"tools\":[{\"id\":\"p1032\"},{\"id\":\"p1033\"},{\"id\":\"p1034\"},{\"id\":\"p1035\"},{\"id\":\"p1036\"},{\"id\":\"p1038\"},{\"id\":\"p1039\"},{\"type\":\"object\",\"name\":\"SaveTool\",\"id\":\"p1040\"},{\"id\":\"p1041\"}]}},\"toolbar_location\":null,\"left\":[{\"type\":\"object\",\"name\":\"LinearAxis\",\"id\":\"p1025\",\"attributes\":{\"ticker\":{\"type\":\"object\",\"name\":\"BasicTicker\",\"id\":\"p1028\",\"attributes\":{\"mantissas\":[1,2,5]}},\"formatter\":{\"type\":\"object\",\"name\":\"BasicTickFormatter\",\"id\":\"p1026\"},\"axis_label\":\"feature_1\",\"major_label_policy\":{\"type\":\"object\",\"name\":\"AllLabels\",\"id\":\"p1027\"}}}],\"below\":[{\"type\":\"object\",\"name\":\"LinearAxis\",\"id\":\"p1018\",\"attributes\":{\"ticker\":{\"type\":\"object\",\"name\":\"BasicTicker\",\"id\":\"p1021\",\"attributes\":{\"mantissas\":[1,2,5]}},\"formatter\":{\"type\":\"object\",\"name\":\"BasicTickFormatter\",\"id\":\"p1019\"},\"major_label_policy\":{\"type\":\"object\",\"name\":\"AllLabels\",\"id\":\"p1020\"}}}],\"center\":[{\"type\":\"object\",\"name\":\"Grid\",\"id\":\"p1024\",\"attributes\":{\"axis\":{\"id\":\"p1018\"}}},{\"type\":\"object\",\"name\":\"Grid\",\"id\":\"p1031\",\"attributes\":{\"dimension\":1,\"axis\":{\"id\":\"p1025\"}}}]}},0,0],[{\"type\":\"object\",\"name\":\"Figure\",\"id\":\"p1062\",\"attributes\":{\"width\":1024,\"height\":150,\"x_range\":{\"id\":\"p1064\"},\"y_range\":{\"type\":\"object\",\"name\":\"FactorRange\",\"id\":\"p1073\",\"attributes\":{\"factors\":[\"red\",\"green\",\"blue\"]}},\"x_scale\":{\"type\":\"object\",\"name\":\"LinearScale\",\"id\":\"p1075\"},\"y_scale\":{\"type\":\"object\",\"name\":\"CategoricalScale\",\"id\":\"p1077\"},\"title\":{\"type\":\"object\",\"name\":\"Title\",\"id\":\"p1066\"},\"renderers\":[{\"type\":\"object\",\"name\":\"GlyphRenderer\",\"id\":\"p1119\",\"attributes\":{\"data_source\":{\"type\":\"object\",\"name\":\"ColumnDataSource\",\"id\":\"p1113\",\"attributes\":{\"selected\":{\"type\":\"object\",\"name\":\"Selection\",\"id\":\"p1114\",\"attributes\":{\"indices\":[],\"line_indices\":[]}},\"selection_policy\":{\"type\":\"object\",\"name\":\"UnionRenderers\",\"id\":\"p1115\"},\"data\":{\"type\":\"map\",\"entries\":[[\"x\",{\"type\":\"ndarray\",\"array\":{\"type\":\"bytes\",\"data\":\"AAAAAAAA8D8AAAAAAAAAQAAAAAAAAAhAAAAAAAAAEEAAAAAAAAAUQA==\"},\"shape\":[5],\"dtype\":\"float64\",\"order\":\"little\"}],[\"y\",{\"type\":\"ndarray\",\"array\":[\"red\",\"blue\",\"red\",\"blue\",\"green\"],\"shape\":[5],\"dtype\":\"object\",\"order\":\"little\"}]]}}},\"view\":{\"type\":\"object\",\"name\":\"CDSView\",\"id\":\"p1120\",\"attributes\":{\"filter\":{\"type\":\"object\",\"name\":\"AllIndices\",\"id\":\"p1121\"}}},\"glyph\":{\"type\":\"object\",\"name\":\"Circle\",\"id\":\"p1116\",\"attributes\":{\"x\":{\"type\":\"field\",\"field\":\"x\"},\"y\":{\"type\":\"field\",\"field\":\"y\"},\"line_color\":{\"type\":\"value\",\"value\":\"#1f77b4\"},\"fill_color\":{\"type\":\"value\",\"value\":\"#1f77b4\"}}},\"nonselection_glyph\":{\"type\":\"object\",\"name\":\"Circle\",\"id\":\"p1117\",\"attributes\":{\"x\":{\"type\":\"field\",\"field\":\"x\"},\"y\":{\"type\":\"field\",\"field\":\"y\"},\"line_color\":{\"type\":\"value\",\"value\":\"#1f77b4\"},\"line_alpha\":{\"type\":\"value\",\"value\":0.1},\"fill_color\":{\"type\":\"value\",\"value\":\"#1f77b4\"},\"fill_alpha\":{\"type\":\"value\",\"value\":0.1},\"hatch_alpha\":{\"type\":\"value\",\"value\":0.1}}},\"muted_glyph\":{\"type\":\"object\",\"name\":\"Circle\",\"id\":\"p1118\",\"attributes\":{\"x\":{\"type\":\"field\",\"field\":\"x\"},\"y\":{\"type\":\"field\",\"field\":\"y\"},\"line_color\":{\"type\":\"value\",\"value\":\"#1f77b4\"},\"line_alpha\":{\"type\":\"value\",\"value\":0.2},\"fill_color\":{\"type\":\"value\",\"value\":\"#1f77b4\"},\"fill_alpha\":{\"type\":\"value\",\"value\":0.2},\"hatch_alpha\":{\"type\":\"value\",\"value\":0.2}}}}}],\"toolbar\":{\"type\":\"object\",\"name\":\"Toolbar\",\"id\":\"p1067\",\"attributes\":{\"tools\":[{\"id\":\"p1092\"},{\"id\":\"p1093\"},{\"id\":\"p1094\"},{\"id\":\"p1095\"},{\"id\":\"p1096\"},{\"id\":\"p1098\"},{\"id\":\"p1099\"},{\"type\":\"object\",\"name\":\"SaveTool\",\"id\":\"p1100\"},{\"id\":\"p1101\"}]}},\"toolbar_location\":null,\"left\":[{\"type\":\"object\",\"name\":\"CategoricalAxis\",\"id\":\"p1086\",\"attributes\":{\"ticker\":{\"type\":\"object\",\"name\":\"CategoricalTicker\",\"id\":\"p1089\"},\"formatter\":{\"type\":\"object\",\"name\":\"CategoricalTickFormatter\",\"id\":\"p1087\"},\"axis_label\":\"feature_2\",\"major_label_policy\":{\"type\":\"object\",\"name\":\"AllLabels\",\"id\":\"p1088\"}}}],\"below\":[{\"type\":\"object\",\"name\":\"LinearAxis\",\"id\":\"p1079\",\"attributes\":{\"ticker\":{\"type\":\"object\",\"name\":\"BasicTicker\",\"id\":\"p1082\",\"attributes\":{\"mantissas\":[1,2,5]}},\"formatter\":{\"type\":\"object\",\"name\":\"BasicTickFormatter\",\"id\":\"p1080\"},\"major_label_policy\":{\"type\":\"object\",\"name\":\"AllLabels\",\"id\":\"p1081\"}}}],\"center\":[{\"type\":\"object\",\"name\":\"Grid\",\"id\":\"p1085\",\"attributes\":{\"axis\":{\"id\":\"p1079\"}}},{\"type\":\"object\",\"name\":\"Grid\",\"id\":\"p1091\",\"attributes\":{\"dimension\":1,\"axis\":{\"id\":\"p1086\"}}}]}},1,0]]}}],\"callbacks\":{\"type\":\"map\"}}};\n",
-       "  const render_items = [{\"docid\":\"bf595bed-9875-4d3a-97fe-79acda08d25a\",\"roots\":{\"p1165\":\"cee9bf9c-702c-47ab-8463-acce41621d85\"},\"root_ids\":[\"p1165\"]}];\n",
-       "  root.Bokeh.embed.embed_items_notebook(docs_json, render_items);\n",
-       "  }\n",
-       "  if (root.Bokeh !== undefined) {\n",
-       "    embed_document(root);\n",
-       "  } else {\n",
-       "    let attempts = 0;\n",
-       "    const timer = setInterval(function(root) {\n",
-       "      if (root.Bokeh !== undefined) {\n",
-       "        clearInterval(timer);\n",
-       "        embed_document(root);\n",
-       "      } else {\n",
-       "        attempts++;\n",
-       "        if (attempts > 100) {\n",
-       "          clearInterval(timer);\n",
-       "          console.log(\"Bokeh: ERROR: Unable to run BokehJS code because BokehJS library is missing\");\n",
-       "        }\n",
-       "      }\n",
-       "    }, 10, root)\n",
-       "  }\n",
-       "})(window);"
+      "source": [
+        "daily_sales = tp.event_set(\n",
+        "\ttimestamps=[\"2020-01-01\", \"2020-01-01\", \"2020-01-02\", \"2020-01-02\"],\n",
+        "\tfeatures={\n",
+        "        \"product\": [1, 2, 1, 2],\n",
+        "        \"sale\": [100.0, 300.0, 90.0, 400.0],\n",
+        "    },\n",
+        "    indexes=[\"product\"]\n",
+        ")\n",
+        "print(daily_sales)"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "40dacbb4",
+      "metadata": {
+        "cell_marker": "\"\"\"",
+        "lines_to_next_cell": 0
+      },
+      "source": [
+        "\n",
+        "The moving sum operator will then be applied independently to the events corresponding to each product."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 43,
+      "id": "2c87a680",
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2023-07-12T19:18:48.201683Z",
+          "iopub.status.busy": "2023-07-12T19:18:48.201488Z",
+          "iopub.status.idle": "2023-07-12T19:18:48.207280Z",
+          "shell.execute_reply": "2023-07-12T19:18:48.206430Z"
+        },
+        "lines_to_next_cell": 2
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "indexes: [('product', int64)]\n",
+              "features: [('sale', float64)]\n",
+              "events:\n",
+              "    product=1 (2 events):\n",
+              "        timestamps: [1.5778e+09 1.5779e+09]\n",
+              "        'sale': [100. 190.]\n",
+              "    product=2 (2 events):\n",
+              "        timestamps: [1.5778e+09 1.5779e+09]\n",
+              "        'sale': [300. 700.]\n",
+              "memory usage: 0.9 kB"
+            ]
+          },
+          "execution_count": 43,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
       ],
-      "application/vnd.bokehjs_exec.v0+json": ""
-     },
-     "metadata": {
-      "application/vnd.bokehjs_exec.v0+json": {
-       "id": "p1165"
-      }
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "!pip install bokeh -q\n",
-    "\n",
-    "evset.plot(interactive=True)"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "cf4d0c27",
-   "metadata": {
-    "cell_marker": "\"\"\"",
-    "lines_to_next_cell": 0
-   },
-   "source": [
-    "\n",
-    "## Feature naming\n",
-    "\n",
-    "Each feature is identified by a name, and the list of features is available through the `features` property of an `EventSetNode`."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "id": "38ff0e20",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-07-12T19:18:48.041769Z",
-     "iopub.status.busy": "2023-07-12T19:18:48.041511Z",
-     "iopub.status.idle": "2023-07-12T19:18:48.045989Z",
-     "shell.execute_reply": "2023-07-12T19:18:48.045296Z"
-    }
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[('feature_1', float64), ('feature_2', float64)]\n"
-     ]
-    }
-   ],
-   "source": [
-    "events = tp.event_set(\n",
-    "\ttimestamps=[1,2,3,4,5],\n",
-    "\tfeatures={\n",
-    "\t    \"feature_1\": [0.5, 0.6, 0.4, 0.4, 0.9],\n",
-    "\t    \"feature_2\": [1.0, 2.0, 3.0, 2.0, 1.0]}\n",
-    "    )\n",
-    "node = events.node()\n",
-    "print(node.features)"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "2cd29020",
-   "metadata": {
-    "cell_marker": "\"\"\"",
-    "lines_to_next_cell": 0
-   },
-   "source": [
-    "\n",
-    "Most operators do not change the input feature's names."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "id": "838449d4",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-07-12T19:18:48.048381Z",
-     "iopub.status.busy": "2023-07-12T19:18:48.048173Z",
-     "iopub.status.idle": "2023-07-12T19:18:48.053544Z",
-     "shell.execute_reply": "2023-07-12T19:18:48.052749Z"
-    }
-   },
-   "outputs": [
+      "source": [
+        "a = daily_sales.node()\n",
+        "\n",
+        "# Compute the moving sum of each index group (a.k.a. each product) individually.\n",
+        "b = tp.moving_sum(a, window_length=tp.duration.weeks(1))\n",
+        "\n",
+        "b.run({a: daily_sales})"
+      ]
+    },
     {
-     "data": {
-      "text/plain": [
-       "[('feature_1', float64), ('feature_2', float64)]"
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "e096897d",
+      "metadata": {
+        "cell_marker": "\"\"\"",
+        "lines_to_next_cell": 0
+      },
+      "source": [
+        "\n",
+        "Horizontal operators can be understood as operators that are applied independently on each index.\n",
+        "\n",
+        "Operators that modify an `EventSetNode`'s indexes are called _vertical operators_. The most important vertical operators are:\n",
+        "\n",
+        "- `tp.add_index()`: Add features to the index.\n",
+        "- `tp.drop_index()`: Remove features from the index, optionally keeping them as features.\n",
+        "- `tp.set_index()`: Changes the index.\n",
+        "- `tp.propagate()`: Expand indexes based on another `EventSet`’s indexes.\n",
+        "\n",
+        "By default, `EventSets` are _flat_, which means they have no index, and therefore all events are in a single global group.\n",
+        "\n",
+        "Also, keep in mind that only string and integer features can be used as indexes.\n",
+        "\n",
+        "`EventSets` can have multiple features as index. In the next example, assume our daily sale aggregates are also annotated with `store` data."
       ]
-     },
-     "execution_count": 20,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "tp.moving_sum(node, window_length=10).features"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "b70cc298",
-   "metadata": {
-    "cell_marker": "\"\"\"",
-    "lines_to_next_cell": 0
-   },
-   "source": [
-    "\n",
-    "Some operators combine two input features with different names, in which case the output name is also combined."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 21,
-   "id": "b10fdec3",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-07-12T19:18:48.056033Z",
-     "iopub.status.busy": "2023-07-12T19:18:48.055834Z",
-     "iopub.status.idle": "2023-07-12T19:18:48.060788Z",
-     "shell.execute_reply": "2023-07-12T19:18:48.060000Z"
-    }
-   },
-   "outputs": [
+    },
     {
-     "data": {
-      "text/plain": [
-       "[('mult_feature_1_feature_2', float64)]"
+      "cell_type": "code",
+      "execution_count": 44,
+      "id": "8badbebf",
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2023-07-12T19:18:48.209523Z",
+          "iopub.status.busy": "2023-07-12T19:18:48.209325Z",
+          "iopub.status.idle": "2023-07-12T19:18:48.213897Z",
+          "shell.execute_reply": "2023-07-12T19:18:48.213288Z"
+        }
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "indexes: []\n",
+            "features: [('store', int64), ('product', int64), ('sale', float64)]\n",
+            "events:\n",
+            "     (4 events):\n",
+            "        timestamps: [1.5778e+09 1.5778e+09 1.5779e+09 1.5779e+09]\n",
+            "        'store': [1 1 1 2]\n",
+            "        'product': [1 2 1 2]\n",
+            "        'sale': [100. 200. 110. 300.]\n",
+            "memory usage: 0.9 kB\n",
+            "\n"
+          ]
+        }
+      ],
+      "source": [
+        "daily_sales = tp.event_set(\n",
+        "\ttimestamps=[\"2020-01-01\", \"2020-01-01\", \"2020-01-02\", \"2020-01-02\"],\n",
+        "\tfeatures={\n",
+        "        \"store\": [1, 1, 1, 2],\n",
+        "        \"product\": [1, 2, 1, 2],\n",
+        "        \"sale\": [100.0, 200.0, 110.0, 300.0],\n",
+        "    },\n",
+        ")\n",
+        "print(daily_sales)"
       ]
-     },
-     "execution_count": 21,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "result = node[\"feature_1\"] * node[\"feature_2\"]\n",
-    "result.features"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "87731369",
-   "metadata": {
-    "cell_marker": "\"\"\"",
-    "lines_to_next_cell": 0
-   },
-   "source": [
-    "\n",
-    "The calendar operators don't depend on input features but on the timestamps, so the output feature name doesn't\n",
-    "relate to the input feature names."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 22,
-   "id": "4182d3f8",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-07-12T19:18:48.063351Z",
-     "iopub.status.busy": "2023-07-12T19:18:48.063139Z",
-     "iopub.status.idle": "2023-07-12T19:18:48.067737Z",
-     "shell.execute_reply": "2023-07-12T19:18:48.066977Z"
-    }
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[('calendar_month', int32)]\n"
-     ]
-    }
-   ],
-   "source": [
-    "date_events = tp.event_set(\n",
-    "\ttimestamps=[\"2020-02-15\", \"2020-06-20\"],\n",
-    "\tfeatures={\"some_feature\": [10, 20]}\n",
-    "    )\n",
-    "date_node = date_events.node()\n",
-    "print(tp.calendar_month(date_node).features)"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "61127d7f",
-   "metadata": {
-    "cell_marker": "\"\"\"",
-    "lines_to_next_cell": 0
-   },
-   "source": [
-    "\n",
-    "You can modify feature names using the `tp.rename()` and `tp.prefix()` operators. `tp.rename()` changes the name of features, while `tp.prefix()` adds a prefix in front of existing feature names. Note that they do not modify the content of the input `EventSetNode`, but return a new `EventSetNode` with the modified feature names."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 23,
-   "id": "bc36bc1f",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-07-12T19:18:48.070434Z",
-     "iopub.status.busy": "2023-07-12T19:18:48.070178Z",
-     "iopub.status.idle": "2023-07-12T19:18:48.074287Z",
-     "shell.execute_reply": "2023-07-12T19:18:48.073625Z"
-    }
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[('renamed_1', float64)]\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Rename a single feature.\n",
-    "renamed_f1 = tp.rename(node[\"feature_1\"], \"renamed_1\")\n",
-    "print(renamed_f1.features)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 24,
-   "id": "a44f6e7a",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-07-12T19:18:48.076479Z",
-     "iopub.status.busy": "2023-07-12T19:18:48.076270Z",
-     "iopub.status.idle": "2023-07-12T19:18:48.080087Z",
-     "shell.execute_reply": "2023-07-12T19:18:48.079462Z"
-    }
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[('renamed_1', float64), ('renamed_2', float64)]\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Rename all features.\n",
-    "renamed_node = tp.rename(node,\n",
-    "    {\"feature_1\": \"renamed_1\", \"feature_2\": \"renamed_2\"}\n",
-    ")\n",
-    "print(renamed_node.features)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 25,
-   "id": "af6103fc",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-07-12T19:18:48.082268Z",
-     "iopub.status.busy": "2023-07-12T19:18:48.082077Z",
-     "iopub.status.idle": "2023-07-12T19:18:48.086119Z",
-     "shell.execute_reply": "2023-07-12T19:18:48.085424Z"
-    }
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[('prefixed.feature_1', float64)]\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Prefix a single feature.\n",
-    "prefixed_f1 = tp.prefix(\"prefixed.\", node[\"feature_1\"])\n",
-    "print(prefixed_f1.features)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 26,
-   "id": "3126cbed",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-07-12T19:18:48.088498Z",
-     "iopub.status.busy": "2023-07-12T19:18:48.088287Z",
-     "iopub.status.idle": "2023-07-12T19:18:48.092046Z",
-     "shell.execute_reply": "2023-07-12T19:18:48.091363Z"
-    }
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[('prefixed.feature_1', float64), ('prefixed.feature_2', float64)]\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Prefix all features.\n",
-    "prefixed_node = tp.prefix(\"prefixed.\", node)\n",
-    "print(prefixed_node.features)"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "085e79c3",
-   "metadata": {
-    "cell_marker": "\"\"\"",
-    "lines_to_next_cell": 0
-   },
-   "source": [
-    "\n",
-    "It is recommended to use `tp.rename()` and `tp.prefix()` to organize your data, and avoid duplicated feature names."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 27,
-   "id": "852abbdd",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-07-12T19:18:48.094459Z",
-     "iopub.status.busy": "2023-07-12T19:18:48.094263Z",
-     "iopub.status.idle": "2023-07-12T19:18:48.098192Z",
-     "shell.execute_reply": "2023-07-12T19:18:48.097520Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "sma_7_node = tp.prefix(\"sma_7.\", tp.simple_moving_average(node, tp.duration.days(7)))\n",
-    "sma_14_node = tp.prefix(\"sma_14.\", tp.simple_moving_average(node, tp.duration.days(14)))"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "ac25eb4a",
-   "metadata": {
-    "cell_marker": "\"\"\"",
-    "lines_to_next_cell": 0
-   },
-   "source": [
-    "\n",
-    "The `tp.glue()` operator can be used to concatenate different features into a single `EventSetNode`, but it will fail if two features with the same name are provided. The following pattern is commonly used in Temporian programs."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 28,
-   "id": "f7d85e33",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-07-12T19:18:48.100474Z",
-     "iopub.status.busy": "2023-07-12T19:18:48.100285Z",
-     "iopub.status.idle": "2023-07-12T19:18:48.104973Z",
-     "shell.execute_reply": "2023-07-12T19:18:48.104296Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "result = tp.glue(\n",
-    "    tp.prefix(\"sma_7.\", tp.simple_moving_average(node, tp.duration.days(7))),\n",
-    "    tp.prefix(\"sma_14.\", tp.simple_moving_average(node, tp.duration.days(14))),\n",
-    ")"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "749df3cc",
-   "metadata": {
-    "cell_marker": "\"\"\"",
-    "lines_to_next_cell": 0
-   },
-   "source": [
-    "\n",
-    "## Casting\n",
-    "\n",
-    "Temporian is strict on feature data types (also called dtype). This means that often, you cannot perform operations between features of different types. For example, you cannot subtract a `tp.float32` and a `tp.float64`. Instead, you must manually cast the features to the same type before performing the operation."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 29,
-   "id": "e1276be1",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-07-12T19:18:48.107140Z",
-     "iopub.status.busy": "2023-07-12T19:18:48.106948Z",
-     "iopub.status.idle": "2023-07-12T19:18:48.110638Z",
-     "shell.execute_reply": "2023-07-12T19:18:48.109910Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "node = tp.input_node(features=[(\"f1\", tp.float32), (\"f2\", tp.float64)])\n",
-    "added = tp.cast(node[\"f1\"], tp.float64) + node[\"f2\"]"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "d45a37bb",
-   "metadata": {
-    "lines_to_next_cell": 0
-   },
-   "source": [
-    "\n",
-    "Casting is especially useful to reduce memory usage. For example, if a feature only contains values between 0 and 10000, using `tp.int32` instead of `tp.int64` will halve memory usage. These optimizations are critical when working with large datasets.\n",
-    "\n",
-    "Casting can also be a necessary step before calling operators that only accept certain input data types.\n",
-    "\n",
-    "Note that in Python, the values `1.0` and `1` are respectively `float64` and `int64`.\n",
-    "\n",
-    "Temporian supports data type casting through the `tp.cast()` operator. Destination data types can be specified in three different ways:\n",
-    "\n",
-    "1. Single data type: converts all input features to the same destination data type.\n",
-    "\n",
-    "   "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 30,
-   "id": "3e3ee4c4",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-07-12T19:18:48.112858Z",
-     "iopub.status.busy": "2023-07-12T19:18:48.112669Z",
-     "iopub.status.idle": "2023-07-12T19:18:48.117232Z",
-     "shell.execute_reply": "2023-07-12T19:18:48.116444Z"
-    },
-    "lines_to_next_cell": 0
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[('f1', float32), ('f2', float64)]"
-      ]
-     },
-     "execution_count": 30,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "node.features"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 31,
-   "id": "6c2444ba",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-07-12T19:18:48.119467Z",
-     "iopub.status.busy": "2023-07-12T19:18:48.119269Z",
-     "iopub.status.idle": "2023-07-12T19:18:48.122662Z",
-     "shell.execute_reply": "2023-07-12T19:18:48.122171Z"
-    }
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[('f1', str_), ('f2', str_)]\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(tp.cast(node, tp.str_).features)"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "59c449d9",
-   "metadata": {
-    "cell_marker": "\"\"\"",
-    "lines_to_next_cell": 0
-   },
-   "source": [
-    "\n",
-    "2. Feature name to data type mapping: converts each feature (specified by name) to a specific data type."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 32,
-   "id": "05ee00a7",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-07-12T19:18:48.124843Z",
-     "iopub.status.busy": "2023-07-12T19:18:48.124658Z",
-     "iopub.status.idle": "2023-07-12T19:18:48.128444Z",
-     "shell.execute_reply": "2023-07-12T19:18:48.127834Z"
-    }
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[('f1', str_), ('f2', int64)]\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(tp.cast(node, {\"f1\": tp.str_, \"f2\": tp.int64}).features)"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "3f85a531",
-   "metadata": {
-    "cell_marker": "\"\"\"",
-    "lines_to_next_cell": 0
-   },
-   "source": [
-    "\n",
-    "3. Data type to data type mapping: converts all features of a specific data type to another data type."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 33,
-   "id": "6deaff88",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-07-12T19:18:48.130815Z",
-     "iopub.status.busy": "2023-07-12T19:18:48.130616Z",
-     "iopub.status.idle": "2023-07-12T19:18:48.134664Z",
-     "shell.execute_reply": "2023-07-12T19:18:48.133974Z"
-    }
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[('f1', str_), ('f2', int64)]\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(tp.cast(node, {tp.float32: tp.str_, tp.float64: tp.int64}).features)"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "915df6c5",
-   "metadata": {
-    "cell_marker": "\"\"\"",
-    "lines_to_next_cell": 0
-   },
-   "source": [
-    "\n",
-    "Keep in mind that casting may fail when the graph is evaluated. For instance, attempting to cast `\"word\"` to `tp.float64` will result in an error. These errors cannot be caught prior to graph evaluation.\n",
-    "\n",
-    "## Arithmetic operators\n",
-    "\n",
-    "Arithmetic operators can be used between the features of an `EventSetNode`, to perform element-wise calculations.\n",
-    "\n",
-    "Common mathematical and bit operations are supported, such as addition (`+`), subtraction (`-`), product (`*`), division (`/`), floor division (`//`), modulo (`%`), comparisons (`>, >=, <, <=`), and bitwise operators (`&, |, ~`).\n",
-    "\n",
-    "These operators are applied index-wise and timestamp-wise, between features in the same position."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 34,
-   "id": "2c673b17",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-07-12T19:18:48.137323Z",
-     "iopub.status.busy": "2023-07-12T19:18:48.136793Z",
-     "iopub.status.idle": "2023-07-12T19:18:48.142502Z",
-     "shell.execute_reply": "2023-07-12T19:18:48.141727Z"
-    },
-    "lines_to_next_cell": 0
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "indexes: []\n",
-      "features: [('add_f1_f3', int64), ('add_f2_f4', float64)]\n",
-      "events:\n",
-      "     (2 events):\n",
-      "        timestamps: [ 1. 10.]\n",
-      "        'add_f1_f3': [100 101]\n",
-      "        'add_f2_f4': [1010. 1020.]\n",
-      "memory usage: 0.7 kB\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "evset = tp.event_set(\n",
-    "    timestamps=[1, 10],\n",
-    "    features={\n",
-    "        \"f1\": [0, 1],\n",
-    "        \"f2\": [10.0, 20.0],\n",
-    "        \"f3\": [100, 100],\n",
-    "        \"f4\": [1000.0, 1000.0],\n",
-    "    },\n",
-    ")\n",
-    "node = evset.node()\n",
-    "\n",
-    "node_added = node[[\"f1\", \"f2\"]] + node[[\"f3\", \"f4\"]]\n",
-    "\n",
-    "evset_added = node_added.run(evset)\n",
-    "print(evset_added)"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "03bd54cc",
-   "metadata": {
-    "cell_marker": "\"\"\"",
-    "lines_to_next_cell": 0
-   },
-   "source": [
-    "\n",
-    "Note that features of type `int64` and `float64` are not mixed above, because otherwise the operation would fail without an explicit type cast."
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "1675fa25",
-   "metadata": {
-    "cell_marker": "\"\"\"",
-    "lines_to_next_cell": 0
-   },
-   "source": [
-    "```python\n",
-    "# Attempt to mix dtypes.\n",
-    ">>> node[\"f1\"] + node[\"f2\"]\n",
-    "Traceback (most recent call last):\n",
-    "    ...\n",
-    "ValueError: corresponding features should have the same dtype. ...\n",
-    "```"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "7b50cf71",
-   "metadata": {
-    "cell_marker": "\"\"\"",
-    "lines_to_next_cell": 0
-   },
-   "source": [
-    "\n",
-    "Refer to the [Casting](#casting) section for more on this.\n",
-    "\n",
-    "All the operators have an equivalent functional form. The example above using `+`, could be rewritten with `tp.add()`."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 35,
-   "id": "3b350c4a",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-07-12T19:18:48.144884Z",
-     "iopub.status.busy": "2023-07-12T19:18:48.144689Z",
-     "iopub.status.idle": "2023-07-12T19:18:48.148299Z",
-     "shell.execute_reply": "2023-07-12T19:18:48.147589Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# Equivalent.\n",
-    "node_added = tp.add(node[[\"f1\", \"f2\"]], node[[\"f3\", \"f4\"]])"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "d65bd8de",
-   "metadata": {
-    "cell_marker": "\"\"\"",
-    "lines_to_next_cell": 0
-   },
-   "source": [
-    "\n",
-    "Other usual comparison and logic operators also work (except `==`, see below)."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 36,
-   "id": "f1462eea",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-07-12T19:18:48.150468Z",
-     "iopub.status.busy": "2023-07-12T19:18:48.150279Z",
-     "iopub.status.idle": "2023-07-12T19:18:48.154461Z",
-     "shell.execute_reply": "2023-07-12T19:18:48.153773Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "is_greater = node[[\"f1\", \"f2\"]] > node[[\"f3\", \"f4\"]]\n",
-    "is_less_or_equal = node[[\"f1\", \"f2\"]] <= node[[\"f3\", \"f4\"]]\n",
-    "is_wrong = is_greater & is_less_or_equal"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "9f01eee7",
-   "metadata": {
-    "cell_marker": "\"\"\"",
-    "lines_to_next_cell": 0
-   },
-   "source": [
-    "\n",
-    "**Warning:** The Python equality operator (`==`) does not compute element-wise equality between features. Use the `tp.equal()` operator instead."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 37,
-   "id": "c610a0d0",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-07-12T19:18:48.156702Z",
-     "iopub.status.busy": "2023-07-12T19:18:48.156507Z",
-     "iopub.status.idle": "2023-07-12T19:18:48.161203Z",
-     "shell.execute_reply": "2023-07-12T19:18:48.160516Z"
-    }
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "schema:\n",
-       "    features: [('eq_f1_f3', bool_)]\n",
-       "    indexes: []\n",
-       "    is_unix_timestamp: False\n",
-       "\n",
-       "features: [Feature(id=140558094330624, creator=Operator(key='EQUAL', id=66, attributes={}))]\n",
-       "sampling: Sampling(id=140557545245616, creator=None),\n",
-       "name: None\n",
-       "creator: Operator(key='EQUAL', id=66, attributes={})\n",
-       "id:140558094330240"
-      ]
-     },
-     "execution_count": 37,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# Works element-wise as expected\n",
-    "tp.equal(node[\"f1\"], node[\"f3\"])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 38,
-   "id": "abda404b",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-07-12T19:18:48.163464Z",
-     "iopub.status.busy": "2023-07-12T19:18:48.163249Z",
-     "iopub.status.idle": "2023-07-12T19:18:48.168151Z",
-     "shell.execute_reply": "2023-07-12T19:18:48.167430Z"
-    }
-   },
-   "outputs": [
+    },
     {
-     "data": {
-      "text/plain": [
-       "False"
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "69b3c03c",
+      "metadata": {
+        "cell_marker": "\"\"\"",
+        "lines_to_next_cell": 0
+      },
+      "source": [
+        "\n",
+        "Since we haven't defined the `indexes` yet, `store` and `product` are just regular features above.\n",
+        "Let's add the `(product, store)` pair as the index."
       ]
-     },
-     "execution_count": 38,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# This is just a boolean\n",
-    "(node[\"f1\"] == node[\"f3\"])\n",
-    "False"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "0fa4a2d1",
-   "metadata": {
-    "cell_marker": "\"\"\"",
-    "lines_to_next_cell": 0
-   },
-   "source": [
-    "\n",
-    "All these operators act feature-wise, i.e. they perform index-feature-wise operations (for each feature in each index key). This implies that the input `EventSetNodes` must have the same number of features."
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "0352b9de",
-   "metadata": {
-    "cell_marker": "\"\"\"",
-    "lines_to_next_cell": 0
-   },
-   "source": [
-    "```python\n",
-    "node[[\"f1\", \"f2\"]] + node[\"f3\"]\n",
-    "Traceback (most recent call last):\n",
-    "    ...\n",
-    "ValueError: The left and right arguments should have the same number of features. ...\n",
-    "```"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "8dd1d7f4",
-   "metadata": {
-    "cell_marker": "\"\"\"",
-    "lines_to_next_cell": 0
-   },
-   "source": [
-    "\n",
-    "The input `EventSetNodes` must also have the same sampling and index."
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "00990d1e",
-   "metadata": {
-    "cell_marker": "\"\"\"",
-    "lines_to_next_cell": 0
-   },
-   "source": [
-    "```python\n",
-    "sampling_1 = tp.event_set(\n",
-    "    timestamps=[0, 1],\n",
-    "    features={\"f1\": [1, 2]},\n",
-    ")\n",
-    "sampling_2 = tp.event_set(\n",
-    "    timestamps=[1, 2],\n",
-    "    features={\"f1\": [3, 4]},\n",
-    ")\n",
-    "sampling_1.node() + sampling_2.node()\n",
-    "Traceback (most recent call last):\n",
-    "    ...\n",
-    "ValueError: Arguments should have the same sampling. ...\n",
-    "```"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "217fa8f5",
-   "metadata": {
-    "cell_marker": "\"\"\"",
-    "lines_to_next_cell": 0
-   },
-   "source": [
-    "\n",
-    "If you want to apply arithmetic operators on `EventSetNodes` with different samplings, take a look at\n",
-    "[Sampling](#sampling) section.\n",
-    "\n",
-    "If you want to apply them on `EventSetNodes` with different indexes, check the\n",
-    "[Vertical operators](#indexes-horizontal-and-vertical-operators) section.\n",
-    "\n",
-    "Operations involving scalars are applied index-feature-element-wise."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 39,
-   "id": "58fe7d8e",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-07-12T19:18:48.170667Z",
-     "iopub.status.busy": "2023-07-12T19:18:48.170470Z",
-     "iopub.status.idle": "2023-07-12T19:18:48.174954Z",
-     "shell.execute_reply": "2023-07-12T19:18:48.174165Z"
-    },
-    "lines_to_next_cell": 0
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "indexes: []\n",
-      "features: [('f1', int64), ('f2', float64), ('f3', int64), ('f4', float64)]\n",
-      "events:\n",
-      "     (2 events):\n",
-      "        timestamps: [ 1. 10.]\n",
-      "        'f1': [ 0 10]\n",
-      "        'f2': [100. 200.]\n",
-      "        'f3': [1000 1000]\n",
-      "        'f4': [10000. 10000.]\n",
-      "memory usage: 0.9 kB\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "node_scalar = node * 10\n",
-    "print(node_scalar.run(evset))"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "a229408c",
-   "metadata": {
-    "cell_marker": "\"\"\"",
-    "lines_to_next_cell": 0
-   },
-   "source": [
-    "\n",
-    "## Sampling\n",
-    "\n",
-    "Arithmetic operators, such as `tp.add()`, require their input arguments to have the same timestamps and [Index](#indexes-horizontal-and-vertical-operators). The unique combination of timestamps and indexes is called a _sampling_.\n",
-    "\n",
-    "<!-- TODO: example -->\n",
-    "\n",
-    "For example, if `EventSetNodes` `a` and `b` have different samplings, `a[\"feature_1\"] + b[\"feature_2\"]` will fail.\n",
-    "\n",
-    "To use arithmetic operators on `EventSets` with different samplings, one of the `EventSets` needs to be resampled to the sampling of the other `EventSet`. Resampling is done with the `tp.resample()` operator.\n",
-    "\n",
-    "The `tp.resample()` operator takes two `EventSets` called `input` and `sampling`, and returns the resampling of the features of `input` according to the timestamps of `sampling` according to the following rules:\n",
-    "\n",
-    "If a timestamp is present in `input` but not in `sampling`, the timestamp is dropped.\n",
-    "If a timestamp is present in both `input` and `sampling`, the timestamp is kept.\n",
-    "If a timestamp is present in `sampling` but not in `input`, a new timestamp is created using the feature values from the _closest anterior_ (not the closest, as that could induce future leakage) timestamp of `input`. This rule is especially useful for events that represent measurements (see [Events and `EventSets`](#events-and-eventsets)).\n",
-    "\n",
-    "**Note:** Features in `sampling` are ignored. This also happens in some other operators that take a `sampling` argument of type `EventSetNode` - it indicates that only the sampling (a.k.a. the indexes and timestamps) of that `EventSetNode` are being used by that operator.\n",
-    "\n",
-    "Given this example:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 40,
-   "id": "087b6fd6",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-07-12T19:18:48.177284Z",
-     "iopub.status.busy": "2023-07-12T19:18:48.177071Z",
-     "iopub.status.idle": "2023-07-12T19:18:48.183612Z",
-     "shell.execute_reply": "2023-07-12T19:18:48.182983Z"
-    },
-    "lines_to_next_cell": 0
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "indexes: []\n",
-       "features: [('x', float64)]\n",
-       "events:\n",
-       "     (7 events):\n",
-       "        timestamps: [ 0.  9. 10. 11. 19. 20. 21.]\n",
-       "        'x': [nan nan  1.  1.  1.  2.  2.]\n",
-       "memory usage: 0.6 kB"
-      ]
-     },
-     "execution_count": 40,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "evset = tp.event_set(\n",
-    "    timestamps=[10, 20, 30],\n",
-    "    features={\n",
-    "        \"x\": [1.0, 2.0, 3.0],\n",
-    "    },\n",
-    ")\n",
-    "node = evset.node()\n",
-    "sampling_evset = tp.event_set(\n",
-    "    timestamps=[0, 9, 10, 11, 19, 20, 21],\n",
-    ")\n",
-    "sampling_node = sampling_evset.node()\n",
-    "resampled = tp.resample(input=node, sampling=sampling_node)\n",
-    "resampled.run({node: evset, sampling_node: sampling_evset})"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "11496f59",
-   "metadata": {
-    "cell_marker": "\"\"\"",
-    "lines_to_next_cell": 0
-   },
-   "source": [
-    "\n",
-    "The following would be the matching between the timestamps of `sampling` and `input`:\n",
-    "\n",
-    "| `sampling` timestamp         | 0   | 9   | 10  | 11  | 19  | 20  | 21  |\n",
-    "| ---------------------------- | --- | --- | --- | --- | --- | --- | --- |\n",
-    "| matching `input` timestamp   | -   | -   | 10  | 10  | 10  | 20  | 20  |\n",
-    "| matching `\"x\"` feature value | NaN | NaN | 1   | 1   | 1   | 2   | 2   |\n",
-    "\n",
-    "If `sampling` contains a timestamp anterior to any timestamp in the `input` (like 0 and 9 in the example above), the feature of the sampled event will be missing. The representation of a missing value depends on its dtype:\n",
-    "\n",
-    "float: `NaN`\n",
-    "integer: `0`\n",
-    "string: `\"\"`\n",
-    "\n",
-    "Back to the example of the `tp.add()` operator, `a` and `b` with different sampling can be added as follows:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 41,
-   "id": "df3bbc7d",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-07-12T19:18:48.185880Z",
-     "iopub.status.busy": "2023-07-12T19:18:48.185684Z",
-     "iopub.status.idle": "2023-07-12T19:18:48.192155Z",
-     "shell.execute_reply": "2023-07-12T19:18:48.191382Z"
-    },
-    "lines_to_next_cell": 0
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "indexes: []\n",
-       "features: [('add_f1_f1', int64)]\n",
-       "events:\n",
-       "     (3 events):\n",
-       "        timestamps: [0. 1. 2.]\n",
-       "        'add_f1_f1': [10 25 34]\n",
-       "memory usage: 0.6 kB"
-      ]
-     },
-     "execution_count": 41,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "sampling_a = tp.event_set(\n",
-    "    timestamps=[0, 1, 2],\n",
-    "    features={\"f1\": [10, 20, 30]},\n",
-    ")\n",
-    "sampling_b = tp.event_set(\n",
-    "    timestamps=[1, 2, 3],\n",
-    "    features={\"f1\": [5, 4, 3]},\n",
-    ")\n",
-    "a = sampling_a.node()\n",
-    "b = sampling_b.node()\n",
-    "result = a + tp.resample(b, a)\n",
-    "result.run({a: sampling_a, b: sampling_b})"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "56313ff2",
-   "metadata": {
-    "cell_marker": "\"\"\"",
-    "lines_to_next_cell": 0
-   },
-   "source": [
-    "\n",
-    "`tp.resample()` is critical to combine events from different, non-synchronized sources. For example, consider a system with two sensors, a thermometer for temperature and a manometer for pressure. The temperature sensor produces measurements every 1 to 10 minutes, while the pressure sensor returns measurements every second. Additionally assume that both sensors are not synchronized. Finally, assume that you need to combine the temperature and pressure measurements with the equation `temperature / pressure`.\n",
-    "\n",
-    "<!-- TODO: image -->\n",
-    "\n",
-    "Since the temperature and pressure `EventSets` have different sampling, you will need to resample one of them. The pressure sensor has higher resolution. Therefore, resampling the temperature to the pressure yields higher resolution than resampling the pressure to the temperature.\n",
-    "\n",
-    "```python\n",
-    "r = tp.resample(termometer[\"temperature\"], manometer) / manometer[\"pressure\"]\n",
-    "```"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "ae131e37",
-   "metadata": {
-    "cell_marker": "\"\"\"",
-    "lines_to_next_cell": 0
-   },
-   "source": [
-    "\n",
-    "When handling non-uniform timestamps it is also common to have a common resampling source.\n",
-    "\n",
-    "```python\n",
-    "sampling_source = # Uniform timestamps every 10 seconds.\n",
-    "r = tp.resample(termometer[\"temperature\"], sampling_source) / tp.resample(manometer[\"pressure\"], sampling_source)\n",
-    "```\n",
-    "\n",
-    "Moving window operators, such as the `tp.simple_moving_average()` or `tp.moving_count()` operators, have an optional `sampling` argument. For example, the signature of the simple moving average operator is `tp.simple_moving_average()(][temporian.simple_moving_average]input: EventSetNode, window_length: Duration, sampling: Optional[EventSetNode] = None)`. If `sampling`is not set, the result will maintain the sampling of the`input`argument. If`sampling`is set, the moving window will be sampled at each timestamp of`sampling` instead, and the result will have those new ones.\n",
-    "\n",
-    "```python\n",
-    "b = tp.simple_moving_average(input=a, window_length=10)\n",
-    "c = tp.simple_moving_average(input=a, window_length=10, sampling=d)\n",
-    "```\n",
-    "\n",
-    "Note that if planning to resample the result of a moving window operator, passing the `sampling` argument is both more efficient and more accurate than calling `tp.resample()` on the result.\n",
-    "\n",
-    "## Indexes, horizontal and vertical operators\n",
-    "\n",
-    "All operators presented so far work on a sequence of related events. For instance, the simple moving average operator computes the average of events within a specific time window. These types of operators are called _horizontal operators_.\n",
-    "\n",
-    "It is sometimes desirable for events in an `EventSet` not to interact with each other. For example, assume a dataset containing the sum of daily sales of a set of products. The objective is to compute the sum of weekly sales of each product independently. In this scenario, the weekly moving sum should be applied individually to each product. If not, you would compute the weekly sales of all the products together.\n",
-    "\n",
-    "To compute the weekly sales of individual products, you can define the `product` feature as the _index_."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 42,
-   "id": "54a71cae",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-07-12T19:18:48.194474Z",
-     "iopub.status.busy": "2023-07-12T19:18:48.194272Z",
-     "iopub.status.idle": "2023-07-12T19:18:48.199461Z",
-     "shell.execute_reply": "2023-07-12T19:18:48.198635Z"
-    },
-    "lines_to_next_cell": 0
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "indexes: [('product', int64)]\n",
-      "features: [('sale', float64)]\n",
-      "events:\n",
-      "    product=1 (2 events):\n",
-      "        timestamps: [1.5778e+09 1.5779e+09]\n",
-      "        'sale': [100.  90.]\n",
-      "    product=2 (2 events):\n",
-      "        timestamps: [1.5778e+09 1.5779e+09]\n",
-      "        'sale': [300. 400.]\n",
-      "memory usage: 0.9 kB\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "daily_sales = tp.event_set(\n",
-    "\ttimestamps=[\"2020-01-01\", \"2020-01-01\", \"2020-01-02\", \"2020-01-02\"],\n",
-    "\tfeatures={\n",
-    "        \"product\": [1, 2, 1, 2],\n",
-    "        \"sale\": [100.0, 300.0, 90.0, 400.0],\n",
-    "    },\n",
-    "    indexes=[\"product\"]\n",
-    ")\n",
-    "print(daily_sales)"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "40dacbb4",
-   "metadata": {
-    "cell_marker": "\"\"\"",
-    "lines_to_next_cell": 0
-   },
-   "source": [
-    "\n",
-    "The moving sum operator will then be applied independently to the events corresponding to each product."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 43,
-   "id": "2c87a680",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-07-12T19:18:48.201683Z",
-     "iopub.status.busy": "2023-07-12T19:18:48.201488Z",
-     "iopub.status.idle": "2023-07-12T19:18:48.207280Z",
-     "shell.execute_reply": "2023-07-12T19:18:48.206430Z"
-    },
-    "lines_to_next_cell": 2
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "indexes: [('product', int64)]\n",
-       "features: [('sale', float64)]\n",
-       "events:\n",
-       "    product=1 (2 events):\n",
-       "        timestamps: [1.5778e+09 1.5779e+09]\n",
-       "        'sale': [100. 190.]\n",
-       "    product=2 (2 events):\n",
-       "        timestamps: [1.5778e+09 1.5779e+09]\n",
-       "        'sale': [300. 700.]\n",
-       "memory usage: 0.9 kB"
-      ]
-     },
-     "execution_count": 43,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "a = daily_sales.node()\n",
-    "\n",
-    "# Compute the moving sum of each index group (a.k.a. each product) individually.\n",
-    "b = tp.moving_sum(a, window_length=tp.duration.weeks(1))\n",
-    "\n",
-    "b.run({a: daily_sales})"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "e096897d",
-   "metadata": {
-    "cell_marker": "\"\"\"",
-    "lines_to_next_cell": 0
-   },
-   "source": [
-    "\n",
-    "Horizontal operators can be understood as operators that are applied independently on each index.\n",
-    "\n",
-    "Operators that modify an `EventSetNode`'s indexes are called _vertical operators_. The most important vertical operators are:\n",
-    "\n",
-    "- `tp.add_index()`: Add features to the index.\n",
-    "- `tp.drop_index()`: Remove features from the index, optionally keeping them as features.\n",
-    "- `tp.set_index()`: Changes the index.\n",
-    "- `tp.propagate()`: Expand indexes based on another `EventSet`’s indexes.\n",
-    "\n",
-    "By default, `EventSets` are _flat_, which means they have no index, and therefore all events are in a single global group.\n",
-    "\n",
-    "Also, keep in mind that only string and integer features can be used as indexes.\n",
-    "\n",
-    "`EventSets` can have multiple features as index. In the next example, assume our daily sale aggregates are also annotated with `store` data."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 44,
-   "id": "8badbebf",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-07-12T19:18:48.209523Z",
-     "iopub.status.busy": "2023-07-12T19:18:48.209325Z",
-     "iopub.status.idle": "2023-07-12T19:18:48.213897Z",
-     "shell.execute_reply": "2023-07-12T19:18:48.213288Z"
-    }
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "indexes: []\n",
-      "features: [('store', int64), ('product', int64), ('sale', float64)]\n",
-      "events:\n",
-      "     (4 events):\n",
-      "        timestamps: [1.5778e+09 1.5778e+09 1.5779e+09 1.5779e+09]\n",
-      "        'store': [1 1 1 2]\n",
-      "        'product': [1 2 1 2]\n",
-      "        'sale': [100. 200. 110. 300.]\n",
-      "memory usage: 0.9 kB\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "daily_sales = tp.event_set(\n",
-    "\ttimestamps=[\"2020-01-01\", \"2020-01-01\", \"2020-01-02\", \"2020-01-02\"],\n",
-    "\tfeatures={\n",
-    "        \"store\": [1, 1, 1, 2],\n",
-    "        \"product\": [1, 2, 1, 2],\n",
-    "        \"sale\": [100.0, 200.0, 110.0, 300.0],\n",
-    "    },\n",
-    ")\n",
-    "print(daily_sales)"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "69b3c03c",
-   "metadata": {
-    "cell_marker": "\"\"\"",
-    "lines_to_next_cell": 0
-   },
-   "source": [
-    "\n",
-    "Since we haven't defined the `indexes` yet, `store` and `product` are just regular features above.\n",
-    "Let's add the `(product, store)` pair as the index."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 45,
-   "id": "479096c3",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-07-12T19:18:48.216113Z",
-     "iopub.status.busy": "2023-07-12T19:18:48.215923Z",
-     "iopub.status.idle": "2023-07-12T19:18:48.221603Z",
-     "shell.execute_reply": "2023-07-12T19:18:48.220925Z"
-    },
-    "lines_to_next_cell": 2
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "indexes: [('product', int64), ('store', int64)]\n",
-       "features: [('sale', float64)]\n",
-       "events:\n",
-       "    product=1 store=1 (2 events):\n",
-       "        timestamps: [1.5778e+09 1.5779e+09]\n",
-       "        'sale': [100. 110.]\n",
-       "    product=2 store=1 (1 events):\n",
-       "        timestamps: [1.5778e+09]\n",
-       "        'sale': [200.]\n",
-       "    product=2 store=2 (1 events):\n",
-       "        timestamps: [1.5779e+09]\n",
-       "        'sale': [300.]\n",
-       "memory usage: 1.2 kB"
-      ]
-     },
-     "execution_count": 45,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "a = daily_sales.node()\n",
-    "b = tp.add_index(a, [\"product\", \"store\"])\n",
-    "b.run({a: daily_sales})"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "c2dc98f6",
-   "metadata": {
-    "cell_marker": "\"\"\"",
-    "lines_to_next_cell": 0
-   },
-   "source": [
-    "\n",
-    "The `moving_sum` operator can be used to calculate the weekly sum of sales\n",
-    "for each `(product, store)` pair."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 46,
-   "id": "4df0d8cf",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-07-12T19:18:48.224209Z",
-     "iopub.status.busy": "2023-07-12T19:18:48.223842Z",
-     "iopub.status.idle": "2023-07-12T19:18:48.230033Z",
-     "shell.execute_reply": "2023-07-12T19:18:48.229051Z"
-    },
-    "lines_to_next_cell": 0
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "indexes: [('product', int64), ('store', int64)]\n",
-       "features: [('sale', float64)]\n",
-       "events:\n",
-       "    product=1 store=1 (2 events):\n",
-       "        timestamps: [1.5778e+09 1.5779e+09]\n",
-       "        'sale': [100. 210.]\n",
-       "    product=2 store=1 (1 events):\n",
-       "        timestamps: [1.5778e+09]\n",
-       "        'sale': [200.]\n",
-       "    product=2 store=2 (1 events):\n",
-       "        timestamps: [1.5779e+09]\n",
-       "        'sale': [300.]\n",
-       "memory usage: 1.2 kB"
-      ]
-     },
-     "execution_count": 46,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# Weekly sales by product and store\n",
-    "c = tp.moving_sum(b[\"sale\"], window_length=tp.duration.weeks(1))\n",
-    "c.run({a: daily_sales})"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "2295d4ee",
-   "metadata": {
-    "cell_marker": "\"\"\"",
-    "lines_to_next_cell": 0
-   },
-   "source": [
-    "\n",
-    "If we want the weekly sum of sales per `store`, we can just drop the `product` index."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 47,
-   "id": "8d9448a2",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-07-12T19:18:48.232589Z",
-     "iopub.status.busy": "2023-07-12T19:18:48.232376Z",
-     "iopub.status.idle": "2023-07-12T19:18:48.239076Z",
-     "shell.execute_reply": "2023-07-12T19:18:48.238391Z"
-    },
-    "lines_to_next_cell": 0
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "indexes: [('store', int64)]\n",
-       "features: [('sale', float64)]\n",
-       "events:\n",
-       "    store=1 (3 events):\n",
-       "        timestamps: [1.5778e+09 1.5778e+09 1.5779e+09]\n",
-       "        'sale': [300. 300. 410.]\n",
-       "    store=2 (1 events):\n",
-       "        timestamps: [1.5779e+09]\n",
-       "        'sale': [300.]\n",
-       "memory usage: 0.9 kB"
-      ]
-     },
-     "execution_count": 47,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# Weekly sales by store (including all products)\n",
-    "d = tp.drop_index(b, \"product\")\n",
-    "e = tp.moving_sum(d[\"sale\"], window_length=tp.duration.weeks(1))\n",
-    "e.run({a: daily_sales})"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "f67b3f0c",
-   "metadata": {
-    "cell_marker": "\"\"\"",
-    "lines_to_next_cell": 0
-   },
-   "source": [
-    "\n",
-    "Finally, let's calculate the ratio of sales of each `(product, store)` pair compared to the whole `store` sales.\n",
-    "\n",
-    "Since `c` (weekly sales for each product and store) and `e` (weekly sales for each store) have different indexes, we cannot use `tp.divide` (or `/`) directly - we must first `propagate` `e` to the `[\"product\", \"store\"]` index."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 48,
-   "id": "4e12a9e0",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-07-12T19:18:48.241327Z",
-     "iopub.status.busy": "2023-07-12T19:18:48.241136Z",
-     "iopub.status.idle": "2023-07-12T19:18:48.247622Z",
-     "shell.execute_reply": "2023-07-12T19:18:48.246940Z"
-    },
-    "lines_to_next_cell": 0
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "indexes: [('product', int64), ('store', int64)]\n",
-      "features: [('div_sale_sale', float64)]\n",
-      "events:\n",
-      "    product=1 store=1 (2 events):\n",
-      "        timestamps: [1.5778e+09 1.5779e+09]\n",
-      "        'div_sale_sale': [0.3333 0.5122]\n",
-      "    product=2 store=1 (1 events):\n",
-      "        timestamps: [1.5778e+09]\n",
-      "        'div_sale_sale': [0.6667]\n",
-      "    product=2 store=2 (1 events):\n",
-      "        timestamps: [1.5779e+09]\n",
-      "        'div_sale_sale': [1.]\n",
-      "memory usage: 1.2 kB\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Copy the content of e (indexed by (store)) into each (store, product).\n",
-    "f = c / tp.propagate(e, sampling=c, resample=True)\n",
-    "\n",
-    "# Equivalent.\n",
-    "f = c / tp.resample(\n",
-    "    tp.propagate(e, sampling=c),\n",
-    "    sampling=c,\n",
-    ")\n",
-    "print(f.run({a: daily_sales}))"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "e73da62c",
-   "metadata": {
-    "cell_marker": "\"\"\"",
-    "lines_to_next_cell": 0
-   },
-   "source": [
-    "\n",
-    "The `tp.propagate()` operator expands the indexes of its `input` (`e` in this case) to match the indexes of its `sampling` by copying the content of `input` into each corresponding index group of `sampling`. Note that `sampling`'s indexes must be a superset of `input`'s indexes.\n",
-    "\n",
-    "## Future leakage\n",
-    "\n",
-    "In supervised learning, [leakage](<https://en.wikipedia.org/wiki/Leakage_(machine_learning)>) is the use of data not available at serving time by a machine learning model. A common example of leakage is _label leakage_, which involves the invalid use of labels in the model input features. Leakage tends to bias model evaluation by making it appear much better than it is in reality. Unfortunately, leakage is often subtle, easy to inject, and challenging to detect.\n",
-    "\n",
-    "Another type of leakage is future leakage, where a model uses data before it is available. Future leakage is particularly easy to create, as all feature data is ultimately available to the model, the problem being it being accessed at the wrong time.\n",
-    "\n",
-    "To avoid future leakage, Temporian operators are guaranteed to not cause future leakage, except for the `tp.leak()` operator. This means that it is impossible to inadvertently add future leakage to a Temporian program.\n",
-    "\n",
-    "`tp.leak()` can be useful for precomputing labels or evaluating machine learning models. However, its outputs shouldn’t be used as input features."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 49,
-   "id": "c07453fa",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-07-12T19:18:48.249853Z",
-     "iopub.status.busy": "2023-07-12T19:18:48.249662Z",
-     "iopub.status.idle": "2023-07-12T19:18:48.254208Z",
-     "shell.execute_reply": "2023-07-12T19:18:48.253485Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "a = tp.input_node(features=[(\"feature_1\", tp.float32)])\n",
-    "b = tp.moving_count(a, 1)\n",
-    "c = tp.moving_count(tp.leak(b, 1), 2)"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "8d973547",
-   "metadata": {
-    "cell_marker": "\"\"\"",
-    "lines_to_next_cell": 0
-   },
-   "source": [
-    "\n",
-    "In this example, `b` does not have a future leak, but `c` does because it depends on `tp.leak()`.\n",
-    "\n",
-    "<!-- TODO: Not implemented yet\n",
-    "\n",
-    "To check programmatically if a `Node` depends on `tp.leak()`, we can use the `tp.has_leak()` function.\n",
-    "\n",
-    "# print(tp.has_leak(b))\n",
-    "# False\n",
-    "\n",
-    "# print(tp.has_leak(c))\n",
-    "# True\n",
-    "\n",
-    "\n",
-    "By using `tp.has_leak()`, we can programmatically identify future leakage and modify our code accordingly.\n",
-    "-->\n",
-    "\n",
-    "## Accessing `EventSet` data\n",
-    "\n",
-    "`EventSet` data can be accessed using their `data` attribute. Temporian internally relies on NumPy, which means that the data access functions always return NumPy arrays."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 50,
-   "id": "7da63117",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-07-12T19:18:48.256575Z",
-     "iopub.status.busy": "2023-07-12T19:18:48.256359Z",
-     "iopub.status.idle": "2023-07-12T19:18:48.261633Z",
-     "shell.execute_reply": "2023-07-12T19:18:48.260922Z"
-    }
-   },
-   "outputs": [
+    },
     {
-     "data": {
-      "text/plain": [
-       "IndexData(features=[array([0.1, 0.2, 0.3])], timestamps=array([1., 2., 3.]))"
+      "cell_type": "code",
+      "execution_count": 45,
+      "id": "479096c3",
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2023-07-12T19:18:48.216113Z",
+          "iopub.status.busy": "2023-07-12T19:18:48.215923Z",
+          "iopub.status.idle": "2023-07-12T19:18:48.221603Z",
+          "shell.execute_reply": "2023-07-12T19:18:48.220925Z"
+        },
+        "lines_to_next_cell": 2
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "indexes: [('product', int64), ('store', int64)]\n",
+              "features: [('sale', float64)]\n",
+              "events:\n",
+              "    product=1 store=1 (2 events):\n",
+              "        timestamps: [1.5778e+09 1.5779e+09]\n",
+              "        'sale': [100. 110.]\n",
+              "    product=2 store=1 (1 events):\n",
+              "        timestamps: [1.5778e+09]\n",
+              "        'sale': [200.]\n",
+              "    product=2 store=2 (1 events):\n",
+              "        timestamps: [1.5779e+09]\n",
+              "        'sale': [300.]\n",
+              "memory usage: 1.2 kB"
+            ]
+          },
+          "execution_count": 45,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "a = daily_sales.node()\n",
+        "b = tp.add_index(a, [\"product\", \"store\"])\n",
+        "b.run({a: daily_sales})"
       ]
-     },
-     "execution_count": 50,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "evset = tp.event_set(\n",
-    "\ttimestamps=[1, 2, 3, 5, 6],\n",
-    "\tfeatures={\n",
-    "        \"f1\": [0.1, 0.2, 0.3, 1.1, 1.2],\n",
-    "        \"f2\": [\"red\", \"red\", \"red\", \"blue\", \"blue\"],\n",
-    "\t},\n",
-    "\tindexes=[\"f2\"],\n",
-    ")\n",
-    "\n",
-    "# Access the data for the index group `f2=red`.\n",
-    "evset.get_index_value((\"red\",))"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "eddfa88e",
-   "metadata": {
-    "cell_marker": "\"\"\"",
-    "lines_to_next_cell": 0
-   },
-   "source": [
-    "\n",
-    "<!--\n",
-    "`EventSet` data can be accessed using the `index()` and `feature()` functions. Temporian internally relies on NumPy, which means that the data access functions always return NumPy arrays.\n",
-    "\n",
-    "evset = tp.event_set(\n",
-    "\ttimestamps=[1, 2, 3, 5, 6],\n",
-    "\tfeatures={\n",
-    "        \"f1\": [0.1, 0.2, 0.3, 1.1, 1.2],\n",
-    "        \"f2\": [\"red\", \"red\", \"red\", \"blue\", \"blue\"],\n",
-    "\t},\n",
-    "\tindexes=[\"f2\"],\n",
-    ")\n",
-    "\n",
-    "# Access the data for the index group `f2=red`.\n",
-    "evset.index(\"red\")\n",
-    "\n",
-    "\n",
-    "# Equivalent.\n",
-    "evset.index((\"red\", ))\n",
-    "\n",
-    "\n",
-    "# Access the data for the index group `f2=red` and feature `f1`.\n",
-    "evset.index(\"red\").feature(\"f1\")\n",
-    "\n",
-    "\n",
-    "If an `EventSet` does not have an index, `feature` can be called directly:\n",
-    "\n",
-    "evset = tp.event_set(\n",
-    "\ttimestamps=[1, 2, 3, 5, 6],\n",
-    "\tfeatures={\n",
-    "        \"f1\": [0.1, 0.2, 0.3, 1.1, 1.2],\n",
-    "        \"f2\": [\"red\", \"red\", \"red\", \"blue\", \"blue\"],\n",
-    "\t},\n",
-    ")\n",
-    "evset.feature(\"f1\")\n",
-    "-->\n",
-    "\n",
-    "## Import and export data\n",
-    "\n",
-    "`EventSets` can be read from and saved to csv files via the `tp.from_csv()` and `tp.to_csv()` functions.\n",
-    "\n",
-    "# Read EventSet from a .csv file.\n",
-    "\n",
-    "```python\n",
-    "evset = tp.from_csv(\n",
-    "    path=\"path/to/file.csv\",\n",
-    "    timestamps=\"timestamp\",\n",
-    "    indexes=[\"product_id\"],\n",
-    ")\n",
-    "\n",
-    "# Save EventSet to a .csv file.\n",
-    "tp.to_csv(evset, path=\"path/to/file.csv\")\n",
-    "```\n",
-    "\n",
-    "Converting `EventSet` data to and from pandas DataFrames is also easily done via `tp.to_pandas()` and `tp.from_pandas()`."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 51,
-   "id": "da239494",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-07-12T19:18:48.264020Z",
-     "iopub.status.busy": "2023-07-12T19:18:48.263823Z",
-     "iopub.status.idle": "2023-07-12T19:18:48.286963Z",
-     "shell.execute_reply": "2023-07-12T19:18:48.286251Z"
-    }
-   },
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "WARNING:root:Feature \"f2\" is an array of numpy.object_ and was casted to numpy.string_ (Note: numpy.string_ is equivalent to numpy.bytes_).\n"
-     ]
-    }
-   ],
-   "source": [
-    "df = pd.DataFrame({\n",
-    "    \"timestamp\": [1, 2, 3, 5, 6],\n",
-    "    \"f1\": [0.1, 0.2, 0.3, 1.1, 1.2],\n",
-    "    \"f2\": [\"red\", \"red\", \"red\", \"blue\", \"blue\"],\n",
-    "})\n",
-    "\n",
-    "# Create EventSet from DataFrame.\n",
-    "evset = tp.from_pandas(df)\n",
-    "\n",
-    "# Convert EventSet to DataFrame.\n",
-    "df = tp.to_pandas(evset)"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "a96084af",
-   "metadata": {
-    "cell_marker": "\"\"\"",
-    "lines_to_next_cell": 0
-   },
-   "source": [
-    "\n",
-    "## Serialization and deserialization of a graph\n",
-    "\n",
-    "Temporian graphs can be exported and imported to a safe-to-share file with `tp.save_graph()` and `tp.load_graph()`. In both functions input and output `EventSetNodes` need to be named, or be assigned a name by passing them as a dictionary.\n",
-    "\n",
-    "```python\n",
-    "# Define a graph.\n",
-    "evset = tp.event_set(\n",
-    "\ttimestamps=[1, 2, 3],\n",
-    "\tfeatures={\"f1\": [0.1, 0.2, 0.3]},\n",
-    ")\n",
-    "a = evset.node()\n",
-    "b = tp.moving_count(a, 1)\n",
-    "\n",
-    "# Save the graph.\n",
-    "tp.save_graph(inputs={\"input_a\": a}, outputs={\"output_b\": b}, path=\"/tmp/my_graph.tem\")\n",
-    "\n",
-    "# Equivalent.\n",
-    "a.name = \"input_a\"\n",
-    "b.name = \"output_b\"\n",
-    "tp.save_graph(inputs=a, outputs=[b], path=\"/tmp/my_graph.tem\")\n",
-    "\n",
-    "# Load the graph.\n",
-    "loaded_inputs, loaded_outputs = tp.load_graph(path=\"/tmp/my_graph.tem\")\n",
-    "\n",
-    "# Run data on the restored graph.\n",
-    "tp.run(loaded_outputs[\"output_b\"], {loaded_inputs[\"input_a\"]: evset})\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "56a28657",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "jupytext": {
-   "cell_metadata_filter": "-all",
-   "main_language": "python",
-   "notebook_metadata_filter": "-all"
-  },
-  "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.6"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "c2dc98f6",
+      "metadata": {
+        "cell_marker": "\"\"\"",
+        "lines_to_next_cell": 0
+      },
+      "source": [
+        "\n",
+        "The `moving_sum` operator can be used to calculate the weekly sum of sales\n",
+        "for each `(product, store)` pair."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 46,
+      "id": "4df0d8cf",
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2023-07-12T19:18:48.224209Z",
+          "iopub.status.busy": "2023-07-12T19:18:48.223842Z",
+          "iopub.status.idle": "2023-07-12T19:18:48.230033Z",
+          "shell.execute_reply": "2023-07-12T19:18:48.229051Z"
+        },
+        "lines_to_next_cell": 0
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "indexes: [('product', int64), ('store', int64)]\n",
+              "features: [('sale', float64)]\n",
+              "events:\n",
+              "    product=1 store=1 (2 events):\n",
+              "        timestamps: [1.5778e+09 1.5779e+09]\n",
+              "        'sale': [100. 210.]\n",
+              "    product=2 store=1 (1 events):\n",
+              "        timestamps: [1.5778e+09]\n",
+              "        'sale': [200.]\n",
+              "    product=2 store=2 (1 events):\n",
+              "        timestamps: [1.5779e+09]\n",
+              "        'sale': [300.]\n",
+              "memory usage: 1.2 kB"
+            ]
+          },
+          "execution_count": 46,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "# Weekly sales by product and store\n",
+        "c = tp.moving_sum(b[\"sale\"], window_length=tp.duration.weeks(1))\n",
+        "c.run({a: daily_sales})"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "2295d4ee",
+      "metadata": {
+        "cell_marker": "\"\"\"",
+        "lines_to_next_cell": 0
+      },
+      "source": [
+        "\n",
+        "If we want the weekly sum of sales per `store`, we can just drop the `product` index."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 47,
+      "id": "8d9448a2",
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2023-07-12T19:18:48.232589Z",
+          "iopub.status.busy": "2023-07-12T19:18:48.232376Z",
+          "iopub.status.idle": "2023-07-12T19:18:48.239076Z",
+          "shell.execute_reply": "2023-07-12T19:18:48.238391Z"
+        },
+        "lines_to_next_cell": 0
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "indexes: [('store', int64)]\n",
+              "features: [('sale', float64)]\n",
+              "events:\n",
+              "    store=1 (3 events):\n",
+              "        timestamps: [1.5778e+09 1.5778e+09 1.5779e+09]\n",
+              "        'sale': [300. 300. 410.]\n",
+              "    store=2 (1 events):\n",
+              "        timestamps: [1.5779e+09]\n",
+              "        'sale': [300.]\n",
+              "memory usage: 0.9 kB"
+            ]
+          },
+          "execution_count": 47,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "# Weekly sales by store (including all products)\n",
+        "d = tp.drop_index(b, \"product\")\n",
+        "e = tp.moving_sum(d[\"sale\"], window_length=tp.duration.weeks(1))\n",
+        "e.run({a: daily_sales})"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "f67b3f0c",
+      "metadata": {
+        "cell_marker": "\"\"\"",
+        "lines_to_next_cell": 0
+      },
+      "source": [
+        "\n",
+        "Finally, let's calculate the ratio of sales of each `(product, store)` pair compared to the whole `store` sales.\n",
+        "\n",
+        "Since `c` (weekly sales for each product and store) and `e` (weekly sales for each store) have different indexes, we cannot use `tp.divide` (or `/`) directly - we must first `propagate` `e` to the `[\"product\", \"store\"]` index."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 48,
+      "id": "4e12a9e0",
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2023-07-12T19:18:48.241327Z",
+          "iopub.status.busy": "2023-07-12T19:18:48.241136Z",
+          "iopub.status.idle": "2023-07-12T19:18:48.247622Z",
+          "shell.execute_reply": "2023-07-12T19:18:48.246940Z"
+        },
+        "lines_to_next_cell": 0
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "indexes: [('product', int64), ('store', int64)]\n",
+            "features: [('div_sale_sale', float64)]\n",
+            "events:\n",
+            "    product=1 store=1 (2 events):\n",
+            "        timestamps: [1.5778e+09 1.5779e+09]\n",
+            "        'div_sale_sale': [0.3333 0.5122]\n",
+            "    product=2 store=1 (1 events):\n",
+            "        timestamps: [1.5778e+09]\n",
+            "        'div_sale_sale': [0.6667]\n",
+            "    product=2 store=2 (1 events):\n",
+            "        timestamps: [1.5779e+09]\n",
+            "        'div_sale_sale': [1.]\n",
+            "memory usage: 1.2 kB\n",
+            "\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Copy the content of e (indexed by (store)) into each (store, product).\n",
+        "f = c / tp.propagate(e, sampling=c, resample=True)\n",
+        "\n",
+        "# Equivalent.\n",
+        "f = c / tp.resample(\n",
+        "    tp.propagate(e, sampling=c),\n",
+        "    sampling=c,\n",
+        ")\n",
+        "print(f.run({a: daily_sales}))"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "e73da62c",
+      "metadata": {
+        "cell_marker": "\"\"\"",
+        "lines_to_next_cell": 0
+      },
+      "source": [
+        "\n",
+        "The `tp.propagate()` operator expands the indexes of its `input` (`e` in this case) to match the indexes of its `sampling` by copying the content of `input` into each corresponding index group of `sampling`. Note that `sampling`'s indexes must be a superset of `input`'s indexes.\n",
+        "\n",
+        "## Future leakage\n",
+        "\n",
+        "In supervised learning, [leakage](<https://en.wikipedia.org/wiki/Leakage_(machine_learning)>) is the use of data not available at serving time by a machine learning model. A common example of leakage is _label leakage_, which involves the invalid use of labels in the model input features. Leakage tends to bias model evaluation by making it appear much better than it is in reality. Unfortunately, leakage is often subtle, easy to inject, and challenging to detect.\n",
+        "\n",
+        "Another type of leakage is future leakage, where a model uses data before it is available. Future leakage is particularly easy to create, as all feature data is ultimately available to the model, the problem being it being accessed at the wrong time.\n",
+        "\n",
+        "To avoid future leakage, Temporian operators are guaranteed to not cause future leakage, except for the `tp.leak()` operator. This means that it is impossible to inadvertently add future leakage to a Temporian program.\n",
+        "\n",
+        "`tp.leak()` can be useful for precomputing labels or evaluating machine learning models. However, its outputs shouldn’t be used as input features."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 49,
+      "id": "c07453fa",
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2023-07-12T19:18:48.249853Z",
+          "iopub.status.busy": "2023-07-12T19:18:48.249662Z",
+          "iopub.status.idle": "2023-07-12T19:18:48.254208Z",
+          "shell.execute_reply": "2023-07-12T19:18:48.253485Z"
+        }
+      },
+      "outputs": [],
+      "source": [
+        "a = tp.input_node(features=[(\"feature_1\", tp.float32)])\n",
+        "b = tp.moving_count(a, 1)\n",
+        "c = tp.moving_count(tp.leak(b, 1), 2)"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "8d973547",
+      "metadata": {
+        "cell_marker": "\"\"\"",
+        "lines_to_next_cell": 0
+      },
+      "source": [
+        "\n",
+        "In this example, `b` does not have a future leak, but `c` does because it depends on `tp.leak()`.\n",
+        "\n",
+        "<!-- TODO: Not implemented yet\n",
+        "\n",
+        "To check programmatically if a `Node` depends on `tp.leak()`, we can use the `tp.has_leak()` function.\n",
+        "\n",
+        "# print(tp.has_leak(b))\n",
+        "# False\n",
+        "\n",
+        "# print(tp.has_leak(c))\n",
+        "# True\n",
+        "\n",
+        "\n",
+        "By using `tp.has_leak()`, we can programmatically identify future leakage and modify our code accordingly.\n",
+        "-->\n",
+        "\n",
+        "## Accessing `EventSet` data\n",
+        "\n",
+        "`EventSet` data can be accessed using their `data` attribute. Temporian internally relies on NumPy, which means that the data access functions always return NumPy arrays."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 50,
+      "id": "7da63117",
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2023-07-12T19:18:48.256575Z",
+          "iopub.status.busy": "2023-07-12T19:18:48.256359Z",
+          "iopub.status.idle": "2023-07-12T19:18:48.261633Z",
+          "shell.execute_reply": "2023-07-12T19:18:48.260922Z"
+        }
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "IndexData(features=[array([0.1, 0.2, 0.3])], timestamps=array([1., 2., 3.]))"
+            ]
+          },
+          "execution_count": 50,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "evset = tp.event_set(\n",
+        "\ttimestamps=[1, 2, 3, 5, 6],\n",
+        "\tfeatures={\n",
+        "        \"f1\": [0.1, 0.2, 0.3, 1.1, 1.2],\n",
+        "        \"f2\": [\"red\", \"red\", \"red\", \"blue\", \"blue\"],\n",
+        "\t},\n",
+        "\tindexes=[\"f2\"],\n",
+        ")\n",
+        "\n",
+        "# Access the data for the index group `f2=red`.\n",
+        "evset.get_index_value((\"red\",))"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "eddfa88e",
+      "metadata": {
+        "cell_marker": "\"\"\"",
+        "lines_to_next_cell": 0
+      },
+      "source": [
+        "\n",
+        "<!--\n",
+        "`EventSet` data can be accessed using the `index()` and `feature()` functions. Temporian internally relies on NumPy, which means that the data access functions always return NumPy arrays.\n",
+        "\n",
+        "evset = tp.event_set(\n",
+        "\ttimestamps=[1, 2, 3, 5, 6],\n",
+        "\tfeatures={\n",
+        "        \"f1\": [0.1, 0.2, 0.3, 1.1, 1.2],\n",
+        "        \"f2\": [\"red\", \"red\", \"red\", \"blue\", \"blue\"],\n",
+        "\t},\n",
+        "\tindexes=[\"f2\"],\n",
+        ")\n",
+        "\n",
+        "# Access the data for the index group `f2=red`.\n",
+        "evset.index(\"red\")\n",
+        "\n",
+        "\n",
+        "# Equivalent.\n",
+        "evset.index((\"red\", ))\n",
+        "\n",
+        "\n",
+        "# Access the data for the index group `f2=red` and feature `f1`.\n",
+        "evset.index(\"red\").feature(\"f1\")\n",
+        "\n",
+        "\n",
+        "If an `EventSet` does not have an index, `feature` can be called directly:\n",
+        "\n",
+        "evset = tp.event_set(\n",
+        "\ttimestamps=[1, 2, 3, 5, 6],\n",
+        "\tfeatures={\n",
+        "        \"f1\": [0.1, 0.2, 0.3, 1.1, 1.2],\n",
+        "        \"f2\": [\"red\", \"red\", \"red\", \"blue\", \"blue\"],\n",
+        "\t},\n",
+        ")\n",
+        "evset.feature(\"f1\")\n",
+        "-->\n",
+        "\n",
+        "## Import and export data\n",
+        "\n",
+        "`EventSets` can be read from and saved to csv files via the `tp.from_csv()` and `tp.to_csv()` functions.\n",
+        "\n",
+        "# Read EventSet from a .csv file.\n",
+        "\n",
+        "```python\n",
+        "evset = tp.from_csv(\n",
+        "    path=\"path/to/file.csv\",\n",
+        "    timestamps=\"timestamp\",\n",
+        "    indexes=[\"product_id\"],\n",
+        ")\n",
+        "\n",
+        "# Save EventSet to a .csv file.\n",
+        "tp.to_csv(evset, path=\"path/to/file.csv\")\n",
+        "```\n",
+        "\n",
+        "Converting `EventSet` data to and from pandas DataFrames is also easily done via `tp.to_pandas()` and `tp.from_pandas()`."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 51,
+      "id": "da239494",
+      "metadata": {
+        "execution": {
+          "iopub.execute_input": "2023-07-12T19:18:48.264020Z",
+          "iopub.status.busy": "2023-07-12T19:18:48.263823Z",
+          "iopub.status.idle": "2023-07-12T19:18:48.286963Z",
+          "shell.execute_reply": "2023-07-12T19:18:48.286251Z"
+        }
+      },
+      "outputs": [
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "WARNING:root:Feature \"f2\" is an array of numpy.object_ and was casted to numpy.string_ (Note: numpy.string_ is equivalent to numpy.bytes_).\n"
+          ]
+        }
+      ],
+      "source": [
+        "df = pd.DataFrame({\n",
+        "    \"timestamp\": [1, 2, 3, 5, 6],\n",
+        "    \"f1\": [0.1, 0.2, 0.3, 1.1, 1.2],\n",
+        "    \"f2\": [\"red\", \"red\", \"red\", \"blue\", \"blue\"],\n",
+        "})\n",
+        "\n",
+        "# Create EventSet from DataFrame.\n",
+        "evset = tp.from_pandas(df)\n",
+        "\n",
+        "# Convert EventSet to DataFrame.\n",
+        "df = tp.to_pandas(evset)"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "id": "a96084af",
+      "metadata": {
+        "cell_marker": "\"\"\"",
+        "lines_to_next_cell": 0
+      },
+      "source": [
+        "\n",
+        "## Serialization and deserialization of a graph\n",
+        "\n",
+        "Temporian graphs can be exported and imported to a safe-to-share file with `tp.save_graph()` and `tp.load_graph()`. In both functions input and output `EventSetNodes` need to be named, or be assigned a name by passing them as a dictionary.\n",
+        "\n",
+        "```python\n",
+        "# Define a graph.\n",
+        "evset = tp.event_set(\n",
+        "\ttimestamps=[1, 2, 3],\n",
+        "\tfeatures={\"f1\": [0.1, 0.2, 0.3]},\n",
+        ")\n",
+        "a = evset.node()\n",
+        "b = tp.moving_count(a, 1)\n",
+        "\n",
+        "# Save the graph.\n",
+        "tp.save_graph(inputs={\"input_a\": a}, outputs={\"output_b\": b}, path=\"/tmp/my_graph.tem\")\n",
+        "\n",
+        "# Equivalent.\n",
+        "a.name = \"input_a\"\n",
+        "b.name = \"output_b\"\n",
+        "tp.save_graph(inputs=a, outputs=[b], path=\"/tmp/my_graph.tem\")\n",
+        "\n",
+        "# Load the graph.\n",
+        "loaded_inputs, loaded_outputs = tp.load_graph(path=\"/tmp/my_graph.tem\")\n",
+        "\n",
+        "# Run data on the restored graph.\n",
+        "tp.run(loaded_outputs[\"output_b\"], {loaded_inputs[\"input_a\"]: evset})\n",
+        "```"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "56a28657",
+      "metadata": {},
+      "outputs": [],
+      "source": []
+    }
+  ],
+  "metadata": {
+    "jupytext": {
+      "cell_metadata_filter": "-all",
+      "main_language": "python",
+      "notebook_metadata_filter": "-all"
+    },
+    "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.6"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 5
 }