Encapsulate brian objects in the same way brian, pytorch, etc. encapsulate other libraries (e.g. numpy, matplotlib)
e.g.

import brian2 as b
from brian2.units import (ms, um, pA, nS, uS, ohm, cm, mV, uF, mvolt)
from dendrify import Soma, Dendrite, NeuronModel

b.prefs.codegen.target = 'numpy'
b.start_scope()    # allows running separate simulations in the same notebook

should be:

import dendrify as d
from dendrify.units import (ms, um, pA, nS, uS, ohm, cm, mV, uF, mvolt)
d.prefs.codegen.target = 'numpy'
d.start_scope()

This makes development and usage easier, cleaner and less ambiguous.

1. Write unit tests
2. Write functional tests
3. Implement a workflow that runs the tests on every push or PR to assure that further changes to the project don't break anything

Logging gives you more flexibility.

See:

• https://stackoverflow.com/a/6918596
• https://realpython.com/python-logging/

sys.exit() raises SystemError. However, dendrify errors vary and are not system-related. So, always calling sys.exit() is misleading.

Suggestion: Replace sys.exit() calls with raising specific exceptions.

E.g. instead of this:

if self.name == other.name:
    print(("ERROR: Cannot connect to compartments with the same name.\n"
           "Program exited"))
    sys.exit()

do this:

if self.name == other.name:
    raise ValueError('Cannot connect to compartments with the same name')

See:

• https://stackoverflow.com/a/24065533 (best practices)
• https://docs.python.org/3/library/exceptions.html (for knowing which exceptions to use for different cases)
• https://docs.python.org/3/library/exceptions.html#exception-hierarchy (to get a sense of the exception hierarchy)

pip install dendrify && python -c 'import dendrify'

yields

Traceback (most recent call last):
   File "<string>", line 1, in <module>
   File "/home/csk/miniconda3/envs/dendrify/lib/python3.10/site-packages/dendrify/__init__.py", line 1, in <module>
      from .compartment import Compartment, Dendrite, Soma
   File "/home/csk/miniconda3/envs/dendrify/lib/python3.10/site-packages/dendrify/compartment.py", line 13, in <module>
      import numpy as np                                                                                                            
ModuleNotFoundError: No module named 'numpy'

This is obviously fixed by installing the required brian2 dependency. However, any required dependencies should be automatically installed when installing the package.

pre is an optional argument.

However, if pre is not given, you raise an exception.

Which implies that pre is mandatory and not optional. So, just make pre a positional argument, so that the user always provides it.

Having to create a NeuronModel and a NeuronGroup and then having to link them is unnecessarily complex for the user.
Linking should at the very least be hidden and not have to be done by the user.

I suggest the following. Just define your own dendrify NeuronGroup that inherits Brian's NeuronGroup and extends it with all the cool functionality of your current NeuronModel class. After this, dendrify will only have one neuron-related class, and no linking.

That would simplify snippets such as the following:

edges = [(soma, apical, 10*nS), (soma, basal, 10*nS)]
pyr_model = NeuronModel(edges, cm=1*uF/(cm**2), gl=50*uS/(cm**2),
                          v_rest=-70*mV, r_axial=150*ohm*cm,
                          scale_factor=3, spine_factor=1.5)

# create a Brian NeuronGroup and link it to the neuron model
pyr_group = b.NeuronGroup(3, model=pyr_model.equations, method='euler',
                          threshold='V_soma > -40*mV', reset='V_soma = -50*mV',
                          refractory=3*ms, namespace=pyr_model.parameters)
pyr_model.link(pyr_group)

into something like this:

edges = [(soma, apical, 10*nS), (soma, basal, 10*nS)]
pyr_group = d.NeuronGroup(3, edges, ...)

So that everything you want to happen, happens inside your NeuronGroup.

Nice and simple.

Putting assignment statements in strings and using exec() (e.g. this) leads to having to do weird things, beforehand. Like, parsing the guts of the main module just to get a hold of a neuron group object. All this is unnecessarily complex.

There are two better ways of doing such things:

1. One alternative is just having the dendrify NeuronModel hold a reference of the brian NeuronGroup. Therefore, to set the rest potential, for example, you can do something like this:

for cpt in self._compartments:
    setattr(self.linked_ng, f'V_{cpt.name}', self.linked_ng.namespace[f'EL_{cpt.name}'])

2. Another simple way would be to implement the suggestion: #13 (comment), by merging your NeuronModel with the brian NeuronGroup. Then, you could just be able to do this:

for cpt in self._compartments:
    setattr(self, f'V_{cpt.name}', self.namespace[f'EL_{cpt.name}'])

since self would itself be just an instance of a brian NeuronGroup subclass.

In order to successfully run the paper_figures/ notebooks , I had to manually install the following requirements:

git-lfs
networkx
seaborn
scipy
statsmodels

These should either be installed at the top of the notebook (e.g. !pip install seaborn --quiet), or at least be inside a paper_figures/requirements.txt file, so a user can easily install them all at once.