obi-notebook 0.1.dev9__tar.gz → 0.2.dev0__tar.gz

{obi_notebook-0.1.dev9 → obi_notebook-0.2.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: obi_notebook
-Version: 0.1.dev9
+Version: 0.2.dev0
 Summary: convenience functions for OBI notebooks
 Author-email: Open Brain Institute <jean-denis.courcol@epfl.ch>
 Maintainer-email: Open Brain Institute <jean-denis.courcol@epfl.ch>

obi_notebook-0.2.dev0/example.ipynb

@@ -0,0 +1,147 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7eb47475-67c6-499a-a2b4-19f8a64974d0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import obi_auth\n",
+    "\n",
+    "from obi_notebook import get_entities, get_projects"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4d984b92-cadd-4b07-9813-b2333272610f",
+   "metadata": {},
+   "source": [
+    "get authentication token for production"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "323cb45c-91e3-451f-8a80-374e61433d31",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "token = obi_auth.get_token(environment=\"production\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b60e8643-3ad5-4619-a052-5bd8b64713fd",
+   "metadata": {},
+   "source": [
+    "a widget to select project to use"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "77c47560-1163-4466-83fc-43abc6e0801a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "project_context = get_projects.get_projects(token)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d538dcac-1bdc-496b-8840-a7b32ea842ed",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "project_context"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "93029f77-d71f-40f4-8c4d-9f23d2b650bc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "circuit_ids = []\n",
+    "circuit_ids = get_entities.get_entities(\n",
+    "    \"circuit\",\n",
+    "    token,\n",
+    "    circuit_ids,\n",
+    "    return_entities=False,\n",
+    "    multi_select=True,\n",
+    "    show_pages=True,\n",
+    "    project_context=project_context,\n",
+    "    page_size=10,\n",
+    "    default_scale=\"small\",\n",
+    "    exclude_scales=[\"single\"],\n",
+    "    add_columns=[\"subject.name\"],\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "da699ed4-39fd-4602-b54d-58a0b58c2539",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "circuit_ids"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a5f5445d-a61a-4fbe-962f-51e701434771",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "morph_ids = []\n",
+    "morph_ids = get_entities.get_entities(\n",
+    "    \"reconstruction-morphology\",\n",
+    "    token,\n",
+    "    morph_ids,\n",
+    "    return_entities=False,\n",
+    "    multi_select=True,\n",
+    "    show_pages=True,\n",
+    "    project_context=project_context,\n",
+    "    page_size=100,\n",
+    "    add_columns=[\"mtypes\"],\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ab24b139",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "morph_ids"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".venv (3.13.1)",
+   "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.13.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

obi_notebook-0.2.dev0/src/obi_notebook/get_entities.py

@@ -0,0 +1,274 @@
+"""A table widget to select entities."""
+
+import ipywidgets as widgets
+import numpy as np
+import pandas as pd
+import requests
+from entitysdk import Client, models, types
+from ipydatagrid import DataGrid, TextRenderer
+from IPython.display import clear_output, display
+
+LST_MTYPES_ = None
+LST_SPECIES_ = None
+STR_NO_MTYPE = "NONE"
+
+
+def _estimate_column_widths(df, char_width=8, padding=2, max_size=250):
+    widths = {}
+    for col in df.columns:
+        max_len = max(df[col].astype(str).map(len).max(), len(col))
+        widths[col] = min(max_size, max_len * char_width + padding)
+    return widths
+
+
+def _resolve_list_to_first_element(obj):
+    if isinstance(obj, list):
+        if len(obj) > 0:
+            return obj[0]["pref_label"]
+        return STR_NO_MTYPE
+    return obj["pref_label"]
+
+
+_df_postprocess_funs = {"reconstruction-morphology": {"mtypes": _resolve_list_to_first_element}}
+
+
+def _list_of_existing_mtypes(entity_core_url, token):
+    global LST_MTYPES_
+    if LST_MTYPES_ is None:
+        response = requests.get(
+            f"{entity_core_url}/mtype",
+            headers={"authorization": f"Bearer {token}"},
+            params={"page_size": 1000},
+            timeout=30,
+        )
+        data = response.json()
+        df_mtype = pd.json_normalize(data["data"])
+        LST_MTYPES_ = list(df_mtype["pref_label"])
+    return LST_MTYPES_
+
+
+def _list_of_existing_species(entity_core_url, token):
+    global LST_SPECIES_
+    if LST_SPECIES_ is None:
+        response = requests.get(
+            f"{entity_core_url}/species",
+            headers={"authorization": f"Bearer {token}"},
+            params={"page_size": 1000},
+            timeout=30,
+        )
+        data = response.json()
+        df_species = pd.json_normalize(data["data"])
+        LST_SPECIES_ = list(df_species["name"])
+    return LST_SPECIES_
+
+
+def get_entities(
+    entity_type,
+    token,
+    result,
+    env="production",
+    project_context=None,
+    return_entities=False,
+    multi_select=True,
+    page_size=10,
+    show_pages=True,
+    add_columns=None,
+    default_scale=None,
+    exclude_scales=None,
+):
+    """Select entities of type entity_type and add them to result.
+
+    Note: The 'result' parameter is a mutable object (a list) that is modified in-place
+      and also returned.
+    """
+    if page_size is not None:
+        if page_size <= 0:
+            raise ValueError("ERROR: Page size must be larger than 0!")
+        # TODO: Could add an upper limit as well here
+
+    if add_columns is None:
+        add_columns = []
+    if exclude_scales is None:
+        exclude_scales = []
+
+    subdomain = "www" if env == "production" else "staging"
+    entity_core_url = f"https://{subdomain}.openbraininstitute.org/api/entitycore"
+
+    # Widgets
+    filters_dict = {}
+    if entity_type == "circuit":
+        scale_options = [
+            _scale.value for _scale in types.CircuitScale if _scale.value not in exclude_scales
+        ]
+        if default_scale is None or default_scale not in scale_options:
+            default_scale = scale_options[0]
+        scale_filter = widgets.Dropdown(
+            options=scale_options,
+            value=default_scale,
+            description="Scale:",
+        )
+        filters_dict["scale"] = scale_filter
+    elif entity_type == "reconstruction-morphology":
+        lst_mtypes = _list_of_existing_mtypes(entity_core_url, token) + [""]
+        mtype_filter = widgets.Combobox(
+            placeholder="Select M-Type",
+            description="M-Type:",
+            options=lst_mtypes,
+            ensure_option=True,
+        )
+        filters_dict["mtype__pref_label"] = mtype_filter
+        lst_species = _list_of_existing_species(entity_core_url, token) + [""]
+        species_filter = widgets.Dropdown(options=lst_species, value="", description="Species:")
+        filters_dict["species__name"] = species_filter
+
+    filters_dict["name__ilike"] = widgets.Text(description="Name:")
+
+    if show_pages:
+        filters_dict["page"] = widgets.Dropdown(
+            options=[1],
+            value=1,
+            description="Results page:",
+            disabled=False,
+            style={"description_width": "auto"},
+            layout=widgets.Layout(width="max-content"),
+        )
+
+    # Output area
+    output = widgets.Output()
+
+    # Fetch and display function
+    def fetch_data(filter_values):
+        if page_size is None:
+            params = {}
+        else:
+            params = {"page_size": page_size}
+        for k, v in filter_values.items():
+            if isinstance(v, str):
+                if len(v.strip()) == 0:
+                    continue
+            params[k] = v
+
+        headers = {"authorization": f"Bearer {token}"}
+        if project_context:
+            headers["virtual-lab-id"] = str(project_context.virtual_lab_id)
+            headers["project-id"] = str(project_context.project_id)
+        response = requests.get(
+            f"{entity_core_url}/{entity_type}",
+            headers=headers,
+            params=params,
+            timeout=30,
+        )
+
+        try:
+            data = response.json()
+            df = pd.json_normalize(data["data"])
+            pagination = data["pagination"]
+            return df, pagination
+        except Exception as e:
+            print("Error fetching or parsing data:", e)
+            return pd.DataFrame(), None
+
+    grid = None
+
+    # On change callback
+    def on_change(change=None):
+        nonlocal result
+        nonlocal grid
+        with output:
+            clear_output()
+            filter_values = {k: v.value for k, v in filters_dict.items()}
+            df, pagination = fetch_data(filter_values)
+
+            proper_columns = [
+                "id",
+                "name",
+                "description",
+                "brain_region.name",
+                "subject.species.name",
+                "species.name",  # For morphologies
+            ] + add_columns
+            if len(df) == 0:
+                if show_pages and filters_dict["page"].value != 1:
+                    filters_dict["page"].options = [1]  # Will update .value as well
+                else:
+                    print("no results")
+                return
+
+            proper_columns = [_col for _col in proper_columns if _col in df.columns]
+            df = df[proper_columns].reset_index(drop=True)
+
+            for colname, fun in _df_postprocess_funs.get(entity_type, {}).items():
+                if colname in df.columns:
+                    df[colname] = df[colname].apply(fun)
+
+            if show_pages:
+                num_pages = np.maximum(
+                    1, np.ceil(pagination["total_items"] / pagination["page_size"]).astype(int)
+                )
+                filters_dict["page"].options = range(1, num_pages + 1)
+                df.index = df.index + (pagination["page"] - 1) * pagination["page_size"]
+
+            column_widths = _estimate_column_widths(df)
+            grid = DataGrid(
+                df,
+                layout={"height": "300px"},
+                # auto_fit_columns=True,
+                auto_fit_params={"area": "all"},
+                selection_mode="row",  # Enable row selection
+                column_widths=column_widths,
+            )
+            grid.default_renderer = TextRenderer()
+            display(grid)
+
+            def on_selection_change(event, grid=grid):
+                with output:
+                    if not multi_select and len(grid.selections) > 0:
+                        if (event["new"][-1]["r1"] != event["new"][-1]["r2"]) or len(
+                            grid.selections
+                        ) > 1:  # Multiple rows selected
+                            if event["new"][-1]["r1"] == event["old"][-1]["r1"]:  # r1 unchanged
+                                new_r = event["new"][-1]["r1"]
+                            else:  # r2 unchanged
+                                new_r = event["new"][-1]["r2"]
+                            # Enforce selection of a single row (last one that was selected)
+                            grid.selections = [
+                                {
+                                    "r1": new_r,
+                                    "r2": new_r,
+                                    "c1": grid.selections[-1]["c1"],
+                                    "c2": grid.selections[-1]["c2"],
+                                }
+                            ]
+                    result.clear()
+                    l_ids = set()
+                    for selection in grid.selections:
+                        for row in range(selection["r1"], selection["r2"] + 1):
+                            l_ids.add(df.iloc[row]["id"])
+
+                    if return_entities:
+                        client = Client(
+                            api_url=entity_core_url,
+                            project_context=project_context,
+                            token_manager=token,
+                        )
+
+                        model_class = getattr(models, entity_type.capitalize())
+                        retrieved_entities = client.search_entity(
+                            entity_type=model_class, query={"id__in": list(l_ids)}
+                        )
+                        result.extend(retrieved_entities)
+                    else:
+                        result.extend(l_ids)
+
+            grid.observe(on_selection_change, names="selections")
+
+    for filter_ in filters_dict.values():
+        filter_.observe(on_change, names="value")
+
+    # Display
+    display(widgets.HBox(list(filters_dict.values())), output)
+
+    # Initial load
+    on_change()
+
+    return result

{obi_notebook-0.1.dev9 → obi_notebook-0.2.dev0}/src/obi_notebook.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: obi_notebook
-Version: 0.1.dev9
+Version: 0.2.dev0
 Summary: convenience functions for OBI notebooks
 Author-email: Open Brain Institute <jean-denis.courcol@epfl.ch>
 Maintainer-email: Open Brain Institute <jean-denis.courcol@epfl.ch>

obi_notebook-0.1.dev9/example.ipynb

@@ -1,182 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "7eb47475-67c6-499a-a2b4-19f8a64974d0",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import obi_auth\n",
-    "from obi_notebook import get_projects, get_entities"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "4d984b92-cadd-4b07-9813-b2333272610f",
-   "metadata": {},
-   "source": [
-    "get authentication token for production"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "323cb45c-91e3-451f-8a80-374e61433d31",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "token = obi_auth.get_token(environment=\"production\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "b60e8643-3ad5-4619-a052-5bd8b64713fd",
-   "metadata": {},
-   "source": [
-    "a widget to select project to use"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "77c47560-1163-4466-83fc-43abc6e0801a",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "cc2954a000034b5db323c3c5bb43a985",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Dropdown(description='Select:', options=(('Understanding connectivity', {'id': 'fe443f04-2d56-4c51-8347-8ca5f3…"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "project_context = get_projects.get_projects(token)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "d538dcac-1bdc-496b-8840-a7b32ea842ed",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "ProjectContext(project_id=UUID('fe443f04-2d56-4c51-8347-8ca5f3a97ee6'), virtual_lab_id=UUID('cee1a37f-fe43-4589-9197-c46746aff976'), environment=<DeploymentEnvironment.production: 'production'>)"
-      ]
-     },
-     "execution_count": 4,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "project_context"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "93029f77-d71f-40f4-8c4d-9f23d2b650bc",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "371c88af967a42a984fdf8fbf362660f",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "HBox(children=(Dropdown(description='Scale:', options=('single', 'pair', 'small', 'microcircuit', 'region', 's…"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "3d13a11549b84a3193044113977ba95b",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Output()"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "circuit_ids = []\n",
-    "circuit_ids = get_entities.get_entities(\"circuit\", token, circuit_ids,)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "da699ed4-39fd-4602-b54d-58a0b58c2539",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "['1be432a7-c7fa-422b-bb47-8b189ede363e',\n",
-       " 'bf3a620d-5a36-401b-97ac-d27cde014039',\n",
-       " 'b907f9a6-04e3-4a51-85f6-25ace2c816dc',\n",
-       " 'ba297b44-9340-4646-8684-01ce31ed33f5',\n",
-       " '8176966b-cce1-45ef-9642-e87c4436ee7d',\n",
-       " 'f5e228e7-1c2b-4fa9-89ae-97026c97f83e']"
-      ]
-     },
-     "execution_count": 9,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "circuit_ids"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "b6b9479f-60b8-4fa1-bd0d-8dbbda0909b8",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python (myenv)",
-   "language": "python",
-   "name": "obi-notebook"
-  },
-  "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.12.8"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

obi_notebook-0.1.dev9/src/obi_notebook/get_entities.py

@@ -1,142 +0,0 @@
-"""A table widget to select entities."""
-
-import ipywidgets as widgets
-import pandas as pd
-import requests
-from entitysdk import Client, models
-from ipydatagrid import DataGrid, TextRenderer
-from IPython.display import clear_output, display
-
-
-def _estimate_column_widths(df, char_width=8, padding=2, max_size=250):
-    widths = {}
-    for col in df.columns:
-        max_len = max(df[col].astype(str).map(len).max(), len(col))
-        widths[col] = min(max_size, max_len * char_width + padding)
-    return widths
-
-
-def get_entities(
-    entity_type, token, result, env="production", project_context=None, return_entities=False
-):
-    """Select entities of type entity_type and add them to result.
-
-    Note: The 'result' parameter is a mutable object (a list) that is modified in-place
-      and also returned.
-    """
-    # Widgets
-    filters_dict = {}
-    if entity_type == "circuit":
-        scale_filter = widgets.Dropdown(
-            options=["single", "pair", "small", "microcircuit", "region", "system", "whole"],
-            description="Scale:",
-        )
-        filters_dict["scale"] = scale_filter
-
-    filters_dict["name"] = widgets.Text(description="Name:")
-
-    # Output area
-    output = widgets.Output()
-
-    subdomain = "www" if env == "production" else "staging"
-    entity_core_url = f"https://{subdomain}.openbraininstitute.org/api/entitycore"
-
-    # Fetch and display function
-    def fetch_data(filter_values):
-        params = {"page_size": 10}
-        for k, v in filter_values.items():
-            if k == "name":
-                params["name__ilike"] = v
-            else:
-                params[k] = v
-
-        headers = {"authorization": f"Bearer {token}"}
-        if project_context:
-            headers["virtual-lab-id"] = project_context.virtual_lab_id
-            headers["project-id"] = project_context.project_id
-        response = requests.get(
-            f"{entity_core_url}/{entity_type}",
-            headers=headers,
-            params=params,
-            timeout=30,
-        )
-
-        try:
-            data = response.json()
-            df = pd.json_normalize(data["data"])
-            return df
-        except Exception as e:
-            print("Error fetching or parsing data:", e)
-            return pd.DataFrame()
-
-    grid = None
-
-    # On change callback
-    def on_change(change=None):
-        nonlocal result
-        nonlocal grid
-        with output:
-            clear_output()
-            filter_values = {k: v.value for k, v in filters_dict.items()}
-            df = fetch_data(filter_values)
-
-            proper_columns = [
-                "id",
-                "name",
-                "description",
-                "brain_region.name",
-                "subject.species.name",
-            ]
-            if len(df) == 0:
-                print("no results")
-                return
-
-            df = df[proper_columns].reset_index(drop=True)
-            column_widths = _estimate_column_widths(df)
-            grid = DataGrid(
-                df,
-                layout={"height": "300px"},
-                # auto_fit_columns=True,
-                auto_fit_params={"area": "all"},
-                selection_mode="row",  # Enable row selection
-                selection_behavior="multi",
-                column_widths=column_widths,
-            )
-            grid.default_renderer = TextRenderer()
-            display(grid)
-
-            def on_selection_change(event, grid=grid):
-                with output:
-                    result.clear()
-                    l_ids = set()
-                    for selection in grid.selections:
-                        for row in range(selection["r1"], selection["r2"] + 1):
-                            l_ids.add(df.iloc[row]["id"])
-
-                    if return_entities:
-                        client = Client(
-                            api_url=entity_core_url,
-                            project_context=project_context,
-                            token_manager=token,
-                        )
-
-                        model_class = getattr(models, entity_type.capitalize())
-                        retrieved_entities = client.search_entity(
-                            entity_type=model_class, query={"id__in": list(l_ids)}
-                        )
-                        result.extend(retrieved_entities)
-                    else:
-                        result.extend(l_ids)
-
-            grid.observe(on_selection_change, names="selections")
-
-    for filter_ in filters_dict.values():
-        filter_.observe(on_change, names="value")
-
-    # Display
-    display(widgets.HBox(list(filters_dict.values())), output)
-
-    # Initial load
-    on_change()
-
-    return result