diff --git a/projects/neurons/README.md b/projects/neurons/README.md
index 647c1eb88c..ea0d943a90 100644
--- a/projects/neurons/README.md
+++ b/projects/neurons/README.md
@@ -21,7 +21,7 @@ Credit for data curation: Mayo Faulkner
 
 ## Supervised and unsupervised learning 
 
-The [Zhong et al,2025](https://doi.org/10.1038/s41586-025-09180-y) dataset ([youtube](https://www.youtube.com/watch?v=78GSgf6Dkkk)) contains simultaneous recordings of up to 80,000 neurons from mouse visual cortex at different stages of visual learning in a virtual reality task with naturalistic images. It also contains recordings made during unsupervised exploration of the same virtual reality environments for comparisons, and recordings made after the introduction of novel stimuli that require behavioral classification.
+The [Zhong et al, 2025](https://doi.org/10.1038/s41586-025-09180-y) dataset ([youtube](https://www.youtube.com/watch?v=o0PFk-lnpuI)) contains simultaneous recordings of up to 80,000 neurons from mouse visual cortex at different stages of visual learning in a virtual reality task with naturalistic images. It also contains recordings made during unsupervised exploration of the same virtual reality environments for comparisons, and recordings made after the introduction of novel stimuli that require behavioral classification.
 
 Credit for data curation: Lin Zhong and Marius Pachitariu
 
diff --git a/projects/neurons/neurons_videos.ipynb b/projects/neurons/neurons_videos.ipynb
index 209f60b690..f0f45b2aca 100644
--- a/projects/neurons/neurons_videos.ipynb
+++ b/projects/neurons/neurons_videos.ipynb
@@ -1,1084 +1,286 @@
 {
-  "cells": [
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "view-in-github",
-        "colab_type": "text"
-      },
-      "source": [
-        "<a href=\"https://colab.research.google.com/github/NeuromatchAcademy/course-content/blob/add_bilibili/projects/neurons/neurons_videos.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "execution": {},
-        "pycharm": {
-          "name": "#%% md\n"
-        },
-        "id": "A0cnlSixVSUc"
-      },
-      "source": [
-        "# Overview videos\n",
-        "\n"
-      ]
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "colab_type": "text",
+    "execution": {},
+    "id": "view-in-github"
+   },
+   "source": [
+    "<a href=\"https://colab.research.google.com/github/NeuromatchAcademy/course-content/blob/main/projects/neurons/neurons_videos.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a> &nbsp; <a href=\"https://kaggle.com/kernels/welcome?src=https://raw.githubusercontent.com/NeuromatchAcademy/course-content/main/projects/neurons/neurons_videos.ipynb\" target=\"_parent\"><img src=\"https://kaggle.com/static/images/open-in-kaggle.svg\" alt=\"Open in Kaggle\"/></a>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "execution": {},
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "# Overview videos\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "cellView": "form",
+    "execution": {},
+    "pycharm": {
+     "name": "#%%\n"
     },
+    "tags": [
+     "remove-input"
+    ]
+   },
+   "outputs": [
     {
-      "cell_type": "code",
-      "execution_count": 1,
-      "metadata": {
-        "cellView": "form",
-        "execution": {},
-        "pycharm": {
-          "name": "#%%\n"
-        },
-        "tags": [
-          "remove-input"
-        ],
-        "id": "kgN-x3fIVSUe",
-        "outputId": "6a0c2061-80a5-4844-aeea-11a7aa734e51",
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 583,
-          "referenced_widgets": [
-            "d44ef1cebe2f4d768639dfcb1310e24f",
-            "fcf9e6b0f71c4807a6309bd01b0d9926",
-            "25e69e6f6c164c0f92095dff81aa57cc",
-            "2e847d6d0f8546b88aa9374f936bbf53",
-            "030b615321a64698af48d669fd3f8c40",
-            "ca4297c0ac7149a1bcaef9472425d162"
-          ]
-        }
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "da461cbe089b4fe2ba966c21fff65517",
+       "version_major": 2,
+       "version_minor": 0
       },
-      "outputs": [
-        {
-          "output_type": "display_data",
-          "data": {
-            "text/plain": [
-              "Tab(children=(Output(), Output()), _titles={'0': 'Youtube', '1': 'Bilibili'})"
-            ],
-            "application/vnd.jupyter.widget-view+json": {
-              "version_major": 2,
-              "version_minor": 0,
-              "model_id": "d44ef1cebe2f4d768639dfcb1310e24f"
-            }
-          },
-          "metadata": {}
-        }
-      ],
-      "source": [
-        "# @title Video: Steinmetz dataset\n",
-        "from ipywidgets import widgets\n",
-        "from IPython.display import YouTubeVideo\n",
-        "from IPython.display import IFrame\n",
-        "from IPython.display import display\n",
-        "\n",
-        "\n",
-        "class PlayVideo(IFrame):\n",
-        "  def __init__(self, id, source, page=1, width=400, height=300, **kwargs):\n",
-        "    self.id = id\n",
-        "    if source == 'Bilibili':\n",
-        "      src = f'https://player.bilibili.com/player.html?bvid={id}&page={page}'\n",
-        "    elif source == 'Osf':\n",
-        "      src = f'https://mfr.ca-1.osf.io/render?url=https://osf.io/download/{id}/?direct%26mode=render'\n",
-        "    super(PlayVideo, self).__init__(src, width, height, **kwargs)\n",
-        "\n",
-        "\n",
-        "def display_videos(video_ids, W=400, H=300, fs=1):\n",
-        "  tab_contents = []\n",
-        "  for i, video_id in enumerate(video_ids):\n",
-        "    out = widgets.Output()\n",
-        "    with out:\n",
-        "      if video_ids[i][0] == 'Youtube':\n",
-        "        video = YouTubeVideo(id=video_ids[i][1], width=W,\n",
-        "                             height=H, fs=fs, rel=0)\n",
-        "        print(f'Video available at https://youtube.com/watch?v={video.id}')\n",
-        "      else:\n",
-        "        video = PlayVideo(id=video_ids[i][1], source=video_ids[i][0], width=W,\n",
-        "                          height=H, fs=fs, autoplay=False)\n",
-        "        if video_ids[i][0] == 'Bilibili':\n",
-        "          print(f'Video available at https://www.bilibili.com/video/{video.id}')\n",
-        "        elif video_ids[i][0] == 'Osf':\n",
-        "          print(f'Video available at https://osf.io/{video.id}')\n",
-        "      display(video)\n",
-        "    tab_contents.append(out)\n",
-        "  return tab_contents\n",
-        "\n",
-        "\n",
-        "video_ids = [('Youtube', 'WXn4-FpVaOo'), ('Bilibili', 'BV1Hh4y1E7Yk')]\n",
-        "tab_contents = display_videos(video_ids, W=854, H=480)\n",
-        "tabs = widgets.Tab()\n",
-        "tabs.children = tab_contents\n",
-        "for i in range(len(tab_contents)):\n",
-        "  tabs.set_title(i, video_ids[i][0])\n",
-        "display(tabs)"
+      "text/plain": [
+       "Tab(children=(Output(), Output()), selected_index=0, titles=('Youtube', 'Bilibili'))"
       ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# @title Video: IBL Brain-wide map dataset\n",
+    "from ipywidgets import widgets\n",
+    "from IPython.display import YouTubeVideo\n",
+    "from IPython.display import IFrame\n",
+    "from IPython.display import display\n",
+    "\n",
+    "\n",
+    "class PlayVideo(IFrame):\n",
+    "  def __init__(self, id, source, page=1, width=400, height=300, **kwargs):\n",
+    "    self.id = id\n",
+    "    if source == 'Bilibili':\n",
+    "      src = f'https://player.bilibili.com/player.html?bvid={id}&page={page}'\n",
+    "    elif source == 'Osf':\n",
+    "      src = f'https://mfr.ca-1.osf.io/render?url=https://osf.io/download/{id}/?direct%26mode=render'\n",
+    "    super(PlayVideo, self).__init__(src, width, height, **kwargs)\n",
+    "\n",
+    "\n",
+    "def display_videos(video_ids, W=400, H=300, fs=1):\n",
+    "  tab_contents = []\n",
+    "  for i, video_id in enumerate(video_ids):\n",
+    "    out = widgets.Output()\n",
+    "    with out:\n",
+    "      if video_ids[i][0] == 'Youtube':\n",
+    "        video = YouTubeVideo(id=video_ids[i][1], width=W,\n",
+    "                             height=H, fs=fs, rel=0)\n",
+    "        print(f'Video available at https://youtube.com/watch?v={video.id}')\n",
+    "      else:\n",
+    "        video = PlayVideo(id=video_ids[i][1], source=video_ids[i][0], width=W,\n",
+    "                          height=H, fs=fs, autoplay=False)\n",
+    "        if video_ids[i][0] == 'Bilibili':\n",
+    "          print(f'Video available at https://www.bilibili.com/video/{video.id}')\n",
+    "        elif video_ids[i][0] == 'Osf':\n",
+    "          print(f'Video available at https://osf.io/{video.id}')\n",
+    "      display(video)\n",
+    "    tab_contents.append(out)\n",
+    "  return tab_contents\n",
+    "\n",
+    "\n",
+    "video_ids = [('Youtube', 'N69nvrnmq9g'), ('Bilibili', 'BV1RkKKzzE3D')]\n",
+    "tab_contents = display_videos(video_ids, W=854, H=480)\n",
+    "tabs = widgets.Tab()\n",
+    "tabs.children = tab_contents\n",
+    "for i in range(len(tab_contents)):\n",
+    "  tabs.set_title(i, video_ids[i][0])\n",
+    "display(tabs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "cellView": "form",
+    "execution": {},
+    "pycharm": {
+     "name": "#%%\n"
     },
+    "tags": [
+     "remove-input"
+    ]
+   },
+   "outputs": [
     {
-      "cell_type": "code",
-      "execution_count": 2,
-      "metadata": {
-        "cellView": "form",
-        "execution": {},
-        "pycharm": {
-          "name": "#%%\n"
-        },
-        "tags": [
-          "remove-input"
-        ],
-        "id": "ACIad90WVSUg",
-        "outputId": "20c80155-f613-4203-e365-43efa23e7a89",
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 583,
-          "referenced_widgets": [
-            "933c1ebd146e4dcc85a0da52c4127ea3",
-            "6b386cf0d57146a19848831709488b97",
-            "04185f5fa2714c7186bd028da1337e56",
-            "1633d8bd49604ddd865ec576da06ee6a",
-            "320a47f7279a43b09247217b0857c895",
-            "ee87b07bd3e549d3b302e13a951bde0f"
-          ]
-        }
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "50308247ca3e4675a49889d09f46a0d1",
+       "version_major": 2,
+       "version_minor": 0
       },
-      "outputs": [
-        {
-          "output_type": "display_data",
-          "data": {
-            "text/plain": [
-              "Tab(children=(Output(), Output()), _titles={'0': 'Youtube', '1': 'Bilibili'})"
-            ],
-            "application/vnd.jupyter.widget-view+json": {
-              "version_major": 2,
-              "version_minor": 0,
-              "model_id": "933c1ebd146e4dcc85a0da52c4127ea3"
-            }
-          },
-          "metadata": {}
-        }
-      ],
-      "source": [
-        "# @title Video: Stringer dataset\n",
-        "from ipywidgets import widgets\n",
-        "from IPython.display import YouTubeVideo\n",
-        "from IPython.display import IFrame\n",
-        "from IPython.display import display\n",
-        "\n",
-        "\n",
-        "class PlayVideo(IFrame):\n",
-        "  def __init__(self, id, source, page=1, width=400, height=300, **kwargs):\n",
-        "    self.id = id\n",
-        "    if source == 'Bilibili':\n",
-        "      src = f'https://player.bilibili.com/player.html?bvid={id}&page={page}'\n",
-        "    elif source == 'Osf':\n",
-        "      src = f'https://mfr.ca-1.osf.io/render?url=https://osf.io/download/{id}/?direct%26mode=render'\n",
-        "    super(PlayVideo, self).__init__(src, width, height, **kwargs)\n",
-        "\n",
-        "\n",
-        "def display_videos(video_ids, W=400, H=300, fs=1):\n",
-        "  tab_contents = []\n",
-        "  for i, video_id in enumerate(video_ids):\n",
-        "    out = widgets.Output()\n",
-        "    with out:\n",
-        "      if video_ids[i][0] == 'Youtube':\n",
-        "        video = YouTubeVideo(id=video_ids[i][1], width=W,\n",
-        "                             height=H, fs=fs, rel=0)\n",
-        "        print(f'Video available at https://youtube.com/watch?v={video.id}')\n",
-        "      else:\n",
-        "        video = PlayVideo(id=video_ids[i][1], source=video_ids[i][0], width=W,\n",
-        "                          height=H, fs=fs, autoplay=False)\n",
-        "        if video_ids[i][0] == 'Bilibili':\n",
-        "          print(f'Video available at https://www.bilibili.com/video/{video.id}')\n",
-        "        elif video_ids[i][0] == 'Osf':\n",
-        "          print(f'Video available at https://osf.io/{video.id}')\n",
-        "      display(video)\n",
-        "    tab_contents.append(out)\n",
-        "  return tab_contents\n",
-        "\n",
-        "\n",
-        "video_ids = [('Youtube', '78GSgf6Dkkk'), ('Bilibili', 'BV1614y1R7wb')]\n",
-        "tab_contents = display_videos(video_ids, W=854, H=480)\n",
-        "tabs = widgets.Tab()\n",
-        "tabs.children = tab_contents\n",
-        "for i in range(len(tab_contents)):\n",
-        "  tabs.set_title(i, video_ids[i][0])\n",
-        "display(tabs)"
+      "text/plain": [
+       "Tab(children=(Output(), Output()), selected_index=0, titles=('Youtube', 'Bilibili'))"
       ]
-    },
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# @title Video: Supervised and Unsupervised dataset\n",
+    "from ipywidgets import widgets\n",
+    "from IPython.display import YouTubeVideo\n",
+    "from IPython.display import IFrame\n",
+    "from IPython.display import display\n",
+    "\n",
+    "\n",
+    "class PlayVideo(IFrame):\n",
+    "  def __init__(self, id, source, page=1, width=400, height=300, **kwargs):\n",
+    "    self.id = id\n",
+    "    if source == 'Bilibili':\n",
+    "      src = f'https://player.bilibili.com/player.html?bvid={id}&page={page}'\n",
+    "    elif source == 'Osf':\n",
+    "      src = f'https://mfr.ca-1.osf.io/render?url=https://osf.io/download/{id}/?direct%26mode=render'\n",
+    "    super(PlayVideo, self).__init__(src, width, height, **kwargs)\n",
+    "\n",
+    "\n",
+    "def display_videos(video_ids, W=400, H=300, fs=1):\n",
+    "  tab_contents = []\n",
+    "  for i, video_id in enumerate(video_ids):\n",
+    "    out = widgets.Output()\n",
+    "    with out:\n",
+    "      if video_ids[i][0] == 'Youtube':\n",
+    "        video = YouTubeVideo(id=video_ids[i][1], width=W,\n",
+    "                             height=H, fs=fs, rel=0)\n",
+    "        print(f'Video available at https://youtube.com/watch?v={video.id}')\n",
+    "      else:\n",
+    "        video = PlayVideo(id=video_ids[i][1], source=video_ids[i][0], width=W,\n",
+    "                          height=H, fs=fs, autoplay=False)\n",
+    "        if video_ids[i][0] == 'Bilibili':\n",
+    "          print(f'Video available at https://www.bilibili.com/video/{video.id}')\n",
+    "        elif video_ids[i][0] == 'Osf':\n",
+    "          print(f'Video available at https://osf.io/{video.id}')\n",
+    "      display(video)\n",
+    "    tab_contents.append(out)\n",
+    "  return tab_contents\n",
+    "\n",
+    "\n",
+    "video_ids = [('Youtube', 'o0PFk-lnpuI'), ('Bilibili', 'BV1614y1R7wb')]\n",
+    "tab_contents = display_videos(video_ids, W=854, H=480)\n",
+    "tabs = widgets.Tab()\n",
+    "tabs.children = tab_contents\n",
+    "for i in range(len(tab_contents)):\n",
+    "  tabs.set_title(i, video_ids[i][0])\n",
+    "display(tabs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "cellView": "form",
+    "execution": {}
+   },
+   "outputs": [
     {
-      "cell_type": "code",
-      "execution_count": 3,
-      "metadata": {
-        "cellView": "form",
-        "execution": {},
-        "id": "3TWFgH3fVSUg",
-        "outputId": "dc1d8efb-1ca2-4959-8108-8856dffd63c2",
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 583,
-          "referenced_widgets": [
-            "a80ebb7c72204c6993a591cc494ba9dc",
-            "68c071817b2d48488e2e5f4a39736d76",
-            "f687a783a17b42bdb8c2cd33c4e73a3c",
-            "e1bdb30c17dc4c02ba6715dc3e4d2dac",
-            "7e13ae45410f424b848f1c8722d8c83e",
-            "0eb6bbc286eb4b8bad0503da78331593"
-          ]
-        }
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "5898603bc01940caa6fcf4d39b5d69d9",
+       "version_major": 2,
+       "version_minor": 0
       },
-      "outputs": [
-        {
-          "output_type": "display_data",
-          "data": {
-            "text/plain": [
-              "Tab(children=(Output(), Output()), _titles={'0': 'Youtube', '1': 'Bilibili'})"
-            ],
-            "application/vnd.jupyter.widget-view+json": {
-              "version_major": 2,
-              "version_minor": 0,
-              "model_id": "a80ebb7c72204c6993a591cc494ba9dc"
-            }
-          },
-          "metadata": {}
-        }
-      ],
-      "source": [
-        "# @title Video: Allen Institute dataset\n",
-        "from ipywidgets import widgets\n",
-        "from IPython.display import YouTubeVideo\n",
-        "from IPython.display import IFrame\n",
-        "from IPython.display import display\n",
-        "\n",
-        "\n",
-        "class PlayVideo(IFrame):\n",
-        "  def __init__(self, id, source, page=1, width=400, height=300, **kwargs):\n",
-        "    self.id = id\n",
-        "    if source == 'Bilibili':\n",
-        "      src = f'https://player.bilibili.com/player.html?bvid={id}&page={page}'\n",
-        "    elif source == 'Osf':\n",
-        "      src = f'https://mfr.ca-1.osf.io/render?url=https://osf.io/download/{id}/?direct%26mode=render'\n",
-        "    super(PlayVideo, self).__init__(src, width, height, **kwargs)\n",
-        "\n",
-        "\n",
-        "def display_videos(video_ids, W=400, H=300, fs=1):\n",
-        "  tab_contents = []\n",
-        "  for i, video_id in enumerate(video_ids):\n",
-        "    out = widgets.Output()\n",
-        "    with out:\n",
-        "      if video_ids[i][0] == 'Youtube':\n",
-        "        video = YouTubeVideo(id=video_ids[i][1], width=W,\n",
-        "                             height=H, fs=fs, rel=0)\n",
-        "        print(f'Video available at https://youtube.com/watch?v={video.id}')\n",
-        "      else:\n",
-        "        video = PlayVideo(id=video_ids[i][1], source=video_ids[i][0], width=W,\n",
-        "                          height=H, fs=fs, autoplay=False)\n",
-        "        if video_ids[i][0] == 'Bilibili':\n",
-        "          print(f'Video available at https://www.bilibili.com/video/{video.id}')\n",
-        "        elif video_ids[i][0] == 'Osf':\n",
-        "          print(f'Video available at https://osf.io/{video.id}')\n",
-        "      display(video)\n",
-        "    tab_contents.append(out)\n",
-        "  return tab_contents\n",
-        "\n",
-        "\n",
-        "video_ids = [('Youtube', '3YP-GYvYnuA'), ('Bilibili', 'BV1KL411W7bY')]\n",
-        "tab_contents = display_videos(video_ids, W=854, H=480)\n",
-        "tabs = widgets.Tab()\n",
-        "tabs.children = tab_contents\n",
-        "for i in range(len(tab_contents)):\n",
-        "  tabs.set_title(i, video_ids[i][0])\n",
-        "display(tabs)"
+      "text/plain": [
+       "Tab(children=(Output(), Output()), selected_index=0, titles=('Youtube', 'Bilibili'))"
       ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
     }
-  ],
-  "metadata": {
-    "colab": {
-      "name": "neurons_videos",
-      "provenance": [],
-      "toc_visible": true,
-      "include_colab_link": true
-    },
-    "kernel": {
-      "display_name": "Python 3",
-      "language": "python",
-      "name": "python3"
-    },
-    "kernelspec": {
-      "display_name": "Python 3",
-      "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.9.17"
-    },
-    "widgets": {
-      "application/vnd.jupyter.widget-state+json": {
-        "d44ef1cebe2f4d768639dfcb1310e24f": {
-          "model_module": "@jupyter-widgets/controls",
-          "model_name": "TabModel",
-          "model_module_version": "1.5.0",
-          "state": {
-            "_dom_classes": [],
-            "_model_module": "@jupyter-widgets/controls",
-            "_model_module_version": "1.5.0",
-            "_model_name": "TabModel",
-            "_titles": {
-              "0": "Youtube",
-              "1": "Bilibili"
-            },
-            "_view_count": null,
-            "_view_module": "@jupyter-widgets/controls",
-            "_view_module_version": "1.5.0",
-            "_view_name": "TabView",
-            "box_style": "",
-            "children": [
-              "IPY_MODEL_fcf9e6b0f71c4807a6309bd01b0d9926",
-              "IPY_MODEL_25e69e6f6c164c0f92095dff81aa57cc"
-            ],
-            "layout": "IPY_MODEL_2e847d6d0f8546b88aa9374f936bbf53",
-            "selected_index": 0
-          }
-        },
-        "fcf9e6b0f71c4807a6309bd01b0d9926": {
-          "model_module": "@jupyter-widgets/output",
-          "model_name": "OutputModel",
-          "model_module_version": "1.0.0",
-          "state": {
-            "_dom_classes": [],
-            "_model_module": "@jupyter-widgets/output",
-            "_model_module_version": "1.0.0",
-            "_model_name": "OutputModel",
-            "_view_count": null,
-            "_view_module": "@jupyter-widgets/output",
-            "_view_module_version": "1.0.0",
-            "_view_name": "OutputView",
-            "layout": "IPY_MODEL_030b615321a64698af48d669fd3f8c40",
-            "msg_id": "",
-            "outputs": [
-              {
-                "output_type": "stream",
-                "name": "stdout",
-                "text": [
-                  "Video available at https://youtube.com/watch?v=WXn4-FpVaOo\n"
-                ]
-              },
-              {
-                "output_type": "display_data",
-                "data": {
-                  "text/plain": "<IPython.lib.display.YouTubeVideo at 0x7f330c8a5ba0>",
-                  "text/html": "\n        <iframe\n            width=\"854\"\n            height=\"480\"\n            src=\"https://www.youtube.com/embed/WXn4-FpVaOo?fs=1&rel=0\"\n            frameborder=\"0\"\n            allowfullscreen\n            \n        ></iframe>\n        ",
-                  "image/jpeg": "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\n"
-                },
-                "metadata": {}
-              }
-            ]
-          }
-        },
-        "25e69e6f6c164c0f92095dff81aa57cc": {
-          "model_module": "@jupyter-widgets/output",
-          "model_name": "OutputModel",
-          "model_module_version": "1.0.0",
-          "state": {
-            "_dom_classes": [],
-            "_model_module": "@jupyter-widgets/output",
-            "_model_module_version": "1.0.0",
-            "_model_name": "OutputModel",
-            "_view_count": null,
-            "_view_module": "@jupyter-widgets/output",
-            "_view_module_version": "1.0.0",
-            "_view_name": "OutputView",
-            "layout": "IPY_MODEL_ca4297c0ac7149a1bcaef9472425d162",
-            "msg_id": "",
-            "outputs": [
-              {
-                "output_type": "stream",
-                "name": "stdout",
-                "text": [
-                  "Video available at https://www.bilibili.com/video/BV1Hh4y1E7Yk\n"
-                ]
-              },
-              {
-                "output_type": "display_data",
-                "data": {
-                  "text/plain": "<__main__.PlayVideo at 0x7f330c59ab90>",
-                  "text/html": "\n        <iframe\n            width=\"854\"\n            height=\"480\"\n            src=\"https://player.bilibili.com/player.html?bvid=BV1Hh4y1E7Yk&page=1?fs=1&autoplay=False\"\n            frameborder=\"0\"\n            allowfullscreen\n            \n        ></iframe>\n        "
-                },
-                "metadata": {}
-              }
-            ]
-          }
-        },
-        "2e847d6d0f8546b88aa9374f936bbf53": {
-          "model_module": "@jupyter-widgets/base",
-          "model_name": "LayoutModel",
-          "model_module_version": "1.2.0",
-          "state": {
-            "_model_module": "@jupyter-widgets/base",
-            "_model_module_version": "1.2.0",
-            "_model_name": "LayoutModel",
-            "_view_count": null,
-            "_view_module": "@jupyter-widgets/base",
-            "_view_module_version": "1.2.0",
-            "_view_name": "LayoutView",
-            "align_content": null,
-            "align_items": null,
-            "align_self": null,
-            "border": null,
-            "bottom": null,
-            "display": null,
-            "flex": null,
-            "flex_flow": null,
-            "grid_area": null,
-            "grid_auto_columns": null,
-            "grid_auto_flow": null,
-            "grid_auto_rows": null,
-            "grid_column": null,
-            "grid_gap": null,
-            "grid_row": null,
-            "grid_template_areas": null,
-            "grid_template_columns": null,
-            "grid_template_rows": null,
-            "height": null,
-            "justify_content": null,
-            "justify_items": null,
-            "left": null,
-            "margin": null,
-            "max_height": null,
-            "max_width": null,
-            "min_height": null,
-            "min_width": null,
-            "object_fit": null,
-            "object_position": null,
-            "order": null,
-            "overflow": null,
-            "overflow_x": null,
-            "overflow_y": null,
-            "padding": null,
-            "right": null,
-            "top": null,
-            "visibility": null,
-            "width": null
-          }
-        },
-        "030b615321a64698af48d669fd3f8c40": {
-          "model_module": "@jupyter-widgets/base",
-          "model_name": "LayoutModel",
-          "model_module_version": "1.2.0",
-          "state": {
-            "_model_module": "@jupyter-widgets/base",
-            "_model_module_version": "1.2.0",
-            "_model_name": "LayoutModel",
-            "_view_count": null,
-            "_view_module": "@jupyter-widgets/base",
-            "_view_module_version": "1.2.0",
-            "_view_name": "LayoutView",
-            "align_content": null,
-            "align_items": null,
-            "align_self": null,
-            "border": null,
-            "bottom": null,
-            "display": null,
-            "flex": null,
-            "flex_flow": null,
-            "grid_area": null,
-            "grid_auto_columns": null,
-            "grid_auto_flow": null,
-            "grid_auto_rows": null,
-            "grid_column": null,
-            "grid_gap": null,
-            "grid_row": null,
-            "grid_template_areas": null,
-            "grid_template_columns": null,
-            "grid_template_rows": null,
-            "height": null,
-            "justify_content": null,
-            "justify_items": null,
-            "left": null,
-            "margin": null,
-            "max_height": null,
-            "max_width": null,
-            "min_height": null,
-            "min_width": null,
-            "object_fit": null,
-            "object_position": null,
-            "order": null,
-            "overflow": null,
-            "overflow_x": null,
-            "overflow_y": null,
-            "padding": null,
-            "right": null,
-            "top": null,
-            "visibility": null,
-            "width": null
-          }
-        },
-        "ca4297c0ac7149a1bcaef9472425d162": {
-          "model_module": "@jupyter-widgets/base",
-          "model_name": "LayoutModel",
-          "model_module_version": "1.2.0",
-          "state": {
-            "_model_module": "@jupyter-widgets/base",
-            "_model_module_version": "1.2.0",
-            "_model_name": "LayoutModel",
-            "_view_count": null,
-            "_view_module": "@jupyter-widgets/base",
-            "_view_module_version": "1.2.0",
-            "_view_name": "LayoutView",
-            "align_content": null,
-            "align_items": null,
-            "align_self": null,
-            "border": null,
-            "bottom": null,
-            "display": null,
-            "flex": null,
-            "flex_flow": null,
-            "grid_area": null,
-            "grid_auto_columns": null,
-            "grid_auto_flow": null,
-            "grid_auto_rows": null,
-            "grid_column": null,
-            "grid_gap": null,
-            "grid_row": null,
-            "grid_template_areas": null,
-            "grid_template_columns": null,
-            "grid_template_rows": null,
-            "height": null,
-            "justify_content": null,
-            "justify_items": null,
-            "left": null,
-            "margin": null,
-            "max_height": null,
-            "max_width": null,
-            "min_height": null,
-            "min_width": null,
-            "object_fit": null,
-            "object_position": null,
-            "order": null,
-            "overflow": null,
-            "overflow_x": null,
-            "overflow_y": null,
-            "padding": null,
-            "right": null,
-            "top": null,
-            "visibility": null,
-            "width": null
-          }
-        },
-        "933c1ebd146e4dcc85a0da52c4127ea3": {
-          "model_module": "@jupyter-widgets/controls",
-          "model_name": "TabModel",
-          "model_module_version": "1.5.0",
-          "state": {
-            "_dom_classes": [],
-            "_model_module": "@jupyter-widgets/controls",
-            "_model_module_version": "1.5.0",
-            "_model_name": "TabModel",
-            "_titles": {
-              "0": "Youtube",
-              "1": "Bilibili"
-            },
-            "_view_count": null,
-            "_view_module": "@jupyter-widgets/controls",
-            "_view_module_version": "1.5.0",
-            "_view_name": "TabView",
-            "box_style": "",
-            "children": [
-              "IPY_MODEL_6b386cf0d57146a19848831709488b97",
-              "IPY_MODEL_04185f5fa2714c7186bd028da1337e56"
-            ],
-            "layout": "IPY_MODEL_1633d8bd49604ddd865ec576da06ee6a",
-            "selected_index": 0
-          }
-        },
-        "6b386cf0d57146a19848831709488b97": {
-          "model_module": "@jupyter-widgets/output",
-          "model_name": "OutputModel",
-          "model_module_version": "1.0.0",
-          "state": {
-            "_dom_classes": [],
-            "_model_module": "@jupyter-widgets/output",
-            "_model_module_version": "1.0.0",
-            "_model_name": "OutputModel",
-            "_view_count": null,
-            "_view_module": "@jupyter-widgets/output",
-            "_view_module_version": "1.0.0",
-            "_view_name": "OutputView",
-            "layout": "IPY_MODEL_320a47f7279a43b09247217b0857c895",
-            "msg_id": "",
-            "outputs": [
-              {
-                "output_type": "stream",
-                "name": "stdout",
-                "text": [
-                  "Video available at https://youtube.com/watch?v=78GSgf6Dkkk\n"
-                ]
-              },
-              {
-                "output_type": "display_data",
-                "data": {
-                  "text/plain": "<IPython.lib.display.YouTubeVideo at 0x7f330c8bc880>",
-                  "text/html": "\n        <iframe\n            width=\"854\"\n            height=\"480\"\n            src=\"https://www.youtube.com/embed/78GSgf6Dkkk?fs=1&rel=0\"\n            frameborder=\"0\"\n            allowfullscreen\n            \n        ></iframe>\n        ",
-                  "image/jpeg": "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\n"
-                },
-                "metadata": {}
-              }
-            ]
-          }
-        },
-        "04185f5fa2714c7186bd028da1337e56": {
-          "model_module": "@jupyter-widgets/output",
-          "model_name": "OutputModel",
-          "model_module_version": "1.0.0",
-          "state": {
-            "_dom_classes": [],
-            "_model_module": "@jupyter-widgets/output",
-            "_model_module_version": "1.0.0",
-            "_model_name": "OutputModel",
-            "_view_count": null,
-            "_view_module": "@jupyter-widgets/output",
-            "_view_module_version": "1.0.0",
-            "_view_name": "OutputView",
-            "layout": "IPY_MODEL_ee87b07bd3e549d3b302e13a951bde0f",
-            "msg_id": "",
-            "outputs": [
-              {
-                "output_type": "stream",
-                "name": "stdout",
-                "text": [
-                  "Video available at https://www.bilibili.com/video/BV1614y1R7wb\n"
-                ]
-              },
-              {
-                "output_type": "display_data",
-                "data": {
-                  "text/plain": "<__main__.PlayVideo at 0x7f330c8bc910>",
-                  "text/html": "\n        <iframe\n            width=\"854\"\n            height=\"480\"\n            src=\"https://player.bilibili.com/player.html?bvid=BV1614y1R7wb&page=1?fs=1&autoplay=False\"\n            frameborder=\"0\"\n            allowfullscreen\n            \n        ></iframe>\n        "
-                },
-                "metadata": {}
-              }
-            ]
-          }
-        },
-        "1633d8bd49604ddd865ec576da06ee6a": {
-          "model_module": "@jupyter-widgets/base",
-          "model_name": "LayoutModel",
-          "model_module_version": "1.2.0",
-          "state": {
-            "_model_module": "@jupyter-widgets/base",
-            "_model_module_version": "1.2.0",
-            "_model_name": "LayoutModel",
-            "_view_count": null,
-            "_view_module": "@jupyter-widgets/base",
-            "_view_module_version": "1.2.0",
-            "_view_name": "LayoutView",
-            "align_content": null,
-            "align_items": null,
-            "align_self": null,
-            "border": null,
-            "bottom": null,
-            "display": null,
-            "flex": null,
-            "flex_flow": null,
-            "grid_area": null,
-            "grid_auto_columns": null,
-            "grid_auto_flow": null,
-            "grid_auto_rows": null,
-            "grid_column": null,
-            "grid_gap": null,
-            "grid_row": null,
-            "grid_template_areas": null,
-            "grid_template_columns": null,
-            "grid_template_rows": null,
-            "height": null,
-            "justify_content": null,
-            "justify_items": null,
-            "left": null,
-            "margin": null,
-            "max_height": null,
-            "max_width": null,
-            "min_height": null,
-            "min_width": null,
-            "object_fit": null,
-            "object_position": null,
-            "order": null,
-            "overflow": null,
-            "overflow_x": null,
-            "overflow_y": null,
-            "padding": null,
-            "right": null,
-            "top": null,
-            "visibility": null,
-            "width": null
-          }
-        },
-        "320a47f7279a43b09247217b0857c895": {
-          "model_module": "@jupyter-widgets/base",
-          "model_name": "LayoutModel",
-          "model_module_version": "1.2.0",
-          "state": {
-            "_model_module": "@jupyter-widgets/base",
-            "_model_module_version": "1.2.0",
-            "_model_name": "LayoutModel",
-            "_view_count": null,
-            "_view_module": "@jupyter-widgets/base",
-            "_view_module_version": "1.2.0",
-            "_view_name": "LayoutView",
-            "align_content": null,
-            "align_items": null,
-            "align_self": null,
-            "border": null,
-            "bottom": null,
-            "display": null,
-            "flex": null,
-            "flex_flow": null,
-            "grid_area": null,
-            "grid_auto_columns": null,
-            "grid_auto_flow": null,
-            "grid_auto_rows": null,
-            "grid_column": null,
-            "grid_gap": null,
-            "grid_row": null,
-            "grid_template_areas": null,
-            "grid_template_columns": null,
-            "grid_template_rows": null,
-            "height": null,
-            "justify_content": null,
-            "justify_items": null,
-            "left": null,
-            "margin": null,
-            "max_height": null,
-            "max_width": null,
-            "min_height": null,
-            "min_width": null,
-            "object_fit": null,
-            "object_position": null,
-            "order": null,
-            "overflow": null,
-            "overflow_x": null,
-            "overflow_y": null,
-            "padding": null,
-            "right": null,
-            "top": null,
-            "visibility": null,
-            "width": null
-          }
-        },
-        "ee87b07bd3e549d3b302e13a951bde0f": {
-          "model_module": "@jupyter-widgets/base",
-          "model_name": "LayoutModel",
-          "model_module_version": "1.2.0",
-          "state": {
-            "_model_module": "@jupyter-widgets/base",
-            "_model_module_version": "1.2.0",
-            "_model_name": "LayoutModel",
-            "_view_count": null,
-            "_view_module": "@jupyter-widgets/base",
-            "_view_module_version": "1.2.0",
-            "_view_name": "LayoutView",
-            "align_content": null,
-            "align_items": null,
-            "align_self": null,
-            "border": null,
-            "bottom": null,
-            "display": null,
-            "flex": null,
-            "flex_flow": null,
-            "grid_area": null,
-            "grid_auto_columns": null,
-            "grid_auto_flow": null,
-            "grid_auto_rows": null,
-            "grid_column": null,
-            "grid_gap": null,
-            "grid_row": null,
-            "grid_template_areas": null,
-            "grid_template_columns": null,
-            "grid_template_rows": null,
-            "height": null,
-            "justify_content": null,
-            "justify_items": null,
-            "left": null,
-            "margin": null,
-            "max_height": null,
-            "max_width": null,
-            "min_height": null,
-            "min_width": null,
-            "object_fit": null,
-            "object_position": null,
-            "order": null,
-            "overflow": null,
-            "overflow_x": null,
-            "overflow_y": null,
-            "padding": null,
-            "right": null,
-            "top": null,
-            "visibility": null,
-            "width": null
-          }
-        },
-        "a80ebb7c72204c6993a591cc494ba9dc": {
-          "model_module": "@jupyter-widgets/controls",
-          "model_name": "TabModel",
-          "model_module_version": "1.5.0",
-          "state": {
-            "_dom_classes": [],
-            "_model_module": "@jupyter-widgets/controls",
-            "_model_module_version": "1.5.0",
-            "_model_name": "TabModel",
-            "_titles": {
-              "0": "Youtube",
-              "1": "Bilibili"
-            },
-            "_view_count": null,
-            "_view_module": "@jupyter-widgets/controls",
-            "_view_module_version": "1.5.0",
-            "_view_name": "TabView",
-            "box_style": "",
-            "children": [
-              "IPY_MODEL_68c071817b2d48488e2e5f4a39736d76",
-              "IPY_MODEL_f687a783a17b42bdb8c2cd33c4e73a3c"
-            ],
-            "layout": "IPY_MODEL_e1bdb30c17dc4c02ba6715dc3e4d2dac",
-            "selected_index": 0
-          }
-        },
-        "68c071817b2d48488e2e5f4a39736d76": {
-          "model_module": "@jupyter-widgets/output",
-          "model_name": "OutputModel",
-          "model_module_version": "1.0.0",
-          "state": {
-            "_dom_classes": [],
-            "_model_module": "@jupyter-widgets/output",
-            "_model_module_version": "1.0.0",
-            "_model_name": "OutputModel",
-            "_view_count": null,
-            "_view_module": "@jupyter-widgets/output",
-            "_view_module_version": "1.0.0",
-            "_view_name": "OutputView",
-            "layout": "IPY_MODEL_7e13ae45410f424b848f1c8722d8c83e",
-            "msg_id": "",
-            "outputs": [
-              {
-                "output_type": "stream",
-                "name": "stdout",
-                "text": [
-                  "Video available at https://youtube.com/watch?v=3YP-GYvYnuA\n"
-                ]
-              },
-              {
-                "output_type": "display_data",
-                "data": {
-                  "text/plain": "<IPython.lib.display.YouTubeVideo at 0x7f330c3e85b0>",
-                  "text/html": "\n        <iframe\n            width=\"854\"\n            height=\"480\"\n            src=\"https://www.youtube.com/embed/3YP-GYvYnuA?fs=1&rel=0\"\n            frameborder=\"0\"\n            allowfullscreen\n            \n        ></iframe>\n        ",
-                  "image/jpeg": "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\n"
-                },
-                "metadata": {}
-              }
-            ]
-          }
-        },
-        "f687a783a17b42bdb8c2cd33c4e73a3c": {
-          "model_module": "@jupyter-widgets/output",
-          "model_name": "OutputModel",
-          "model_module_version": "1.0.0",
-          "state": {
-            "_dom_classes": [],
-            "_model_module": "@jupyter-widgets/output",
-            "_model_module_version": "1.0.0",
-            "_model_name": "OutputModel",
-            "_view_count": null,
-            "_view_module": "@jupyter-widgets/output",
-            "_view_module_version": "1.0.0",
-            "_view_name": "OutputView",
-            "layout": "IPY_MODEL_0eb6bbc286eb4b8bad0503da78331593",
-            "msg_id": "",
-            "outputs": [
-              {
-                "output_type": "stream",
-                "name": "stdout",
-                "text": [
-                  "Video available at https://www.bilibili.com/video/BV1KL411W7bY\n"
-                ]
-              },
-              {
-                "output_type": "display_data",
-                "data": {
-                  "text/plain": "<__main__.PlayVideo at 0x7f330c3e8850>",
-                  "text/html": "\n        <iframe\n            width=\"854\"\n            height=\"480\"\n            src=\"https://player.bilibili.com/player.html?bvid=BV1KL411W7bY&page=1?fs=1&autoplay=False\"\n            frameborder=\"0\"\n            allowfullscreen\n            \n        ></iframe>\n        "
-                },
-                "metadata": {}
-              }
-            ]
-          }
-        },
-        "e1bdb30c17dc4c02ba6715dc3e4d2dac": {
-          "model_module": "@jupyter-widgets/base",
-          "model_name": "LayoutModel",
-          "model_module_version": "1.2.0",
-          "state": {
-            "_model_module": "@jupyter-widgets/base",
-            "_model_module_version": "1.2.0",
-            "_model_name": "LayoutModel",
-            "_view_count": null,
-            "_view_module": "@jupyter-widgets/base",
-            "_view_module_version": "1.2.0",
-            "_view_name": "LayoutView",
-            "align_content": null,
-            "align_items": null,
-            "align_self": null,
-            "border": null,
-            "bottom": null,
-            "display": null,
-            "flex": null,
-            "flex_flow": null,
-            "grid_area": null,
-            "grid_auto_columns": null,
-            "grid_auto_flow": null,
-            "grid_auto_rows": null,
-            "grid_column": null,
-            "grid_gap": null,
-            "grid_row": null,
-            "grid_template_areas": null,
-            "grid_template_columns": null,
-            "grid_template_rows": null,
-            "height": null,
-            "justify_content": null,
-            "justify_items": null,
-            "left": null,
-            "margin": null,
-            "max_height": null,
-            "max_width": null,
-            "min_height": null,
-            "min_width": null,
-            "object_fit": null,
-            "object_position": null,
-            "order": null,
-            "overflow": null,
-            "overflow_x": null,
-            "overflow_y": null,
-            "padding": null,
-            "right": null,
-            "top": null,
-            "visibility": null,
-            "width": null
-          }
-        },
-        "7e13ae45410f424b848f1c8722d8c83e": {
-          "model_module": "@jupyter-widgets/base",
-          "model_name": "LayoutModel",
-          "model_module_version": "1.2.0",
-          "state": {
-            "_model_module": "@jupyter-widgets/base",
-            "_model_module_version": "1.2.0",
-            "_model_name": "LayoutModel",
-            "_view_count": null,
-            "_view_module": "@jupyter-widgets/base",
-            "_view_module_version": "1.2.0",
-            "_view_name": "LayoutView",
-            "align_content": null,
-            "align_items": null,
-            "align_self": null,
-            "border": null,
-            "bottom": null,
-            "display": null,
-            "flex": null,
-            "flex_flow": null,
-            "grid_area": null,
-            "grid_auto_columns": null,
-            "grid_auto_flow": null,
-            "grid_auto_rows": null,
-            "grid_column": null,
-            "grid_gap": null,
-            "grid_row": null,
-            "grid_template_areas": null,
-            "grid_template_columns": null,
-            "grid_template_rows": null,
-            "height": null,
-            "justify_content": null,
-            "justify_items": null,
-            "left": null,
-            "margin": null,
-            "max_height": null,
-            "max_width": null,
-            "min_height": null,
-            "min_width": null,
-            "object_fit": null,
-            "object_position": null,
-            "order": null,
-            "overflow": null,
-            "overflow_x": null,
-            "overflow_y": null,
-            "padding": null,
-            "right": null,
-            "top": null,
-            "visibility": null,
-            "width": null
-          }
-        },
-        "0eb6bbc286eb4b8bad0503da78331593": {
-          "model_module": "@jupyter-widgets/base",
-          "model_name": "LayoutModel",
-          "model_module_version": "1.2.0",
-          "state": {
-            "_model_module": "@jupyter-widgets/base",
-            "_model_module_version": "1.2.0",
-            "_model_name": "LayoutModel",
-            "_view_count": null,
-            "_view_module": "@jupyter-widgets/base",
-            "_view_module_version": "1.2.0",
-            "_view_name": "LayoutView",
-            "align_content": null,
-            "align_items": null,
-            "align_self": null,
-            "border": null,
-            "bottom": null,
-            "display": null,
-            "flex": null,
-            "flex_flow": null,
-            "grid_area": null,
-            "grid_auto_columns": null,
-            "grid_auto_flow": null,
-            "grid_auto_rows": null,
-            "grid_column": null,
-            "grid_gap": null,
-            "grid_row": null,
-            "grid_template_areas": null,
-            "grid_template_columns": null,
-            "grid_template_rows": null,
-            "height": null,
-            "justify_content": null,
-            "justify_items": null,
-            "left": null,
-            "margin": null,
-            "max_height": null,
-            "max_width": null,
-            "min_height": null,
-            "min_width": null,
-            "object_fit": null,
-            "object_position": null,
-            "order": null,
-            "overflow": null,
-            "overflow_x": null,
-            "overflow_y": null,
-            "padding": null,
-            "right": null,
-            "top": null,
-            "visibility": null,
-            "width": null
-          }
-        }
-      }
-    }
+   ],
+   "source": [
+    "# @title Video: Allen Institute dataset\n",
+    "from ipywidgets import widgets\n",
+    "from IPython.display import YouTubeVideo\n",
+    "from IPython.display import IFrame\n",
+    "from IPython.display import display\n",
+    "\n",
+    "\n",
+    "class PlayVideo(IFrame):\n",
+    "  def __init__(self, id, source, page=1, width=400, height=300, **kwargs):\n",
+    "    self.id = id\n",
+    "    if source == 'Bilibili':\n",
+    "      src = f'https://player.bilibili.com/player.html?bvid={id}&page={page}'\n",
+    "    elif source == 'Osf':\n",
+    "      src = f'https://mfr.ca-1.osf.io/render?url=https://osf.io/download/{id}/?direct%26mode=render'\n",
+    "    super(PlayVideo, self).__init__(src, width, height, **kwargs)\n",
+    "\n",
+    "\n",
+    "def display_videos(video_ids, W=400, H=300, fs=1):\n",
+    "  tab_contents = []\n",
+    "  for i, video_id in enumerate(video_ids):\n",
+    "    out = widgets.Output()\n",
+    "    with out:\n",
+    "      if video_ids[i][0] == 'Youtube':\n",
+    "        video = YouTubeVideo(id=video_ids[i][1], width=W,\n",
+    "                             height=H, fs=fs, rel=0)\n",
+    "        print(f'Video available at https://youtube.com/watch?v={video.id}')\n",
+    "      else:\n",
+    "        video = PlayVideo(id=video_ids[i][1], source=video_ids[i][0], width=W,\n",
+    "                          height=H, fs=fs, autoplay=False)\n",
+    "        if video_ids[i][0] == 'Bilibili':\n",
+    "          print(f'Video available at https://www.bilibili.com/video/{video.id}')\n",
+    "        elif video_ids[i][0] == 'Osf':\n",
+    "          print(f'Video available at https://osf.io/{video.id}')\n",
+    "      display(video)\n",
+    "    tab_contents.append(out)\n",
+    "  return tab_contents\n",
+    "\n",
+    "\n",
+    "video_ids = [('Youtube', '3YP-GYvYnuA'), ('Bilibili', 'BV1KL411W7bY')]\n",
+    "tab_contents = display_videos(video_ids, W=854, H=480)\n",
+    "tabs = widgets.Tab()\n",
+    "tabs.children = tab_contents\n",
+    "for i in range(len(tab_contents)):\n",
+    "  tabs.set_title(i, video_ids[i][0])\n",
+    "display(tabs)"
+   ]
+  }
+ ],
+ "metadata": {
+  "colab": {
+   "collapsed_sections": [],
+   "include_colab_link": true,
+   "name": "neurons_videos",
+   "provenance": [],
+   "toc_visible": true
+  },
+  "kernel": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
   },
-  "nbformat": 4,
-  "nbformat_minor": 0
-}
\ No newline at end of file
+  "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.9.23"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}