bluecellulab 2.6.50__py3-none-any.whl → 2.6.52__py3-none-any.whl

bluecellulab/analysis/analysis.py

@@ -4,14 +4,17 @@ try:
 except ImportError:
     efel = None
 from itertools import islice
+from itertools import repeat
 import logging
 from matplotlib.collections import LineCollection
 import matplotlib.pyplot as plt
+from multiprocessing import Pool
 import neuron
 import numpy as np
 import pathlib
 import seaborn as sns
 
+
 from bluecellulab import Cell
 from bluecellulab.analysis.inject_sequence import run_stimulus
 from bluecellulab.analysis.plotting import plot_iv_curve, plot_fi_curve
@@ -87,30 +90,35 @@ def compute_plot_iv_curve(cell,
 
     list_amp = np.linspace(rheobase - 2, rheobase - 0.1, nb_bins)  # [nA]
 
-    steps = []
-    times = []
-    voltages = []
     # inject step current and record voltage response
     stim_factory = StimulusFactory(dt=0.1)
-    for amp in list_amp:
-        step_stimulus = stim_factory.step(pre_delay=stim_start, duration=duration, post_delay=post_delay, amplitude=amp)
-        recording = run_stimulus(cell.template_params,
-                                 step_stimulus,
-                                 section=injecting_section,
-                                 segment=injecting_segment,
-                                 recording_section=recording_section,
-                                 recording_segment=recording_segment)
-        steps.append(step_stimulus)
-        times.append(recording.time)
-        voltages.append(recording.voltage)
+    steps = [
+        stim_factory.step(pre_delay=stim_start, duration=duration, post_delay=post_delay, amplitude=amp)
+        for amp in list_amp
+    ]
+
+    with Pool(len(steps)) as p:
+        recordings = p.starmap(
+            run_stimulus,
+            zip(
+                repeat(cell.template_params),
+                steps,
+                repeat(injecting_section),
+                repeat(injecting_segment),
+                repeat(True),  # cvode
+                repeat(True),  # add_hypamp
+                repeat(recording_section),
+                repeat(recording_segment),
+            )
+        )
 
     steady_states = []
     # compute steady state response
     efel.set_setting('Threshold', threshold_voltage)
-    for voltage, t in zip(voltages, times):
+    for recording in recordings:
         trace = {
-            'T': t,
-            'V': voltage,
+            'T': recording.time,
+            'V': recording.voltage,
             'stim_start': [stim_start],
             'stim_end': [stim_start + duration]
         }
@@ -194,24 +202,30 @@ def compute_plot_fi_curve(cell,
         rheobase = calculate_rheobase(cell=cell, section=injecting_section, segx=injecting_segment)
 
     list_amp = np.linspace(rheobase, max_current, nb_bins)  # [nA]
-    steps = []
-    spikes = []
-    # inject step current and record spike response
     stim_factory = StimulusFactory(dt=0.1)
-    for amp in list_amp:
-        step_stimulus = stim_factory.step(pre_delay=stim_start, duration=duration, post_delay=post_delay, amplitude=amp)
-        recording = run_stimulus(cell.template_params,
-                                 step_stimulus,
-                                 section=injecting_section,
-                                 segment=injecting_segment,
-                                 recording_section=recording_section,
-                                 recording_segment=recording_segment,
-                                 enable_spike_detection=True,
-                                 threshold_spike_detection=threshold_voltage)
-        steps.append(step_stimulus)
-        spikes.append(recording.spike)
-
-    spike_count = [len(spike) for spike in spikes]
+    steps = [
+        stim_factory.step(pre_delay=stim_start, duration=duration, post_delay=post_delay, amplitude=amp)
+        for amp in list_amp
+    ]
+
+    with Pool(len(steps)) as p:
+        recordings = p.starmap(
+            run_stimulus,
+            zip(
+                repeat(cell.template_params),
+                steps,
+                repeat(injecting_section),
+                repeat(injecting_segment),
+                repeat(True),  # cvode
+                repeat(True),  # add_hypamp
+                repeat(recording_section),
+                repeat(recording_segment),
+                repeat(True),  # enable_spike_detection
+                repeat(threshold_voltage),  # threshold_spike_detection
+            )
+        )
+
+    spike_count = [len(recording.spike) for recording in recordings]
 
     plot_fi_curve(list_amp,
                   spike_count,

bluecellulab/cell/core.py

@@ -525,6 +525,10 @@ class Cell(InjectableMixin, PlottableMixin):
         nc.record(spike_vec)
         self.recordings[f"spike_detector_{location}_{threshold}"] = spike_vec
 
+    def is_recording_spikes(self, location: str, threshold: float) -> bool:
+        key = f"spike_detector_{location}_{threshold}"
+        return key in self.recordings
+
     def get_recorded_spikes(self, location: str, threshold: float = -30) -> list[float]:
         """Get recorded spikes in the current cell.
 
@@ -756,6 +760,18 @@ 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 get_variable_recording(self, variable: str, section, segx) -> np.ndarray:
+        if variable == "v":
+            return self.get_voltage_recording(section=section, segx=segx)
+        else:
+            raise ValueError(f"Unsupported variable '{variable}'")
+
     @property
     def n_segments(self) -> int:
         """Get the number of segments in the cell."""

bluecellulab/circuit/config/sonata_simulation_config.py

@@ -13,6 +13,8 @@
 # limitations under the License.
 from __future__ import annotations
 from functools import lru_cache
+import json
+import logging
 from pathlib import Path
 from typing import Optional
 
@@ -21,6 +23,8 @@ from bluecellulab.stimulus.circuit_stimulus_definitions import Stimulus
 
 from bluepysnap import Simulation as SnapSimulation
 
+logger = logging.getLogger(__name__)
+
 
 class SonataSimulationConfig:
     """Sonata implementation of SimulationConfig protocol."""
@@ -74,9 +78,42 @@ class SonataSimulationConfig:
             result.append(ConnectionOverrides.from_sonata(conn_entry))
         return result
 
+    @lru_cache(maxsize=1)
+    def get_compartment_sets(self) -> dict[str, dict]:
+        filepath = self.impl.config.get("compartment_sets_file")
+        if not filepath:
+            raise ValueError("No 'compartment_sets_file' entry found in SONATA config.")
+        with open(filepath, 'r') as f:
+            return json.load(f)
+
+    @lru_cache(maxsize=1)
+    def get_node_sets(self) -> dict[str, dict]:
+        filepath = self.impl.circuit.config.get("node_sets_file")
+        if not filepath:
+            raise ValueError("No 'node_sets_file' entry found in SONATA config.")
+        with open(filepath, 'r') as f:
+            return json.load(f)
+
+    @lru_cache(maxsize=1)
+    def get_report_entries(self) -> dict[str, dict]:
+        """Returns the 'reports' dictionary from the SONATA simulation config.
+
+        Each key is a report name, and the value is its configuration.
+        """
+        reports = self.impl.config.get("reports", {})
+        if not isinstance(reports, dict):
+            raise ValueError("Invalid format for 'reports' in SONATA config.")
+        return reports
+
     def connection_entries(self) -> list[ConnectionOverrides]:
         return self._connection_entries() + self._connection_overrides
 
+    def report_file_path(self, report_cfg: dict, report_key: str) -> Path:
+        """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")
+        return output_dir / file_name
+
     @property
     def base_seed(self) -> int:
         return self.impl.run.random_seed
@@ -135,7 +172,13 @@ class SonataSimulationConfig:
 
     @property
     def output_root_path(self) -> str:
-        return self.impl.config["output"]["output_dir"]
+        return self.impl.config.get("output", {}).get("output_dir", "output")
+
+    @property
+    def spikes_file_path(self) -> Path:
+        output_dir = Path(self.output_root_path)
+        spikes_file = self.impl.config.get("output", {}).get("spikes_file", "spikes.h5")
+        return output_dir / spikes_file
 
     @property
     def extracellular_calcium(self) -> Optional[float]:

bluecellulab/circuit/iotools.py

@@ -17,7 +17,6 @@ from __future__ import annotations
 from pathlib import Path
 import logging
 
-import bluepy
 import numpy as np
 
 from bluecellulab.circuit.node_id import CellId
@@ -28,6 +27,7 @@ logger = logging.getLogger(__name__)
 def parse_outdat(path: str | Path) -> dict[CellId, np.ndarray]:
     """Parse the replay spiketrains in a out.dat formatted file pointed to by
     path."""
+    import bluepy
     spikes = bluepy.impl.spike_report.SpikeReport.load(path).get()
     # convert Series to DataFrame with 2 columns for `groupby` operation
     spike_df = spikes.to_frame().reset_index()

bluecellulab/circuit_simulation.py

@@ -17,10 +17,12 @@ simulations."""
 
 from __future__ import annotations
 from collections.abc import Iterable
+import os
 from pathlib import Path
 from typing import Optional
 import logging
 
+from collections import defaultdict
 import neuron
 import numpy as np
 import pandas as pd
@@ -45,6 +47,7 @@ from bluecellulab.circuit.simulation_access import BluepySimulationAccess, Simul
 from bluecellulab.importer import load_mod_files
 from bluecellulab.rngsettings import RNGSettings
 from bluecellulab.simulation.neuron_globals import NeuronGlobals
+from bluecellulab.simulation.report import configure_all_reports, write_compartment_report, write_sonata_spikes
 from bluecellulab.stimulus.circuit_stimulus_definitions import Noise, OrnsteinUhlenbeck, RelativeOrnsteinUhlenbeck, RelativeShotNoise, ShotNoise
 import bluecellulab.stimulus.circuit_stimulus_definitions as circuit_stimulus_definitions
 from bluecellulab.exceptions import BluecellulabError
@@ -301,6 +304,16 @@ class CircuitSimulation:
                 add_linear_stimuli=add_linear_stimuli
             )
 
+        configure_all_reports(
+            cells=self.cells,
+            simulation_config=self.circuit_access.config
+        )
+
+        # add spike recordings
+        for cell in self.cells.values():
+            if not cell.is_recording_spikes("soma", threshold=self.spike_threshold):
+                cell.start_recording_spikes(None, location="soma", threshold=self.spike_threshold)
+
     def _add_stimuli(self, add_noise_stimuli=False,
                      add_hyperpolarizing_stimuli=False,
                      add_relativelinear_stimuli=False,
@@ -458,13 +471,26 @@ class CircuitSimulation:
     @staticmethod
     def merge_pre_spike_trains(*train_dicts) -> dict[CellId, np.ndarray]:
         """Merge presynaptic spike train dicts."""
-        filtered_dicts = [d for d in train_dicts if d not in [None, {}, [], ()]]
+        filtered_dicts = [d for d in train_dicts if isinstance(d, dict) and d]
+
+        if not filtered_dicts:
+            logger.warning("merge_pre_spike_trains: No presynaptic spike trains found.")
+            return {}
 
         all_keys = set().union(*[d.keys() for d in filtered_dicts])
-        return {
-            k: np.sort(np.concatenate([d[k] for d in filtered_dicts if k in d]))
-            for k in all_keys
-        }
+        result = {}
+
+        for k in all_keys:
+            valid_arrays = []
+            for d in filtered_dicts:
+                if k in d:
+                    val = d[k]
+                    if isinstance(val, (np.ndarray, list)) and len(val) > 0:
+                        valid_arrays.append(np.asarray(val))
+            if valid_arrays:
+                result[k] = np.sort(np.concatenate(valid_arrays))
+
+        return result
 
     def _add_connections(
             self,
@@ -646,6 +672,8 @@ class CircuitSimulation:
             forward_skip_value=forward_skip_value,
             show_progress=show_progress)
 
+        self.write_reports()
+
     def get_mainsim_voltage_trace(
             self, cell_id: int | tuple[str, int], t_start=None, t_stop=None, t_step=None
     ) -> np.ndarray:
@@ -779,3 +807,76 @@ class CircuitSimulation:
                                  record_dt=cell_kwargs['record_dt'],
                                  template_format=cell_kwargs['template_format'],
                                  emodel_properties=cell_kwargs['emodel_properties'])
+
+    def write_reports(self):
+        """Write all reports defined in the simulation config."""
+        report_entries = self.circuit_access.config.get_report_entries()
+
+        for report_name, report_cfg in report_entries.items():
+            report_type = report_cfg.get("type", "compartment")
+            section = report_cfg.get("sections")
+
+            if report_type != "compartment":
+                raise NotImplementedError(f"Report type '{report_type}' is not supported.")
+
+            output_path = self.circuit_access.config.report_file_path(report_cfg, report_name)
+            if section == "compartment_set":
+                if report_cfg.get("cells") is not None:
+                    raise ValueError(
+                        "Report config error: 'cells' must not be set when using 'compartment_set' sections."
+                    )
+                compartment_sets = self.circuit_access.config.get_compartment_sets()
+                write_compartment_report(
+                    report_name=report_name,
+                    output_path=output_path,
+                    cells=self.cells,
+                    report_cfg=report_cfg,
+                    source_sets=compartment_sets,
+                    source_type="compartment_set"
+                )
+
+            else:
+                node_sets = self.circuit_access.config.get_node_sets()
+                if report_cfg.get("compartments") not in ("center", "all"):
+                    raise ValueError(
+                        f"Unsupported 'compartments' value '{report_cfg.get('compartments')}' "
+                        "for node-based section recording (must be 'center' or 'all')."
+                    )
+                write_compartment_report(
+                    report_name=report_name,
+                    output_path=output_path,
+                    cells=self.cells,
+                    report_cfg=report_cfg,
+                    source_sets=node_sets,
+                    source_type="node_set"
+                )
+
+        self.write_spike_report()
+
+    def write_spike_report(self):
+        """Collect and write in-memory recorded spike times to a SONATA HDF5
+        file, grouped by population as required by the SONATA specification."""
+        output_path = self.circuit_access.config.spikes_file_path
+
+        if os.path.exists(output_path):
+            os.remove(output_path)
+
+        # Group spikes per population
+        spikes_by_population = defaultdict(dict)
+        for gid, cell in self.cells.items():
+            pop = getattr(gid, 'population_name', None)
+            if pop is None:
+                continue
+            try:
+                cell_spikes = cell.get_recorded_spikes(location="soma", threshold=self.spike_threshold)
+                if cell_spikes is not None:
+                    spikes_by_population[pop][gid.id] = list(cell_spikes)
+            except AttributeError:
+                continue
+
+        # Ensure we at least create empty groups for all known populations
+        all_populations = set(getattr(gid, 'population_name', None) for gid in self.cells.keys())
+
+        for pop in all_populations:
+            spikes = spikes_by_population.get(pop, {})  # May be empty
+            write_sonata_spikes(output_path, spikes, pop)

bluecellulab/simulation/report.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."""
+
+import logging
+from pathlib import Path
+import h5py
+from typing import List
+import numpy as np
+import os
+
+from bluecellulab.tools import resolve_segments, resolve_source_nodes
+from bluecellulab.cell.cell_dict import CellDict
+
+logger = logging.getLogger(__name__)
+
+
+def _configure_recording(cell, report_cfg, source, source_type, report_name):
+    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}"
+            )
+
+
+def configure_all_reports(cells, simulation_config):
+    report_entries = simulation_config.get_report_entries()
+
+    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"
+            source_sets = simulation_config.get_compartment_sets()
+            source_name = report_cfg.get("compartments")
+            if not source_name:
+                logger.warning(f"Report '{report_name}' does not specify a node set in 'compartments' for {source_type}.")
+                continue
+        else:
+            source_type = "node_set"
+            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}.")
+                continue
+
+        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.")
+            continue
+
+        population = source["population"]
+        node_ids, _ = resolve_source_nodes(source, source_type, cells, population)
+
+        for node_id in node_ids:
+            cell = cells.get((population, node_id))
+            if not cell:
+                continue
+            _configure_recording(cell, report_cfg, source, source_type, report_name)
+
+
+def write_compartment_report(
+    report_name: str,
+    output_path: str,
+    cells: CellDict,
+    report_cfg: dict,
+    source_sets: dict,
+    source_type: str,
+):
+    """Write a SONATA-compatible compartment report to an HDF5 file.
+
+    This function collects time series data (e.g., membrane voltage, ion currents)
+    from a group of cells defined by either a node set or a compartment set, and
+    writes the data to a SONATA-style report file.
+
+    Args:
+        output_path (str): Path to the output HDF5 file.
+        cells (CellDict): Mapping of (population, node_id) to cell objects that
+            provide access to pre-recorded variable traces.
+        report_cfg (dict): Configuration for the report. Must include:
+            - "variable_name": Name of the variable to report (e.g., "v", "ica", "ina").
+            - "start_time", "end_time", "dt": Timing parameters.
+            - "cells" or "compartments": Name of the node or compartment set.
+        source_sets (dict): Dictionary of either node sets or compartment sets.
+        source_type (str): Either "node_set" or "compartment_set".
+
+    Raises:
+        ValueError: If the specified source set is not found.
+
+    Notes:
+        - Currently supports only variables explicitly handled in Cell.get_variable_recording().
+        - Cells without recordings for the requested variable will be skipped.
+    """
+    source_name = report_cfg.get("cells") if source_type == "node_set" else report_cfg.get("compartments")
+    source = source_sets.get(source_name)
+    if not source:
+        logger.warning(f"{source_type.title()} '{source_name}' not found for report '{report_name}', skipping write.")
+        return
+
+    population = source["population"]
+
+    node_ids, compartment_nodes = resolve_source_nodes(source, source_type, cells, population)
+
+    data_matrix: List[np.ndarray] = []
+    recorded_node_ids: List[int] = []
+    index_pointers: List[int] = [0]
+    element_ids: List[int] = []
+
+    for node_id in node_ids:
+        try:
+            cell = cells[(population, node_id)]
+        except KeyError:
+            continue
+        if not cell:
+            continue
+
+        targets = resolve_segments(cell, report_cfg, node_id, compartment_nodes, source_type)
+        for sec, sec_name, seg in targets:
+            try:
+                variable = report_cfg.get("variable_name", "v")
+                trace = cell.get_variable_recording(variable=variable, section=sec, segx=seg)
+                data_matrix.append(trace)
+                recorded_node_ids.append(node_id)
+                element_ids.append(len(element_ids))
+                index_pointers.append(index_pointers[-1] + 1)
+            except Exception as e:
+                logger.warning(f"Failed recording: GID {node_id} sec {sec_name} seg {seg}: {e}")
+
+    if not data_matrix:
+        logger.warning(f"No data recorded for report '{source_name}'. Skipping write.")
+        return
+
+    write_sonata_report_file(
+        output_path, population, data_matrix, recorded_node_ids, index_pointers, element_ids, report_cfg
+    )
+
+
+def write_sonata_report_file(
+    output_path, population, data_matrix, recorded_node_ids, index_pointers, element_ids, report_cfg
+):
+    data_array = np.stack(data_matrix, axis=1)
+    node_ids_arr = np.array(recorded_node_ids, dtype=np.uint64)
+    index_ptr_arr = np.array(index_pointers, dtype=np.uint64)
+    element_ids_arr = np.array(element_ids, dtype=np.uint32)
+    time_array = np.array([
+        report_cfg.get("start_time", 0.0),
+        report_cfg.get("end_time", 0.0),
+        report_cfg.get("dt", 0.1)
+    ], dtype=np.float64)
+
+    output_path = Path(output_path)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    with h5py.File(output_path, "w") as f:
+        grp = f.require_group(f"/report/{population}")
+        data_ds = grp.create_dataset("data", data=data_array.astype(np.float32))
+
+        variable = report_cfg.get("variable_name", "v")
+        if variable == "v":
+            data_ds.attrs["units"] = "mV"
+
+        mapping = grp.require_group("mapping")
+        mapping.create_dataset("node_ids", data=node_ids_arr)
+        mapping.create_dataset("index_pointers", data=index_ptr_arr)
+        mapping.create_dataset("element_ids", data=element_ids_arr)
+        time_ds = mapping.create_dataset("time", data=time_array)
+        time_ds.attrs["units"] = "ms"
+
+
+def write_sonata_spikes(f_name: str, spikes_dict: dict[int, np.ndarray], population: str):
+    """Write a SONATA spike group to a spike file from {node_id: [t1, t2,
+    ...]}."""
+    all_node_ids: List[int] = []
+    all_timestamps: List[float] = []
+
+    for node_id, times in spikes_dict.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 '{population}'.")
+
+    # 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]
+
+    os.makedirs(os.path.dirname(f_name), exist_ok=True)
+    with h5py.File(f_name, 'a') as f:  # 'a' to allow multiple writes
+        spikes_group = f.require_group("spikes")
+        if population in spikes_group:
+            logger.warning(f"Overwriting existing group for population '{population}' in {f_name}.")
+            del spikes_group[population]
+
+        group = spikes_group.create_group(population)
+        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)
+
+        timestamps_ds.attrs["units"] = "ms"  # SONATA-required

