bluecellulab 2.6.66__tar.gz → 2.6.67__tar.gz

{bluecellulab-2.6.66 → bluecellulab-2.6.67}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bluecellulab
-Version: 2.6.66
+Version: 2.6.67
 Summary: Biologically detailed neural network simulations and analysis.
 Author: Blue Brain Project, EPFL
 License: Apache2.0
@@ -28,6 +28,8 @@ Requires-Dist: typing-extensions>=4.8.0
 Requires-Dist: networkx>=3.1
 Requires-Dist: h5py>=3.8.0
 Requires-Dist: seaborn
+Provides-Extra: examples
+Requires-Dist: ipywidgets; extra == "examples"
 Dynamic: license-file
 
 |banner|

{bluecellulab-2.6.66 → bluecellulab-2.6.67}/bluecellulab/cell/core.py

@@ -316,6 +316,7 @@ class Cell(InjectableMixin, PlottableMixin):
         """Adds recording to AIS."""
         self.add_recording("self.axonal[1](0.5)._ref_v", dt=dt)
 
+    @deprecated("Use add_variable_recording('v', ...) instead.")
     def add_voltage_recording(
         self, section: Optional[NeuronSection] = None, segx: float = 0.5, dt: Optional[float] = None
     ) -> None:
@@ -334,6 +335,7 @@ class Cell(InjectableMixin, PlottableMixin):
         var_name = section_to_voltage_recording_str(section, segx)
         self.add_recording(var_name, dt)
 
+    @deprecated("Use get_variable_recording('v', ...) instead.")
     def get_voltage_recording(
         self, section: Optional[NeuronSection] = None, segx: float = 0.5
     ) -> np.ndarray:
@@ -760,17 +762,66 @@ class Cell(InjectableMixin, PlottableMixin):
         """Get a vector of AIS voltage."""
         return self.get_recording('self.axonal[1](0.5)._ref_v')
 
-    def add_variable_recording(self, variable: str, section, segx):
-        if variable == "v":
-            self.add_voltage_recording(section, segx)
-        else:
-            raise ValueError(f"Unsupported variable for recording: {variable}")
+    def add_variable_recording(
+        self,
+        variable: str,
+        section: Optional[NeuronSection] = None,
+        segx: float = 0.5,
+        dt: Optional[float] = None
+    ) -> None:
+        """Add a recording of any NEURON RANGE variable (e.g., gna, gk, ina)
+        from a given section and segment.
 
-    def get_variable_recording(self, variable: str, section, segx) -> np.ndarray:
-        if variable == "v":
-            return self.get_voltage_recording(section=section, segx=segx)
+        Args:
+            variable: The NEURON variable name to record (e.g., "gna").
+            section: The section to record from (defaults to soma).
+            segx: Segment position between 0 and 1.
+            dt: Optional recording time step.
+        """
+
+        if section is None:
+            section = self.soma
+
+        # Optional: validate before constructing the string
+        seg = section(segx)
+        if "." in variable:
+            mech, var = variable.split(".", 1)
+            mobj = getattr(seg, mech, None)
+            if mobj is None or not hasattr(mobj, f"_ref_{var}"):
+                raise ValueError(
+                    f"'{variable}' not recordable at {section.name()}({segx}). "
+                    f"Mechanisms here: {list(section.psection()['density_mechs'].keys())}"
+                )
         else:
-            raise ValueError(f"Unsupported variable '{variable}'")
+            if not hasattr(seg, f"_ref_{variable}"):
+                raise ValueError(
+                    f"'{variable}' not recordable at {section.name()}({segx}). "
+                    f"(Top-level vars are typically v/ina/ik/ica)"
+                )
+
+        var_name = section_to_variable_recording_str(section, segx, variable)
+        self.add_recording(var_name, dt)
+
+    def get_variable_recording(
+        self, variable: str, section: Optional[NeuronSection], segx: float
+    ) -> np.ndarray:
+        """Get a recording of any variable recorded from a section and segment.
+
+        Args:
+            variable: The name of the recorded variable (e.g., 'v', 'gna').
+            section: The NEURON section object.
+            segx: Segment location from 0 to 1.
+
+        Returns:
+            NumPy array of recorded values.
+
+        Raises:
+            ValueError: If the recording is not found.
+        """
+        if section is None:
+            section = self.soma
+        recording_name = section_to_variable_recording_str(section, segx, variable)
+        return self.get_recording(recording_name)
 
     @property
     def n_segments(self) -> int:
@@ -843,3 +894,24 @@ class Cell(InjectableMixin, PlottableMixin):
 
     def __del__(self):
         self.delete()
+
+
+def section_to_variable_recording_str(section, segx: float, variable: str) -> str:
+    """Build an evaluable NEURON pointer string for `add_recording`.
+
+    Accepts:
+      - top-level vars: "v", "ina", "ik", ...
+      - mechanism-scoped vars: "kca.gkca", "na3.m", "na3.h", ...
+
+    Returns examples:
+      neuron.h.soma[0](0.5)._ref_v
+      neuron.h.soma[0](0.5)._ref_ina
+      neuron.h.soma[0](0.5).kca._ref_gkca
+      neuron.h.dend[3](0.7).na3._ref_m
+    """
+    sec_name = section.name()
+    if "." in variable:
+        mech, var = variable.split(".", 1)
+        return f"neuron.h.{sec_name}({segx}).{mech}._ref_{var}"
+    else:
+        return f"neuron.h.{sec_name}({segx})._ref_{variable}"

