bluecellulab 2.6.71__tar.gz → 2.6.73__tar.gz

{bluecellulab-2.6.71 → bluecellulab-2.6.73}/.github/workflows/test.yml

@@ -14,7 +14,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ["3.9", "3.10", "3.11", "3.12"]
+        python-version: ["3.9", "3.10", "3.11", "3.12", "3.13"]
 
     steps:
     - uses: actions/checkout@v4

{bluecellulab-2.6.71 → bluecellulab-2.6.73}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bluecellulab
-Version: 2.6.71
+Version: 2.6.73
 Summary: Biologically detailed neural network simulations and analysis.
 Author: Blue Brain Project, EPFL
 License: Apache2.0
@@ -19,7 +19,7 @@ Description-Content-Type: text/x-rst
 License-File: LICENSE
 License-File: AUTHORS.txt
 Requires-Dist: NEURON<9.0.0,>=8.0.2
-Requires-Dist: numpy<2.0.0,>=1.8.0
+Requires-Dist: numpy>=2.0.0
 Requires-Dist: matplotlib<4.0.0,>=3.0.0
 Requires-Dist: pandas<3.0.0,>=1.0.0
 Requires-Dist: bluepysnap<4.0.0,>=3.0.0
@@ -102,7 +102,7 @@ Main dependencies
 =================
 
 * `Python 3.9+ <https://www.python.org/downloads/release/python-390/>`_
-* `Neuron 8.0.2+ <https://pypi.org/project/NEURON/>`_
+* `NEURON <=8.2.7 <https://pypi.org/project/NEURON/>`__
 
 Installation
 ============

{bluecellulab-2.6.71 → bluecellulab-2.6.73}/README.rst

@@ -67,7 +67,7 @@ Main dependencies
 =================
 
 * `Python 3.9+ <https://www.python.org/downloads/release/python-390/>`_
-* `Neuron 8.0.2+ <https://pypi.org/project/NEURON/>`_
+* `NEURON <=8.2.7 <https://pypi.org/project/NEURON/>`__
 
 Installation
 ============

{bluecellulab-2.6.71 → bluecellulab-2.6.73}/bluecellulab/cell/core.py

@@ -19,7 +19,7 @@ import logging
 
 from pathlib import Path
 import queue
-from typing import Optional
+from typing import List, Optional, Tuple
 from typing_extensions import deprecated
 
 import neuron
@@ -793,13 +793,13 @@ class Cell(InjectableMixin, PlottableMixin):
             mech, var = variable.split(".", 1)
             mobj = getattr(seg, mech, None)
             if mobj is None or not hasattr(mobj, f"_ref_{var}"):