bluecellulab/tools.py

@@ -394,14 +394,14 @@ def check_empty_topology() -> bool:
 
 
 def calculate_max_thresh_current(cell: Cell,
-                                 threshold_voltage: float = -30.0,
+                                 threshold_voltage: float = -20.0,
                                  section: str = "soma[0]",
                                  segx: float = 0.5) -> float:
     """Calculate the upper bound threshold current.
 
     Args:
         cell (bluecellulab.cell.Cell): The initialized cell model.
-        threshold_voltage (float, optional): Voltage threshold for spike detection. Default is -30.0 mV.
+        threshold_voltage (float, optional): Voltage threshold for spike detection. Default is -20.0 mV.
         section (str, optional): The section where current is injected.
         segx (float, optional): Fractional location within the section for current injection.
 
@@ -508,19 +508,85 @@ def validate_section_and_segment(cell: Cell, section_name: str, segment_position
 
 
 def get_section(cell: Cell, section_name: str) -> NeuronSection:
-    """Retrieve a NEURON section from the cell by its name.
+    """Return a single, fully specified NEURON section (e.g., 'soma[0]',
+    'dend[3]').
 
-    Args:
-        cell (Cell): The cell object containing the sections.
-        section_name (str): The name of the section to retrieve.
+    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}]")
 
-    Returns:
-        NeuronSection: The NEURON section corresponding to the provided name.
+
+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: If the section with the specified name does not exist.
+        ValueError or TypeError if no valid sections are found.
     """
