bluecellulab 2.2.7__tar.gz → 2.3.2__tar.gz

{bluecellulab-2.2.7 → bluecellulab-2.3.2}/.github/workflows/release.yml

@@ -8,6 +8,8 @@ on:
 jobs:
   call-test-workflow:
     uses: BlueBrain/BlueCelluLab/.github/workflows/test.yml@main
+    secrets:
+      CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
 
   build-and-publish:
     name: Build, publish on PyPI and make a GitHub release

{bluecellulab-2.2.7 → bluecellulab-2.3.2}/.github/workflows/test.yml

@@ -4,7 +4,10 @@ on:
     pull_request:
     # allows this workflow to be reusable (e.g. by the build workflow)
     workflow_call:
-
+      secrets:
+        CODECOV_TOKEN:
+          description: The token to upload coverage to codecov
+          required: true
 
 jobs:
   tests:

{bluecellulab-2.2.7 → bluecellulab-2.3.2}/CHANGELOG.rst

@@ -1,6 +1,40 @@
 Changelog
 ==========
 
+2.4.0
+------
+
+* Add StimulusFactory enabling Python generated Stimulus creation
+* Stimulus creation through StimulusFactory is decoupled from the Cell object
+* Cell.add_step and Cell.add_ramp use StimulusFactory
+* Move stimuli module to stimulus/circuit_stimulus_definitions
+* [DOCS] Add list of stimuli page that describe, generate and plot the stimuli
+* Add jupyter notebook displaying how to inject the StimulusFactory Stimulus into Cell
+
+2.3.0
+-------
+
+* Cell class no longer serialises the following attributes
+  - secname_to_hsection
+  - secname_to_isec
+  - serialized
+  - cellname
+* The direct access to hsection option is removed. The access is through psection.
+* solves the dependency issue between init_psections and get_psections
+* avoids storing lists of NEURON sections for each Cell. Instead turns them into properties.
+* Dendrogram plotting functions are decoupled from PSection
+
+
+2.2.0
+------
+
+* Add default value for segx param, improve docs vcs: #minor (#127)
+
+2.1.0
+---------
+
+* Allow API functions to be used without loading hoc/mod (#124)
+
 2.0.0
 ---------
 

{bluecellulab-2.2.7 → bluecellulab-2.3.2}/PKG-INFO

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

{bluecellulab-2.2.7 → bluecellulab-2.3.2}/bluecellulab/cell/core.py

@@ -27,12 +27,11 @@ import numpy as np
 import pandas as pd
 
 import bluecellulab
-from bluecellulab import psection
+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.serialized_sections import SerializedSections
 from bluecellulab.cell.template import NeuronTemplate, public_hoc_cell
 from bluecellulab.circuit.config.sections import Conditions
 from bluecellulab.circuit import EmodelProperties, SynapseProperty
@@ -42,7 +41,7 @@ from bluecellulab.exceptions import BluecellulabError
 from bluecellulab.importer import load_hoc_and_mod_files
 from bluecellulab.neuron_interpreter import eval_neuron
 from bluecellulab.rngsettings import RNGSettings
-from bluecellulab.stimuli import SynapseReplay
+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
@@ -99,8 +98,6 @@ class Cell(InjectableMixin, PlottableMixin):
         # diameters of the loaded morph are wrong
         neuron.h.finitialize()
 
-        self.cellname = neuron.h.secname(sec=self.soma).split(".")[0]
-
         if rng_settings is None:
             self.rng_settings = RNGSettings("Random123")  # SONATA value
         else:
@@ -112,25 +109,17 @@ class Cell(InjectableMixin, PlottableMixin):
 
         self.ips: dict[SynapseID, HocObjectType] = {}
         self.syn_mini_netcons: dict[SynapseID, HocObjectType] = {}
-        self.serialized: Optional[SerializedSections] = None
 
         # Be careful when removing this,
         # time recording needs this push
         self.soma.push()
         self.hocname = neuron.h.secname(sec=self.soma).split(".")[0]
-        self.somatic = list(public_hoc_cell(self.cell).somatic)
-        self.basal = list(public_hoc_cell(self.cell).basal)  # dend is same as basal
-        self.apical = list(public_hoc_cell(self.cell).apical)
-        self.axonal = list(public_hoc_cell(self.cell).axonal)
-        self.all = list(public_hoc_cell(self.cell).all)
         self.record_dt = record_dt
         self.add_recordings(['self.soma(0.5)._ref_v', 'neuron.h._ref_t'],
                             dt=self.record_dt)
 
         self.delayed_weights = queue.PriorityQueue()  # type: ignore
-        self.secname_to_isec: dict[str, int] = {}
-        self.secname_to_hsection: dict[str, HocObjectType] = {}
-        self.secname_to_psection: dict[str, psection.PSection] = {}
+        self.psections, self.secname_to_psection = init_psections(public_hoc_cell(self.cell))
 
         self.emodel_properties = emodel_properties
         if template_format == 'v6':
@@ -153,12 +142,29 @@ class Cell(InjectableMixin, PlottableMixin):
         # Used to know when re_init_rng() can be executed
         self.is_made_passive = False
 
-        self.psections: dict[int, psection.PSection] = {}
-
         neuron.h.pop_section()  # Undoing soma push
-        # self.init_psections()
         self.sonata_proxy: Optional[SonataProxy] = None
 
+    @property
+    def somatic(self) -> list[NeuronSection]:
+        return list(public_hoc_cell(self.cell).somatic)
+
+    @property
+    def basal(self) -> list[NeuronSection]:
+        return list(public_hoc_cell(self.cell).basal)
+
+    @property
+    def apical(self) -> list[NeuronSection]:
+        return list(public_hoc_cell(self.cell).apical)
+
+    @property
+    def axonal(self) -> list[NeuronSection]:
+        return list(public_hoc_cell(self.cell).axonal)
+
+    @property
+    def all(self) -> list[NeuronSection]:
+        return list(public_hoc_cell(self.cell).all)
+
     def __repr__(self) -> str:
         base_info = f"Cell Object: {super().__repr__()}"
         hoc_info = f"NEURON ID: {self.template_id}"
@@ -168,47 +174,6 @@ class Cell(InjectableMixin, PlottableMixin):
         """Connect this cell to a circuit via sonata proxy."""
         self.sonata_proxy = sonata_proxy
 
-    def init_psections(self) -> None:
-        """Initialize the psections list.
-
-        This list contains the Python representation of the psections of
-        this morphology.
-        """
-        for hsection in self.all:
-            secname = neuron.h.secname(sec=hsection)
-            self.secname_to_hsection[secname] = hsection
-            self.secname_to_psection[secname] = psection.PSection(hsection)
-
-        # section are not serialized yet, do it now
-        if self.serialized is None:
-            self.serialized = SerializedSections(public_hoc_cell(self.cell))
-
-        for isec in self.serialized.isec2sec:
-            hsection = self.get_hsection(isec)
-            if hsection:
-                secname = neuron.h.secname(sec=hsection)
-                self.psections[isec] = self.secname_to_psection[secname]
-                self.psections[isec].isec = isec
-                self.secname_to_isec[secname] = isec
-
-        # Set the parents and children of all the psections
-        for psec in self.psections.values():
-            hparent = psec.hparent
-            if hparent:
-                parentname = neuron.h.secname(sec=hparent)
-                psec.pparent = self.get_psection(secname=parentname)
-            else:
-                psec.pparent = None
-
-            for hchild in psec.hchildren:
-                childname = neuron.h.secname(sec=hchild)
-                pchild = self.get_psection(secname=childname)
-                psec.add_pchild(pchild)
-
-    def get_section_id(self, secname: str) -> int:
-        """Returns the id of the section with name secname."""
-        return self.secname_to_psection[secname].isec
-
     def re_init_rng(self, use_random123_stochkv: bool = False) -> None:
         """Reinitialize the random number generator for stochastic channels."""
 
@@ -233,44 +198,16 @@ class Cell(InjectableMixin, PlottableMixin):
             else:
                 self.cell.re_init_rng()
 
-    def get_psection(self, section_id=None, secname=None):
-        """Return a python section with the specified section id or name.
-
-        Parameters
-        ----------
-        section_id: int
-                    Return the PSection object based on section id
-        secname: string
-                 Return the PSection object based on section name
-
-        Returns
-        -------
-        psection: PSection
-                  PSection object of the specified section id or name
-        """
-        if section_id is not None:
+    def get_psection(self, section_id: int | str) -> PSection:
+        """Return a python section with the specified section id."""
+        if isinstance(section_id, int):
             return self.psections[section_id]
-        elif secname is not None:
-            return self.secname_to_psection[secname]
+        elif isinstance(section_id, str):
+            return self.secname_to_psection[section_id]
         else:
-            raise Exception(
-                "Cell: get_psection requires or a section_id or a secname")
-
-    def get_hsection(self, section_id: int | float) -> NeuronSection:
-        """Use the serialized object to find a hoc section from a section
-        id."""
-        section_id = int(section_id)
-        # section are not serialized yet, do it now
-        if self.serialized is None:
-            self.serialized = SerializedSections(public_hoc_cell(self.cell))
-
-        try:
-            sec_ref = self.serialized.isec2sec[section_id]
-        except IndexError as e:
-            raise IndexError(
-                f"bluecellulab get_hsection: section-id {section_id} not found in {self.morphology_path}"
-            ) from e
-        return sec_ref.sec
+            raise BluecellulabError(
+                f"Section id must be an int or a str, not {type(section_id)}"
+            )
 
     def make_passive(self) -> None:
         """Make the cell passive by deactivating all the active channels."""
@@ -551,7 +488,8 @@ class Cell(InjectableMixin, PlottableMixin):
 
         base_seed = self.rng_settings.base_seed
         weight = syn_description[SynapseProperty.G_SYNX]
-        post_sec_id = syn_description[SynapseProperty.POST_SECTION_ID]
+        # numpy int to int
+        post_sec_id = int(syn_description[SynapseProperty.POST_SECTION_ID])
 
         location = SynapseFactory.determine_synapse_location(
             syn_description, self
@@ -572,7 +510,7 @@ class Cell(InjectableMixin, PlottableMixin):
             spont_minis_rate = inh_mini_frequency
 
         if spont_minis_rate is not None and spont_minis_rate > 0:
-            sec = self.get_hsection(post_sec_id)
+            sec = self.get_psection(post_sec_id).hsection
             # add the *minis*: spontaneous synaptic events
             self.ips[synapse_id] = neuron.h.\
                 InhPoissonStim(location, sec=sec)

{bluecellulab-2.2.7 → bluecellulab-2.3.2}/bluecellulab/cell/injector.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """Contains injection functionality for the cell."""
-
+from __future__ import annotations
 import math
 import warnings
 import logging
@@ -27,7 +27,7 @@ from bluecellulab.cell.stimuli_generator import (
     get_relative_shotnoise_params,
 )
 from bluecellulab.exceptions import BluecellulabError
-from bluecellulab.stimuli import (
+from bluecellulab.stimulus.circuit_stimulus_definitions import (
     ClampMode,
     Hyperpolarizing,
     Noise,
@@ -36,7 +36,8 @@ from bluecellulab.stimuli import (
     RelativeOrnsteinUhlenbeck,
     RelativeShotNoise,
 )
-from bluecellulab.type_aliases import HocObjectType
+from bluecellulab.stimulus.factory import StimulusFactory
+from bluecellulab.type_aliases import NeuronSection
 
 
 logger = logging.getLogger(__name__)
@@ -69,36 +70,62 @@ class InjectableMixin:
         self.persistent.append(tstim)
         return tstim
 
-    def add_step(self, start_time, stop_time, level, section=None, segx=0.5):
-        """Add a step current injection."""
-        if section is None:
-            section = self.soma
-
-        tstim = neuron.h.TStim(segx, sec=section)
-        duration = stop_time - start_time
-        tstim.pulse(start_time, duration, level)
-        self.persistent.append(tstim)
-        return tstim
+    def add_step(
+        self,
+        start_time: float,
+        stop_time: float,
+        level: float,
+        section: NeuronSection | None = None,
+        segx: float = 0.5,
+        dt: float = 0.025
+    ) -> tuple[np.ndarray, np.ndarray]:
+        """Add a step current injection.
 
-    def add_ramp(self, start_time, stop_time, start_level, stop_level,
-                 section=None, segx=0.5):
-        """Add a ramp current injection."""
-        if section is None:
-            section = self.soma
+        Args:
+            start_time: Start time of the step injection in seconds.
+            stop_time: Stop time of the step injection in seconds.
+            level: Current level to inject in nanoamperes (nA).
+            section: The section to inject current into.
+                Defaults to the soma section.
+            segx: The fractional location within the section to inject.
+                Defaults to 0.5 (center of the section).
+
+        Returns:
+            Tuple of time and current data.
+        """
+        stim = StimulusFactory(dt=dt).step(start_time, stop_time, level)
+        t_content, i_content = stim.time, stim.current
+        self.inject_current_waveform(t_content, i_content, section, segx)
+        return (t_content, i_content)
 
-        tstim = neuron.h.TStim(segx, sec=section)
+    def add_ramp(
+        self,
+        start_time: float,
+        stop_time: float,
+        start_level: float,
+        stop_level: float,
+        section: NeuronSection | None = None,
+        segx: float = 0.5,
+        dt: float = 0.025
+    ) -> tuple[np.ndarray, np.ndarray]:
+        """Add a ramp current injection.
 
-        tstim.ramp(
-            0.0,
-            start_time,
-            start_level,
-            stop_level,
-            stop_time - start_time,
-            0.0,
-            0.0)
+        Args:
+            start_time: Start time of the ramp injection in seconds.
+            stop_time: Stop time of the ramp injection in seconds.
+            start_level: Current level at the start of the ramp in nanoamperes (nA).
+            stop_level: Current level at the end of the ramp in nanoamperes (nA).
+            section: The section to inject current into (optional). Defaults to soma.
+            segx: The fractional location within the section to inject (optional).
+
+        Returns:
+            A tuple of numpy arrays containing time and current data.
+        """
+        stim = StimulusFactory(dt=dt).ramp(start_time, stop_time, start_level, stop_level)
+        t_content, i_content = stim.time, stim.current
+        self.inject_current_waveform(t_content, i_content, section, segx)
 
-        self.persistent.append(tstim)
-        return tstim
+        return t_content, i_content
 
     def add_voltage_clamp(
             self, stop_time, level, rs=None, section=None, segx=0.5,
@@ -395,32 +422,22 @@ class InjectableMixin:
         else:
             return self.inject_current_clamp_signal(section, segx, tvec, svec)
 
-    def inject_current_waveform(self, t_content, i_content, section=None,
-                                segx=0.5):
-        """Inject a custom current to the cell."""
-        start_time = t_content[0]
-        stop_time = t_content[-1]
-        time = neuron.h.Vector()
-        currents = neuron.h.Vector()
-        time = time.from_python(t_content)
-        currents = currents.from_python(i_content)
-
+    def inject_current_waveform(self, t_content, i_content, section=None, segx=0.5):
+        """Inject a custom current waveform into the cell."""
         if section is None:
             section = self.soma
+
+        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.append(pulse)
-        self.persistent.append(time)
-        self.persistent.append(currents)
-        setattr(pulse, 'del', start_time)
-        pulse.dur = stop_time - start_time
-        currents.play(pulse._ref_amp, time)
-        return currents
-
-    @deprecated("Use inject_current_waveform instead.")
-    def injectCurrentWaveform(self, t_content, i_content, section=None,
-                              segx=0.5):
-        """Inject a current in the cell."""
-        return self.inject_current_waveform(t_content, i_content, section, segx)
+        self.persistent.extend([pulse, 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)
+
+        return current_vector
 
     @deprecated("Use add_sin_current instead.")
     def addSineCurrentInject(self, start_time, stop_time, freq,
@@ -435,7 +452,7 @@ class InjectableMixin:
         t_content = np.arange(start_time, stop_time, dt)
         i_content = [amplitude * math.sin(freq * (x - start_time) * (
             2 * math.pi)) + mid_level for x in t_content]
-        self.injectCurrentWaveform(t_content, i_content)
+        self.inject_current_waveform(t_content, i_content)
         return (t_content, i_content)
 
     def add_sin_current(self, amp, start_time, duration, frequency,
@@ -454,9 +471,9 @@ class InjectableMixin:
         tau: float,
         gmax: float,
         e: float,
-        section: HocObjectType,
+        section: NeuronSection,
         segx=0.5,
-    ) -> HocObjectType:
+    ) -> NeuronSection:
         """Add an AlphaSynapse NEURON point process stimulus to the cell."""
         syn = neuron.h.AlphaSynapse(segx, sec=section)
         syn.onset = onset

{bluecellulab-2.2.7 → bluecellulab-2.3.2}/bluecellulab/cell/plotting.py

@@ -60,7 +60,6 @@ class PlottableMixin:
             scale_bar_size=10.0,
             fig_title=None):
         """Show a dendrogram of the cell."""
-        self.init_psections()
         cell_dendrogram = bluecellulab.Dendrogram(
             self.psections,
             variable=variable,

{bluecellulab-2.2.7 → bluecellulab-2.3.2}/bluecellulab/cell/serialized_sections.py

@@ -13,11 +13,11 @@
 # limitations under the License.
 """Module that allows morphology sections to be accessed from an array by
 index."""
-
+from __future__ import annotations
 import logging
 import warnings
 import neuron
-from bluecellulab.type_aliases import HocObjectType
+from bluecellulab.type_aliases import HocObjectType, NeuronSection
 
 
 logger = logging.getLogger(__name__)
@@ -27,7 +27,7 @@ warnings.filterwarnings("once", category=UserWarning, module=__name__)
 class SerializedSections:
 
     def __init__(self, cell: HocObjectType) -> None:
-        self.isec2sec = {}
+        self.isec2sec: dict[int, NeuronSection] = {}
         n = cell.nSecAll
 
         for index, sec in enumerate(cell.all, start=1):

{bluecellulab-2.2.7 → bluecellulab-2.3.2}/bluecellulab/circuit/config/bluepy_simulation_config.py

@@ -25,7 +25,7 @@ if BLUEPY_AVAILABLE:
     from bluepy.utils import open_utf8
 
 from bluecellulab.circuit.config.sections import Conditions, ConnectionOverrides
-from bluecellulab.stimuli import Stimulus
+from bluecellulab.stimulus.circuit_stimulus_definitions import Stimulus
 
 
 class BluepySimulationConfig:

{bluecellulab-2.2.7 → bluecellulab-2.3.2}/bluecellulab/circuit/config/definition.py

@@ -18,7 +18,7 @@ from typing import Optional, Protocol
 
 
 from bluecellulab.circuit.config.sections import Conditions, ConnectionOverrides
-from bluecellulab.stimuli import Stimulus
+from bluecellulab.stimulus.circuit_stimulus_definitions import Stimulus
 
 
 class SimulationConfig(Protocol):

{bluecellulab-2.2.7 → bluecellulab-2.3.2}/bluecellulab/circuit/config/sonata_simulation_config.py

@@ -17,7 +17,7 @@ from pathlib import Path
 from typing import Optional
 
 from bluecellulab.circuit.config.sections import Conditions, ConnectionOverrides
-from bluecellulab.stimuli import Stimulus
+from bluecellulab.stimulus.circuit_stimulus_definitions import Stimulus
 
 from bluepysnap import Simulation as SnapSimulation
 

{bluecellulab-2.2.7 → bluecellulab-2.3.2}/bluecellulab/dendrogram.py

@@ -12,8 +12,54 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """Class that represents a dendrogram window."""
-
+from __future__ import annotations
 import numpy as np
+import pylab
+
+from bluecellulab.psection import PSection
+from bluecellulab.psegment import PSegment
+
+
+def setup_draw(psegments: list[PSegment], maxsegdiam: float, figure, x, y, variable=None, varbounds=None) -> None:
+    """Setup draw of psection."""
+    y_accum = 0.0
+    for psegment in psegments:
+        psegment.setupDraw(figure,
+                           x + (maxsegdiam - psegment.diam) / 2,
+                           y + y_accum,
+                           variable=variable,
+                           varbounds=varbounds)
+        y_accum += psegment.L
+
+
+def draw_tree(psection: PSection, figure, x, y, variable=None, varbounds=None) -> None:
+    """Draw a dendritic tree."""
+    # Draw myself
+    setup_draw(
+        psection.psegments, psection.maxsegdiam, figure, x, y, variable=variable, varbounds=varbounds
+    )
+
+    # Draw children
+
+    # First child is a same x coordinate
+    new_x = x  # + self.L + self.xSpacing
+
+    # Children drawn L + ySpacing heigher
+    new_y = y + psection.L + psection.ySpacing
+
+    for child in psection.pchildren:
+        draw_tree(child, figure, new_x, new_y, variable=variable, varbounds=varbounds)
+        pylab.plot(
+            [x + psection.diam / 2, new_x + child.diam / 2],
+            [y + psection.L, new_y], 'k')
+        # Prepare new_x for next child
+        new_x = new_x + child.tree_width()
+
+
+def redraw_psection(psection: PSection) -> None:
+    """Redraw psection."""
+    for psegment in psection.psegments:
+        psegment.redraw()
 
 
 class Dendrogram:
@@ -21,7 +67,7 @@ class Dendrogram:
 
     def __init__(
             self,
-            psections,
+            psections: list[PSection],
             variable=None,
             active=False,
             save_fig_path=None,
@@ -30,7 +76,6 @@ class Dendrogram:
             scale_bar_size=10.0,
             fig_title=None,
             fig_show=True):
-        import pylab
 
         if interactive:
             pylab.ion()
@@ -48,15 +93,14 @@ class Dendrogram:
         self.psections = psections
         # neuron.h.finitialize()
 
-        # self.hroot = neuron.h.SectionRef(sec=self.sections[0]).root
-        self.proot = psections[0]
-        # self.psections = [self.proot] + self.proot.getAllPDescendants()
+        self.proot: PSection = psections[0]
+        self.psections = [self.proot] + self.proot.all_descendants()
 
         xSpacing = self.proot.xSpacing
         ySpacing = self.proot.ySpacing
 
-        max_y = self.proot.treeHeight() + self.proot.ySpacing + title_space
-        max_x = self.proot.treeWidth() + self.proot.xSpacing + scale_bar_size
+        max_y = self.proot.tree_height() + self.proot.ySpacing + title_space
+        max_x = self.proot.tree_width() + self.proot.xSpacing + scale_bar_size
         pylab.xlim([0, max_x])
         pylab.ylim([0, max_y])
         pylab.gca().set_xticks([])
@@ -79,9 +123,9 @@ class Dendrogram:
             cbar.ax.set_yticklabels(["%.2e" % (
                 varbounds[0]), "%.2e" % (varbounds[1])])
 
-        self.proot.drawTree(self.dend_figure, self.proot.xSpacing,
-                            self.proot.ySpacing, variable=variable,
-                            varbounds=varbounds)
+        draw_tree(self.proot, self.dend_figure, self.proot.xSpacing,
+                  self.proot.ySpacing, variable=variable,
+                  varbounds=varbounds)
 
         if scale_bar:
             pylab.plot(
@@ -119,8 +163,10 @@ class Dendrogram:
 
         self.dend_figure.canvas.draw()
 
-        for secid in self.psections:
-            psections[secid].redraw()
+        for section in self.psections:
+            section_id = section.isec
+            if section_id is not None:
+                redraw_psection(psections[section_id])
 
         self.canvas = self.dend_figure.gca().figure.canvas
         self.ax = self.dend_figure.gca()
@@ -138,15 +184,13 @@ class Dendrogram:
         if not interactive and fig_show:
             pylab.show()
 
-    def redraw(self):
+    def redraw(self) -> None:
         """Redraw the dendrogram."""
         if self.active:
             if not self.drawCount:
                 for psection in self.psections:
-                    psection.redraw()
+                    redraw_psection(psection)
                 self.canvas.blit(self.ax.bbox)
                 self.drawCount = 1
             else:
                 self.drawCount = self.drawCount - 1
-
-        return True