bluecellulab 2.6.71__py3-none-any.whl → 2.6.73__py3-none-any.whl

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/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/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/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/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/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/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/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/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/reports/utils.py

@@ -17,50 +17,13 @@ from collections import defaultdict
 import logging
 from typing import Dict, Any, List
 
-from bluecellulab.tools import resolve_segments, resolve_source_nodes
+from bluecellulab.tools import (
+    resolve_source_nodes,
+)
 
 logger = logging.getLogger(__name__)
 
-
-def _configure_recording(cell, report_cfg, source, source_type, 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.
-
-    report_cfg : dict
-        The configuration dictionary for this report.
-
-    source : dict
-        The source definition specifying nodes or compartments.
-
-    source_type : str
-        Either "node_set" or "compartment_set".
-
-    report_name : str
-        The name of the report (used in logging).
-    """
-    variable = report_cfg.get("variable_name", "v")
-
-    node_id = cell.cell_id
-    compartment_nodes = source.get("compartment_set") if source_type == "compartment_set" else None
-
-    targets = resolve_segments(cell, report_cfg, node_id, compartment_nodes, source_type)
-    for sec, sec_name, seg in targets:
-        try:
-            cell.add_variable_recording(variable=variable, section=sec, segx=seg)
-        except AttributeError:
-            logger.warning(f"Recording for variable '{variable}' is not implemented in Cell.")
-            return
-        except Exception as e:
-            logger.warning(
-                f"Failed to record '{variable}' at {sec_name}({seg}) on GID {node_id} for report '{report_name}': {e}"
-            )
+SUPPORTED_REPORT_TYPES = {"compartment", "compartment_set"}
 
 
 def configure_all_reports(cells, simulation_config):
@@ -83,39 +46,132 @@ def configure_all_reports(cells, simulation_config):
 
     for report_name, report_cfg in report_entries.items():
         report_type = report_cfg.get("type", "compartment")
-        section = report_cfg.get("sections", "soma")
-
-        if report_type != "compartment":
-            raise NotImplementedError(f"Report type '{report_type}' is not supported.")
-
-        if section == "compartment_set":
-            source_type = "compartment_set"
+        if report_type == "compartment_set":
             source_sets = simulation_config.get_compartment_sets()
-            source_name = report_cfg.get("compartments")
+            source_name = report_cfg.get("compartment_set")
             if not source_name:
-                logger.warning(f"Report '{report_name}' does not specify a node set in 'compartments' for {source_type}.")
+                logger.warning(
+                    f"Report '{report_name}' does not specify a node set in 'compartment_set' for {report_type}."
+                )
                 continue
-        else:
-            source_type = "node_set"
+        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 {source_type}.")
+                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"{source_type.title()} '{source_name}' not found for report '{report_name}', skipping recording.")
+            logger.warning(
+                f"{report_type} '{source_name}' not found for report '{report_name}', skipping recording."
+            )
             continue
 
         population = source["population"]
-        node_ids, _ = resolve_source_nodes(source, source_type, cells, population)
-
-        for node_id in node_ids:
+        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:
+            if not cell or recording_sites is None:
                 continue
-            _configure_recording(cell, report_cfg, source, source_type, report_name)
+
+            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(
@@ -144,13 +200,28 @@ def extract_spikes_from_cells(
     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 (population, gid) tuple.")
+            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)
-        if times is not None and len(times) > 0:
-            spikes_by_pop[pop][gid] = list(times)
+        # Always assign, even if empty
+        spikes_by_pop[pop][gid] = list(times) if times is not None else []
 
     return dict(spikes_by_pop)

bluecellulab/reports/writers/compartment.py

@@ -16,10 +16,11 @@ from pathlib import Path
 import numpy as np
 import h5py
 from typing import Dict, List
+
 from .base_writer import BaseReportWriter
 from bluecellulab.reports.utils import (
+    build_recording_sites,
     resolve_source_nodes,
-    resolve_segments,
 )
 import logging
 
@@ -31,52 +32,67 @@ class CompartmentReportWriter(BaseReportWriter):
 
     def write(self, cells: Dict, tstart=0):
         report_name = self.cfg.get("name", "unnamed")
-        # section     = self.cfg.get("sections")
         variable = self.cfg.get("variable_name", "v")
+        report_type = self.cfg.get("type", "compartment")
 
+        # Resolve source set
         source_sets = self.cfg["_source_sets"]
-        source_type = self.cfg["_source_type"]
-        src_name = self.cfg.get("cells") if source_type == "node_set" else self.cfg.get("compartments")
+        if report_type == "compartment":
+            src_name = self.cfg.get("cells")
+        elif report_type == "compartment_set":
+            src_name = self.cfg.get("compartment_set")
+        else:
+            raise NotImplementedError(
+                f"Unsupported report type '{report_type}' in configuration for report '{report_name}'"
+            )
+
         src = source_sets.get(src_name)
         if not src:
-            logger.warning(f"{source_type.title()} '{src_name}' not found – skipping '{report_name}'.")
+            logger.warning(f"{report_type} '{src_name}' not found – skipping '{report_name}'.")
             return
 
         population = src["population"]
-        node_ids, comp_nodes = resolve_source_nodes(src, source_type, cells, population)
+        node_ids, comp_nodes = resolve_source_nodes(src, report_type, cells, population)
+        recording_sites_per_cell = build_recording_sites(
+            cells, node_ids, population, report_type, self.cfg, comp_nodes
+        )
+
+        # Detect trace mode
+        sample_cell = next(iter(cells.values()))
+        is_trace_mode = isinstance(sample_cell, dict)
 
         data_matrix: List[np.ndarray] = []
         node_id_list: List[int] = []
         idx_ptr: List[int] = [0]
         elem_ids: List[int] = []
 
-        for nid in node_ids:
+        for nid in sorted(recording_sites_per_cell):
+            recording_sites = recording_sites_per_cell[nid]
             cell = cells.get((population, nid)) or cells.get(f"{population}_{nid}")
             if cell is None:
+                logger.warning(f"Cell or trace for ({population}, {nid}) not found – skipping.")
                 continue
 
-            if isinstance(cell, dict):
-                # No section/segment structure to resolve for traces
-                trace = np.asarray(cell["voltage"], dtype=np.float32)
-                data_matrix.append(trace)
-                node_id_list.append(nid)
-                elem_ids.append(len(elem_ids))
-                idx_ptr.append(idx_ptr[-1] + 1)
-                continue
-
-            targets = resolve_segments(cell, self.cfg, nid, comp_nodes, source_type)
-            for sec, sec_name, seg in targets:
-                try:
-                    if hasattr(cell, "get_variable_recording"):
-                        trace = cell.get_variable_recording(variable=variable, section=sec, segx=seg)
-                    else:
-                        trace = np.asarray(cell["voltage"], dtype=np.float32)
-                    data_matrix.append(trace)
+            if is_trace_mode:
+                voltage = np.asarray(cell["voltage"], dtype=np.float32)
+                for sec, sec_name, seg in recording_sites:
+                    data_matrix.append(voltage)
                     node_id_list.append(nid)
                     elem_ids.append(len(elem_ids))
                     idx_ptr.append(idx_ptr[-1] + 1)
-                except Exception as e:
-                    logger.warning(f"Failed recording {nid}:{sec_name}@{seg}: {e}")
+            else:
+                for sec, sec_name, seg in recording_sites:
+                    try:
+                        if hasattr(cell, "get_variable_recording"):
+                            trace = cell.get_variable_recording(variable=variable, section=sec, segx=seg)
+                        else:
+                            trace = np.asarray(cell["voltage"], dtype=np.float32)
+                        data_matrix.append(trace)
+                        node_id_list.append(nid)
+                        elem_ids.append(len(elem_ids))
+                        idx_ptr.append(idx_ptr[-1] + 1)
+                    except Exception as e:
+                        logger.warning(f"Failed recording {nid}:{sec_name}@{seg}: {e}")
 
         if not data_matrix:
             logger.warning(f"No data for report '{report_name}'.")
@@ -148,7 +164,8 @@ class CompartmentReportWriter(BaseReportWriter):
         if dt_report < sim_dt:
             logger.warning(
                 f"Requested report dt={dt_report} ms is finer than simulation dt={sim_dt} ms. "
-                f"Clamping report dt to {sim_dt} ms."
+                f"Clamping report dt to {sim_dt} ms. "
+                f"To achieve finer temporal resolution, reduce the simulation dt in your config."
             )
             dt_report = sim_dt
 
@@ -161,7 +178,7 @@ class CompartmentReportWriter(BaseReportWriter):
         # Downsample the data if needed
         # Compute start and end indices in the original data
         start_index = int(round((start_time - tstart) / sim_dt))
-        end_index = int(round((end_time - tstart) / sim_dt)) + 1  # inclusive
+        end_index = int(round((end_time - tstart) / sim_dt))
 
         # Now slice and downsample
         data_matrix_downsampled = [

bluecellulab/reports/writers/spikes.py

@@ -25,37 +25,62 @@ class SpikeReportWriter(BaseReportWriter):
     """Writes SONATA spike report from pop→gid→times mapping."""
 
     def write(self, spikes_by_pop: Dict[str, Dict[int, list]]):
+        """Write SONATA spike report with per-population groups.
+
+        Creates empty datasets for populations without spikes.
+        """
+
+        # Remove any existing file
         if self.output_path.exists():
             self.output_path.unlink()
 
+        # Make sure parent directory exists
         self.output_path.parent.mkdir(parents=True, exist_ok=True)
 
-        for pop, gid_map in spikes_by_pop.items():
-            all_node_ids: List[int] = []
-            all_timestamps: List[float] = []
-            for node_id, times in gid_map.items():
-                all_node_ids.extend([node_id] * len(times))
-                all_timestamps.extend(times)
+        # Always create the file and /spikes group
+        with h5py.File(self.output_path, "w") as f:
+            spikes_group = f.create_group("spikes")
+
+            for pop, gid_map in spikes_by_pop.items():
+                all_node_ids: List[int] = []
+                all_timestamps: List[float] = []
+
+                for node_id, times in gid_map.items():
+                    all_node_ids.extend([node_id] * len(times))
+                    all_timestamps.extend(times)
 
-            if not all_timestamps:
-                logger.warning(f"No spikes to write for population '{pop}'.")
+                if not all_timestamps:
+                    logger.warning(f"No spikes to write for population '{pop}'.")
 
-            # Sort by time for consistency
-            sorted_indices = np.argsort(all_timestamps)
-            node_ids_sorted = np.array(all_node_ids, dtype=np.uint64)[sorted_indices]
-            timestamps_sorted = np.array(all_timestamps, dtype=np.float64)[sorted_indices]
+                # Sort by time for consistency (will be empty arrays if no spikes)
+                sorted_indices = np.argsort(all_timestamps)
+                node_ids_sorted = np.array(all_node_ids, dtype=np.uint64)[
+                    sorted_indices
+                ]
+                timestamps_sorted = np.array(all_timestamps, dtype=np.float64)[
+                    sorted_indices
+                ]
 
-            with h5py.File(self.output_path, 'a') as f:
-                spikes_group = f.require_group("spikes")
                 if pop in spikes_group:
-                    logger.warning(f"Overwriting existing group for population '{pop}' in {self.output_path}.")
+                    logger.warning(
+                        f"Overwriting existing group for population '{pop}' in {self.output_path}."
+                    )
                     del spikes_group[pop]
 
                 group = spikes_group.create_group(pop)
-                sorting_enum = h5py.enum_dtype({'none': 0, 'by_id': 1, 'by_time': 2}, basetype='u1')
-                group.attrs.create("sorting", 2, dtype=sorting_enum)  # 2 = by_time
-
-                timestamps_ds = group.create_dataset("timestamps", data=timestamps_sorted)
-                group.create_dataset("node_ids", data=node_ids_sorted)
 
+                # SONATA requires the 'sorting' attribute
+                sorting_enum = h5py.enum_dtype(
+                    {"none": 0, "by_id": 1, "by_time": 2}, basetype="u1"
+                )
+                if timestamps_sorted.size > 0:
+                    group.attrs.create("sorting", 2, dtype=sorting_enum)  # 2 = by_time
+                else:
+                    group.attrs.create("sorting", 0, dtype=sorting_enum)  # 0 = none
+
+                # Always create datasets (even empty)
+                timestamps_ds = group.create_dataset(
+                    "timestamps", data=timestamps_sorted
+                )
                 timestamps_ds.attrs["units"] = "ms"  # SONATA-required
+                group.create_dataset("node_ids", data=node_ids_sorted)

bluecellulab/tools.py

@@ -29,7 +29,6 @@ from bluecellulab.exceptions import UnsteadyCellError
 from bluecellulab.simulation.neuron_globals import set_neuron_globals
 from bluecellulab.simulation.parallel import IsolatedProcess
 from bluecellulab.utils import CaptureOutput
-from bluecellulab.type_aliases import NeuronSection
 
 
 logger = logging.getLogger(__name__)
@@ -119,7 +118,7 @@ def calculate_SS_voltage_subprocess(
         emodel_properties=emodel_properties,
     )
 
-    sec = get_section(cell, section)
+    sec = cell.get_section(section)
     neuron_section = sec
     cell.add_voltage_recording(cell.sections[section], segx)
     cell.add_ramp(500, 5000, step_level, step_level, section=neuron_section, segx=segx)
@@ -313,7 +312,7 @@ def detect_spike_step_subprocess(
         template_format=template_format,
         emodel_properties=emodel_properties)
 
-    sec = get_section(cell, section)
+    sec = cell.get_section(section)
     cell.add_voltage_recording(cell.sections[section], segx)
 
     neuron_section = sec
@@ -517,88 +516,19 @@ def validate_section_and_segment(cell: Cell, section_name: str, segment_position
         raise ValueError(f"Segment position must be between 0.0 and 1.0, got {segment_position}.")
 
 
-def get_section(cell: Cell, 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 cell.sections:
-        section = cell.sections[section_name]
-        if hasattr(section, "nseg"):
-            return section
-        raise TypeError(f"'{section_name}' exists but is not a NEURON section.")
-
-    available = ", ".join(cell.sections.keys())
-    raise ValueError(f"Section '{section_name}' not found. Available: [{available}]")
-
-
-def get_sections(cell, section_name: str):
-    """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 or TypeError if no valid sections are found.
-    """
-    # Try to interpret as fully qualified section name
-    try:
-        return [get_section(cell, 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 cell.sections.items()
-        if name.startswith(f"{section_name}[")
-    ]
-    if matched:
-        return matched
-
-    available = ", ".join(cell.sections.keys())
-    raise ValueError(f"Section '{section_name}' not found. Available: [{available}]")
-
-
-def resolve_segments(cell, report_cfg, node_id, compartment_nodes, source_type):
-    """Determine which segments to record from one or more NEURON sections."""
-    section_name = report_cfg.get("sections", "soma")
-    compartment = report_cfg.get("compartments", "center")
-
-    if source_type == "compartment_set":
-        return [
-            (get_section(cell, sec), sec, seg)
-            for _, sec, seg in compartment_nodes if _ == node_id
-        ]
-
-    sections = get_sections(cell, 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))
-        else:
-            raise ValueError(
-                f"Unsupported 'compartments' value '{compartment}' — must be 'center' or 'all'."
-            )
-
-    return targets
-
-
-def resolve_source_nodes(source, source_type, cells, population):
-    if source_type == "compartment_set":
+def resolve_source_nodes(source, report_type, cells, population):
+    if report_type == "compartment_set":
         compartment_nodes = source.get("compartment_set", [])
         node_ids = [entry[0] for entry in compartment_nodes]
-    else:  # node_set
+    elif report_type == "compartment":
         node_ids = source.get("node_id")
         if node_ids is None:
             node_ids = [node_id for (pop, node_id) in cells.keys() if pop == population]
         compartment_nodes = None
+    else:
+        raise NotImplementedError(
+            f"Unsupported source type '{report_type}' in configuration for report."
+        )
     return node_ids, compartment_nodes
 
 

bluecellulab/utils.py

@@ -53,7 +53,7 @@ class NumpyEncoder(json.JSONEncoder):
             ),
         ):
             return int(obj)
-        elif isinstance(obj, (np.float_, np.float16, np.float32, np.float64)):
+        elif isinstance(obj, (np.float64, np.float16, np.float32, np.float64)):
             return float(obj)
         elif isinstance(obj, np.ndarray):
             return obj.tolist()

{bluecellulab-2.6.71.dist-info → bluecellulab-2.6.73.dist-info}/METADATA

@@ -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.dist-info → bluecellulab-2.6.73.dist-info}/RECORD

@@ -1,18 +1,18 @@
 bluecellulab/__init__.py,sha256=1d_CKIJLIpon7o13h3lBnV_-33obZEPwa9KDTjlFPD8,880
-bluecellulab/circuit_simulation.py,sha256=CryoBSUGc9z6nIAyNzCsyppeSlc_URJX6hZoZPgQI2Q,36807
+bluecellulab/circuit_simulation.py,sha256=GGAkJq0Jk_ClB1XTyrf8g6Sirntj0E9IBeI76acJ2yU,36769
 bluecellulab/connection.py,sha256=-xT0mU7ppeHI_qjCKj17TtxXVVcUDgBsaMKt9ODmcEU,4640
 bluecellulab/dendrogram.py,sha256=FjS6RZ6xcp5zJoY5d5qv_edqPM13tL2-UANgbZuDBjY,6427
 bluecellulab/exceptions.py,sha256=1lKD92VIyD8cUggAI1SLxeKzj_09Ik_TlHCzPLCvDHg,2379
 bluecellulab/graph.py,sha256=o-9NnRrli0AqfGcw0-nhjaICH2IeqCH76uAlbZbo2dQ,3419
 bluecellulab/importer.py,sha256=ePxoquSRGGK123mR_VWDLKf9CE-N28NXAAY1DCm3T7Y,2900
 bluecellulab/neuron_interpreter.py,sha256=Nerehh6SNIRcTH8NHvyZvL_axadeix67uer-lRGuw9U,2185
-bluecellulab/plotwindow.py,sha256=ePU-EegZ1Sqk0SoYYiQ6k24ZO4s3Hgfpx10uePiJ5xM,2721
+bluecellulab/plotwindow.py,sha256=496tNvrd7xQ9SbSLRXF1VPIvWWqA2jl03-ZPMJ-wx_0,2756
 bluecellulab/psection.py,sha256=FSOwRNuOTyB469BM-jPEf9l1J59FamXmzrQgBI6cnP4,6174
 bluecellulab/psegment.py,sha256=PTgoGLqM4oFIdF_8QHFQCU59j-8TQmtq6PakiGUQhIo,3138
 bluecellulab/rngsettings.py,sha256=2Ykb4Ylk3XTs58x1UIxjg8XJqjSpnCgKRZ8avXCDpxk,4237
-bluecellulab/tools.py,sha256=ePal9-y6AnIgSdRzqqL8fH57M96VXUWPEGvJ7mpz4Ps,21926
+bluecellulab/tools.py,sha256=OamYjgBBBiUiXlf4zCDOjI-SuA6o9Ck8UsKsAi_8gEg,19483
 bluecellulab/type_aliases.py,sha256=DvgjERv2Ztdw_sW63JrZTQGpJ0x5uMTFB5hcBHDb0WA,441
-bluecellulab/utils.py,sha256=0NhwlzyLnSi8kziSfDsQf7pokO4qDkMJVAO33kSX4O0,2227
+bluecellulab/utils.py,sha256=tATZ814TtQO3fTsm5Q0KiANCDLFDZYtkfFQlI-Kxx_U,2228
 bluecellulab/verbosity.py,sha256=T0IgX7DrRo19faxrT4Xzb27gqxzoILQ8FzYKxvUeaPM,1342
 bluecellulab/analysis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bluecellulab/analysis/analysis.py,sha256=qZN2R7IKMOda8sVEDU61TkTDNUbaZjIWbwP3pM6Fcm8,24184
@@ -21,7 +21,7 @@ bluecellulab/analysis/plotting.py,sha256=PqRoaZz33ULMw8A9YnZXXrxcUd84M_dwlYMTFhG
 bluecellulab/analysis/utils.py,sha256=eMirP557D11BuedgSqjripDxOq1haIldNbnYNetV1bg,121
 bluecellulab/cell/__init__.py,sha256=Sbc0QOsJ8E7tSwf3q7fsXuE_SevBN6ZmoCVyyU5zfII,208
 bluecellulab/cell/cell_dict.py,sha256=VE7pi-NsMVRSmo-PSdbiLYmolDOu0Gc6JxFBkuQpFdk,1346
-bluecellulab/cell/core.py,sha256=xNyY3Ly4E7wb4LGIYcA2vT0EKsQYd1tNItcmxgKKK2o,38267
+bluecellulab/cell/core.py,sha256=ndfDwcYfINe-T9hniH-XL9TKPCa6c2sNa-HuCfDVKZE,44213
 bluecellulab/cell/injector.py,sha256=GB0pmyZMOHNV-lzd_t4cLoDE87S58IMbe7-qU1zBWvE,19033
 bluecellulab/cell/plotting.py,sha256=t2qDUabFtsBb-nJMkDh5UfsgW-wvQ2wfDwAVZ8-hWPo,4032
 bluecellulab/cell/random.py,sha256=pemekc11geRBKD8Ghb82tvKOZLfFWkUz1IKLc_NWg-A,1773
@@ -38,31 +38,31 @@ bluecellulab/cell/ballstick/morphology.asc,sha256=EO0VIRilJAwpiDP2hIevwusfvYptNY
 bluecellulab/circuit/__init__.py,sha256=Khpa13nzNvDlDS2JduyoFTukEduEkWCc5ML_JwGpmZs,361
 bluecellulab/circuit/format.py,sha256=90gWOXg6HK0R9a4WFSnnRH8XezxmzOGk5dRpJHbvbbU,1674
 bluecellulab/circuit/iotools.py,sha256=Q65xYDaiensMtrulC3OLsS2_hcWr_Kje0nXFrAizMMo,1589
-bluecellulab/circuit/node_id.py,sha256=FdoFAGq0_sCyQySOuNI0chdbVr3L8R0w2Y1em5MyIDA,1265
+bluecellulab/circuit/node_id.py,sha256=g_f_PvjaX59yXBTWRIpXibbgFny6xBWVErjVErahTTc,1259
 bluecellulab/circuit/simulation_access.py,sha256=8LX5nbKw_Hu7AR3pGLdTFGwehvhaj-r8Mh1q3dVoiVg,7745
 bluecellulab/circuit/synapse_properties.py,sha256=TvUMiXZAAeYo1zKkus3z1EUvrE9QCIQ3Ze-jSnPSJWY,6374
 bluecellulab/circuit/validate.py,sha256=wntnr7oIDyasqD1nM-kqz1NpfWDxBGhx0Ep3e5hHXIw,3593
 bluecellulab/circuit/circuit_access/__init__.py,sha256=sgp6m5kP-pq60V1IFGUiSUR1OW01zdxXNNUJmPA8anI,201
-bluecellulab/circuit/circuit_access/bluepy_circuit_access.py,sha256=m5PWSYrrkORb55HN1ZgJpQFLeSHxsNBtzyJ1n0zuVro,14295
+bluecellulab/circuit/circuit_access/bluepy_circuit_access.py,sha256=Ivj7RqIK0OYUuraTpQU1h_oeE2somBn_Tnji6XcjFt8,14383
 bluecellulab/circuit/circuit_access/definition.py,sha256=_sUU0DkesGOFW82kS1G9vki0o0aQP76z3Ltk7Vo9KK4,4435
-bluecellulab/circuit/circuit_access/sonata_circuit_access.py,sha256=tADHxVZw4VgZAz2z4NKMUwc0rd_EO40EZggw5fDhnF4,10411
+bluecellulab/circuit/circuit_access/sonata_circuit_access.py,sha256=OfqVS3z_t7dsnRuihF15fW-KuOCd7BXqRoFblpo2VL4,10441
 bluecellulab/circuit/config/__init__.py,sha256=aaoJXRKBJzpxxREo9NxKc-_CCPmVeuR1mcViRXcLrC4,215
-bluecellulab/circuit/config/bluepy_simulation_config.py,sha256=V3eqOzskX7VrMDpl-nMQVEhDg8QWgRmRduyJBii5sgI,6974
+bluecellulab/circuit/config/bluepy_simulation_config.py,sha256=3l0TqoQhsltvQnF-rKK_zFEu0-L6dAhW-Ch6z9C4wZw,7216
 bluecellulab/circuit/config/definition.py,sha256=cotKRDHOjzZKNgNSrZ29voU-66W8jaGt5yuge1hyv18,2953
 bluecellulab/circuit/config/sections.py,sha256=QRnU44-OFvHxcF1LX4bAEP9dk3I6UKsuPNBbWkdfmRE,7151
-bluecellulab/circuit/config/sonata_simulation_config.py,sha256=8b3OkjYG7MJnrm498Tx6x1B2MbvwDZO0aAAxy6iHuts,7983
+bluecellulab/circuit/config/sonata_simulation_config.py,sha256=M3dD9B69VK01lRaR84PiAj8th-x8hrAE80IpGDLqvi8,8056
 bluecellulab/hoc/Cell.hoc,sha256=z77qRQG_-afj-RLX0xN6V-K6Duq3bR7vmlDrGWPdh4E,16435
 bluecellulab/hoc/RNGSettings.hoc,sha256=okJBdqlPXET8BrpG1Q31GdaxHfpe3CE0L5P7MAhfQTE,1227
 bluecellulab/hoc/TDistFunc.hoc,sha256=WKX-anvL83xGuGPH9g1oIORB17UM4Pi3-iIXzKO-pUQ,2663
 bluecellulab/hoc/TStim.hoc,sha256=noBJbM_ZqF6T6MEgBeowNzz21I9QeYZ5brGgUvCSm4k,8473
 bluecellulab/hoc/fileUtils.hoc,sha256=LSM7BgyjYVqo2DGSOKvg4W8IIusbsL45JVYK0vgwitU,2539
 bluecellulab/reports/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bluecellulab/reports/manager.py,sha256=hy54B7AXa46bgjKJ_Ar65_GYIu9C8Zg2fgxIlxSweRE,3284
-bluecellulab/reports/utils.py,sha256=yZPtO0HXs6HPDVOZQbeXlPajnSOqE2Qmx8VufQFJFT0,5557
+bluecellulab/reports/manager.py,sha256=bKtqxOnZcta4HwrlWN51ysfMmvcbISksUpOKF0pJFV0,4021
+bluecellulab/reports/utils.py,sha256=wnYFo1xKbBRu1KZTIea83Wvakoo_SQ94QiqOD26cEe0,8271
 bluecellulab/reports/writers/__init__.py,sha256=Q8Y2GC83jseH5QY9IlEQsvaUQIH-BzgqhVjGRWD5j90,826
 bluecellulab/reports/writers/base_writer.py,sha256=P5ramFD2oFIroEBCH1pAscbkfcBIVYFIBg4pVpSP2IU,1042
-bluecellulab/reports/writers/compartment.py,sha256=EwFc2NwqhGEwGShEFOIrpYWRgH4b7qZCwsPvpUxeboU,7212
-bluecellulab/reports/writers/spikes.py,sha256=ycMuoT6f-UbAbC47X9gkG44OQYeAGBQMB2RdJAq3Ykg,2558
+bluecellulab/reports/writers/compartment.py,sha256=vtBRBNHm6NRnX09RZCszC9MKpiZqqVovlhwsfitzaRU,7960
+bluecellulab/reports/writers/spikes.py,sha256=FJm74SKeMb0h_oNucwWoNrh8xLObzinQTOHH0v1xKeU,3375
 bluecellulab/simulation/__init__.py,sha256=P2ebt0SFw-08J3ihN-LeRn95HeF79tzA-Q0ReLm32dM,214
 bluecellulab/simulation/neuron_globals.py,sha256=wvh6HfVYXoUsAcy17wqI_4SOqBCovRGEEaW9ANDgiIQ,4943
 bluecellulab/simulation/parallel.py,sha256=oQ_oV2EKr8gP4yF2Dq8q9MiblDyi89_wBgLzQkLV_U0,1514
@@ -76,9 +76,9 @@ bluecellulab/synapse/__init__.py,sha256=RW8XoAMXOvK7OG1nHl_q8jSEKLj9ZN4oWf2nY9HA
 bluecellulab/synapse/synapse_factory.py,sha256=NHwRMYMrnRVm_sHmyKTJ1bdoNmWZNU4UPOGu7FCi-PE,6987
 bluecellulab/synapse/synapse_types.py,sha256=zs_yBvGTH4QrbQF3nEViidyq1WM_ZcTSFdjUxB3khW0,16871
 bluecellulab/validation/validation.py,sha256=D35LE_131CtIzeeePAPz1OFzncGjAcvF02lSIvGvL2E,21331
-bluecellulab-2.6.71.dist-info/licenses/AUTHORS.txt,sha256=EDs3H-2HXBojbma10psixk3C2rFiOCTIREi2ZAbXYNQ,179
-bluecellulab-2.6.71.dist-info/licenses/LICENSE,sha256=dAMAR2Sud4Nead1wGFleKiwTZfkTNZbzmuGfcTKb3kg,11335
-bluecellulab-2.6.71.dist-info/METADATA,sha256=1dFG_vPcTlOZSX9CTbOdsa1uPxdc1OmlLrCdxTaDccA,8359
-bluecellulab-2.6.71.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-bluecellulab-2.6.71.dist-info/top_level.txt,sha256=VSyEP8w9l3pXdRkyP_goeMwiNA8KWwitfAqUkveJkdQ,13
-bluecellulab-2.6.71.dist-info/RECORD,,
+bluecellulab-2.6.73.dist-info/licenses/AUTHORS.txt,sha256=EDs3H-2HXBojbma10psixk3C2rFiOCTIREi2ZAbXYNQ,179
+bluecellulab-2.6.73.dist-info/licenses/LICENSE,sha256=dAMAR2Sud4Nead1wGFleKiwTZfkTNZbzmuGfcTKb3kg,11335
+bluecellulab-2.6.73.dist-info/METADATA,sha256=5caaaN9HbahBUG9GX5Q4jhWNe4NiREQHB2WqfPdj8Sc,8354
+bluecellulab-2.6.73.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+bluecellulab-2.6.73.dist-info/top_level.txt,sha256=VSyEP8w9l3pXdRkyP_goeMwiNA8KWwitfAqUkveJkdQ,13
+bluecellulab-2.6.73.dist-info/RECORD,,