+    # Try to interpret as fully qualified section name
     try:
-        return cell.sections[section_name]
-    except KeyError:
-        raise ValueError(f"Section '{section_name}' not found in the cell.")
+        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":
+        compartment_nodes = source.get("compartment_set", [])
+        node_ids = [entry[0] for entry in compartment_nodes]
+    else:  # node_set
+        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
+    return node_ids, compartment_nodes

bluecellulab/utils.py

@@ -4,6 +4,8 @@ from __future__ import annotations
 import contextlib
 import io
 import json
+import multiprocessing
+from multiprocessing import pool
 
 import numpy as np
 
@@ -56,3 +58,27 @@ class NumpyEncoder(json.JSONEncoder):
         elif isinstance(obj, np.ndarray):
             return obj.tolist()
         return json.JSONEncoder.default(self, obj)
+
+
+class NoDaemonProcess(multiprocessing.Process):
+    """Class that represents a non-daemon process."""
+
+    # pylint: disable=dangerous-default-value
+
+    def __init__(self, group=None, target=None, name=None, args=(), kwargs={}):
+        """Ensures group=None, for macosx."""
+        super().__init__(group=None, target=target, name=name, args=args, kwargs=kwargs)
+
+    @property
+    def daemon(self):
+        return False
+
+    @daemon.setter
+    def daemon(self, val):
+        pass
+
+
+class NestedPool(pool.Pool):  # pylint: disable=abstract-method
+    """Class that represents a MultiProcessing nested pool."""
+
+    Process = NoDaemonProcess

