bsb-nest 4.3.1__tar.gz → 5.0.0__tar.gz

bsb_nest-5.0.0/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.4
+Name: bsb-nest
+Version: 5.0.0
+Summary: NEST simulation adapter for the BSB framework.
+Author-email: Robin De Schepper <robin@alexandria.sc>, Dimitri Rodarie <dimitri.rodarie@unipv.it>
+Requires-Python: >=3.10,<4
+Description-Content-Type: text/markdown
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+License-File: LICENSE
+Requires-Dist: bsb-core~=6.0
+Requires-Dist: bsb-core[parallel] ; extra == "parallel"
+Provides-Extra: parallel
+
+[![Build Status](https://github.com/dbbs-lab/bsb-nest/actions/workflows/main.yml/badge.svg)](https://github.com/dbbs-lab/bsb-nest/actions/workflows/main.yml)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+
+# bsb-nest
+
+bsb-nest is a plugin of the [BSB](https://github.com/dbbs-lab/bsb). 
+It contains the interfaces and tools to simulate BSB circuit with the 
+[NEST simulator](https://www.nest-simulator.org/).
+

{bsb_nest-4.3.1 → bsb_nest-5.0.0}/README.md

@@ -1,9 +1,8 @@
 [![Build Status](https://github.com/dbbs-lab/bsb-nest/actions/workflows/main.yml/badge.svg)](https://github.com/dbbs-lab/bsb-nest/actions/workflows/main.yml)
-[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
 
 # bsb-nest
 
-bsb-nest is a pluggin of [BSB](https://github.com/dbbs-lab/bsb) (see also 
-[bsb-core](https://github.com/dbbs-lab/bsb-core)). 
+bsb-nest is a plugin of the [BSB](https://github.com/dbbs-lab/bsb). 
 It contains the interfaces and tools to simulate BSB circuit with the 
 [NEST simulator](https://www.nest-simulator.org/).

bsb_nest-5.0.0/bsb_nest/__init__.py

@@ -0,0 +1,27 @@
+"""
+NEST simulation adapter for the BSB framework.
+"""
+
+from bsb import SimulationBackendPlugin
+
+from .adapter import NestAdapter
+from .devices import (
+    DCGenerator,
+    Multimeter,
+    PoissonGenerator,
+    SinusoidalPoissonGenerator,
+    SpikeRecorder,
+)
+from .simulation import NestSimulation
+
+__plugin__ = SimulationBackendPlugin(Simulation=NestSimulation, Adapter=NestAdapter)
+
+__all__ = [
+    "DCGenerator",
+    "Multimeter",
+    "NestAdapter",
+    "NestSimulation",
+    "PoissonGenerator",
+    "SinusoidalPoissonGenerator",
+    "SpikeRecorder",
+]

{bsb_nest-4.3.1 → bsb_nest-5.0.0}/bsb_nest/adapter.py

@@ -1,9 +1,9 @@
+import contextlib
 import sys
 import typing
 
 import nest
 from bsb import (
-    MPI,
     AdapterError,
     AdapterProgress,
     SimulationData,
@@ -32,7 +32,7 @@ class NestResult(SimulationResult):
             segment.spiketrains.append(
                 SpikeTrain(
                     events["times"],
-                    waveforms=events["senders"],
+                    array_annotations={"senders": events["senders"]},
                     t_stop=nest.biological_time,
                     units="ms",
                     **annotations,
@@ -43,18 +43,38 @@ class NestResult(SimulationResult):
 
 
 class NestAdapter(SimulatorAdapter):
-    def __init__(self):
-        self.simdata = dict()
+    def __init__(self, comm=None):
+        super().__init__(comm=comm)
         self.loaded_modules = set()
 
-    def simulate(self, simulation):
+    def simulate(self, *simulations, post_prepare=None):
         try:
             self.reset_kernel()
-            return super().simulate(simulation)
+            return super().simulate(*simulations, post_prepare=post_prepare)
         finally:
             self.reset_kernel()
 
-    def prepare(self, simulation, comm=None):
+    def prepare(self, simulation):
+        """
+        Prepare the simulation environment in NEST.
+
+        This method initializes internal data structures and performs all
+        setup steps required before running the simulation:
+
+        - Loads and installs required NEST modules.
+        - Applies simulation-level settings (e.g., resolution, verbosity, seed).
+        - Creates neuron populations based on cell models.
+        - Establishes connectivity between neurons using connection models.
+        - Instantiates devices (e.g., recorders, stimuli) used in the simulation.
+
+        If any error occurs during preparation, the corresponding internal state
+        is cleaned up to avoid partial setups.
+
+        :param simulation: The simulation configuration to prepare.
+        :type simulation: NestSimulation
+        :returns: The prepared simulation data associated with the given simulation.
+        :rtype: bsb.simulation.adapter.SimulationData
+        """
         self.simdata[simulation] = SimulationData(
             simulation, result=NestResult(simulation)
         )
@@ -79,7 +99,7 @@ class NestAdapter(SimulatorAdapter):
         # to appropriately warn them when they load them twice.
         self.loaded_modules = set()
 
-    def run(self, *simulations, comm=None):
+    def run(self, *simulations):
         unprepared = [sim for sim in simulations if sim not in self.simdata]
         if unprepared:
             raise AdapterError(f"Unprepared for simulations: {', '.join(unprepared)}")
@@ -96,7 +116,7 @@ class NestAdapter(SimulatorAdapter):
             for sim in simulations:
                 del self.simdata[sim]
         progress.complete()
-        report(f"Simulation done.", level=2)
+        report("Simulation done.", level=2)
         return results
 
     def load_modules(self, simulation):
@@ -107,9 +127,10 @@ class NestAdapter(SimulatorAdapter):
             except Exception as e:
                 if e.errorname == "DynamicModuleManagementError":
                     if "loaded already" in e.message:
-                        # Modules stay loaded in between `ResetKernel` calls. If the module
-                        # is not in the `loaded_modules` set, then it's the first time this
-                        # `reset`/`prepare` cycle, and there is no user-side issue.
+                        # Modules stay loaded in between `ResetKernel` calls.
+                        # If the module is not in the `loaded_modules` set, then
+                        # it's the first time this `reset`/`prepare` cycle,
+                        # and there is no user-side issue.
                         if module in self.loaded_modules:
                             warn(f"Already loaded '{module}'.", KernelWarning)
                     elif "file not found" in e.message:
@@ -134,33 +155,33 @@ class NestAdapter(SimulatorAdapter):
         """
         simdata = self.simdata[simulation]
         iter = simulation.connection_models.values()
-        if MPI.get_rank() == 0:
+        if self.comm.get_rank() == 0:
             iter = tqdm(iter, desc="", file=sys.stdout)
         for connection_model in iter:
-            try:
-                iter.set_description(connection_model.name)
-            except AttributeError:
+            with contextlib.suppress(AttributeError):
                 # Only rank 0 should report progress bar
-                pass
+                iter.set_description(connection_model.name)
             cs = simulation.scaffold.get_connectivity_set(
                 connection_model.tag or connection_model.name
             )
             try:
                 pre_nodes = simdata.populations[simulation.get_model_of(cs.pre_type)]
             except KeyError:
-                raise NestModelError(f"No model found for {cs.pre_type}")
+                raise NestModelError(f"No model found for {cs.pre_type}") from None
             try:
                 post_nodes = simdata.populations[simulation.get_model_of(cs.post_type)]
             except KeyError:
-                raise NestModelError(f"No model found for {cs.post_type}")
+                raise NestModelError(f"No model found for {cs.post_type}") from None
             try:
                 simdata.connections[connection_model] = (
                     connection_model.create_connections(
-                        simdata, pre_nodes, post_nodes, cs
+                        simdata, pre_nodes, post_nodes, cs, self.comm
                     )
                 )
-            except Exception as e:
-                raise NestConnectError(f"{connection_model} error during connect.")
+            except Exception:
+                raise NestConnectError(
+                    f"{connection_model} error during connect."
+                ) from None
 
     def create_devices(self, simulation):
         simdata = self.simdata[simulation]
@@ -175,8 +196,8 @@ class NestAdapter(SimulatorAdapter):
             nest.rng_seed = simulation.seed
 
     def check_comm(self):
-        if nest.NumProcesses() != MPI.get_size():
+        if nest.NumProcesses() != self.comm.get_size():
             raise RuntimeError(
-                f"NEST is managing {nest.NumProcesses()} processes, but {MPI.get_size()}"
-                " were detected. Please check your MPI setup."
+                f"NEST is managing {nest.NumProcesses()} processes, but "
+                f"{self.comm.get_size()} were detected. Please check your MPI setup."
             )

{bsb_nest-4.3.1 → bsb_nest-5.0.0}/bsb_nest/cell.py

@@ -7,7 +7,9 @@ from .distributions import NestRandomDistribution, nest_parameter
 @config.node
 class NestCell(CellModel):
     model = config.attr(type=str, default="iaf_psc_alpha")
+    """Importable reference to the NEST model describing the cell type."""
     constants = config.dict(type=nest_parameter())
+    """Dictionary of the constants values to assign to the cell model."""
 
     def create_population(self, simdata):
         n = len(simdata.placement[self])

{bsb_nest-4.3.1 → bsb_nest-5.0.0}/bsb_nest/connection.py

@@ -4,7 +4,7 @@ import sys
 import nest
 import numpy as np
 import psutil
-from bsb import MPI, ConnectionModel, compose_nodes, config, types
+from bsb import ConnectionModel, compose_nodes, config, types
 from tqdm import tqdm
 
 from .distributions import nest_parameter
@@ -13,17 +13,32 @@ from .exceptions import NestConnectError
 
 @config.node
 class NestSynapseSettings:
+    """
+    Class interfacing a NEST synapse model.
+    """
+
     model = config.attr(type=str, default="static_synapse")
+    """Importable reference to the NEST model describing the synapse type."""
     weight = config.attr(type=float, required=True)
+    """Weight of the connection between the presynaptic and the postsynaptic cells."""
     delay = config.attr(type=float, required=True)
+    """Delay of the transmission between the presynaptic and the postsynaptic cells."""
     receptor_type = config.attr(type=int)
+    """Index of the postsynaptic receptor to target."""
     constants = config.catch_all(type=nest_parameter())
+    """Dictionary of the constants values to assign to the synapse model."""
 
 
 @config.node
 class NestConnectionSettings:
+    """
+    Class interfacing a NEST connection rule.
+    """
+
     rule = config.attr(type=str)
+    """Importable reference to the Nest connection rule used to connect the cells."""
     constants = config.catch_all(type=types.any_())
+    """Dictionary of parameters to assign to the connection rule."""
 
 
 class LazySynapseCollection:
@@ -50,10 +65,21 @@ class LazySynapseCollection:
 
 @config.dynamic(attr_name="model_strategy", required=False)
 class NestConnection(compose_nodes(NestConnectionSettings, ConnectionModel)):
-    tag = config.attr(type=str)
+    """
+    Class interfacing a NEST connection, including its connection rule and synaptic
+    parameters.
+    """
+
+    model_strategy: str
+    """
+    Specifies the strategy used by the connection model for synapse creation and
+    management.
+    """
+
     synapse = config.attr(type=NestSynapseSettings, required=True)
+    """Nest synapse model with its parameters."""
 
-    def create_connections(self, simdata, pre_nodes, post_nodes, cs):
+    def create_connections(self, simdata, pre_nodes, post_nodes, cs, comm):
         import nest
 
         syn_spec = self.get_syn_spec()
@@ -64,11 +90,11 @@ class NestConnection(compose_nodes(NestConnectionSettings, ConnectionModel)):
         if self.rule is not None:
             nest.Connect(pre_nodes, post_nodes, self.get_conn_spec(), syn_spec)
         else:
-            MPI.barrier()
+            comm.barrier()
             for pre_locs, post_locs in self.predict_mem_iterator(
-                pre_nodes, post_nodes, cs
+                pre_nodes, post_nodes, cs, comm
             ):
-                MPI.barrier()
+                comm.barrier()
                 if len(pre_locs) == 0 or len(post_locs) == 0:
                     continue
                 cell_pairs, multiplicity = np.unique(
@@ -89,36 +115,36 @@ class NestConnection(compose_nodes(NestConnectionSettings, ConnectionModel)):
                     ssw,
                     return_synapsecollection=False,
                 )
-            MPI.barrier()
+            comm.barrier()
         return LazySynapseCollection(pre_nodes, post_nodes)
 
-    def predict_mem_iterator(self, pre_nodes, post_nodes, cs):
+    def predict_mem_iterator(self, pre_nodes, post_nodes, cs, comm):
         avmem = psutil.virtual_memory().available
         predicted_all_mem = (
             len(pre_nodes) * 8 * 2 + len(post_nodes) * 8 * 2 + len(cs) * 6 * 8 * (16 + 2)
-        ) * MPI.get_size()
+        ) * comm.get_size()
         n_chunks = len(cs.get_local_chunks("out"))
         predicted_local_mem = (predicted_all_mem / n_chunks) if n_chunks > 0 else 0.0
         if predicted_local_mem > avmem / 2:
             # Iterate block-by-block
-            return self.block_iterator(cs)
+            return self.block_iterator(cs, comm)
         elif predicted_all_mem > avmem / 2:
             # Iterate local hyperblocks
-            return self.local_iterator(cs)
+            return self.local_iterator(cs, comm)
         else:
             # Iterate all
             return (cs.load_connections().as_globals().all(),)
 
-    def block_iterator(self, cs):
+    def block_iterator(self, cs, comm):
         locals = cs.get_local_chunks("out")
 
         def block_iter():
             iter = locals
-            if MPI.get_rank() == 0:
+            if comm.get_rank() == 0:
                 iter = tqdm(iter, desc="hyperblocks", file=sys.stdout)
             for local in iter:
                 inner_iter = cs.load_connections().as_globals().from_(local)
-                if MPI.get_rank() == 0:
+                if comm.get_rank() == 0:
                     yield from tqdm(
                         inner_iter,
                         desc="blocks",
@@ -131,9 +157,9 @@ class NestConnection(compose_nodes(NestConnectionSettings, ConnectionModel)):
 
         return block_iter()
 
-    def local_iterator(self, cs):
+    def local_iterator(self, cs, comm):
         iter = cs.get_local_chunks("out")
-        if MPI.get_rank() == 0:
+        if comm.get_rank() == 0:
             iter = tqdm(iter, desc="hyperblocks", file=sys.stdout)
         yield from (
             cs.load_connections().as_globals().from_(local).all() for local in iter

{bsb_nest-4.3.1 → bsb_nest-5.0.0}/bsb_nest/device.py

@@ -1,23 +1,28 @@
-import typing
+import abc
 import warnings
 
 import nest
-from bsb import DeviceModel, SimulationData, Targetting, config, refs, types
-
-if typing.TYPE_CHECKING:
-    from .adapter import NestAdapter
-    from .simulation import NestSimulation
+from bsb import DeviceModel, Targetting, config, refs, types
 
 
 @config.node
 class NestRule:
+    """
+    Interface to connect a device directly through the NEST interface.
+    """
+
     rule = config.attr(type=str, required=True)
+    """Connection rule to connect """
     constants = config.catch_all(type=types.any_())
+    """Dictionary of parameters for the targetting rule."""
     cell_models = config.reflist(refs.sim_cell_model_ref)
+    """Reference to the Nest cell model to target with the Device"""
 
 
 @config.dynamic(attr_name="device", auto_classmap=True, default="external")
 class NestDevice(DeviceModel):
+    device: str
+    """Name of the NEST device model (e.g., "spike_generator", "poisson_generator")."""
     weight = config.attr(type=float, required=True)
     """weight of the connection between the device and its target"""
     delay = config.attr(type=float, required=True)
@@ -31,17 +36,17 @@ class NestDevice(DeviceModel):
 
     def get_dict_targets(
         self,
-        adapter: "NestAdapter",
-        simulation: "NestSimulation",
-        simdata: "SimulationData",
+        adapter,
+        simulation,
+        simdata,
     ) -> dict:
         """
         Get a dictionary from a target group to its NEST Collection
         for each target group of the device.
 
-        :param bsb_nest.NestAdapter adapter:
-        :param bsb_nest.NestSimulation simulation: Nest simulation instance
-        :param bsb.SimulationData simdata: Simulation data instance
+        :param bsb_nest.adapter.NestAdapter adapter: Nest adapter instance
+        :param bsb_nest.simulation.NestSimulation simulation: Nest simulation instance
+        :param bsb.simulation.adapter.SimulationData simdata: Simulation data instance
         :return: dictionary of device target group to NEST Collection
         :rtype: dict
         """
@@ -65,16 +70,16 @@ class NestDevice(DeviceModel):
 
     def get_target_nodes(
         self,
-        adapter: "NestAdapter",
-        simulation: "NestSimulation",
-        simdata: "SimulationData",
+        adapter,
+        simulation,
+        simdata,
     ):
         """
         Get the NEST Collection of the targets of the device.
 
-        :param bsb_nest.NestAdapter adapter:
-        :param bsb_nest.NestSimulation simulation: Nest simulation instance
-        :param bsb.SimulationData simdata: Simulation data instance
+        :param bsb_nest.adapter.NestAdapter adapter:
+        :param bsb_nest.simulation.NestSimulation simulation: Nest simulation instance
+        :param bsb.simulation.adapter.SimulationData simdata: Simulation data instance
         :return: Flattened NEST collection with all the targets of the device
         """
         targets_dict = self.get_dict_targets(adapter, simulation, simdata)
@@ -82,7 +87,7 @@ class NestDevice(DeviceModel):
 
     def connect_to_nodes(self, device, nodes):
         if len(nodes) == 0:
-            warnings.warn(f"{self.name} has no targets")
+            warnings.warn(f"{self.name} has no targets", stacklevel=2)
         else:
             try:
                 nest.Connect(
@@ -108,11 +113,33 @@ class NestDevice(DeviceModel):
         simdata.devices[self] = device
         return device
 
+    @abc.abstractmethod
+    def implement(
+        self,
+        adapter,
+        simulation,
+        simdata,
+    ):
+        """
+        Create, connect and register the Nest device.
+
+        :param bsb_nest.adapter.NestAdapter adapter:
+        :param bsb_nest.simulation.NestSimulation simulation: Nest simulation instance
+        :param bsb.simulation.adapter.SimulationData simdata: Simulation data instance
+        """
+        pass
+
 
 @config.node
 class ExtNestDevice(NestDevice, classmap_entry="external"):
+    """
+    Class interfacing Nest devices.
+    """
+
     nest_model = config.attr(type=str, required=True)
+    """Importable reference to the NEST model describing the device type."""
     constants = config.dict(type=types.or_(types.number(), str))
+    """Dictionary of the constants values to assign to the device model."""
 
     def implement(self, adapter, simulation, simdata):
         simdata.devices[self] = device = nest.Create(

{bsb_nest-4.3.1 → bsb_nest-5.0.0}/bsb_nest/devices/__init__.py

@@ -3,3 +3,11 @@ from .multimeter import Multimeter
 from .poisson_generator import PoissonGenerator
 from .sinusoidal_poisson_generator import SinusoidalPoissonGenerator
 from .spike_recorder import SpikeRecorder
+
+__all__ = [
+    "DCGenerator",
+    "Multimeter",
+    "PoissonGenerator",
+    "SinusoidalPoissonGenerator",
+    "SpikeRecorder",
+]

{bsb_nest-4.3.1 → bsb_nest-5.0.0}/bsb_nest/devices/multimeter.py

@@ -18,13 +18,12 @@ class Multimeter(NestDevice, classmap_entry="multimeter"):
     def boot(self):
         _util.assert_samelen(self.properties, self.units)
         for i in range(len(self.units)):
-            if not self.units[i] in pq.units.__dict__.keys():
+            if self.units[i] not in pq.units.__dict__:
                 raise ConfigurationError(
                     f"Unit {self.units[i]} not in the list of known units of quantities"
                 )
 
     def implement(self, adapter, simulation, simdata):
-
         targets_dict = self.get_dict_targets(adapter, simulation, simdata)
         nodes = self._flatten_nodes_ids(targets_dict)
         inv_targets = self._invert_targets_dict(targets_dict)
@@ -44,7 +43,7 @@ class Multimeter(NestDevice, classmap_entry="multimeter"):
             senders = device.events["senders"]
             for sender in np.unique(senders):
                 sender_filter = senders == sender
-                for prop, unit in zip(self.properties, self.units):
+                for prop, unit in zip(self.properties, self.units, strict=False):
                     segment.analogsignals.append(
                         AnalogSignal(
                             device.events[prop][sender_filter],

{bsb_nest-4.3.1 → bsb_nest-5.0.0}/bsb_nest/devices/poisson_generator.py

@@ -32,7 +32,7 @@ class PoissonGenerator(NestDevice, classmap_entry="poisson_generator"):
                 SpikeTrain(
                     sr.events["times"],
                     units="ms",
-                    senders=sr.events["senders"],
+                    array_annotations={"senders": sr.events["senders"]},
                     t_stop=simulation.duration,
                     device=self.name,
                     pop_size=len(nodes),

{bsb_nest-4.3.1 → bsb_nest-5.0.0}/bsb_nest/devices/sinusoidal_poisson_generator.py

@@ -24,11 +24,11 @@ class SinusoidalPoissonGenerator(
         If not specified, generator will last until the end of the simulation."""
 
     def boot(self):
-        if self.stop is not None:
-            if self.stop <= self.start:
-                raise ConfigurationError(
-                    f"Stop time (given: {self.stop}) must be greater than start time (given: {self.start})."
-                )
+        if self.stop is not None and self.stop <= self.start:
+            raise ConfigurationError(
+                f"Stop time (given: {self.stop}) must be greater than start time "
+                f"(given: {self.start})."
+            )
 
     def implement(self, adapter, simulation, simdata):
         nodes = self.get_target_nodes(adapter, simulation, simdata)
@@ -53,7 +53,7 @@ class SinusoidalPoissonGenerator(
                 SpikeTrain(
                     sr.events["times"],
                     units="ms",
-                    senders=sr.events["senders"],
+                    array_annotations={"senders": sr.events["senders"]},
                     t_stop=simulation.duration,
                     device=self.name,
                     pop_size=len(nodes),

{bsb_nest-4.3.1 → bsb_nest-5.0.0}/bsb_nest/devices/spike_recorder.py

@@ -10,7 +10,6 @@ class SpikeRecorder(NestDevice, classmap_entry="spike_recorder"):
     weight = config.provide(1)
 
     def implement(self, adapter, simulation, simdata):
-
         nodes = self.get_target_nodes(adapter, simulation, simdata)
         device = self.register_device(simdata, nest.Create("spike_recorder"))
         self.connect_to_nodes(device, nodes)
@@ -20,7 +19,7 @@ class SpikeRecorder(NestDevice, classmap_entry="spike_recorder"):
                 SpikeTrain(
                     device.events["times"],
                     units="ms",
-                    senders=device.events["senders"],
+                    array_annotations={"senders": device.events["senders"]},
                     t_stop=simulation.duration,
                     device=self.name,
                     pop_size=len(nodes),

{bsb_nest-4.3.1 → bsb_nest-5.0.0}/bsb_nest/distributions.py

@@ -3,10 +3,7 @@ import typing
 
 import errr
 import nest.random.hl_api_random as _distributions
-from bsb import DistributionCastError, TypeHandler, config, types
-
-if typing.TYPE_CHECKING:
-    from bsb import Scaffold
+from bsb import DistributionCastError, Scaffold, TypeHandler, config, types
 
 _available_distributions = [d for d in _distributions.__all__]
 
@@ -23,7 +20,8 @@ class NestRandomDistribution:
     )
     """Distribution name. Should correspond to a function of nest.random.hl_api_random"""
     parameters: dict[str, typing.Any] = config.catch_all(type=types.any_())
-    """Dictionary of parameters to assign to the distribution. Should correspond to NEST's"""
+    """Dictionary of parameters to assign to the distribution. 
+    Should correspond to NEST's"""
 
     def __init__(self, **kwargs):
         try:
@@ -45,12 +43,12 @@ class NestRandomDistribution:
 
 class nest_parameter(TypeHandler):
     """
-    Type validator. Type casts the value or node to a Nest parameter, that can be either a value or
-    a NestRandomDistribution.
+    Type validator. Type casts the value or node to a Nest parameter, that can be either
+    a value or a NestRandomDistribution.
     """
 
     def __call__(self, value, _key=None, _parent=None):
-        if isinstance(value, builtins.dict) and "distribution" in value.keys():
+        if isinstance(value, builtins.dict) and "distribution" in value:
             return NestRandomDistribution(**value, _key=_key, _parent=_parent)
         return value
 

{bsb_nest-4.3.1 → bsb_nest-5.0.0}/bsb_nest/simulation.py

@@ -22,6 +22,15 @@ class NestSimulation(Simulation):
     seed = config.attr(type=int, default=None)
     """Random seed for the simulations"""
 
-    cell_models = config.dict(type=NestCell, required=True)
-    connection_models = config.dict(type=NestConnection, required=True)
-    devices = config.dict(type=NestDevice, required=True)
+    cell_models: config._attrs.cfgdict[NestCell] = config.dict(
+        type=NestCell, required=True
+    )
+    """Dictionary of cell models in the simulation."""
+    connection_models: config._attrs.cfgdict[NestConnection] = config.dict(
+        type=NestConnection, required=True
+    )
+    """Dictionary of connection models in the simulation."""
+    devices: config._attrs.cfgdict[NestDevice] = config.dict(
+        type=NestDevice, required=True
+    )
+    """Dictionary of devices in the simulation."""

bsb_nest-5.0.0/pyproject.toml

@@ -0,0 +1,67 @@
+dependency-groups = { }
+
+[build-system]
+requires = [ "flit_core >=3.2,<4" ]
+build-backend = "flit_core.buildapi"
+
+[project]
+name = "bsb-nest"
+version = "5.0.0"
+readme = "README.md"
+requires-python = ">=3.10,<4"
+dynamic = [ "description" ]
+classifiers = [
+  "License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)"
+]
+dependencies = [ "bsb-core~=6.0" ]
+
+  [[project.authors]]
+  name = "Robin De Schepper"
+  email = "robin@alexandria.sc"
+
+  [[project.authors]]
+  name = "Dimitri Rodarie"
+  email = "dimitri.rodarie@unipv.it"
+
+  [project.license]
+  file = "LICENSE"
+
+  [project.optional-dependencies]
+  parallel = [ "bsb-core[parallel]" ]
+
+[project.entry-points."bsb.simulation_backends"]
+nest = "bsb_nest"
+
+[tool.uv]
+default-groups = [ "dev", "docs", "test" ]
+sources = { }
+
+[tool.flit.module]
+name = "bsb_nest"
+
+[tool.coverage.run]
+branch = true
+source = [ "bsb_nest" ]
+
+[tool.coverage.report]
+exclude_lines = [ "if TYPE_CHECKING:" ]
+show_missing = true
+
+[tool.ruff]
+exclude = [ ".ruff_cache", ".svn", ".tox", ".venv", "dist" ]
+line-length = 90
+indent-width = 4
+
+  [tool.ruff.format]
+  quote-style = "double"
+  indent-style = "space"
+  skip-magic-trailing-comma = false
+  line-ending = "auto"
+  docstring-code-format = true
+  docstring-code-line-length = 90
+
+  [tool.ruff.lint]
+  select = [ "E", "F", "UP", "B", "SIM", "I" ]
+  ignore = [ ]
+  fixable = [ "ALL" ]
+  unfixable = [ ]

bsb_nest-4.3.1/PKG-INFO

@@ -1,36 +0,0 @@
-Metadata-Version: 2.3
-Name: bsb-nest
-Version: 4.3.1
-Summary: NEST simulation adapter for the BSB framework.
-Author-email: Robin De Schepper <robingilbert.deschepper@unipv.it>
-Description-Content-Type: text/markdown
-Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
-Requires-Dist: bsb-core~=4.1
-Requires-Dist: bsb-nest[test] ; extra == "dev"
-Requires-Dist: build~=1.0 ; extra == "dev"
-Requires-Dist: twine~=4.0 ; extra == "dev"
-Requires-Dist: pre-commit~=3.5 ; extra == "dev"
-Requires-Dist: black~=24.1.1 ; extra == "dev"
-Requires-Dist: isort~=5.12 ; extra == "dev"
-Requires-Dist: snakeviz~=2.1 ; extra == "dev"
-Requires-Dist: bump-my-version~=0.24 ; extra == "dev"
-Requires-Dist: bsb-core[parallel] ; extra == "parallel"
-Requires-Dist: bsb-core[parallel] ; extra == "test"
-Requires-Dist: bsb-test~=4.0 ; extra == "test"
-Requires-Dist: bsb-hdf5~=4.0 ; extra == "test"
-Requires-Dist: bsb-arbor~=4.0 ; extra == "test"
-Requires-Dist: coverage~=7.0 ; extra == "test"
-Provides-Extra: dev
-Provides-Extra: parallel
-Provides-Extra: test
-
-[![Build Status](https://github.com/dbbs-lab/bsb-nest/actions/workflows/main.yml/badge.svg)](https://github.com/dbbs-lab/bsb-nest/actions/workflows/main.yml)
-[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
-
-# bsb-nest
-
-bsb-nest is a pluggin of [BSB](https://github.com/dbbs-lab/bsb) (see also 
-[bsb-core](https://github.com/dbbs-lab/bsb-core)). 
-It contains the interfaces and tools to simulate BSB circuit with the 
-[NEST simulator](https://www.nest-simulator.org/).
-

bsb_nest-4.3.1/bsb_nest/__init__.py

@@ -1,12 +0,0 @@
-"""
-NEST simulation adapter for the BSB framework.
-"""
-
-from bsb import SimulationBackendPlugin
-
-from . import devices
-from .adapter import NestAdapter
-from .simulation import NestSimulation
-
-__plugin__ = SimulationBackendPlugin(Simulation=NestSimulation, Adapter=NestAdapter)
-__version__ = "4.3.1"

bsb_nest-4.3.1/pyproject.toml

@@ -1,70 +0,0 @@
-[build-system]
-requires = ["flit_core >=3.2,<4"]
-build-backend = "flit_core.buildapi"
-
-[project]
-name = "bsb-nest"
-authors = [{name = "Robin De Schepper", email = "robingilbert.deschepper@unipv.it"}]
-readme = "README.md"
-license = {file = "LICENSE"}
-classifiers = ["License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)"]
-dynamic = ["version", "description"]
-dependencies = ["bsb-core~=4.1"]
-
-[tool.flit.module]
-name = "bsb_nest"
-
-[project.entry-points."bsb.simulation_backends"]
-nest = "bsb_nest"
-
-[project.optional-dependencies]
-parallel = ["bsb-core[parallel]"]
-test = [
-    "bsb-core[parallel]",
-    "bsb-test~=4.0",
-    "bsb-hdf5~=4.0",
-    # Required to load the Brunel config file
-    "bsb-arbor~=4.0",
-    "coverage~=7.0"
-]
-dev = [
-    "bsb-nest[test]",
-    "build~=1.0",
-    "twine~=4.0",
-    "pre-commit~=3.5",
-    "black~=24.1.1",
-    "isort~=5.12",
-    "snakeviz~=2.1",
-    "bump-my-version~=0.24"
-]
-
-[tool.black]
-line-length = 90
-
-[tool.isort]
-profile = "black"
-known_third_party = ["nest"]
-
-[tool.bumpversion]
-current_version = "4.3.1"
-parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
-serialize = ["{major}.{minor}.{patch}"]
-search = "{current_version}"
-replace = "{new_version}"
-regex = false
-ignore_missing_version = false
-tag = true
-sign_tags = false
-tag_name = "v{new_version}"
-tag_message = "Bump version: {current_version} → {new_version}"
-allow_dirty = false
-commit = true
-message = "Bump version: {current_version} → {new_version}"
-commit_args = "--no-verify"
-
-[tool.bumpversion.parts.pre_l]
-values = ["dev", "a", "b", "rc", "final"]
-optional_value = "final"
-
-[[tool.bumpversion.files]]
-filename = "bsb_nest/__init__.py"