-                raise ValueError(
+                raise AttributeError(
                     f"'{variable}' not recordable at {section.name()}({segx}). "
                     f"Mechanisms here: {list(section.psection()['density_mechs'].keys())}"
                 )
         else:
             if not hasattr(seg, f"_ref_{variable}"):
-                raise ValueError(
+                raise AttributeError(
                     f"'{variable}' not recordable at {section.name()}({segx}). "
                     f"(Top-level vars are typically v/ina/ik/ica)"
                 )
@@ -911,6 +911,150 @@ class Cell(InjectableMixin, PlottableMixin):
     def __del__(self):
         self.delete()
 
+    def get_section(self, section_name: str) -> NeuronSection:
+        """Return a single, fully specified NEURON section (e.g., 'soma[0]',
+        'dend[3]').
+
+        Raises:
+            ValueError or TypeError if the section is not found or invalid.
+        """
+        if section_name in self.sections:
+            section = self.sections[section_name]
+            if hasattr(section, "nseg"):
+                return section
+            raise TypeError(f"'{section_name}' exists but is not a NEURON section.")
+
+        available = ", ".join(self.sections.keys())
+        raise ValueError(f"Section '{section_name}' not found. Available: [{available}]")
+
+    def get_sections(self, section_name: str) -> List[NeuronSection]:
+        """Return a list of NEURON sections.
+
+        If the section name is a fully specified one (e.g., 'dend[3]'), return it as a list of one.
+        If the section name is a base name (e.g., 'dend'), return all matching sections like 'dend[0]', 'dend[1]', etc.
+
+        Raises:
+            ValueError if no valid sections are found.
+        """
+        # Try to interpret as fully qualified section name
+        try:
+            return [self.get_section(section_name)]
+        except ValueError:
+            pass  # Not a precise match; try prefix match
+
+        # Fallback to prefix-based match (e.g., 'dend' → 'dend[0]', 'dend[1]', ...)
+        matched = [
+            section for name, section in self.sections.items()
+            if name.startswith(f"{section_name}[")
+        ]
+        if matched:
+            return matched
+
+        available = ", ".join(self.sections.keys())
+        raise ValueError(f"Section '{section_name}' not found. Available: [{available}]")
+
+    def get_section_by_id(self, section_id: int) -> NeuronSection:
+        """Return NEURON section by global section index (LibSONATA
+        ordering)."""
+        if not self.psections:
+            self._init_psections()
+
+        try:
+            return self.psections[int(section_id)].hsection
+        except KeyError:
+            raise IndexError(f"Section ID {section_id} is out of range for cell {self.cell_id.id}")
+
+    def resolve_segments_from_compartment_set(self, node_id, compartment_nodes) -> List[Tuple[NeuronSection, str, float]]:
+        """Resolve segments for a cell using a predefined compartment node
+        list.
+
+        Supports both LibSONATA format ([node_id, section_id, seg]) and
+        name-based format ([node_id, section_name, seg]).
+        """
+        result = []
+        for n_id, sec_ref, seg in compartment_nodes:
+            if n_id != node_id:
+                continue
+
+            if isinstance(sec_ref, str):
+                # Name-based: e.g., "dend[5]"
+                section = self.get_section(sec_ref)
+                sec_name = section.name().split(".")[-1]
+            elif isinstance(sec_ref, int):
+                # ID-based: resolve by section index
+                try:
+                    section = self.get_section_by_id(sec_ref)
+                    sec_name = section.name().split(".")[-1]
+                except AttributeError:
+                    raise ValueError(f"Cell object does not support section lookup by index: {sec_ref}")
+            else:
+                raise TypeError(f"Unsupported section reference type: {type(sec_ref)}")
+
+            result.append((section, sec_name, seg))
+        return result
+
+    def resolve_segments_from_config(self, report_cfg) -> List[Tuple[NeuronSection, str, float]]:
+        """Resolve segments from NEURON sections based on config."""
+        compartment = report_cfg.get("compartments", "center")
+        if compartment not in {"center", "all"}:
+            raise ValueError(
+                f"Unsupported 'compartments' value '{compartment}' — must be 'center' or 'all'."
+            )
+
+        section_name = report_cfg.get("sections", "soma")
+        sections = self.get_sections(section_name)
+
+        targets = []
+        for sec in sections:
+            sec_name = sec.name().split(".")[-1]
+            if compartment == "center":
+                targets.append((sec, sec_name, 0.5))
+            elif compartment == "all":
+                for seg in sec:
+                    targets.append((sec, sec_name, seg.x))
+        return targets
+
+    def configure_recording(self, recording_sites, variable_name, report_name):
+        """Configure recording of a variable on a single cell.
+
+        This function sets up the recording of the specified variable (e.g., membrane voltage)
+        in the target cell, for each resolved segment.
+
+        Parameters
+        ----------
+        cell : Any
+            The cell object on which to configure recordings.
+
+        recording_sites : list of tuples
+            List of tuples (section, section_name, segment) where:
+            - section is the section object in the cell.
+            - section_name is the name of the section.
+            - segment is the Neuron segment index (0-1).
+
+        variable_name : str
+            The name of the variable to record (e.g., "v" for membrane voltage).
+
+        report_name : str
+            The name of the report (used in logging).
+        """
+        node_id = self.cell_id.id
+
+        for sec, sec_name, seg in recording_sites:
+            try:
+                self.add_variable_recording(variable=variable_name, section=sec, segx=seg)
+                logger.info(
+                    f"Recording '{variable_name}' at {sec_name}({seg}) on GID {node_id} for report '{report_name}'"
+                )
+            except AttributeError:
+                logger.warning(
+                    f"Recording for variable '{variable_name}' is not implemented in Cell."
+                )
+                return
+            except Exception as e:
+                logger.warning(
+                    f"Failed to record '{variable_name}' at {sec_name}({seg}) on GID {node_id} for report '{report_name}': {e}"
+                )
+
     def add_currents_recordings(
         self,
         section,

{bluecellulab-2.6.71 → bluecellulab-2.6.73}/bluecellulab/circuit/circuit_access/bluepy_circuit_access.py

@@ -19,6 +19,7 @@ import os
 from pathlib import Path
 from typing import Optional
 
+from bluecellulab.circuit.circuit_access.definition import CircuitAccess
 import neuron
 import pandas as pd
 from bluecellulab import circuit
@@ -42,7 +43,7 @@ if BLUEPY_AVAILABLE:
 logger = logging.getLogger(__name__)
 
 
-class BluepyCircuitAccess:
+class BluepyCircuitAccess(CircuitAccess):
     """Bluepy implementation of CircuitAccess protocol."""
 
     def __init__(self, simulation_config: str | Path | SimulationConfig) -> None:

{bluecellulab-2.6.71 → bluecellulab-2.6.73}/bluecellulab/circuit/circuit_access/sonata_circuit_access.py

@@ -25,7 +25,7 @@ from bluepysnap import Circuit as SnapCircuit
 import neuron
 import pandas as pd
 from bluecellulab import circuit
-from bluecellulab.circuit.circuit_access.definition import EmodelProperties
+from bluecellulab.circuit.circuit_access.definition import CircuitAccess, EmodelProperties
 from bluecellulab.circuit import CellId, SynapseProperty
 from bluecellulab.circuit.config import SimulationConfig
 from bluecellulab.circuit.synapse_properties import SynapseProperties
@@ -38,7 +38,7 @@ from bluecellulab.circuit.synapse_properties import (
 logger = logging.getLogger(__name__)
 
 
-class SonataCircuitAccess:
+class SonataCircuitAccess(CircuitAccess):
     """Sonata implementation of CircuitAccess protocol."""
 
     def __init__(self, simulation_config: str | Path | SimulationConfig) -> None:

{bluecellulab-2.6.71 → bluecellulab-2.6.73}/bluecellulab/circuit/config/bluepy_simulation_config.py

@@ -188,6 +188,16 @@ class BluepySimulationConfig:
         else:
             return None
 
+    @property
+    def tstart(self) -> Optional[float]:
+        return 0.0
+
+    @property
+    def tstop(self) -> Optional[float]:
+        if 'Duration' in self.impl.Run:
+            return float(self.impl.Run['Duration'])
+        return None
+
     def add_connection_override(
         self,
         connection_override: ConnectionOverrides

{bluecellulab-2.6.71 → bluecellulab-2.6.73}/bluecellulab/circuit/config/sonata_simulation_config.py

@@ -130,6 +130,8 @@ class SonataSimulationConfig:
         """Resolve the full path for the report output file."""
         output_dir = Path(self.output_root_path)
         file_name = report_cfg.get("file_name", f"{report_key}.h5")
+        if not file_name.endswith(".h5"):
+            file_name += ".h5"
         return output_dir / file_name
 
     @property

{bluecellulab-2.6.71 → bluecellulab-2.6.73}/bluecellulab/circuit/node_id.py

@@ -31,6 +31,6 @@ def create_cell_id(cell_id: int | tuple[str, int] | CellId) -> CellId:
         return CellId("", cell_id)
 
 
-def create_cell_ids(cell_ids: list[int] | list[tuple[str, int] | CellId]) -> list[CellId]:
+def create_cell_ids(cell_ids: list[int | tuple[str, int] | CellId]) -> list[CellId]:
     """Make a list of CellId from a list of tuple or int."""
     return [create_cell_id(cell_id) for cell_id in cell_ids]

{bluecellulab-2.6.71 → bluecellulab-2.6.73}/bluecellulab/circuit_simulation.py

@@ -125,7 +125,7 @@ class CircuitSimulation:
 
     def instantiate_gids(
         self,
-        cells: int | tuple[str, int] | list[int] | list[tuple[str, int]],
+        cells: int | tuple[str, int] | list[int | tuple[str, int]],
         add_replay: bool = False,
         add_stimuli: bool = False,
         add_synapses: bool = False,
@@ -223,7 +223,7 @@ class CircuitSimulation:
                                 will automatically set this option to
                                 True.
         """
-        if not isinstance(cells, Iterable) or isinstance(cells, tuple):
+        if not isinstance(cells, list):
             cells = [cells]
 
         # convert to CellId objects

{bluecellulab-2.6.71 → bluecellulab-2.6.73}/bluecellulab/plotwindow.py

@@ -42,7 +42,7 @@ class PlotWindow:
         linenumber = 0
         for var_name in self.var_list:
             recording = self.cell.get_recording(var_name)
-            if recording:
+            if recording is not None and recording.size > 0:
                 time = self.cell.get_time()
             else:
                 time = self.cell.get_time()[1:]

{bluecellulab-2.6.71 → bluecellulab-2.6.73}/bluecellulab/reports/manager.py

@@ -14,7 +14,11 @@
 
 from typing import Optional, Dict
 from bluecellulab.reports.writers import get_writer
-from bluecellulab.reports.utils import extract_spikes_from_cells  # helper you already have / write
+from bluecellulab.reports.utils import SUPPORTED_REPORT_TYPES, extract_spikes_from_cells  # helper you already have / write
+
+import logging
+
+logger = logging.getLogger(__name__)
 
 
 class ReportManager:
@@ -52,21 +56,30 @@ class ReportManager:
 
     def _write_voltage_reports(self, cells_or_traces):
         for name, rcfg in self.cfg.get_report_entries().items():
-            if rcfg.get("type") != "compartment":
+            if rcfg.get("type") not in SUPPORTED_REPORT_TYPES:
                 continue
 
-            section = rcfg.get("sections")
-            if section == "compartment_set":
+            report_type = rcfg.get("type")
+            if report_type == "compartment_set":
                 if rcfg.get("cells") is not None:
-                    raise ValueError("'cells' may not be set with 'compartment_set'")
-                src_sets, src_type = self.cfg.get_compartment_sets(), "compartment_set"
-            else:
-                if rcfg.get("compartments") not in ("center", "all"):
+                    raise ValueError("'cells' may not be set when using 'compartment_set' report type.")
+                if rcfg.get("sections") is not None:
+                    raise ValueError("'sections' may not be set when using 'compartment_set' report type.")
+                if rcfg.get("compartments") is not None:
+                    raise ValueError("'compartments' may not be set when using 'compartment_set' report type.")
+                src_sets = self.cfg.get_compartment_sets()
+            elif report_type == "compartment":
+                compartments = rcfg.get("compartments") or "center"
+                if compartments not in ("center", "all"):
                     raise ValueError("invalid 'compartments' value")
-                src_sets, src_type = self.cfg.get_node_sets(), "node_set"
+                if rcfg.get("cells") is None:
+                    raise ValueError("'cells' must be specified when using compartment reports")
+                src_sets = self.cfg.get_node_sets()
+            else:
+                logger.error(f"Unsupported report type '{report_type}' in configuration for report '{name}'")
 
             rcfg["_source_sets"] = src_sets
-            rcfg["_source_type"] = src_type
+            rcfg["name"] = name
 
             out_path = self.cfg.report_file_path(rcfg, name)
             writer = get_writer("compartment")(rcfg, out_path, self.dt)

bluecellulab-2.6.73/bluecellulab/reports/utils.py

@@ -0,0 +1,227 @@
+# Copyright 2025 Open Brain Institute
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Report class of bluecellulab."""
+
+from collections import defaultdict
+import logging
+from typing import Dict, Any, List
+
+from bluecellulab.tools import (
+    resolve_source_nodes,
+)
+
+logger = logging.getLogger(__name__)
+
+SUPPORTED_REPORT_TYPES = {"compartment", "compartment_set"}
+
+
+def configure_all_reports(cells, simulation_config):
+    """Configure recordings for all reports defined in the simulation
+    configuration.
+
+    This iterates through all report entries, resolves source nodes or compartments,
+    and configures the corresponding recordings on each cell.
+
+    Parameters
+    ----------
+    cells : dict
+        Mapping from (population, gid) → Cell object.
+
+    simulation_config : Any
+        Simulation configuration object providing report entries,
+        node sets, and compartment sets.
+    """
+    report_entries = simulation_config.get_report_entries()
+
+    for report_name, report_cfg in report_entries.items():
+        report_type = report_cfg.get("type", "compartment")
+        if report_type == "compartment_set":
+            source_sets = simulation_config.get_compartment_sets()
+            source_name = report_cfg.get("compartment_set")
+            if not source_name:
+                logger.warning(
+                    f"Report '{report_name}' does not specify a node set in 'compartment_set' for {report_type}."
+                )
+                continue
+        elif report_type == "compartment":
+            source_sets = simulation_config.get_node_sets()
+            source_name = report_cfg.get("cells")
+            if not source_name:
+                logger.warning(
+                    f"Report '{report_name}' does not specify a node set in 'cells' for {report_type}."
+                )
+                continue
+        else:
+            raise NotImplementedError(
+                f"Report type '{report_type}' is not supported. "
+                f"Supported types: {SUPPORTED_REPORT_TYPES}"
+            )
+
+        source = source_sets.get(source_name)
+        if not source:
+            logger.warning(
+                f"{report_type} '{source_name}' not found for report '{report_name}', skipping recording."
+            )
+            continue
+
+        population = source["population"]
+        node_ids, compartment_nodes = resolve_source_nodes(
+            source, report_type, cells, population
+        )
+        recording_sites_per_cell = build_recording_sites(
+            cells, node_ids, population, report_type, report_cfg, compartment_nodes
+        )
+        variable_name = report_cfg.get("variable_name", "v")
+
+        for node_id, recording_sites in recording_sites_per_cell.items():
+            cell = cells.get((population, node_id))
+            if not cell or recording_sites is None:
+                continue
+
+            cell.configure_recording(recording_sites, variable_name, report_name)
+
+
+def build_recording_sites(
+    cells_or_traces, node_ids, population, report_type, report_cfg, compartment_nodes
+):
+    """Build per-cell recording sites based on source type and report
+    configuration.
+
+    This function resolves the segments (section, name, seg.x) where variables
+    should be recorded for each cell, based on either a node set (standard
+    compartment reports) or a compartment set (predefined segment list).
+
+    Parameters
+    ----------
+    cells_or_traces : dict
+        Either a mapping from (population, node_id) to Cell objects (live sim),
+        or from gid_key strings to trace dicts (gathered traces on rank 0).
+
+    node_ids : list of int
+        List of node IDs for which recordings should be configured.
+
+    population : str
+        Name of the population to which the cells belong.
+
+    report_type : str
+        The report type, either 'compartment_set' or 'compartment'.
+
+    report_cfg : dict
+        Configuration dictionary specifying report parameters
+
+    compartment_nodes : list or None
+        Optional list of [node_id, section_name, seg_x] defining segment locations
+        for each cell (used if report_type == 'compartment_set').
+
+    Returns
+    -------
+    dict
+        Mapping from node ID to list of recording site tuples:
+        (section_object, section_name, seg_x).
+    """
+    targets_per_cell = {}
+
+    for node_id in node_ids:
+        # Handle both (pop, id) and "pop_id" keys
+        key = (population, node_id)
+        cell_or_trace = cells_or_traces.get(key) or cells_or_traces.get(f"{population}_{node_id}")
+        if not cell_or_trace:
+            continue
+
+        if isinstance(cell_or_trace, dict):  # Trace dict, not Cell
+            if report_type == "compartment_set":
+                # Find all entries matching node_id
+                targets = [
+                    (None, section_name, segx)
+                    for nid, section_name, segx in compartment_nodes
+                    if nid == node_id
+                ]
+            elif report_type == "compartment":
+                section_name = report_cfg.get("sections", "soma")
+                segx = 0.5 if report_cfg.get("compartments", "center") == "center" else 0.0
+                targets = [(None, f"{section_name}[0]", segx)]
+            else:
+                raise NotImplementedError(
+                    f"Unsupported report type '{report_type}' in trace-based output."
+                )
+        else:
+            # Cell object
+            if report_type == "compartment_set":
+                targets = cell_or_trace.resolve_segments_from_compartment_set(
+                    node_id, compartment_nodes
+                )
+            elif report_type == "compartment":
+                targets = cell_or_trace.resolve_segments_from_config(report_cfg)
+            else:
+                raise NotImplementedError(
+                    f"Report type '{report_type}' is not supported. "
+                    f"Supported types: {SUPPORTED_REPORT_TYPES}"
+                )
+
+        targets_per_cell[node_id] = targets
+
+    return targets_per_cell
+
+
+def extract_spikes_from_cells(
+    cells: Dict[Any, Any],
+    location: str = "soma",
+    threshold: float = -20.0,
+) -> Dict[str, Dict[int, list]]:
+    """Extract spike times from recorded cells, grouped by population.
+
+    Parameters
+    ----------
+    cells : dict
+        Mapping from (population, gid) → Cell object, or similar.
+
+    location : str
+        Recording location passed to Cell.get_recorded_spikes().
+
+    threshold : float
+        Voltage threshold (mV) used for spike detection.
+
+    Returns
+    -------
+    spikes_by_population : dict
+        {population → {gid_int → [spike_times_ms]}}
+    """
+    spikes_by_pop: defaultdict[str, Dict[int, List[float]]] = defaultdict(dict)
+
+    for key, cell in cells.items():
+        # Resolve the key to (population, gid)
+        if isinstance(key, tuple):
+            pop, gid = key
+        elif isinstance(key, str):
+            try:
+                pop, gid_str = key.rsplit("_", 1)
+                gid = int(gid_str)
+            except Exception:
+                raise ValueError(
+                    f"Cell key '{key}' could not be parsed as 'population_gid'"
+                )
+        else:
+            raise ValueError(f"Cell key '{key}' is not a recognized format.")
+
+        if not hasattr(cell, "get_recorded_spikes"):
+            raise TypeError(
+                f"Cannot extract spikes: cell entry {key} is not a Cell object (got {type(cell)}). "
+                "If you have precomputed traces, pass them as `spikes_by_pop`."
+            )
+
+        times = cell.get_recorded_spikes(location=location, threshold=threshold)
+        # Always assign, even if empty
+        spikes_by_pop[pop][gid] = list(times) if times is not None else []
+
+    return dict(spikes_by_pop)