bluecellulab/validation/validation.py

@@ -24,6 +24,7 @@ from bluecellulab.analysis.analysis import compute_plot_fi_curve
 from bluecellulab.analysis.analysis import compute_plot_iv_curve
 from bluecellulab.analysis.inject_sequence import run_multirecordings_stimulus
 from bluecellulab.analysis.inject_sequence import run_stimulus
+from bluecellulab.cell.core import Cell
 from bluecellulab.stimulus.factory import IDRestTimings
 from bluecellulab.stimulus.factory import StimulusFactory
 from bluecellulab.tools import calculate_input_resistance
@@ -79,12 +80,12 @@ def plot_traces(recordings, out_dir, fname, title, labels=None, xlim=None):
     return outpath
 
 
-def spiking_test(cell, rheobase, out_dir, spike_threshold_voltage=-30.):
+def spiking_test(template_params, rheobase, out_dir, spike_threshold_voltage=-30.):
     """Spiking test: cell should spike."""
     stim_factory = StimulusFactory(dt=1.0)
     step_stimulus = stim_factory.idrest(threshold_current=rheobase, threshold_percentage=200)
     recording = run_stimulus(
-        cell.template_params,
+        template_params,
         step_stimulus,
         "soma[0]",
         0.5,
@@ -111,13 +112,13 @@ def spiking_test(cell, rheobase, out_dir, spike_threshold_voltage=-30.):
     }
 
 
