bsb-arbor 4.1.1__tar.gz → 6.0.0__tar.gz

bsb_arbor-6.0.0/PKG-INFO

@@ -0,0 +1,23 @@
+Metadata-Version: 2.4
+Name: bsb-arbor
+Version: 6.0.0
+Summary: Arbor 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: numpy~=1.21
+Requires-Dist: bsb-core~=6.0
+Requires-Dist: arborize~=6.0
+Requires-Dist: arbor~=0.10; sys_platform != 'win32'
+
+[![Build Status](https://github.com/dbbs-lab/bsb-arbor/actions/workflows/main.yml/badge.svg)](https://github.com/dbbs-lab/bsb-arbor/actions/workflows/main.yml)
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+
+# bsb-arbor
+
+bsb-arbor is a plugin of the [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 
+[Arbor simulator](https://arbor-sim.org/).

{bsb_arbor-4.1.1 → bsb_arbor-6.0.0}/README.md

@@ -3,7 +3,7 @@
 
 # bsb-arbor
 
-bsb-nest is a plugin of the [BSB](https://github.com/dbbs-lab/bsb) (see also 
+bsb-arbor is a plugin of the [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 
 [Arbor simulator](https://arbor-sim.org/).

bsb_arbor-6.0.0/bsb_arbor/__init__.py

@@ -0,0 +1,20 @@
+"""
+Arbor simulation adapter for the BSB framework.
+"""
+
+from bsb import SimulationBackendPlugin
+
+from .adapter import ArborAdapter
+from .devices import PoissonGenerator, Probe, SpikeRecorder
+from .simulation import ArborSimulation
+
+__plugin__ = SimulationBackendPlugin(Simulation=ArborSimulation, Adapter=ArborAdapter)
+
+
+__all__ = [
+    "PoissonGenerator",
+    "Probe",
+    "SpikeRecorder",
+    "ArborAdapter",
+    "ArborSimulation",
+]

{bsb_arbor-4.1.1 → bsb_arbor-6.0.0}/bsb_arbor/adapter.py

@@ -7,7 +7,6 @@ import arbor
 import numpy as np
 from arbor import units as U
 from bsb import (
-    MPI,
     AdapterError,
     Chunk,
     SimulationData,
@@ -22,9 +21,16 @@ if typing.TYPE_CHECKING:
 
 
 class ArborSimulationData(SimulationData):
+    """
+    Container class for simulation data.
+    """
+
     def __init__(self, simulation):
+        """
+        Container class for simulation data.
+        """
         super().__init__(simulation)
-        self.arbor_sim: "arbor.simulation" = None
+        self.arbor_sim: arbor.simulation = None
 
 
 class ReceiverCollection(list):
@@ -47,7 +53,8 @@ class ReceiverCollection(list):
 
 class SingleReceiverCollection(list):
     """
-    The single receiver collection redirects all incoming connections to the same receiver
+    The single receiver collection redirects all incoming connections to the same
+    receiver.
     """
 
     def append(self, rcv):
@@ -56,7 +63,20 @@ class SingleReceiverCollection(list):
 
 
 class Population:
+    """
+    Represents a population of cells for the Arbor simulator.
+
+    This class manages a collection of cells from a specific cell model, handling their
+    GID ranges and providing methods to access and manipulate subsets of the population.
+    """
     def __init__(self, simdata, cell_model, offset):
+        """
+        Initialize a population of cells.
+
+        :param simdata: The simulation data container
+        :param cell_model: The cell model for this population
+        :param offset: The GID offset for this population
+        """
         self._model = cell_model
         self._simdata = simdata
         ps = cell_model.get_placement_set(simdata.chunks)
@@ -65,30 +85,70 @@ class Population:
 
     @property
     def model(self):
+        """
+        Get the cell model associated with this population.
+
+        :return: The cell model object
+        """
         return self._model
 
     @property
     def offset(self):
+        """
+        Get the GID offset for this population.
+
+        :return: The GID offset value
+        """
         return self._offset
 
     def __len__(self):
+        """
+        Get the total number of cells in this population.
+
+        :return: The number of cells
+        """
         return sum(stop - start for start, stop in self._ranges)
 
     def __contains__(self, i):
+        """
+        Check if a GID is part of this population.
+
+        :param i: The GID to check
+        :return: True if the GID is in this population, False otherwise
+        """
         return any(start <= i < stop for start, stop in self._ranges)
 
     def copy(self):
+        """
+        Create a copy of this population.
+
+        :return: A new Population instance with the same properties
+        """
         return Population(self._simdata, self._model, self._offset)
 
     def __getitem__(self, item):
+        """
+        Get a subset of the population based on the provided index or mask.
+
+        Supports various indexing methods:
+        - Boolean masking: Select cells based on a boolean mask
+        - Integer indexing: Select specific cells by their indices
+        - Slicing: Select a range of cells
+
+        :param item: The index, slice, or mask to use for selection
+        :return: A new Population instance containing the selected cells
+        :raises ValueError: If the dimensions of the mask don't match the population
+        :raises IndexError: If an index is out of bounds
+        """
         # Boolean masking, kind of
-        if getattr(item, "dtype", None) == bool or _all_bools(item):
+        if getattr(item, "dtype", None) == bool or _all_bools(item):  # noqa: E721
             if len(item) != len(self):
                 raise ValueError(
-                    f"Dimension mismatch between population ({len(self)}) and mask ({len(item)})"
+                    f"Dimension mismatch between population ({len(self)}) "
+                    f"and mask ({len(item)})"
                 )
             return self._subpop_np(np.array(self)[item])
-        elif getattr(item, "dtype", None) == int or _all_ints(item):
+        elif getattr(item, "dtype", None) == int or _all_ints(item):  # noqa: E721
             if getattr(item, "ndim", None) == 0:
                 return self._subpop_one(item)
             return self._subpop_np(np.array(self)[item])
@@ -98,6 +158,14 @@ class Population:
             return self._subpop_one(item)
 
     def _get_ranges(self, chunks, ps, offset):
+        """
+        Calculate the GID ranges for this population based on chunk statistics.
+
+        :param chunks: The simulation chunks to include
+        :param ps: The placement set for the cell model
+        :param offset: The starting GID offset
+        :return: A list of (start, stop) tuples representing GID ranges
+        """
         stats = ps.get_chunk_stats()
         ranges = []
         for chunk, len_ in sorted(
@@ -109,6 +177,15 @@ class Population:
         return ranges
 
     def _subpop_np(self, arr):
+        """
+        Create a subpopulation from a numpy array of indices.
+
+        This method handles array-based indexing, including boolean masks,
+        integer arrays, and slices.
+
+        :param arr: A numpy array of indices to include in the subpopulation
+        :return: A new Population instance containing only the selected cells
+        """
         pop = self.copy()
         if not len(pop):
             return pop
@@ -130,6 +207,13 @@ class Population:
         return pop
 
     def _subpop_one(self, item):
+        """
+        Create a subpopulation containing a single cell.
+
+        :param item: The index of the cell to include
+        :return: A new Population instance containing only the selected cell
+        :raises IndexError: If the index is out of bounds
+        """
         if item >= len(self):
             raise IndexError(f"Index {item} out of bounds for size {len(self)}")
         pop = self.copy()
@@ -142,9 +226,12 @@ class Population:
                 ptr += stop - start
 
     def __iter__(self):
-        yield from itertools.chain.from_iterable(
-            range(r[0], r[1]) for r in self._ranges
-        )
+        """
+        Iterate over all GIDs in this population.
+
+        :yield: Each GID in the population's ranges
+        """
+        yield from itertools.chain.from_iterable(range(r[0], r[1]) for r in self._ranges)
 
 
 class GIDManager:
@@ -281,36 +368,27 @@ class ArborRecipe(arbor.recipe):
 
 
 class ArborAdapter(SimulatorAdapter):
-    def __init__(self):
-        super().__init__()
-        self.simdata: typing.Dict["ArborSimulation", "SimulationData"] = {}
-
-    def get_rank(self):
-        return MPI.get_rank()
-
-    def get_size(self):
-        return MPI.get_size()
-
-    def broadcast(self, data, root=0):
-        return MPI.bcast(data, root)
-
-    def barrier(self):
-        return MPI.barrier()
-
-    def prepare(self, simulation: "ArborSimulation", comm=None):
+    def __init__(self, comm=None):
+        super().__init__(comm)
+        self.simdata: dict[ArborSimulation, ArborSimulationData] = {}
+
+    def prepare(self, simulation: "ArborSimulation") -> ArborSimulationData:
+        """
+        Prepares the arbor simulation engine with the given simulation.
+        """
         simdata = self._create_simdata(simulation)
         try:
             context = arbor.context(arbor.proc_allocation(threads=simulation.threads))
-            if MPI.get_size() > 1:
+            if self.comm.get_size() > 1:
                 if not arbor.config()["mpi4py"]:
                     warn(
                         f"Arbor does not seem to be built with MPI support, running"
-                        "duplicate simulations on {MPI.get_size()} nodes."
+                        f"duplicate simulations on {self.comm.get_size()} nodes."
                     )
                 else:
                     context = arbor.context(
                         arbor.proc_allocation(threads=simulation.threads),
-                        mpi=comm or MPI.get_communicator(),
+                        mpi=self.comm.get_communicator(),
                     )
             if simulation.profiling:
                 if arbor.config()["profiling"]:
@@ -318,7 +396,8 @@ class ArborAdapter(SimulatorAdapter):
                     arbor.profiler_initialize(context)
                 else:
                     raise RuntimeError(
-                        "Arbor must be built with profiling support to use the `profiling` flag."
+                        "Arbor must be built with profiling support to use the "
+                        "`profiling` flag."
                     )
             simdata.gid_manager = self.get_gid_manager(simulation, simdata)
             simdata.populations = simdata.gid_manager.get_populations()
@@ -342,12 +421,13 @@ class ArborAdapter(SimulatorAdapter):
 
     def prepare_samples(self, simulation, simdata):
         for device in simulation.devices.values():
-            device.prepare_samples(simdata)
+            device.prepare_samples(simdata, comm=self.comm)
 
     def run(self, *simulations):
         if len(simulations) != 1:
             raise RuntimeError(
-                "Can not run multiple simultaneous simulations. Composition not implemented."
+                "Can not run multiple simultaneous simulations. Composition not "
+                "implemented."
             )
         simulation = simulations[0]
         try:
@@ -358,7 +438,7 @@ class ArborAdapter(SimulatorAdapter):
                 f"Can't run unprepared simulation '{simulation.name}'"
             ) from None
         try:
-            if not MPI.get_rank():
+            if not self.comm.get_rank():
                 arbor_sim.record(arbor.spike_recording.all)
 
             start = time.time()
@@ -381,7 +461,7 @@ class ArborAdapter(SimulatorAdapter):
         return ArborRecipe(simulation, simdata)
 
     def _create_simdata(self, simulation):
-        self.simdata[simulation] = simdata = SimulationData(simulation)
+        self.simdata[simulation] = simdata = ArborSimulationData(simulation)
         self._assign_chunks(simulation, simdata)
         return simdata
 
@@ -431,14 +511,14 @@ class ArborAdapter(SimulatorAdapter):
 
     def _assign_chunks(self, simulation, simdata):
         chunk_stats = simulation.scaffold.storage.get_chunk_stats()
-        size = MPI.get_size()
-        all_chunks = [Chunk.from_id(int(chunk), None) for chunk in chunk_stats.keys()]
+        size = self.comm.get_size()
+        all_chunks = [Chunk.from_id(int(chunk), None) for chunk in chunk_stats]
         simdata.node_chunk_alloc = [all_chunks[rank::size] for rank in range(0, size)]
         simdata.chunk_node_map = {}
         for node, chunks in enumerate(simdata.node_chunk_alloc):
             for chunk in chunks:
                 simdata.chunk_node_map[chunk] = node
-        simdata.chunks = simdata.node_chunk_alloc[MPI.get_rank()]
+        simdata.chunks = simdata.node_chunk_alloc[self.comm.get_rank()]
 
 
 def _all_bools(arr):

{bsb_arbor-4.1.1 → bsb_arbor-6.0.0}/bsb_arbor/cell.py

@@ -1,14 +1,10 @@
 import abc
-import typing
 
 import arbor
-from bsb import CellModel, ConfigurationError, config, types
+from bsb import CellModel, ConfigurationError, PlacementSet, config, types
 
 from .adapter import SingleReceiverCollection
 
-if typing.TYPE_CHECKING:
-    from bsb import PlacementSet
-
 
 @config.dynamic(
     attr_name="model_strategy",
@@ -17,11 +13,18 @@ if typing.TYPE_CHECKING:
     classmap_entry=None,
 )
 class ArborCell(CellModel):
+    model_strategy: config.ConfigurationAttribute
+    """
+    Optional importable reference to a different modelling strategy than the default
+    Arborize strategy.
+    """
     gap = config.attr(type=bool, default=False)
+    """Is this synapse a gap junction?"""
     model = config.attr(type=types.class_(), required=True)
+    """Importable reference to the arborize model describing the cell type."""
 
     @abc.abstractmethod
-    def cache_population_data(self, simdata, ps: "PlacementSet"):
+    def cache_population_data(self, simdata, ps: PlacementSet):
         pass
 
     @abc.abstractmethod
@@ -51,9 +54,11 @@ class ArborCell(CellModel):
 @config.node
 class LIFCell(ArborCell, classmap_entry="lif"):
     model = config.unset()
+    """Importable reference to the arborize model describing the cell type."""
     constants = config.dict(type=types.any_())
+    """Dictionary linking the parameters' name to its value."""
 
-    def cache_population_data(self, simdata, ps: "PlacementSet"):
+    def cache_population_data(self, simdata, ps: PlacementSet):
         pass
 
     def discard_population_data(self):
@@ -66,7 +71,7 @@ class LIFCell(ArborCell, classmap_entry="lif"):
         return arbor.cell_kind.lif
 
     def get_description(self, gid):
-        cell = arbor.lif_cell(f"-1_-1", f"-1_-1_0")
+        cell = arbor.lif_cell("-1_-1", "-1_-1_0")
         try:
             for k, v in self.constants.items():
                 setattr(cell, k, v * getattr(cell, k).units)

{bsb_arbor-4.1.1 → bsb_arbor-6.0.0}/bsb_arbor/connection.py

@@ -41,8 +41,11 @@ class Connection:
 @config.node
 class ArborConnection(ConnectionModel):
     gap = config.attr(type=bool, default=False)
+    """Is this synapce a gap junction?"""
     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."""
 
     def create_gap_junctions_on(self, gj_on_gid, conns):
         for pre_loc, post_loc in conns:
@@ -56,12 +59,10 @@ class ArborConnection(ConnectionModel):
             )
 
     def create_connections_from(self, conns_from_gid, conns, pop_pre, pop_post):
-        for pre_loc, post_loc in conns:
+        for pre_loc, _post_loc in conns:
             conns_from_gid[int(pre_loc[0] + pop_pre.offset)].append(pre_loc[1:])
 
     def gap_junction(self, conn):
-        l = arbor.cell_local_label(f"gap_{conn.to_compartment.id}")
-        g = arbor.cell_global_label(
-            int(conn.from_id), f"gap_{conn.from_compartment.id}"
-        )
-        return arbor.gap_junction_connection(g, l, self.weight)
+        l_ = arbor.cell_local_label(f"gap_{conn.to_compartment.id}")
+        g = arbor.cell_global_label(int(conn.from_id), f"gap_{conn.from_compartment.id}")
+        return arbor.gap_junction_connection(g, l_, self.weight)

{bsb_arbor-4.1.1 → bsb_arbor-6.0.0}/bsb_arbor/device.py

@@ -6,9 +6,14 @@ from bsb import DeviceModel, Targetting, config, types
 
 @config.dynamic(attr_name="device", auto_classmap=True, classmap_entry=None)
 class ArborDevice(DeviceModel):
+    device: config.ConfigurationAttribute
+    """Optional importable reference to the device strategy."""
     targetting = config.attr(type=Targetting, required=True)
+    """Targets of the device, which should be either a population or a nest rule."""
     resolution = config.attr(type=float)
+    """Time resolution of the device."""
     sampling_policy = config.attr(type=types.in_(["exact"]))
+    """Policy used to sample simulation data from the device."""
 
     def __init__(self, **kwargs):
         self._probe_ids = []
@@ -19,7 +24,7 @@ class ArborDevice(DeviceModel):
     def register_probe_id(self, gid, tag):
         self._probe_ids.append((gid, tag))
 
-    def prepare_samples(self, simdata):
+    def prepare_samples(self, simdata, comm):
         self._handles = [
             self.sample(simdata.arbor_sim, probe_id) for probe_id in self._probe_ids
         ]
@@ -34,7 +39,7 @@ class ArborDevice(DeviceModel):
 
     def get_meta(self):
         attrs = ("name", "sampling_policy", "resolution")
-        return dict(zip(attrs, (getattr(self, attr) for attr in attrs)))
+        return dict(zip(attrs, (getattr(self, attr) for attr in attrs), strict=False))
 
     @abc.abstractmethod
     def implement_probes(self, simdata, target):

{bsb_arbor-4.1.1 → bsb_arbor-6.0.0}/bsb_arbor/devices/__init__.py

@@ -1,3 +1,9 @@
 from .poisson_generator import PoissonGenerator
 from .probe import Probe
 from .spike_recorder import SpikeRecorder
+
+__all__ = [
+    "PoissonGenerator",
+    "Probe",
+    "SpikeRecorder",
+]

{bsb_arbor-4.1.1 → bsb_arbor-6.0.0}/bsb_arbor/devices/poisson_generator.py

@@ -9,9 +9,13 @@ from ..device import ArborDevice
 @config.node
 class PoissonGenerator(ArborDevice, classmap_entry="poisson_generator"):
     record = config.attr(type=bool, default=True)
+    """Flag to save the spikes generated to file."""
     rate = config.attr(type=float, required=True)
+    """Frequency of the 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)
+    """Delay of the transmission between the device and its target."""
 
     def implement_probes(self, simdata, gid):
         return []

{bsb_arbor-4.1.1 → bsb_arbor-6.0.0}/bsb_arbor/devices/probe.py

@@ -11,7 +11,6 @@ class Probe(ArborDevice):
         return f"cable_probe_{self.probe_type}"
 
     def validate_specifics(self):
-
         if self.get_probe_name() not in vars(arbor):
             raise ConfigurationError(
                 f"`{self.probe_type}` is not a valid probe type for `{self.name}`"
@@ -22,9 +21,9 @@ class Probe(ArborDevice):
         kwargs = dict((k, getattr(self, k)) for k in probe_args if hasattr(self, k))
         return [getattr(arbor, self.get_probe_name())(**kwargs)]
 
-    def prepare_samples(self, sim):
-        super().prepare_samples(sim)
-        for probe_id, handle in zip(self._probe_ids, self._handles):
+    def prepare_samples(self, sim, comm):
+        super().prepare_samples(sim, comm)
+        for probe_id, handle in zip(self._probe_ids, self._handles, strict=False):
             self.adapter.result.add(ProbeRecorder(self, sim, probe_id, handle))
 
 

{bsb_arbor-4.1.1 → bsb_arbor-6.0.0}/bsb_arbor/devices/spike_recorder.py

@@ -1,6 +1,5 @@
 import neo
 from bsb import config
-from bsb.services import MPI
 
 from ..device import ArborDevice
 
@@ -10,9 +9,9 @@ class SpikeRecorder(ArborDevice, classmap_entry="spike_recorder"):
     def boot(self):
         self._gids = set()
 
-    def prepare_samples(self, simdata):
-        super().prepare_samples(simdata)
-        if not MPI.get_rank():
+    def prepare_samples(self, simdata, comm):
+        super().prepare_samples(simdata, comm)
+        if not comm.get_rank():
 
             def record_device_spikes(segment):
                 spiketrain = list()
@@ -25,7 +24,7 @@ class SpikeRecorder(ArborDevice, classmap_entry="spike_recorder"):
                     neo.SpikeTrain(
                         spiketrain,
                         units="ms",
-                        senders=senders,
+                        array_annotations={"senders": senders},
                         t_stop=self.simulation.duration,
                         device=self.name,
                         gids=list(self._gids),

bsb_arbor-6.0.0/bsb_arbor/simulation.py

@@ -0,0 +1,38 @@
+import psutil
+from bsb import Simulation, config, types
+
+from .cell import ArborCell
+from .connection import ArborConnection
+from .device import ArborDevice
+
+
+@config.node
+class ArborSimulation(Simulation):
+    """
+    Interface between the scaffold model and the Arbor simulator.
+    """
+
+    resolution = config.attr(type=types.float(min=0.0), default=0.1)
+    """Simulation time step size in milliseconds."""
+    profiling = config.attr(type=bool)
+    """Flag to perform profiling during the simulation."""
+    cell_models: config._attrs.cfgdict[ArborCell] = config.dict(
+        type=ArborCell, required=True
+    )
+    """Dictionary of cell models in the simulation."""
+    connection_models: config._attrs.cfgdict[ArborConnection] = config.dict(
+        type=ArborConnection, required=True
+    )
+    """Dictionary of connection models in the simulation."""
+    devices: config._attrs.cfgdict[ArborDevice] = config.dict(
+        type=ArborDevice, required=True
+    )
+    """Dictionary of devices in the simulation."""
+
+    @config.property(default=1)
+    def threads(self):
+        return self._threads
+
+    @threads.setter
+    def threads(self, value):
+        self._threads = value if value != "all" else psutil.cpu_count(logical=False)

bsb_arbor-6.0.0/pyproject.toml

@@ -0,0 +1,69 @@
+dependency-groups = { }
+
+[build-system]
+requires = [ "flit_core >=3.2,<4" ]
+build-backend = "flit_core.buildapi"
+
+[project]
+name = "bsb-arbor"
+version = "6.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 = [
+  "numpy~=1.21",
+  "bsb-core~=6.0",
+  "arborize~=6.0",
+  "arbor~=0.10; sys_platform != 'win32'"
+]
+
+  [[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.entry-points."bsb.simulation_backends"]
+arbor = "bsb_arbor"
+
+[tool.uv]
+default-groups = [ "dev", "docs", "test" ]
+sources = { }
+
+[tool.flit.module]
+name = "bsb_arbor"
+
+[tool.coverage.run]
+branch = true
+source = [ "bsb_arbor" ]
+
+[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_arbor-4.1.1/PKG-INFO

@@ -1,37 +0,0 @@
-Metadata-Version: 2.3
-Name: bsb-arbor
-Version: 4.1.1
-Summary: Arbor 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: numpy~=1.21
-Requires-Dist: bsb-core~=5.0
-Requires-Dist: arbor~=0.10
-Requires-Dist: arborize[arbor]~=4.0
-Requires-Dist: bsb-arbor[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-hdf5~=5.0 ; extra == "test"
-Requires-Dist: bsb-test~=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-arbor/actions/workflows/main.yml/badge.svg)](https://github.com/dbbs-lab/bsb-arbor/actions/workflows/main.yml)
-[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
-
-# bsb-arbor
-
-bsb-nest is a plugin of the [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 
-[Arbor simulator](https://arbor-sim.org/).

bsb_arbor-4.1.1/bsb_arbor/__init__.py

@@ -1,12 +0,0 @@
-"""
-Arbor simulation adapter for the BSB framework
-"""
-
-from bsb import SimulationBackendPlugin
-
-from . import devices
-from .adapter import ArborAdapter
-from .simulation import ArborSimulation
-
-__version__ = "4.1.1"
-__plugin__ = SimulationBackendPlugin(Simulation=ArborSimulation, Adapter=ArborAdapter)

bsb_arbor-4.1.1/bsb_arbor/simulation.py

@@ -1,23 +0,0 @@
-import psutil
-from bsb import Simulation, config, types
-
-from .cell import ArborCell
-from .connection import ArborConnection
-from .device import ArborDevice
-
-
-@config.node
-class ArborSimulation(Simulation):
-    resolution = config.attr(type=types.float(min=0.0), default=0.1)
-    profiling = config.attr(type=bool)
-    cell_models = config.dict(type=ArborCell, required=True)
-    connection_models = config.dict(type=ArborConnection, required=True)
-    devices = config.dict(type=ArborDevice, required=True)
-
-    @config.property(default=1)
-    def threads(self):
-        return self._threads
-
-    @threads.setter
-    def threads(self, value):
-        self._threads = value if value != "all" else psutil.cpu_count(logical=False)

bsb_arbor-4.1.1/pyproject.toml

@@ -1,69 +0,0 @@
-[build-system]
-requires = ["flit_core >=3.2,<4"]
-build-backend = "flit_core.buildapi"
-
-[project]
-name = "bsb-arbor"
-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 = [
-    "numpy~=1.21",
-    "bsb-core~=5.0",
-    "arbor~=0.10",
-    "arborize[arbor]~=4.0"
-]
-
-[project.entry-points."bsb.simulation_backends"]
-arbor = "bsb_arbor"
-
-[tool.flit.module]
-name = "bsb_arbor"
-
-[project.optional-dependencies]
-parallel = ["bsb-core[parallel]"]
-test = [
-    "bsb-core[parallel]",
-    "bsb-hdf5~=5.0",
-    "bsb-test~=4.0",
-    "coverage~=7.0"
-]
-dev = [
-    "bsb-arbor[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.isort]
-profile = "black"
-
-[tool.bumpversion]
-current_version = "4.1.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_arbor/__init__.py"