bluecellulab 2.4.0__py3-none-any.whl → 2.4.1__py3-none-any.whl

bluecellulab/analysis/inject_sequence.py

@@ -0,0 +1,130 @@
+"""Module for injecting a sequence of protocols to the cell."""
+from __future__ import annotations
+from enum import Enum, auto
+from typing import NamedTuple, Sequence, Dict
+
+import neuron
+import numpy as np
+from bluecellulab.cell.core import Cell
+from bluecellulab.cell.template import TemplateParams
+from bluecellulab.simulation.simulation import Simulation
+from bluecellulab.stimulus.factory import Stimulus, StimulusFactory
+from bluecellulab.utils import IsolatedProcess
+
+
+class StimulusName(Enum):
+    """Allowed values for the StimulusName."""
+    AP_WAVEFORM = auto()
+    IDREST = auto()
+    IV = auto()
+    FIRE_PATTERN = auto()
+
+
+class Recording(NamedTuple):
+    """A tuple of the current, voltage and time recordings."""
+    current: np.ndarray
+    voltage: np.ndarray
+    time: np.ndarray
+
+
+StimulusRecordings = Dict[str, Recording]
+
+
+def run_stimulus(
+    template_params: TemplateParams,
+    stimulus: Stimulus,
+    section: str,
+    segment: float,
+    duration: float,
+) -> Recording:
+    """Creates a cell and stimulates it with a given stimulus.
+
+    Args:
+        template_params: The parameters to create the cell from a template.
+        stimulus: The input stimulus to inject into the cell.
+        section: Name of the section of cell where the stimulus is to be injected.
+        segment: The segment of the section where the stimulus is to be injected.
+        duration: The duration for which the simulation is to be run.
+
+    Returns:
+        The voltage-time recording at the specified location.
+
+    Raises:
+        ValueError: If the time and voltage arrays are not the same length.
+    """
+    cell = Cell.from_template_parameters(template_params)
+    neuron_section = cell.sections[section]
+    cell.add_voltage_recording(neuron_section, segment)
+    iclamp, _ = cell.inject_current_waveform(
+        stimulus.time, stimulus.current, section=neuron_section, segx=segment
+    )
+    current_vector = neuron.h.Vector()
+    current_vector.record(iclamp._ref_i)
+    simulation = Simulation(cell)
+    simulation.run(duration)
+    current = np.array(current_vector.to_python())
+    voltage = cell.get_voltage_recording(neuron_section, segment)
+    time = cell.get_time()
+    if len(time) != len(voltage) or len(time) != len(current):
+        raise ValueError("Time, current and voltage arrays are not the same length")
+    return Recording(current, voltage, time)
+
+
+def apply_multiple_step_stimuli(
+    cell: Cell,
+    stimulus_name: StimulusName,
+    amplitudes: Sequence[float],
+    duration: float,
+    section_name: str | None = None,
+    segment: float = 0.5,
+    n_processes: int | None = None,
+) -> StimulusRecordings:
+    """Apply multiple stimuli to the cell on isolated processes.
+
+    Args:
+        cell: The cell to which the stimuli are applied.
+        stimulus_name: The name of the stimulus to apply.
+        amplitudes: The amplitudes of the stimuli to apply.
+        duration: The duration for which each stimulus is applied.
+        section_name: Section name of the cell where the stimuli are applied.
+          If None, the stimuli are applied at the soma[0] of the cell.
+        segment: The segment of the section where the stimuli are applied.
+        n_processes: The number of processes to use for running the stimuli.
+
+    Returns:
+        A dictionary where the keys are the names of the stimuli and the values
+        are the recordings of the cell's response to each stimulus.
+
+    Raises:
+        ValueError: If the stimulus name is not recognized.
+    """
+    res: StimulusRecordings = {}
+    stim_factory = StimulusFactory(dt=1.0)
+    task_args = []
+    section_name = section_name if section_name is not None else "soma[0]"
+
+    # Prepare arguments for each stimulus
+    for amplitude in amplitudes:
+        if stimulus_name == StimulusName.AP_WAVEFORM:
+            stimulus = stim_factory.ap_waveform(threshold_current=cell.threshold, threshold_percentage=amplitude)
+        elif stimulus_name == StimulusName.IDREST:
+            stimulus = stim_factory.idrest(threshold_current=cell.threshold, threshold_percentage=amplitude)
+        elif stimulus_name == StimulusName.IV:
+            stimulus = stim_factory.iv(threshold_current=cell.threshold, threshold_percentage=amplitude)
+        elif stimulus_name == StimulusName.FIRE_PATTERN:
+            stimulus = stim_factory.fire_pattern(threshold_current=cell.threshold, threshold_percentage=amplitude)
+        else:
+            raise ValueError("Unknown stimulus name.")
+
+        task_args.append((cell.template_params, stimulus, section_name, segment, duration))
+
+    with IsolatedProcess(processes=n_processes) as pool:
+        # Map expects a function and a list of argument tuples
+        results = pool.starmap(run_stimulus, task_args)
+
+    # Associate each result with a key
+    for amplitude, result in zip(amplitudes, results):
+        key = f"{stimulus_name}_{amplitude}"
+        res[key] = result
+
+    return res