-def depolarization_block_test(cell, rheobase, out_dir):
+def depolarization_block_test(template_params, rheobase, out_dir):
     """Depolarization block test: no depolarization block should be detected."""
     # Run the stimulus
     stim_factory = StimulusFactory(dt=1.0)
     step_stimulus = stim_factory.idrest(threshold_current=rheobase, threshold_percentage=200)
     recording = run_stimulus(
-        cell.template_params,
+        template_params,
         step_stimulus,
         "soma[0]",
         0.5,
@@ -151,16 +152,16 @@ def depolarization_block_test(cell, rheobase, out_dir):
     }
 
 
-def bpap_test(cell, rheobase, out_dir="./"):
+def bpap_test(template_params, rheobase, out_dir="./"):
     """Back-propagating action potential test: exponential fit should decay.
 
     Args:
-        cell (Cell): The cell to test.
+        template_params (dict): The template parameters for creating the cell.
         rheobase (float): The rheobase current to use for the test.
         out_dir (str): Directory to save the figure.
     """
     amplitude = 10. * rheobase  # Use 1000% of the rheobase current
-    bpap = BPAP(cell)
+    bpap = BPAP(Cell.from_template_parameters(template_params))
     bpap.run(duration=1500, amplitude=amplitude)
     soma_amp, dend_amps, dend_dist, apic_amps, apic_dist = bpap.get_amplitudes_and_distances()
     validated, notes = bpap.validate(soma_amp, dend_amps, dend_dist, apic_amps, apic_dist)
@@ -190,11 +191,11 @@ def bpap_test(cell, rheobase, out_dir="./"):
     }
 
 
-def ais_spiking_test(cell, rheobase, out_dir, spike_threshold_voltage=-30.):
+def ais_spiking_test(template_params, rheobase, out_dir, spike_threshold_voltage=-30.):
     """AIS spiking test: axon should spike before soma."""
     name = "Simulatable Neuron AIS Spiking Validation"
     # Check that the cell has an axon