{bluecellulab-2.6.66 → bluecellulab-2.6.67}/bluecellulab/tools.py

@@ -632,3 +632,108 @@ def compute_memodel_properties(
     )
 
     return {"holding_current": holding_current, "rheobase": rheobase, "rin": rin}
+
+
+def list_segment_ion_variables(cell, xs=(0.5,)):
+    """Enumerate top-level ionic variables (e.g. v, ina, ik, gna) available for
+    each section at specified segment locations.
+
+    Includes:
+      - Membrane potential (v)
+      - Standard ionic currents (ina, ik, ica, icl)
+      - Reversal potentials (ena, ek, eca, ecl)
+      - Conductances if exposed (gna, gk, gca, gcl)
+    """
+    out = {}
+    for sec in cell.sections.values():
+        xmap = {}
+        for x in xs:
+            seg = sec(x)
+
+            vars_ = []
+            # voltage always there
+            if hasattr(seg, "_ref_v"):
+                vars_.append("v")
+
+            # ionic currents (present if mechanisms with ions are inserted)
+            for ion in ("na", "k", "ca", "cl"):
+                if hasattr(seg, f"_ref_i{ion}"):
+                    vars_.append(f"i{ion}")
+                if hasattr(seg, f"_ref_e{ion}"):
+                    vars_.append(f"e{ion}")
+                if hasattr(seg, f"_ref_g{ion}"):
+                    vars_.append(f"g{ion}")
+
+            xmap[float(x)] = sorted(set(vars_))
+
+        out[sec.name()] = xmap
+    return out
+
+
+def list_segment_mechanism_variables(cell, xs=(0.5,), include_point_mechs=False):
+    """Enumerate mechanism-scoped recordables per section/segment.
+
+    Returns:
+        dict: A nested dictionary of the form::
+
+            {
+                "<secname>": {
+                    x: {
+                        "mech": {
+                            "<density_mech>": [<vars>],
+                            ...
+                        },
+                        "point": {
+                            "<point_mech>": [<vars>],
+                            ...
+                        }  # present only if include_point_mechs
+                    },
+                    ...
+                },
+                ...
+            }
+    """
+    out = {}
+    for sec in cell.sections.values():
+        dens = sec.psection().get("density_mechs", {}) or {}
+        points = sec.psection().get("point_mechs", {}) or {}
+        xmap = {}
+
+        for x in xs:
+            seg = sec(x)
+
+            # Density mechanisms
+            mech_map = {}
+            for mech, vardict in dens.items():
+                mobj = getattr(seg, mech, None)
+                if mobj is None:
+                    continue
+                # take var names advertised by psection(), keep those that are actually _ref_-exposed
+                vars_found = sorted(
+                    v for v in vardict.keys()
+                    if hasattr(mobj, f"_ref_{v}")
+                )
+                if vars_found:
+                    mech_map[mech] = vars_found
+
+            entry = {"mech": mech_map}
+
+            # Point processes
+            if include_point_mechs:
+                pp_map = {}
+                for pp, vardict in points.items():
+                    pobj = getattr(seg, pp, None)
+                    if pobj is None:
+                        continue
+                    vars_found = sorted(
+                        v for v in vardict.keys()
+                        if hasattr(pobj, f"_ref_{v}")
+                    )
+                    if vars_found:
+                        pp_map[pp] = vars_found
+                entry["point"] = pp_map
+
+            xmap[float(x)] = entry
+
+        out[sec.name()] = xmap
+    return out

{bluecellulab-2.6.66 → bluecellulab-2.6.67}/bluecellulab.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bluecellulab
-Version: 2.6.66
+Version: 2.6.67
 Summary: Biologically detailed neural network simulations and analysis.
 Author: Blue Brain Project, EPFL
 License: Apache2.0
@@ -28,6 +28,8 @@ Requires-Dist: typing-extensions>=4.8.0
 Requires-Dist: networkx>=3.1
 Requires-Dist: h5py>=3.8.0
 Requires-Dist: seaborn
+Provides-Extra: examples
+Requires-Dist: ipywidgets; extra == "examples"
 Dynamic: license-file
 
 |banner|

{bluecellulab-2.6.66 → bluecellulab-2.6.67}/bluecellulab.egg-info/requires.txt

@@ -8,3 +8,6 @@ typing-extensions>=4.8.0
 networkx>=3.1
 h5py>=3.8.0
 seaborn
+
+[examples]
+ipywidgets

{bluecellulab-2.6.66 → bluecellulab-2.6.67}/pyproject.toml

@@ -41,6 +41,11 @@ dependencies = [
 ]
 requires-python = ">=3.9"
 
+[project.optional-dependencies]
+examples = [
+    "ipywidgets",
+]
+
 [project.urls]
 Homepage = "https://github.com/openbraininstitute/BlueCelluLab"
 Documentation = "https://bluecellulab.readthedocs.io/"

{bluecellulab-2.6.66 → bluecellulab-2.6.67}/tox.ini

@@ -50,6 +50,7 @@ commands =
 
 [testenv:examples]
 envdir={toxworkdir}/{envname}
+extras = examples
 deps =
     pytest>=7.3.1,<9.0.0
     pytest-xdist>=3.3.1  # multiprocessing