bluecellulab/cell/core.py

@@ -27,12 +27,13 @@ import numpy as np
 import pandas as pd
 
 import bluecellulab
+from bluecellulab.cell.recording import section_to_voltage_recording_str
 from bluecellulab.psection import PSection, init_psections
 from bluecellulab.cell.injector import InjectableMixin
 from bluecellulab.cell.plotting import PlottableMixin
 from bluecellulab.cell.section_distance import EuclideanSectionDistance
 from bluecellulab.cell.sonata_proxy import SonataProxy
-from bluecellulab.cell.template import NeuronTemplate, public_hoc_cell
+from bluecellulab.cell.template import NeuronTemplate, TemplateParams, public_hoc_cell
 from bluecellulab.circuit.config.sections import Conditions
 from bluecellulab.circuit import EmodelProperties, SynapseProperty
 from bluecellulab.circuit.node_id import CellId
@@ -44,7 +45,7 @@ from bluecellulab.rngsettings import RNGSettings
 from bluecellulab.stimulus.circuit_stimulus_definitions import SynapseReplay
 from bluecellulab.synapse import SynapseFactory, Synapse
 from bluecellulab.synapse.synapse_types import SynapseID
-from bluecellulab.type_aliases import HocObjectType, NeuronSection
+from bluecellulab.type_aliases import HocObjectType, NeuronSection, SectionMapping
 
 logger = logging.getLogger(__name__)
 
@@ -54,6 +55,24 @@ class Cell(InjectableMixin, PlottableMixin):
 
     last_id = 0
 