-    if len(cell.axonal) == 0:
+    if len(Cell.from_template_parameters(template_params).axonal) == 0:
         return {
             "name": name,
             "passed": True,
@@ -206,7 +207,7 @@ def ais_spiking_test(cell, rheobase, out_dir, spike_threshold_voltage=-30.):
     stim_factory = StimulusFactory(dt=1.0)
     step_stimulus = stim_factory.idrest(threshold_current=rheobase, threshold_percentage=200)
     recordings = run_multirecordings_stimulus(
-        cell.template_params,
+        template_params,
         step_stimulus,
         "soma[0]",
         0.5,
@@ -259,14 +260,14 @@ def ais_spiking_test(cell, rheobase, out_dir, spike_threshold_voltage=-30.):
     }
 
 
-def hyperpolarization_test(cell, rheobase, out_dir):
+def hyperpolarization_test(template_params, rheobase, out_dir):
     """Hyperpolarization test: hyperpolarized voltage should be lower than RMP."""
     name = "Simulatable Neuron Hyperpolarization Validation"
     # Run the stimulus
     stim_factory = StimulusFactory(dt=1.0)
     step_stimulus = stim_factory.iv(threshold_current=rheobase, threshold_percentage=-40)
     recording = run_stimulus(
-        cell.template_params,
+        template_params,
         step_stimulus,
         "soma[0]",
         0.5,
@@ -331,11 +332,11 @@ def rin_test(rin):
     }
 
 
-def iv_test(cell, rheobase, out_dir, spike_threshold_voltage=-30.):
+def iv_test(template_params, rheobase, out_dir, spike_threshold_voltage=-30.):
     """IV curve should have a positive slope."""
     name = "Simulatable Neuron IV Curve Validation"
     amps, steady_states = compute_plot_iv_curve(
-        cell,
+        Cell.from_template_parameters(template_params),
         rheobase=rheobase,
         threshold_voltage=spike_threshold_voltage,
         nb_bins=5,
@@ -369,11 +370,11 @@ def iv_test(cell, rheobase, out_dir, spike_threshold_voltage=-30.):
     }
 
 
-def fi_test(cell, rheobase, out_dir, spike_threshold_voltage=-30.):
+def fi_test(template_params, rheobase, out_dir, spike_threshold_voltage=-30.):
     """FI curve should have a positive slope."""
     name = "Simulatable Neuron FI Curve Validation"
     amps, spike_counts = compute_plot_fi_curve(
-        cell,
+        Cell.from_template_parameters(template_params),
         rheobase=rheobase,
         threshold_voltage=spike_threshold_voltage,
         nb_bins=5,
@@ -421,7 +422,6 @@ def run_validations(
     out_dir = pathlib.Path(output_dir) / cell_name
     out_dir.mkdir(parents=True, exist_ok=True)
 
-    # cell = Cell.from_template_parameters(template_params)
     # get me-model properties
     holding_current = cell.hypamp if cell.hypamp else 0.0
     if cell.threshold:
@@ -437,41 +437,69 @@ def run_validations(
         emodel_properties=cell.template_params.emodel_properties,
     )
 
-    # Validation 1: Spiking Test
-    logger.debug("Running spiking test")
-    spiking_test_result = spiking_test(cell, rheobase, out_dir, spike_threshold_voltage)
+    logger.debug("Running validations...")
+    from bluecellulab.utils import NestedPool
+    with NestedPool(processes=8) as pool:
+        # Validation 1: Spiking Test
+        spiking_test_result_future = pool.apply_async(
+            spiking_test,
+            (cell.template_params, rheobase, out_dir, spike_threshold_voltage)
+        )
 
-    # Validation 2: Depolarization Block Test
-    logger.debug("Running depolarization block test")
-    depolarization_block_result = depolarization_block_test(cell, rheobase, out_dir)
+        # Validation 2: Depolarization Block Test
+        depolarization_block_result_future = pool.apply_async(
+            depolarization_block_test,
+            (cell.template_params, rheobase, out_dir)
+        )
 
-    # Validation 3: Backpropagating AP Test
-    logger.debug("Running backpropagating AP test")
-    bpap_result = bpap_test(cell, rheobase, out_dir)
+        # Validation 3: Backpropagating AP Test
+        bpap_result_future = pool.apply_async(
+            bpap_test,
+            (cell.template_params, rheobase, out_dir)
+        )
 
-    # Validation 4: Postsynaptic Potential Test
-    # logger.debug("Running postsynaptic potential test")
-    # We have to wait for ProbAMPANMDA_EMS to be present in entitycore to implement this test
+        # Validation 4: Postsynaptic Potential Test
+        # We have to wait for ProbAMPANMDA_EMS to be present in entitycore to implement this test
 
-    # Validation 5: AIS Spiking Test
-    logger.debug("Running AIS spiking test")
-    ais_spiking_test_result = ais_spiking_test(cell, rheobase, out_dir, spike_threshold_voltage)
+        # Validation 5: AIS Spiking Test
+        ais_spiking_test_result_future = pool.apply_async(
+            ais_spiking_test,
+            (cell.template_params, rheobase, out_dir, spike_threshold_voltage)
+        )
 
-    # Validation 6: Hyperpolarization Test
-    logger.debug("Running hyperpolarization test")
-    hyperpolarization_result = hyperpolarization_test(cell, rheobase, out_dir)
+        # Validation 6: Hyperpolarization Test
+        hyperpolarization_result_future = pool.apply_async(
+            hyperpolarization_test,
+            (cell.template_params, rheobase, out_dir)
+        )
 
-    # Validation 7: Rin Test
-    logger.debug("Running Rin test")
-    rin_result = rin_test(rin)
+        # Validation 7: Rin Test
+        rin_result_future = pool.apply_async(
+            rin_test,
+            (rin,)
+        )
+
+        # # Validation 8: IV Test
+        iv_test_result_future = pool.apply_async(
+            iv_test,
+            (cell.template_params, rheobase, out_dir, spike_threshold_voltage)
+        )
 
-    # # Validation 8: IV Test
-    logger.debug("Running IV test")
-    iv_test_result = iv_test(cell, rheobase, out_dir, spike_threshold_voltage)
+        # # Validation 9: FI Test
+        fi_test_result_future = pool.apply_async(
+            fi_test,
+            (cell.template_params, rheobase, out_dir, spike_threshold_voltage)
+        )
 
-    # # Validation 9: FI Test
-    logger.debug("Running FI test")
-    fi_test_result = fi_test(cell, rheobase, out_dir, spike_threshold_voltage)
+        # Wait for all validations to complete
+        spiking_test_result = spiking_test_result_future.get()
+        depolarization_block_result = depolarization_block_result_future.get()
+        bpap_result = bpap_result_future.get()
+        ais_spiking_test_result = ais_spiking_test_result_future.get()
+        hyperpolarization_result = hyperpolarization_result_future.get()
+        rin_result = rin_result_future.get()
+        iv_test_result = iv_test_result_future.get()
+        fi_test_result = fi_test_result_future.get()
 
     return {
         "memodel_properties": {

{bluecellulab-2.6.50.dist-info → bluecellulab-2.6.52.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bluecellulab
-Version: 2.6.50
+Version: 2.6.52
 Summary: Biologically detailed neural network simulations and analysis.
 Author: Blue Brain Project, EPFL
 License: Apache2.0

{bluecellulab-2.6.50.dist-info → bluecellulab-2.6.52.dist-info}/RECORD

@@ -1,5 +1,5 @@
 bluecellulab/__init__.py,sha256=1d_CKIJLIpon7o13h3lBnV_-33obZEPwa9KDTjlFPD8,880
-bluecellulab/circuit_simulation.py,sha256=dXaYblCWWMX2I7HhlL0chTyelePj-6Io2NNdGK5oB-o,35020
+bluecellulab/circuit_simulation.py,sha256=zF72yNZnnGUN40Vp66VFvr2Rz4tVuD3iWtvao23GoHQ,39270
 bluecellulab/connection.py,sha256=-xT0mU7ppeHI_qjCKj17TtxXVVcUDgBsaMKt9ODmcEU,4640
 bluecellulab/dendrogram.py,sha256=FjS6RZ6xcp5zJoY5d5qv_edqPM13tL2-UANgbZuDBjY,6427
 bluecellulab/exceptions.py,sha256=1lKD92VIyD8cUggAI1SLxeKzj_09Ik_TlHCzPLCvDHg,2379
@@ -10,18 +10,18 @@ bluecellulab/plotwindow.py,sha256=ePU-EegZ1Sqk0SoYYiQ6k24ZO4s3Hgfpx10uePiJ5xM,27
 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=hF1HJcera0oggetsfN5PNTRYCpFS0sQiZlVxw4jRd1g,17968
+bluecellulab/tools.py,sha256=Cc-Pv_7ban1EA9aqj8mfnjq-187llqj5WVzuQdesqhc,20395
 bluecellulab/type_aliases.py,sha256=DvgjERv2Ztdw_sW63JrZTQGpJ0x5uMTFB5hcBHDb0WA,441
-bluecellulab/utils.py,sha256=SbOOkzw1YGjCKV3qOw0zpabNEy7V9BRtgMLsQJiFRq4,1526
+bluecellulab/utils.py,sha256=0NhwlzyLnSi8kziSfDsQf7pokO4qDkMJVAO33kSX4O0,2227
 bluecellulab/verbosity.py,sha256=T0IgX7DrRo19faxrT4Xzb27gqxzoILQ8FzYKxvUeaPM,1342
 bluecellulab/analysis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bluecellulab/analysis/analysis.py,sha256=kZaSYCYOK3A4rrYFPfdsw6rsbjutP-cpFt_VxDx73cs,21270
+bluecellulab/analysis/analysis.py,sha256=53g6SW_9ZbG3fbhuXJqurAPRR4VG1jsZYK6efq-EwfA,21229
 bluecellulab/analysis/inject_sequence.py,sha256=uU6Q6y0ErMDDEgdsTZBXCJ4LgwkATY7G8Fa6mmjpL98,12523
 bluecellulab/analysis/plotting.py,sha256=PqRoaZz33ULMw8A9YnZXXrxcUd84M_dwlYMTFhG7YT4,3999
 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=BualY0WOtC0arKmvKzQ3sQ0fhc2jrtd6wqSd9M-e25E,33797
+bluecellulab/cell/core.py,sha256=2dRx5ueElOJthhmnrijbBb9rH9xlJRp_hyZ73YHLGas,34478
 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
@@ -36,7 +36,7 @@ bluecellulab/cell/ballstick/emodel.hoc,sha256=7WcuepK-wB9bASRvNdCwO9Woc9-SpBCFqB
 bluecellulab/cell/ballstick/morphology.asc,sha256=EO0VIRilJAwpiDP2hIevwusfvYptNYhvsu1f5GgbSQo,190
 bluecellulab/circuit/__init__.py,sha256=Khpa13nzNvDlDS2JduyoFTukEduEkWCc5ML_JwGpmZs,361
 bluecellulab/circuit/format.py,sha256=90gWOXg6HK0R9a4WFSnnRH8XezxmzOGk5dRpJHbvbbU,1674
-bluecellulab/circuit/iotools.py,sha256=h3nlPp1b30VVjkxg6hIfZibdXODxpFXXD1guR2fa0rg,1585
+bluecellulab/circuit/iotools.py,sha256=Q65xYDaiensMtrulC3OLsS2_hcWr_Kje0nXFrAizMMo,1589
 bluecellulab/circuit/node_id.py,sha256=FdoFAGq0_sCyQySOuNI0chdbVr3L8R0w2Y1em5MyIDA,1265
 bluecellulab/circuit/simulation_access.py,sha256=keME58gzLVAPEg2nnWD_bwEm9V2Kjeqyfoj_55GPMCM,7061
 bluecellulab/circuit/synapse_properties.py,sha256=TvUMiXZAAeYo1zKkus3z1EUvrE9QCIQ3Ze-jSnPSJWY,6374
@@ -49,7 +49,7 @@ bluecellulab/circuit/config/__init__.py,sha256=aaoJXRKBJzpxxREo9NxKc-_CCPmVeuR1m
 bluecellulab/circuit/config/bluepy_simulation_config.py,sha256=V3eqOzskX7VrMDpl-nMQVEhDg8QWgRmRduyJBii5sgI,6974
 bluecellulab/circuit/config/definition.py,sha256=I1jd4KUX21mw03FEv1aYNsT0UFbDANY3YEPwwKXqe4k,2774
 bluecellulab/circuit/config/sections.py,sha256=QRnU44-OFvHxcF1LX4bAEP9dk3I6UKsuPNBbWkdfmRE,7151
-bluecellulab/circuit/config/sonata_simulation_config.py,sha256=7yEvuourzN2nRjzsA5CcDF8pcjEyjSJHitp3OH-ijgk,4829
+bluecellulab/circuit/config/sonata_simulation_config.py,sha256=Rg1qEyGIh5s6kusE-9Z1r3LwZ4bxtF7aYr0-UeTOD6k,6536
 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
@@ -58,6 +58,7 @@ bluecellulab/hoc/fileUtils.hoc,sha256=LSM7BgyjYVqo2DGSOKvg4W8IIusbsL45JVYK0vgwit
 bluecellulab/simulation/__init__.py,sha256=P2ebt0SFw-08J3ihN-LeRn95HeF79tzA-Q0ReLm32dM,214
 bluecellulab/simulation/neuron_globals.py,sha256=iBjhg0-1YMP5LsVdtUDt24PEypkCL6mlyzEBZqoS8xo,4508
 bluecellulab/simulation/parallel.py,sha256=oQ_oV2EKr8gP4yF2Dq8q9MiblDyi89_wBgLzQkLV_U0,1514
+bluecellulab/simulation/report.py,sha256=KA8Swdxy-52AIQFMUNHq4suIZhLxesOL32ZudeM-QBg,9298
 bluecellulab/simulation/simulation.py,sha256=VhftOMYU1Rfrphvud6f0U4kvbUivSviQ5TlVljuTb88,6486
 bluecellulab/stimulus/__init__.py,sha256=DgIgVaSyR-URf3JZzvO6j-tjCerzvktuK-ep8pjMRPQ,37
 bluecellulab/stimulus/circuit_stimulus_definitions.py,sha256=dTpwfRxH4c4yJDYyKrO6X-2Nqdy-QT3GxGQjfsRhNVY,17158
@@ -66,10 +67,10 @@ bluecellulab/stimulus/stimulus.py,sha256=a_hKJUtZmIgjiFjbJf6RzUPokELqn0IHCgIWGw5
 bluecellulab/synapse/__init__.py,sha256=RW8XoAMXOvK7OG1nHl_q8jSEKLj9ZN4oWf2nY9HAwuk,192
 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=GxqyMCJ2wYXVJC-3TTqpQFF_uIlfs1lq9jeJmSCuopg,17038
-bluecellulab-2.6.50.dist-info/licenses/AUTHORS.txt,sha256=EDs3H-2HXBojbma10psixk3C2rFiOCTIREi2ZAbXYNQ,179
-bluecellulab-2.6.50.dist-info/licenses/LICENSE,sha256=dAMAR2Sud4Nead1wGFleKiwTZfkTNZbzmuGfcTKb3kg,11335
-bluecellulab-2.6.50.dist-info/METADATA,sha256=-d8pVyjbpYrjC5xmEl1c1FGNJEk3lGI6ZCa8s9FmAyE,8259
-bluecellulab-2.6.50.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-bluecellulab-2.6.50.dist-info/top_level.txt,sha256=VSyEP8w9l3pXdRkyP_goeMwiNA8KWwitfAqUkveJkdQ,13
-bluecellulab-2.6.50.dist-info/RECORD,,
+bluecellulab/validation/validation.py,sha256=EN9HMty70VPwnEPhWUmN5F-MGWbMN3uU0DmNnjL0ucw,18209
+bluecellulab-2.6.52.dist-info/licenses/AUTHORS.txt,sha256=EDs3H-2HXBojbma10psixk3C2rFiOCTIREi2ZAbXYNQ,179
+bluecellulab-2.6.52.dist-info/licenses/LICENSE,sha256=dAMAR2Sud4Nead1wGFleKiwTZfkTNZbzmuGfcTKb3kg,11335
+bluecellulab-2.6.52.dist-info/METADATA,sha256=dpyLb82oMOxH5zViSJr5Q9HbpmYDuGv8f_GgNJdOc8g,8259
+bluecellulab-2.6.52.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+bluecellulab-2.6.52.dist-info/top_level.txt,sha256=VSyEP8w9l3pXdRkyP_goeMwiNA8KWwitfAqUkveJkdQ,13
+bluecellulab-2.6.52.dist-info/RECORD,,