+    @classmethod
+    def from_template_parameters(
+        cls, template_params: TemplateParams, cell_id: Optional[CellId] = None,
+        record_dt: Optional[float] = None
+    ) -> Cell:
+        """Create a cell from a TemplateParams object.
+
+        Useful in isolating runs.
+        """
+        return cls(
+            template_path=template_params.template_filepath,
+            morphology_path=template_params.morph_filepath,
+            cell_id=cell_id,
+            record_dt=record_dt,
+            template_format=template_params.template_format,
+            emodel_properties=template_params.emodel_properties,
+        )
+
     @load_hoc_and_mod_files
     def __init__(self,
                  template_path: str | Path,
@@ -73,6 +92,12 @@ class Cell(InjectableMixin, PlottableMixin):
             emodel_properties: Template specific emodel properties.
         """
         super().__init__()
+        self.template_params = TemplateParams(
+            template_filepath=template_path,
+            morph_filepath=morphology_path,
+            template_format=template_format,
+            emodel_properties=emodel_properties,
+        )
         if cell_id is None:
             cell_id = CellId("", Cell.last_id)
             Cell.last_id += 1
@@ -86,17 +111,16 @@ class Cell(InjectableMixin, PlottableMixin):
             if emodel_properties is None:
                 raise BluecellulabError('EmodelProperties must be provided for v6 template')
             self.hypamp: float | None = emodel_properties.holding_current
-            self.threshold: float | None = emodel_properties.threshold_current
+            self.threshold: float = emodel_properties.threshold_current
         else:
             try:
                 self.hypamp = self.cell.getHypAmp()
             except AttributeError:
                 self.hypamp = None
-
             try:
                 self.threshold = self.cell.getThreshold()
             except AttributeError:
-                self.threshold = None
+                self.threshold = 0.0
         self.soma = public_hoc_cell(self.cell).soma[0]
         # WARNING: this finitialize 'must' be here, otherwhise the
         # diameters of the loaded morph are wrong
@@ -131,6 +155,13 @@ class Cell(InjectableMixin, PlottableMixin):
         # as the object exists
         self.persistent: list[HocObjectType] = []
 
+    def _extract_sections(self, sections) -> SectionMapping:
+        res: SectionMapping = {}
+        for section in sections:
+            key_name = str(section).split(".")[-1]
+            res[key_name] = section
+        return res
+
     @property
     def somatic(self) -> list[NeuronSection]:
         return list(public_hoc_cell(self.cell).somatic)
@@ -148,8 +179,8 @@ class Cell(InjectableMixin, PlottableMixin):
         return list(public_hoc_cell(self.cell).axonal)
 
     @property
-    def all(self) -> list[NeuronSection]:
-        return list(public_hoc_cell(self.cell).all)
+    def sections(self) -> SectionMapping:
+        return self._extract_sections(public_hoc_cell(self.cell).all)
 
     def __repr__(self) -> str:
         base_info = f"Cell Object: {super().__repr__()}"
@@ -197,7 +228,7 @@ class Cell(InjectableMixin, PlottableMixin):
 
     def make_passive(self) -> None:
         """Make the cell passive by deactivating all the active channels."""
-        for section in self.all:
+        for section in self.sections.values():
             mech_names = set()
             for seg in section:
                 for mech in seg:
@@ -232,14 +263,14 @@ class Cell(InjectableMixin, PlottableMixin):
 
     def _default_enable_ttx(self) -> None:
         """Default enable_ttx implementation."""
-        for section in self.all:
+        for section in self.sections.values():
             if not neuron.h.ismembrane("TTXDynamicsSwitch"):
                 section.insert('TTXDynamicsSwitch')
             section.ttxo_level_TTXDynamicsSwitch = 1.0
 
     def _default_disable_ttx(self) -> None:
         """Default disable_ttx implementation."""
-        for section in self.all:
+        for section in self.sections.values():
             if not neuron.h.ismembrane("TTXDynamicsSwitch"):
                 section.insert('TTXDynamicsSwitch')
             section.ttxo_level_TTXDynamicsSwitch = 1e-14
@@ -247,7 +278,7 @@ class Cell(InjectableMixin, PlottableMixin):
     def area(self) -> float:
         """The total surface area of the cell."""
         area = 0.0
-        for section in self.all:
+        for section in self.sections.values():
             x_s = np.arange(1.0 / (2 * section.nseg), 1.0,
                             1.0 / (section.nseg))
             for x in x_s:
@@ -297,7 +328,7 @@ class Cell(InjectableMixin, PlottableMixin):
         self.add_recording("self.axonal[1](0.5)._ref_v", dt=dt)
 
     def add_voltage_recording(
-        self, section: "neuron.h.Section", segx: float = 0.5, dt: Optional[float] = None
+        self, section: Optional[NeuronSection] = None, segx: float = 0.5, dt: Optional[float] = None
     ) -> None:
         """Add a voltage recording to a certain section at a given segment
         (segx).
@@ -309,11 +340,13 @@ class Cell(InjectableMixin, PlottableMixin):
             dt: Recording time step. If not provided, the recording step will
                 default to the simulator's time step.
         """
-        var_name = f"neuron.h.{section.name()}({segx})._ref_v"
+        if section is None:
+            section = self.soma
+        var_name = section_to_voltage_recording_str(section, segx)
         self.add_recording(var_name, dt)
 
     def get_voltage_recording(
-        self, section: "neuron.h.Section", segx: float = 0.5
+        self, section: Optional[NeuronSection] = None, segx: float = 0.5
     ) -> np.ndarray:
         """Get a voltage recording for a certain section at a given segment
         (segx).
@@ -329,7 +362,9 @@ class Cell(InjectableMixin, PlottableMixin):
         Raises:
             BluecellulabError: If voltage recording was not added previously using add_voltage_recording.
         """
-        recording_name = f"neuron.h.{section.name()}({segx})._ref_v"
+        if section is None:
+            section = self.soma
+        recording_name = section_to_voltage_recording_str(section, segx)
         if recording_name in self.recordings:
             return self.get_recording(recording_name)
         else:
@@ -340,15 +375,13 @@ class Cell(InjectableMixin, PlottableMixin):
 
     def add_allsections_voltagerecordings(self):
         """Add a voltage recording to every section of the cell."""
-        all_sections = public_hoc_cell(self.cell).all
-        for section in all_sections:
+        for section in self.sections.values():
             self.add_voltage_recording(section, dt=self.record_dt)
 
     def get_allsections_voltagerecordings(self) -> dict[str, np.ndarray]:
         """Get all the voltage recordings from all the sections."""
         all_section_voltages = {}
-        all_sections = public_hoc_cell(self.cell).all
-        for section in all_sections:
+        for section in self.sections.values():
             recording = self.get_voltage_recording(section)
             all_section_voltages[section.name()] = recording
         return all_section_voltages
@@ -426,10 +459,10 @@ class Cell(InjectableMixin, PlottableMixin):
         """
         if location == "soma":
             sec = public_hoc_cell(self.cell).soma[0]
-            source = public_hoc_cell(self.cell).soma[0](1)._ref_v
+            source = sec(1)._ref_v
         elif location == "AIS":
             sec = public_hoc_cell(self.cell).axon[1]
-            source = public_hoc_cell(self.cell).axon[1](0.5)._ref_v
+            source = sec(0.5)._ref_v
         else:
             raise ValueError("Spike detection location must be soma or AIS")
         netcon = neuron.h.NetCon(source, target, sec=sec)
@@ -682,9 +715,10 @@ class Cell(InjectableMixin, PlottableMixin):
         """Get a vector of AIS voltage."""
         return self.get_recording('self.axonal[1](0.5)._ref_v')
 
-    def getNumberOfSegments(self) -> int:
+    @property
+    def n_segments(self) -> int:
         """Get the number of segments in the cell."""
-        return sum(section.nseg for section in self.all)
+        return sum(section.nseg for section in self.sections.values())
 
     def add_synapse_replay(
         self, stimulus: SynapseReplay, spike_threshold: float, spike_location: str

bluecellulab/cell/injector.py

@@ -443,14 +443,14 @@ class InjectableMixin:
         time_vector = neuron.h.Vector().from_python(t_content)
         current_vector = neuron.h.Vector().from_python(i_content)
 
-        pulse = neuron.h.IClamp(segx, sec=section)
-        self.persistent.extend([pulse, time_vector, current_vector])
+        iclamp = neuron.h.IClamp(segx, sec=section)
+        self.persistent.extend([iclamp, time_vector, current_vector])
 
-        pulse.delay = t_content[0]
-        pulse.dur = t_content[-1] - t_content[0]
-        current_vector.play(pulse._ref_amp, time_vector)
+        iclamp.delay = t_content[0]
+        iclamp.dur = t_content[-1] - t_content[0]
+        current_vector.play(iclamp._ref_amp, time_vector)
 
-        return current_vector
+        return iclamp, current_vector
 
     @deprecated("Use add_sin_current instead.")
     def addSineCurrentInject(self, start_time, stop_time, freq,

bluecellulab/cell/recording.py

@@ -0,0 +1,8 @@
+"""Neuron recordings related functions."""
+from __future__ import annotations
+from bluecellulab.type_aliases import NeuronSection
+
+
+def section_to_voltage_recording_str(section: NeuronSection, segment=0.5) -> str:
+    """Converts a section and segment to voltage recording string."""
+    return f"neuron.h.{section.name()}({segment})._ref_v"

bluecellulab/cell/template.py

@@ -20,7 +20,7 @@ import os
 from pathlib import Path
 import re
 import string
-from typing import Optional
+from typing import NamedTuple, Optional
 
 import neuron
 
@@ -44,6 +44,13 @@ def public_hoc_cell(cell: HocObjectType) -> HocObjectType:
          from the hoc model. Either getCell() or CellRef needs to be provided""")
 
 
+class TemplateParams(NamedTuple):
+    template_filepath: str | Path
+    morph_filepath: str | Path
+    template_format: str
+    emodel_properties: Optional[EmodelProperties]
+
+
 class NeuronTemplate:
     """NeuronTemplate representation."""
 

bluecellulab/type_aliases.py

@@ -1,5 +1,6 @@
 """Type aliases used within the package."""
-
+from __future__ import annotations
+from typing import Dict
 from typing_extensions import TypeAlias
 from neuron import h as hoc_type
 
@@ -8,3 +9,5 @@ NeuronRNG: TypeAlias = hoc_type
 NeuronVector: TypeAlias = hoc_type
 NeuronSection: TypeAlias = hoc_type
 TStim: TypeAlias = hoc_type
+
+SectionMapping = Dict[str, NeuronSection]

bluecellulab/utils.py

@@ -50,5 +50,11 @@ class IsolatedProcess(Pool):
     Use this when running isolated NEURON simulations. Running 2 NEURON
     simulations on a single process is to be avoided.
     """
-    def __init__(self):
-        super().__init__(processes=1, maxtasksperchild=1)
+    def __init__(self, processes: int | None = 1):
+        """Initialize the IsolatedProcess pool.
+
+        Args:
+            processes: The number of processes to use for running the stimuli.
+            If set to None, then the number returned by os.cpu_count() is used.
+        """
+        super().__init__(processes=processes, maxtasksperchild=1)

{bluecellulab-2.4.0.dist-info → bluecellulab-2.4.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bluecellulab
-Version: 2.4.0
+Version: 2.4.1
 Summary: The Pythonic Blue Brain simulator access
 Home-page: https://github.com/BlueBrain/BlueCelluLab
 Author: Blue Brain Project, EPFL

{bluecellulab-2.4.0.dist-info → bluecellulab-2.4.1.dist-info}/RECORD

@@ -11,20 +11,23 @@ bluecellulab/psegment.py,sha256=rBryDYHC_uDK9itfXXrFZ0DL9F6WgRICL0j5EHN56QM,3125
 bluecellulab/rngsettings.py,sha256=qjwnzAEdbRt66DKd_NTD2OZnlu4hDH7UUOXxd0G9c_Q,4244
 bluecellulab/ssim.py,sha256=U8HFKso4lQkKowts_x2DQfG3ihR56KcN0ITeTlGu3hI,33533
 bluecellulab/tools.py,sha256=tS9a9VDMQOVw6zIllT3FxPIzQk4xheNlGf8lpIg01FY,10931
-bluecellulab/type_aliases.py,sha256=D-evdt299aK61rTh8YGCj-atcj_iFgZbqEoa2LcAiFw,340
-bluecellulab/utils.py,sha256=N9jOOcaxfa4DmG41d7N-M_ywtkAUrRh20llu0gOqXlQ,1743
+bluecellulab/type_aliases.py,sha256=DvgjERv2Ztdw_sW63JrZTQGpJ0x5uMTFB5hcBHDb0WA,441
+bluecellulab/utils.py,sha256=fgqjgy3xzyL0zu-qjCPJdHp6PEAHADCzlr2FqyBmzHI,2012
 bluecellulab/verbosity.py,sha256=T0IgX7DrRo19faxrT4Xzb27gqxzoILQ8FzYKxvUeaPM,1342
+bluecellulab/analysis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bluecellulab/analysis/inject_sequence.py,sha256=jfEESRAUKAWgjceNWfx3Rwe1gDNWhxwZL4PfnJZCzrg,4930
 bluecellulab/cell/__init__.py,sha256=Sbc0QOsJ8E7tSwf3q7fsXuE_SevBN6ZmoCVyyU5zfII,208
 bluecellulab/cell/cell_dict.py,sha256=PVmZsjhZ9jp3HC-8QmdFqp-crAcVMSVeLWujcOPLlpo,1346
-bluecellulab/cell/core.py,sha256=A-41oObOZKY5H9MkbYIPpQXAaGPeHtK3aAKWZlirjuw,30861
-bluecellulab/cell/injector.py,sha256=28R3MTcnqAB_GGz23BTyWqCurMMkDrrNorgzWDKEFRs,18078
+bluecellulab/cell/core.py,sha256=r_9nq9MBm-VM-oZQc2KN3a4GxFRYgWy9AF-XpjMIDAE,32156
+bluecellulab/cell/injector.py,sha256=XC49VSHw78xCHzLJKO_-unnnVZAZXsYg5qbmZPx01AA,18091
 bluecellulab/cell/plotting.py,sha256=_hZs5oYG4vmJBVf05cJ2O_cVazi5Eap8OkL9BtIwjW8,4001
 bluecellulab/cell/random.py,sha256=FDby9BN4eJT27COwHP59bhDE2v-c6rdOKNFj3cYZTVY,1773
+bluecellulab/cell/recording.py,sha256=dekJspPb_5yrS6WR3aXtvZ6KWwMNbyhe5aIOVtNDHpY,342
 bluecellulab/cell/section_distance.py,sha256=J8-oqgCHzRaJkpfjPUR6NFtXDhwbrXad9nDaTCKNkTU,3908
 bluecellulab/cell/serialized_sections.py,sha256=UQUecO07ChRZ7xHuDp-QAQRUpUiIwROzHxjZliP9gfQ,1614
 bluecellulab/cell/sonata_proxy.py,sha256=dLT9mLlGVpXxj2O2lXN0g7Sq4BwroPLVdPikR2yNMv4,1529
 bluecellulab/cell/stimuli_generator.py,sha256=cJwjNwsQeEBHLjuJIFv6VBSqd9IpmbR7CuSMyotCiWc,6320
-bluecellulab/cell/template.py,sha256=EW7-hSa_sfWwd2hH_w48sHAlrN9O7XJSmnPfoWFdz08,7374
+bluecellulab/cell/template.py,sha256=K8Vp1-yE6-9wxjmhkLBhnjBhgciUixoMk8LU-GioTgM,7562
 bluecellulab/cell/ballstick/__init__.py,sha256=v1Z8tHFfbpWShxOBdShCUaE0utoz-7rZumuNBQtNOFI,439
 bluecellulab/cell/ballstick/emodel.hoc,sha256=7WcuepK-wB9bASRvNdCwO9Woc9-SpBCFqBqCXKgjsV8,1517
 bluecellulab/cell/ballstick/morphology.asc,sha256=EO0VIRilJAwpiDP2hIevwusfvYptNYhvsu1f5GgbSQo,190
@@ -58,9 +61,9 @@ bluecellulab/stimulus/factory.py,sha256=AOby3Sp2g8BJsRccz3afazfCyysyWIgLtcliWlye
 bluecellulab/synapse/__init__.py,sha256=RW8XoAMXOvK7OG1nHl_q8jSEKLj9ZN4oWf2nY9HAwuk,192
 bluecellulab/synapse/synapse_factory.py,sha256=YkvxbdGF-u-vxYdbRNTlX-9AtSC_3t_FQRFhybwzgrk,6805
 bluecellulab/synapse/synapse_types.py,sha256=4gne-hve2vq1Lau-LAVPsfLjffVYqAYBW3kCfC7_600,16871
-bluecellulab-2.4.0.dist-info/AUTHORS.txt,sha256=EDs3H-2HXBojbma10psixk3C2rFiOCTIREi2ZAbXYNQ,179
-bluecellulab-2.4.0.dist-info/LICENSE,sha256=xOouu1gC1GGklDxkITlaVl60I9Ab860O-nZsFbWydvU,11749
-bluecellulab-2.4.0.dist-info/METADATA,sha256=INJHNIWkhkP13SaZcuI50UsUJ8-hTjW35YS_YcAfGZA,6907
-bluecellulab-2.4.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-bluecellulab-2.4.0.dist-info/top_level.txt,sha256=VSyEP8w9l3pXdRkyP_goeMwiNA8KWwitfAqUkveJkdQ,13
-bluecellulab-2.4.0.dist-info/RECORD,,
+bluecellulab-2.4.1.dist-info/AUTHORS.txt,sha256=EDs3H-2HXBojbma10psixk3C2rFiOCTIREi2ZAbXYNQ,179
+bluecellulab-2.4.1.dist-info/LICENSE,sha256=xOouu1gC1GGklDxkITlaVl60I9Ab860O-nZsFbWydvU,11749
+bluecellulab-2.4.1.dist-info/METADATA,sha256=7Ug3ADUg1_1XIbqRyQ07KaSb512jch3wiaxRKsxkXPY,6907
+bluecellulab-2.4.1.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+bluecellulab-2.4.1.dist-info/top_level.txt,sha256=VSyEP8w9l3pXdRkyP_goeMwiNA8KWwitfAqUkveJkdQ,13
+bluecellulab-2.4.1.dist-info/RECORD,,