def test_TMDApicalAlgo():
        algo, grower = _setup_test(TMDApicalAlgo, SectionGrowerPath)
    
        stop, num_sec = algo.initialize()
        expected_stop = {"TMD": TMDStop(bif_id=1, bif=9.7747, term_id=0, term=159.798, ref=0.0)}
        assert stop == expected_stop
        assert_equal(num_sec, 10)
    
        grower.id = 1
        s1, s2 = algo.bifurcate(grower)
        assert_equal(algo.apical_section, 1)
>       _assert_dict_or_array(
            s1,
            {
                "direction": [0.57735, 0.57735, 0.57735],
                "process": "major",
                "first_point": [1.1, 0.0, 0.0],
                "stop": {"TMD": TMDStop(bif_id=2, bif=18.5246, term_id=0, term=159.798, ref=0.0)},
            },
        )

tests/test_algo.py:240: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

dict1 = {'direction': array([0, 1, 0]), 'first_point': array([1.1, 0. , 0. ]), 'process': 'major', 'stop': {'TMD': <neurots.generate.algorithms.common.TMDStop object at 0x7effbb617670>}}
dict2 = {'direction': [0.57735, 0.57735, 0.57735], 'first_point': [1.1, 0.0, 0.0], 'process': 'major', 'stop': {'TMD': <neurots.generate.algorithms.common.TMDStop object at 0x7effbb6094c0>}}

    def _assert_dict_or_array(dict1, dict2):
        assert_equal(set(dict1.keys()), set(dict2.keys()))
        for key in dict1.keys():
            if isinstance(dict1[key], np.ndarray):
>               assert_array_almost_equal(dict1[key], dict2[key])
E               AssertionError: 
E               Arrays are not almost equal to 6 decimals
E               
E               Mismatched elements: 3 / 3 (100%)
E               Max absolute difference: 0.57735
E               Max relative difference: 1.
E                x: array([0, 1, 0])
E                y: array([0.57735, 0.57735, 0.57735])

tests/test_algo.py:79: AssertionError

def test_TMDGradientAlgo():
        algo, grower = _setup_test(TMDGradientAlgo, SectionGrowerPath)
    
        stop, num_sec = algo.initialize()
        expected_stop = {"TMD": TMDStop(bif_id=1, bif=9.7747, term_id=0, term=159.798, ref=0.0)}
        assert stop == expected_stop
        assert_equal(num_sec, 10)
    
        s1, s2 = algo.bifurcate(grower)
>       _assert_dict_or_array(
            s1,
            {
                "direction": [0.57735, 0.57735, 0.57735],
                "process": "major",
                "first_point": [1.1, 0.0, 0.0],
                "stop": {"TMD": TMDStop(bif_id=2, bif=18.5246, term_id=0, term=159.798, ref=0.0)},
            },
        )

tests/test_algo.py:294: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

dict1 = {'direction': array([0, 1, 0]), 'first_point': array([1.1, 0. , 0. ]), 'process': 'major', 'stop': {'TMD': <neurots.generate.algorithms.common.TMDStop object at 0x7f3b1c4f26a0>}}
dict2 = {'direction': [0.57735, 0.57735, 0.57735], 'first_point': [1.1, 0.0, 0.0], 'process': 'major', 'stop': {'TMD': <neurots.generate.algorithms.common.TMDStop object at 0x7f3b1c4f2ca0>}}

    def _assert_dict_or_array(dict1, dict2):
        assert_equal(set(dict1.keys()), set(dict2.keys()))
        for key in dict1.keys():
            if isinstance(dict1[key], np.ndarray):
>               assert_array_almost_equal(dict1[key], dict2[key])
E               AssertionError: 
E               Arrays are not almost equal to 6 decimals
E               
E               Mismatched elements: 3 / 3 (100%)
E               Max absolute difference: 0.57735
E               Max relative difference: 1.
E                x: array([0, 1, 0])
E                y: array([0.57735, 0.57735, 0.57735])

tests/test_algo.py:79: AssertionError

self = <tests.test_neuron_functional.TestBioRatL5Tpc2 object at 0x7fb3a1369460>
tmpdir = local('/home/runner/work/NeuroTS/NeuroTS/.tox/min_versions/tmp/popen-gw1/test_default0')

    def test_default(self, tmpdir):
>       _test_full(
            "path_distances",
            "bio_rat_L5_TPC_B_distribution.json",
            "params2.json",
            "expected_bio_rat_L5_TPC_B_with_params2.h5",
            "expected_bio_rat_L5_TPC_B_with_params2_persistence_diagram.json",
            output_dir=tmpdir,
        )

tests/test_neuron_functional.py:621: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

feature = 'path_distances'
distributions = {'apical_dendrite': {'filtration_metric': 'path_distances', 'min_bar_length': 1.0, 'num_trees': {'data': {'bins': [1],....4106653615432989, 0.5277795547616266, -0.18579814237229897], ...], ...], ...}, 'diameter': {'method': 'uniform'}, ...}
parameters = 'params2.json'
ref_cell = 'expected_bio_rat_L5_TPC_B_with_params2.h5'
ref_persistence_diagram = 'expected_bio_rat_L5_TPC_B_with_params2_persistence_diagram.json'
rng_or_seed = None, skip_preprocessing = False
output_dir = local('/home/runner/work/NeuroTS/NeuroTS/.tox/min_versions/tmp/popen-gw1/test_default0')

    def _test_full(
        feature,
        distributions,
        parameters,
        ref_cell,
        ref_persistence_diagram,
        rng_or_seed=None,
        skip_preprocessing=False,
        output_dir=None,
    ):
        distributions, params = _load_inputs(join(_path, distributions), join(_path, parameters))
        if rng_or_seed is None:
            np.random.seed(0)
            n = NeuronGrower(
                input_distributions=distributions,
                input_parameters=params,
                skip_preprocessing=skip_preprocessing,
            ).grow()
        else:
            n = NeuronGrower(
                input_distributions=distributions,
                input_parameters=params,
                rng_or_seed=rng_or_seed,
                skip_preprocessing=skip_preprocessing,
            ).grow()
    
        with TemporaryDirectory("test_grower") as folder:
            out_neuron = join(folder, "test_output_neuron_.h5")
            n.write(out_neuron)
    
            # For checking purposes, we can output the cells as swc
            if output_dir is not None:
                if not os.path.exists(output_dir):
                    os.mkdir(output_dir)
                n.write(join(output_dir, basename(ref_cell)))
    
            if ref_persistence_diagram is not None:
                # Load with TMD and extract radial persistence
                n0 = tmd.io.load_neuron(out_neuron)
    
                actual_persistence_diagram = tmd.methods.get_persistence_diagram(
                    n0.apical_dendrite[0], feature=feature
                )
                if output_dir is not None:
                    with open(
                        join(output_dir, basename(ref_persistence_diagram)), "w", encoding="utf-8"
                    ) as f:
                        json.dump(actual_persistence_diagram, f, sort_keys=True, indent=2)
    
                with open(join(_path, ref_persistence_diagram), encoding="utf-8") as f:
                    expected_persistence_diagram = json.load(f)
                assert_close_persistent_diagram(
                    actual_persistence_diagram, expected_persistence_diagram
                )
>           assert not diff(out_neuron, join(_path, ref_cell))
E           AssertionError: assert not <morph_tool.morphio_diff.DiffResult object at 0x7fb3a13efb80>
E            +  where <morph_tool.morphio_diff.DiffResult object at 0x7fb3a13efb80> = diff('/tmp/tmp1xk2w9citest_grower/test_output_neuron_.h5', '/home/runner/work/NeuroTS/NeuroTS/tests/data/expected_bio_rat_L5_TPC_B_with_params2.h5')
E            +    where '/home/runner/work/NeuroTS/NeuroTS/tests/data/expected_bio_rat_L5_TPC_B_with_params2.h5' = join('/home/runner/work/NeuroTS/NeuroTS/tests/data', 'expected_bio_rat_L5_TPC_B_with_params2.h5')

tests/test_neuron_functional.py:132: AssertionError

def test_breaker_of_tmd_algo():
        """Test example that could break tmd_algo. Test should fail if problem occurs.
        Otherwise, this grower should run smoothly.
        """
        distributions, params = _load_inputs(
            join(_path, "bio_distr_breaker.json"), join(_path, "bio_params_breaker.json")
        )
        np.random.seed(3367155)
        N = NeuronGrower(input_distributions=distributions, input_parameters=params)
        n = N.grow()
    
        assert_array_equal(N.apical_sections, [10])
>       assert_array_almost_equal(
            n.sections[118].points[-1],
            np.array([-170.45485, 42.04766, -26.375393]),
            decimal=5,
        )
E       AssertionError: 
E       Arrays are not almost equal to 5 decimals
E       
E       Mismatched elements: 3 / 3 (100%)
E       Max absolute difference: 165.69951562
E       Max relative difference: 3.15924248
E        x: array([ -4.75533, 174.88641,  -9.35779], dtype=float32)
E        y: array([-170.45485,   42.04766,  -26.37539])

tests/test_neuron_functional.py:297: AssertionError

tmpdir = local('/home/runner/work/NeuroTS/NeuroTS/.tox/min_versions/tmp/popen-gw3/test_axon_grower0')

    def test_axon_grower(tmpdir):
        """Test axon grower, which should only grow trunks with 1 section to allow later axon grafting.
    
        The num_seg value in the parameters is set to 999 but only 1 segment should be synthesized.
        """
    
        _test_full(
            "radial_distances",
            "axon_trunk_distribution.json",
            "axon_trunk_parameters.json",
            "test_axon_grower.h5",
            None,
            output_dir=tmpdir / "default",
        )
        _test_full(
            "radial_distances",
            "axon_trunk_distribution.json",
            "axon_trunk_parameters.json",
            "test_axon_grower.h5",
            None,
            rng_or_seed=build_random_generator(0),
            output_dir=tmpdir / "rng",
        )
        _test_full(
            "radial_distances",
            "axon_trunk_distribution.json",
            "axon_trunk_parameters_orientation_manager.json",
            "test_axon_grower.h5",
            None,
            skip_preprocessing=True,
            output_dir=tmpdir / "skip_preprocessing",
        )
        _test_full(
            "radial_distances",
            "axon_trunk_distribution.json",
            "axon_trunk_parameters_orientation_manager.json",
            "test_axon_grower.h5",
            None,
            rng_or_seed=build_random_generator(0),
            skip_preprocessing=True,
            output_dir=tmpdir / "rng_and_skip_preprocessing",
        )
    
>       _test_full(
            "radial_distances",
            "axon_trunk_distribution.json",
            "axon_trunk_parameters_absolute.json",
            "test_axon_grower_absolute.h5",
            None,
            output_dir=tmpdir / "default_absolute",
        )

tests/test_neuron_functional.py:366: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

feature = 'radial_distances'
distributions = {'apical_dendrite': {}, 'axon': {'num_trees': {'data': {'bins': [1], 'weights': [1]}}, 'trunk': {'absolute_elevation_d...292436, 1.566630375543904, 2.9393430149240416], 'weights': [4, 3, 1, 1, 2]}}}}, 'diameter': {'method': 'uniform'}, ...}
parameters = 'axon_trunk_parameters_absolute.json'
ref_cell = 'test_axon_grower_absolute.h5', ref_persistence_diagram = None
rng_or_seed = None, skip_preprocessing = False
output_dir = local('/home/runner/work/NeuroTS/NeuroTS/.tox/min_versions/tmp/popen-gw3/test_axon_grower0/default_absolute')

    def _test_full(
        feature,
        distributions,
        parameters,
        ref_cell,
        ref_persistence_diagram,
        rng_or_seed=None,
        skip_preprocessing=False,
        output_dir=None,
    ):
        distributions, params = _load_inputs(join(_path, distributions), join(_path, parameters))
        if rng_or_seed is None:
            np.random.seed(0)
            n = NeuronGrower(
                input_distributions=distributions,
                input_parameters=params,
                skip_preprocessing=skip_preprocessing,
            ).grow()
        else:
            n = NeuronGrower(
                input_distributions=distributions,
                input_parameters=params,
                rng_or_seed=rng_or_seed,
                skip_preprocessing=skip_preprocessing,
            ).grow()
    
        with TemporaryDirectory("test_grower") as folder:
            out_neuron = join(folder, "test_output_neuron_.h5")
            n.write(out_neuron)
    
            # For checking purposes, we can output the cells as swc
            if output_dir is not None:
                if not os.path.exists(output_dir):
                    os.mkdir(output_dir)
                n.write(join(output_dir, basename(ref_cell)))
    
            if ref_persistence_diagram is not None:
                # Load with TMD and extract radial persistence
                n0 = tmd.io.load_neuron(out_neuron)
    
                actual_persistence_diagram = tmd.methods.get_persistence_diagram(
                    n0.apical_dendrite[0], feature=feature
                )
                if output_dir is not None:
                    with open(
                        join(output_dir, basename(ref_persistence_diagram)), "w", encoding="utf-8"
                    ) as f:
                        json.dump(actual_persistence_diagram, f, sort_keys=True, indent=2)
    
                with open(join(_path, ref_persistence_diagram), encoding="utf-8") as f:
                    expected_persistence_diagram = json.load(f)
                assert_close_persistent_diagram(
                    actual_persistence_diagram, expected_persistence_diagram
                )
>           assert not diff(out_neuron, join(_path, ref_cell))
E           AssertionError: assert not <morph_tool.morphio_diff.DiffResult object at 0x7effbb492490>
E            +  where <morph_tool.morphio_diff.DiffResult object at 0x7effbb492490> = diff('/tmp/tmpr7ggz7rftest_grower/test_output_neuron_.h5', '/home/runner/work/NeuroTS/NeuroTS/tests/data/test_axon_grower_absolute.h5')
E            +    where '/home/runner/work/NeuroTS/NeuroTS/tests/data/test_axon_grower_absolute.h5' = join('/home/runner/work/NeuroTS/NeuroTS/tests/data', 'test_axon_grower_absolute.h5')

tests/test_neuron_functional.py:132: AssertionError

tmpdir = local('/home/runner/work/NeuroTS/NeuroTS/.tox/min_versions/tmp/popen-gw3/test_basic_grower0')

    def test_basic_grower(tmpdir):
>       _test_full(
            "radial_distances",
            "bio_trunk_distribution.json",
            "trunk_parameters.json",
            "test_trunk_grower.h5",
            None,
            output_dir=tmpdir / "default",
        )

tests/test_neuron_functional.py:405: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

feature = 'radial_distances'
distributions = {'apical_dendrite': {'filtration_metric': 'trunk_length', 'min_bar_length': 1.0, 'num_trees': {'data': {'bins': [1], '...292436, 1.566630375543904, 2.9393430149240416], 'weights': [4, 3, 1, 1, 2]}}}}, 'diameter': {'method': 'uniform'}, ...}
parameters = 'trunk_parameters.json', ref_cell = 'test_trunk_grower.h5'
ref_persistence_diagram = None, rng_or_seed = None, skip_preprocessing = False
output_dir = local('/home/runner/work/NeuroTS/NeuroTS/.tox/min_versions/tmp/popen-gw3/test_basic_grower0/default')

    def _test_full(
        feature,
        distributions,
        parameters,
        ref_cell,
        ref_persistence_diagram,
        rng_or_seed=None,
        skip_preprocessing=False,
        output_dir=None,
    ):
        distributions, params = _load_inputs(join(_path, distributions), join(_path, parameters))
        if rng_or_seed is None:
            np.random.seed(0)
            n = NeuronGrower(
                input_distributions=distributions,
                input_parameters=params,
                skip_preprocessing=skip_preprocessing,
            ).grow()
        else:
            n = NeuronGrower(
                input_distributions=distributions,
                input_parameters=params,
                rng_or_seed=rng_or_seed,
                skip_preprocessing=skip_preprocessing,
            ).grow()
    
        with TemporaryDirectory("test_grower") as folder:
            out_neuron = join(folder, "test_output_neuron_.h5")
            n.write(out_neuron)
    
            # For checking purposes, we can output the cells as swc
            if output_dir is not None:
                if not os.path.exists(output_dir):
                    os.mkdir(output_dir)
                n.write(join(output_dir, basename(ref_cell)))
    
            if ref_persistence_diagram is not None:
                # Load with TMD and extract radial persistence
                n0 = tmd.io.load_neuron(out_neuron)
    
                actual_persistence_diagram = tmd.methods.get_persistence_diagram(
                    n0.apical_dendrite[0], feature=feature
                )
                if output_dir is not None:
                    with open(
                        join(output_dir, basename(ref_persistence_diagram)), "w", encoding="utf-8"
                    ) as f:
                        json.dump(actual_persistence_diagram, f, sort_keys=True, indent=2)
    
                with open(join(_path, ref_persistence_diagram), encoding="utf-8") as f:
                    expected_persistence_diagram = json.load(f)
                assert_close_persistent_diagram(
                    actual_persistence_diagram, expected_persistence_diagram
                )
>           assert not diff(out_neuron, join(_path, ref_cell))
E           AssertionError: assert not <morph_tool.morphio_diff.DiffResult object at 0x7effbb442970>
E            +  where <morph_tool.morphio_diff.DiffResult object at 0x7effbb442970> = diff('/tmp/tmp0fmozf4btest_grower/test_output_neuron_.h5', '/home/runner/work/NeuroTS/NeuroTS/tests/data/test_trunk_grower.h5')
E            +    where '/home/runner/work/NeuroTS/NeuroTS/tests/data/test_trunk_grower.h5' = join('/home/runner/work/NeuroTS/NeuroTS/tests/data', 'test_trunk_grower.h5')

tests/test_neuron_functional.py:132: AssertionError

def test_basic_grower_with_generator():
        distributions, params = _load_inputs(
            join(_path, "bio_trunk_distribution.json"),
            join(_path, "trunk_parameters.json"),
        )
        expected_pts = [
            [-0.7312348484992981, 7.604228973388672, 11.173797607421875],
            [-13.377432823181152, -1.2863954305648804, 2.9336819648742676],
            [11.861421585083008, -0.049414388835430145, 6.1279988288879395],
            [-2.3804218769073486, 12.54181957244873, 1.118072748184204],
        ]
    
        rng = np.random.default_rng(0)
        rng_or_seeds = [0, rng]
    
        for rng_or_seed in rng_or_seeds:
            n = NeuronGrower(
                input_distributions=distributions,
                input_parameters=params,
                rng_or_seed=rng_or_seed,
            ).grow()
            assert len(n.root_sections) == 4
>           assert_array_almost_equal(
                [i.points[-1].tolist() for i in n.root_sections],
                expected_pts,
            )
E           AssertionError: 
E           Arrays are not almost equal to 6 decimals
E           
E           Mismatched elements: 12 / 12 (100%)
E           Max absolute difference: 4.68638051
E           Max relative difference: 78.82940394
E            x: array([[-0.511599,  9.385795,  7.817605],
E                  [-9.209658,  3.399985,  2.019685],
E                  [ 8.413467,  3.845892,  4.346673],
E                  [-1.759138, 12.613012,  0.826259]])
E            y: array([[ -0.731235,   7.604229,  11.173798],
E                  [-13.377433,  -1.286395,   2.933682],
E                  [ 11.861422,  -0.049414,   6.127999],
E                  [ -2.380422,  12.54182 ,   1.118073]])

tests/test_neuron_functional.py:446: AssertionError

self = <tests.test_neuron_functional.TestPathGrower object at 0x7effbb506460>
tmpdir = local('/home/runner/work/NeuroTS/NeuroTS/.tox/min_versions/tmp/popen-gw3/test_default0')

    def test_default(self, tmpdir):
>       _test_full(
            "path_distances",
            "bio_distribution.json",
            "bio_path_params.json",
            "path_grower.h5",
            "bio_path_persistence_diagram.json",
            output_dir=tmpdir,
        )

tests/test_neuron_functional.py:459: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

feature = 'path_distances'
distributions = {'apical_dendrite': {'filtration_metric': 'path_distances', 'min_bar_length': 1.0, 'num_trees': {'data': {'bins': [1],...665, 0.02188742478139427], [265.46654445080054, 0, nan, nan, nan, nan]]], ...}, 'diameter': {'method': 'uniform'}, ...}
parameters = 'bio_path_params.json', ref_cell = 'path_grower.h5'
ref_persistence_diagram = 'bio_path_persistence_diagram.json'
rng_or_seed = None, skip_preprocessing = False
output_dir = local('/home/runner/work/NeuroTS/NeuroTS/.tox/min_versions/tmp/popen-gw3/test_default0')

    def _test_full(
        feature,
        distributions,
        parameters,
        ref_cell,
        ref_persistence_diagram,
        rng_or_seed=None,
        skip_preprocessing=False,
        output_dir=None,
    ):
        distributions, params = _load_inputs(join(_path, distributions), join(_path, parameters))
        if rng_or_seed is None:
            np.random.seed(0)
            n = NeuronGrower(
                input_distributions=distributions,
                input_parameters=params,
                skip_preprocessing=skip_preprocessing,
            ).grow()
        else:
            n = NeuronGrower(
                input_distributions=distributions,
                input_parameters=params,
                rng_or_seed=rng_or_seed,
                skip_preprocessing=skip_preprocessing,
            ).grow()
    
        with TemporaryDirectory("test_grower") as folder:
            out_neuron = join(folder, "test_output_neuron_.h5")
            n.write(out_neuron)
    
            # For checking purposes, we can output the cells as swc
            if output_dir is not None:
                if not os.path.exists(output_dir):
                    os.mkdir(output_dir)
                n.write(join(output_dir, basename(ref_cell)))
    
            if ref_persistence_diagram is not None:
                # Load with TMD and extract radial persistence
                n0 = tmd.io.load_neuron(out_neuron)
    
                actual_persistence_diagram = tmd.methods.get_persistence_diagram(
                    n0.apical_dendrite[0], feature=feature
                )
                if output_dir is not None:
                    with open(
                        join(output_dir, basename(ref_persistence_diagram)), "w", encoding="utf-8"
                    ) as f:
                        json.dump(actual_persistence_diagram, f, sort_keys=True, indent=2)
    
                with open(join(_path, ref_persistence_diagram), encoding="utf-8") as f:
                    expected_persistence_diagram = json.load(f)
                assert_close_persistent_diagram(
                    actual_persistence_diagram, expected_persistence_diagram
                )
>           assert not diff(out_neuron, join(_path, ref_cell))
E           AssertionError: assert not <morph_tool.morphio_diff.DiffResult object at 0x7effbb46ba30>
E            +  where <morph_tool.morphio_diff.DiffResult object at 0x7effbb46ba30> = diff('/tmp/tmpr0h7h2kvtest_grower/test_output_neuron_.h5', '/home/runner/work/NeuroTS/NeuroTS/tests/data/path_grower.h5')
E            +    where '/home/runner/work/NeuroTS/NeuroTS/tests/data/path_grower.h5' = join('/home/runner/work/NeuroTS/NeuroTS/tests/data', 'path_grower.h5')

tests/test_neuron_functional.py:132: AssertionError

def test_get_bif_directional():
>       assert_array_almost_equal(
            _bf.directional([0.0, 1.0, 0.0], [0.0, 0.0, 0.0, np.pi / 2]),
            (np.array([0.0, 1.0, 0.0]), np.array([0.0, 0.0, 1.0])),
        )
E       AssertionError: 
E       Arrays are not almost equal to 6 decimals
E       
E       Mismatched elements: 2 / 6 (33.3%)
E       Max absolute difference: 1.
E       Max relative difference: 1.
E        x: array([[0., 1., 0.],
E              [0., 1., 0.]])
E        y: array([[0., 1., 0.],
E              [0., 0., 1.]])

tests/test_morphmath_bifurcation.py:26: AssertionError

def test_soma_grower():
        # pylint: disable=no-member
        # pylint: disable=unsubscriptable-object
        np.random.seed(0)
        with open(os.path.join(_path, "dummy_distribution.json"), encoding="utf-8") as f:
            distributions = json.load(f)
    
        with open(os.path.join(_path, "dummy_params.json"), encoding="utf-8") as f:
            params = json.load(f)
    
        grower = NeuronGrower(input_distributions=distributions, input_parameters=params).grow()
        expected = morphio.Morphology(os.path.join(_path, "dummy_neuron.asc"))
    
        assert_array_almost_equal(grower.soma.points, expected.soma.points)
>       assert_array_almost_equal(grower.root_sections[0].points, expected.root_sections[0].points)
E       AssertionError: 
E       Arrays are not almost equal to 6 decimals
E       
E       Mismatched elements: 6 / 9 (66.7%)
E       Max absolute difference: 2.637164
E       Max relative difference: 0.29820755
E        x: array([[-1.161602, -7.935147, 13.00619 ],
E              [-1.161602, -7.105966, 13.00619 ],
E              [-1.290905, -6.206221, 12.927537]], dtype=float32)
E        y: array([[-1.161602, -7.935147, 13.00619 ],
E              [-1.224638, -8.365755, 13.711984],
E              [-1.44443 , -8.843385, 14.457643]], dtype=float32)

tests/test_soma_grower.py:451: AssertionError

self = <tests.test_neuron_functional.TestBioRatL5Tpc2 object at 0x7fb3a136d190>
tmpdir = local('/home/runner/work/NeuroTS/NeuroTS/.tox/min_versions/tmp/popen-gw1/test_with_rng0')

    def test_with_rng(self, tmpdir):
>       _test_full(
            "path_distances",
            "bio_rat_L5_TPC_B_distribution.json",
            "params2.json",
            "expected_bio_rat_L5_TPC_B_with_params2.h5",
            "expected_bio_rat_L5_TPC_B_with_params2_persistence_diagram.json",
            rng_or_seed=build_random_generator(0),
            output_dir=tmpdir,
        )

tests/test_neuron_functional.py:631: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

feature = 'path_distances'
distributions = {'apical_dendrite': {'filtration_metric': 'path_distances', 'min_bar_length': 1.0, 'num_trees': {'data': {'bins': [1],....4106653615432989, 0.5277795547616266, -0.18579814237229897], ...], ...], ...}, 'diameter': {'method': 'uniform'}, ...}
parameters = 'params2.json'
ref_cell = 'expected_bio_rat_L5_TPC_B_with_params2.h5'
ref_persistence_diagram = 'expected_bio_rat_L5_TPC_B_with_params2_persistence_diagram.json'
rng_or_seed = RandomState(MT19937) at 0x7FB3A145F740, skip_preprocessing = False
output_dir = local('/home/runner/work/NeuroTS/NeuroTS/.tox/min_versions/tmp/popen-gw1/test_with_rng0')

    def _test_full(
        feature,
        distributions,
        parameters,
        ref_cell,
        ref_persistence_diagram,
        rng_or_seed=None,
        skip_preprocessing=False,
        output_dir=None,
    ):
        distributions, params = _load_inputs(join(_path, distributions), join(_path, parameters))
        if rng_or_seed is None:
            np.random.seed(0)
            n = NeuronGrower(
                input_distributions=distributions,
                input_parameters=params,
                skip_preprocessing=skip_preprocessing,
            ).grow()
        else:
            n = NeuronGrower(
                input_distributions=distributions,
                input_parameters=params,
                rng_or_seed=rng_or_seed,
                skip_preprocessing=skip_preprocessing,
            ).grow()
    
        with TemporaryDirectory("test_grower") as folder:
            out_neuron = join(folder, "test_output_neuron_.h5")
            n.write(out_neuron)
    
            # For checking purposes, we can output the cells as swc
            if output_dir is not None:
                if not os.path.exists(output_dir):
                    os.mkdir(output_dir)
                n.write(join(output_dir, basename(ref_cell)))
    
            if ref_persistence_diagram is not None:
                # Load with TMD and extract radial persistence
                n0 = tmd.io.load_neuron(out_neuron)
    
                actual_persistence_diagram = tmd.methods.get_persistence_diagram(
                    n0.apical_dendrite[0], feature=feature
                )
                if output_dir is not None:
                    with open(
                        join(output_dir, basename(ref_persistence_diagram)), "w", encoding="utf-8"
                    ) as f:
                        json.dump(actual_persistence_diagram, f, sort_keys=True, indent=2)
    
                with open(join(_path, ref_persistence_diagram), encoding="utf-8") as f:
                    expected_persistence_diagram = json.load(f)
                assert_close_persistent_diagram(
                    actual_persistence_diagram, expected_persistence_diagram
                )
>           assert not diff(out_neuron, join(_path, ref_cell))
E           AssertionError: assert not <morph_tool.morphio_diff.DiffResult object at 0x7fb3a1348a90>
E            +  where <morph_tool.morphio_diff.DiffResult object at 0x7fb3a1348a90> = diff('/tmp/tmpuzsx9so6test_grower/test_output_neuron_.h5', '/home/runner/work/NeuroTS/NeuroTS/tests/data/expected_bio_rat_L5_TPC_B_with_params2.h5')
E            +    where '/home/runner/work/NeuroTS/NeuroTS/tests/data/expected_bio_rat_L5_TPC_B_with_params2.h5' = join('/home/runner/work/NeuroTS/NeuroTS/tests/data', 'expected_bio_rat_L5_TPC_B_with_params2.h5')

tests/test_neuron_functional.py:132: AssertionError

self = <tests.test_neuron_functional.TestPathGrower object at 0x7effbb524e20>
tmpdir = local('/home/runner/work/NeuroTS/NeuroTS/.tox/min_versions/tmp/popen-gw3/test_with_rng0')

    def test_with_rng(self, tmpdir):
>       _test_full(
            "path_distances",
            "bio_distribution.json",
            "bio_path_params.json",
            "path_grower.h5",
            "bio_path_persistence_diagram.json",
            rng_or_seed=build_random_generator(0),
            output_dir=tmpdir,
        )

tests/test_neuron_functional.py:469: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

feature = 'path_distances'
distributions = {'apical_dendrite': {'filtration_metric': 'path_distances', 'min_bar_length': 1.0, 'num_trees': {'data': {'bins': [1],...665, 0.02188742478139427], [265.46654445080054, 0, nan, nan, nan, nan]]], ...}, 'diameter': {'method': 'uniform'}, ...}
parameters = 'bio_path_params.json', ref_cell = 'path_grower.h5'
ref_persistence_diagram = 'bio_path_persistence_diagram.json'
rng_or_seed = RandomState(MT19937) at 0x7EFFBB65CA40, skip_preprocessing = False
output_dir = local('/home/runner/work/NeuroTS/NeuroTS/.tox/min_versions/tmp/popen-gw3/test_with_rng0')

    def _test_full(
        feature,
        distributions,
        parameters,
        ref_cell,
        ref_persistence_diagram,
        rng_or_seed=None,
        skip_preprocessing=False,
        output_dir=None,
    ):
        distributions, params = _load_inputs(join(_path, distributions), join(_path, parameters))
        if rng_or_seed is None:
            np.random.seed(0)
            n = NeuronGrower(
                input_distributions=distributions,
                input_parameters=params,
                skip_preprocessing=skip_preprocessing,
            ).grow()
        else:
            n = NeuronGrower(
                input_distributions=distributions,
                input_parameters=params,
                rng_or_seed=rng_or_seed,
                skip_preprocessing=skip_preprocessing,
            ).grow()
    
        with TemporaryDirectory("test_grower") as folder:
            out_neuron = join(folder, "test_output_neuron_.h5")
            n.write(out_neuron)
    
            # For checking purposes, we can output the cells as swc
            if output_dir is not None:
                if not os.path.exists(output_dir):
                    os.mkdir(output_dir)
                n.write(join(output_dir, basename(ref_cell)))
    
            if ref_persistence_diagram is not None:
                # Load with TMD and extract radial persistence
                n0 = tmd.io.load_neuron(out_neuron)
    
                actual_persistence_diagram = tmd.methods.get_persistence_diagram(
                    n0.apical_dendrite[0], feature=feature
                )
                if output_dir is not None:
                    with open(
                        join(output_dir, basename(ref_persistence_diagram)), "w", encoding="utf-8"
                    ) as f:
                        json.dump(actual_persistence_diagram, f, sort_keys=True, indent=2)
    
                with open(join(_path, ref_persistence_diagram), encoding="utf-8") as f:
                    expected_persistence_diagram = json.load(f)
                assert_close_persistent_diagram(
                    actual_persistence_diagram, expected_persistence_diagram
                )
>           assert not diff(out_neuron, join(_path, ref_cell))
E           AssertionError: assert not <morph_tool.morphio_diff.DiffResult object at 0x7effbb524070>
E            +  where <morph_tool.morphio_diff.DiffResult object at 0x7effbb524070> = diff('/tmp/tmpl36x7wqwtest_grower/test_output_neuron_.h5', '/home/runner/work/NeuroTS/NeuroTS/tests/data/path_grower.h5')
E            +    where '/home/runner/work/NeuroTS/NeuroTS/tests/data/path_grower.h5' = join('/home/runner/work/NeuroTS/NeuroTS/tests/data', 'path_grower.h5')

tests/test_neuron_functional.py:132: AssertionError

self = <tests.test_neuron_functional.TestPathGrower object at 0x7effbb4467c0>
tmpdir = local('/home/runner/work/NeuroTS/NeuroTS/.tox/min_versions/tmp/popen-gw3/test_skip_preprocessing0')

    def test_skip_preprocessing(self, tmpdir):
>       _test_full(
            "path_distances",
            "bio_distribution.json",
            "bio_path_params_orientation_manager.json",
            "path_grower.h5",
            "bio_path_persistence_diagram.json",
            skip_preprocessing=True,
            output_dir=tmpdir,
        )

tests/test_neuron_functional.py:480: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

feature = 'path_distances'
distributions = {'apical_dendrite': {'filtration_metric': 'path_distances', 'min_bar_length': 1.0, 'num_trees': {'data': {'bins': [1],...665, 0.02188742478139427], [265.46654445080054, 0, nan, nan, nan, nan]]], ...}, 'diameter': {'method': 'uniform'}, ...}
parameters = 'bio_path_params_orientation_manager.json'
ref_cell = 'path_grower.h5'
ref_persistence_diagram = 'bio_path_persistence_diagram.json'
rng_or_seed = None, skip_preprocessing = True
output_dir = local('/home/runner/work/NeuroTS/NeuroTS/.tox/min_versions/tmp/popen-gw3/test_skip_preprocessing0')

    def _test_full(
        feature,
        distributions,
        parameters,
        ref_cell,
        ref_persistence_diagram,
        rng_or_seed=None,
        skip_preprocessing=False,
        output_dir=None,
    ):
        distributions, params = _load_inputs(join(_path, distributions), join(_path, parameters))
        if rng_or_seed is None:
            np.random.seed(0)
            n = NeuronGrower(
                input_distributions=distributions,
                input_parameters=params,
                skip_preprocessing=skip_preprocessing,
            ).grow()
        else:
            n = NeuronGrower(
                input_distributions=distributions,
                input_parameters=params,
                rng_or_seed=rng_or_seed,
                skip_preprocessing=skip_preprocessing,
            ).grow()
    
        with TemporaryDirectory("test_grower") as folder:
            out_neuron = join(folder, "test_output_neuron_.h5")
            n.write(out_neuron)
    
            # For checking purposes, we can output the cells as swc
            if output_dir is not None:
                if not os.path.exists(output_dir):
                    os.mkdir(output_dir)
                n.write(join(output_dir, basename(ref_cell)))
    
            if ref_persistence_diagram is not None:
                # Load with TMD and extract radial persistence
                n0 = tmd.io.load_neuron(out_neuron)
    
                actual_persistence_diagram = tmd.methods.get_persistence_diagram(
                    n0.apical_dendrite[0], feature=feature
                )
                if output_dir is not None:
                    with open(
                        join(output_dir, basename(ref_persistence_diagram)), "w", encoding="utf-8"
                    ) as f:
                        json.dump(actual_persistence_diagram, f, sort_keys=True, indent=2)
    
                with open(join(_path, ref_persistence_diagram), encoding="utf-8") as f:
                    expected_persistence_diagram = json.load(f)
                assert_close_persistent_diagram(
                    actual_persistence_diagram, expected_persistence_diagram
                )
>           assert not diff(out_neuron, join(_path, ref_cell))
E           AssertionError: assert not <morph_tool.morphio_diff.DiffResult object at 0x7effbb446be0>
E            +  where <morph_tool.morphio_diff.DiffResult object at 0x7effbb446be0> = diff('/tmp/tmp9t1hbdkztest_grower/test_output_neuron_.h5', '/home/runner/work/NeuroTS/NeuroTS/tests/data/path_grower.h5')
E            +    where '/home/runner/work/NeuroTS/NeuroTS/tests/data/path_grower.h5' = join('/home/runner/work/NeuroTS/NeuroTS/tests/data', 'path_grower.h5')

tests/test_neuron_functional.py:132: AssertionError

self = <tests.test_neuron_functional.TestBioRatL5Tpc2 object at 0x7fb3a0e83700>
tmpdir = local('/home/runner/work/NeuroTS/NeuroTS/.tox/min_versions/tmp/popen-gw1/test_skip_preprocessing0')

    def test_skip_preprocessing(self, tmpdir):
>       _test_full(
            "path_distances",
            "bio_rat_L5_TPC_B_distribution.json",
            "params2_orientation_manager.json",
            "expected_bio_rat_L5_TPC_B_with_params2.h5",
            "expected_bio_rat_L5_TPC_B_with_params2_persistence_diagram.json",
            skip_preprocessing=True,
            output_dir=tmpdir,
        )

tests/test_neuron_functional.py:642: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

feature = 'path_distances'
distributions = {'apical_dendrite': {'filtration_metric': 'path_distances', 'min_bar_length': 1.0, 'num_trees': {'data': {'bins': [1],....4106653615432989, 0.5277795547616266, -0.18579814237229897], ...], ...], ...}, 'diameter': {'method': 'uniform'}, ...}
parameters = 'params2_orientation_manager.json'
ref_cell = 'expected_bio_rat_L5_TPC_B_with_params2.h5'
ref_persistence_diagram = 'expected_bio_rat_L5_TPC_B_with_params2_persistence_diagram.json'
rng_or_seed = None, skip_preprocessing = True
output_dir = local('/home/runner/work/NeuroTS/NeuroTS/.tox/min_versions/tmp/popen-gw1/test_skip_preprocessing0')

    def _test_full(
        feature,
        distributions,
        parameters,
        ref_cell,
        ref_persistence_diagram,
        rng_or_seed=None,
        skip_preprocessing=False,
        output_dir=None,
    ):
        distributions, params = _load_inputs(join(_path, distributions), join(_path, parameters))
        if rng_or_seed is None:
            np.random.seed(0)
            n = NeuronGrower(
                input_distributions=distributions,
                input_parameters=params,
                skip_preprocessing=skip_preprocessing,
            ).grow()
        else:
            n = NeuronGrower(
                input_distributions=distributions,
                input_parameters=params,
                rng_or_seed=rng_or_seed,
                skip_preprocessing=skip_preprocessing,
            ).grow()
    
        with TemporaryDirectory("test_grower") as folder:
            out_neuron = join(folder, "test_output_neuron_.h5")
            n.write(out_neuron)
    
            # For checking purposes, we can output the cells as swc
            if output_dir is not None:
                if not os.path.exists(output_dir):
                    os.mkdir(output_dir)
                n.write(join(output_dir, basename(ref_cell)))
    
            if ref_persistence_diagram is not None:
                # Load with TMD and extract radial persistence
                n0 = tmd.io.load_neuron(out_neuron)
    
                actual_persistence_diagram = tmd.methods.get_persistence_diagram(
                    n0.apical_dendrite[0], feature=feature
                )
                if output_dir is not None:
                    with open(
                        join(output_dir, basename(ref_persistence_diagram)), "w", encoding="utf-8"
                    ) as f:
                        json.dump(actual_persistence_diagram, f, sort_keys=True, indent=2)
    
                with open(join(_path, ref_persistence_diagram), encoding="utf-8") as f:
                    expected_persistence_diagram = json.load(f)
                assert_close_persistent_diagram(
                    actual_persistence_diagram, expected_persistence_diagram
                )
>           assert not diff(out_neuron, join(_path, ref_cell))
E           AssertionError: assert not <morph_tool.morphio_diff.DiffResult object at 0x7fb3a0e839d0>
E            +  where <morph_tool.morphio_diff.DiffResult object at 0x7fb3a0e839d0> = diff('/tmp/tmpkzd8xp1mtest_grower/test_output_neuron_.h5', '/home/runner/work/NeuroTS/NeuroTS/tests/data/expected_bio_rat_L5_TPC_B_with_params2.h5')
E            +    where '/home/runner/work/NeuroTS/NeuroTS/tests/data/expected_bio_rat_L5_TPC_B_with_params2.h5' = join('/home/runner/work/NeuroTS/NeuroTS/tests/data', 'expected_bio_rat_L5_TPC_B_with_params2.h5')

tests/test_neuron_functional.py:132: AssertionError

self = <tests.test_neuron_functional.TestGradientPathGrower object at 0x7f3b1c2e75b0>
tmpdir = local('/home/runner/work/NeuroTS/NeuroTS/.tox/min_versions/tmp/popen-gw0/test_default0')

    def test_default(self, tmpdir):
>       _test_full(
            "path_distances",
            "bio_distribution.json",
            "bio_gradient_path_params.json",
            "gradient_path_grower.h5",
            "gradient_path_persistence_diagram.json",
            output_dir=tmpdir,
        )

tests/test_neuron_functional.py:529: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

feature = 'path_distances'
distributions = {'apical_dendrite': {'filtration_metric': 'path_distances', 'min_bar_length': 1.0, 'num_trees': {'data': {'bins': [1],...665, 0.02188742478139427], [265.46654445080054, 0, nan, nan, nan, nan]]], ...}, 'diameter': {'method': 'uniform'}, ...}
parameters = 'bio_gradient_path_params.json'
ref_cell = 'gradient_path_grower.h5'
ref_persistence_diagram = 'gradient_path_persistence_diagram.json'
rng_or_seed = None, skip_preprocessing = False
output_dir = local('/home/runner/work/NeuroTS/NeuroTS/.tox/min_versions/tmp/popen-gw0/test_default0')

    def _test_full(
        feature,
        distributions,
        parameters,
        ref_cell,
        ref_persistence_diagram,
        rng_or_seed=None,
        skip_preprocessing=False,
        output_dir=None,
    ):
        distributions, params = _load_inputs(join(_path, distributions), join(_path, parameters))
        if rng_or_seed is None:
            np.random.seed(0)
            n = NeuronGrower(
                input_distributions=distributions,
                input_parameters=params,
                skip_preprocessing=skip_preprocessing,
            ).grow()
        else:
            n = NeuronGrower(
                input_distributions=distributions,
                input_parameters=params,
                rng_or_seed=rng_or_seed,
                skip_preprocessing=skip_preprocessing,
            ).grow()
    
        with TemporaryDirectory("test_grower") as folder:
            out_neuron = join(folder, "test_output_neuron_.h5")
            n.write(out_neuron)
    
            # For checking purposes, we can output the cells as swc
            if output_dir is not None:
                if not os.path.exists(output_dir):
                    os.mkdir(output_dir)
                n.write(join(output_dir, basename(ref_cell)))
    
            if ref_persistence_diagram is not None:
                # Load with TMD and extract radial persistence
                n0 = tmd.io.load_neuron(out_neuron)
    
                actual_persistence_diagram = tmd.methods.get_persistence_diagram(
                    n0.apical_dendrite[0], feature=feature
                )
                if output_dir is not None:
                    with open(
                        join(output_dir, basename(ref_persistence_diagram)), "w", encoding="utf-8"
                    ) as f:
                        json.dump(actual_persistence_diagram, f, sort_keys=True, indent=2)
    
                with open(join(_path, ref_persistence_diagram), encoding="utf-8") as f:
                    expected_persistence_diagram = json.load(f)
                assert_close_persistent_diagram(
                    actual_persistence_diagram, expected_persistence_diagram
                )
>           assert not diff(out_neuron, join(_path, ref_cell))
E           AssertionError: assert not <morph_tool.morphio_diff.DiffResult object at 0x7f3b1c2ebb80>
E            +  where <morph_tool.morphio_diff.DiffResult object at 0x7f3b1c2ebb80> = diff('/tmp/tmp4r_qriq2test_grower/test_output_neuron_.h5', '/home/runner/work/NeuroTS/NeuroTS/tests/data/gradient_path_grower.h5')
E            +    where '/home/runner/work/NeuroTS/NeuroTS/tests/data/gradient_path_grower.h5' = join('/home/runner/work/NeuroTS/NeuroTS/tests/data', 'gradient_path_grower.h5')

tests/test_neuron_functional.py:132: AssertionError

self = <tests.test_neuron_functional.TestPathGrower object at 0x7effbb456f10>
tmpdir = local('/home/runner/work/NeuroTS/NeuroTS/.tox/min_versions/tmp/popen-gw3/test_skip_rng_and_preprocessin0')

    def test_skip_rng_and_preprocessing(self, tmpdir):
>       _test_full(
            "path_distances",
            "bio_distribution.json",
            "bio_path_params_orientation_manager.json",
            "path_grower.h5",
            "bio_path_persistence_diagram.json",
            skip_preprocessing=True,
            rng_or_seed=build_random_generator(0),
            output_dir=tmpdir,
        )

tests/test_neuron_functional.py:491: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

feature = 'path_distances'
distributions = {'apical_dendrite': {'filtration_metric': 'path_distances', 'min_bar_length': 1.0, 'num_trees': {'data': {'bins': [1],...665, 0.02188742478139427], [265.46654445080054, 0, nan, nan, nan, nan]]], ...}, 'diameter': {'method': 'uniform'}, ...}
parameters = 'bio_path_params_orientation_manager.json'
ref_cell = 'path_grower.h5'
ref_persistence_diagram = 'bio_path_persistence_diagram.json'
rng_or_seed = RandomState(MT19937) at 0x7EFFBB65CC40, skip_preprocessing = True
output_dir = local('/home/runner/work/NeuroTS/NeuroTS/.tox/min_versions/tmp/popen-gw3/test_skip_rng_and_preprocessin0')

    def _test_full(
        feature,
        distributions,
        parameters,
        ref_cell,
        ref_persistence_diagram,
        rng_or_seed=None,
        skip_preprocessing=False,
        output_dir=None,
    ):
        distributions, params = _load_inputs(join(_path, distributions), join(_path, parameters))
        if rng_or_seed is None:
            np.random.seed(0)
            n = NeuronGrower(
                input_distributions=distributions,
                input_parameters=params,
                skip_preprocessing=skip_preprocessing,
            ).grow()
        else:
            n = NeuronGrower(
                input_distributions=distributions,
                input_parameters=params,
                rng_or_seed=rng_or_seed,
                skip_preprocessing=skip_preprocessing,
            ).grow()
    
        with TemporaryDirectory("test_grower") as folder:
            out_neuron = join(folder, "test_output_neuron_.h5")
            n.write(out_neuron)
    
            # For checking purposes, we can output the cells as swc
            if output_dir is not None:
                if not os.path.exists(output_dir):
                    os.mkdir(output_dir)
                n.write(join(output_dir, basename(ref_cell)))
    
            if ref_persistence_diagram is not None:
                # Load with TMD and extract radial persistence
                n0 = tmd.io.load_neuron(out_neuron)
    
                actual_persistence_diagram = tmd.methods.get_persistence_diagram(
                    n0.apical_dendrite[0], feature=feature
                )
                if output_dir is not None:
                    with open(
                        join(output_dir, basename(ref_persistence_diagram)), "w", encoding="utf-8"
                    ) as f:
                        json.dump(actual_persistence_diagram, f, sort_keys=True, indent=2)
    
                with open(join(_path, ref_persistence_diagram), encoding="utf-8") as f:
                    expected_persistence_diagram = json.load(f)
                assert_close_persistent_diagram(
                    actual_persistence_diagram, expected_persistence_diagram
                )
>           assert not diff(out_neuron, join(_path, ref_cell))
E           AssertionError: assert not <morph_tool.morphio_diff.DiffResult object at 0x7effbb456ca0>
E            +  where <morph_tool.morphio_diff.DiffResult object at 0x7effbb456ca0> = diff('/tmp/tmp5o4jdbswtest_grower/test_output_neuron_.h5', '/home/runner/work/NeuroTS/NeuroTS/tests/data/path_grower.h5')
E            +    where '/home/runner/work/NeuroTS/NeuroTS/tests/data/path_grower.h5' = join('/home/runner/work/NeuroTS/NeuroTS/tests/data', 'path_grower.h5')

tests/test_neuron_functional.py:132: AssertionError

self = <tests.test_neuron_functional.TestGradientPathGrower object at 0x7f3b1c0879d0>
tmpdir = local('/home/runner/work/NeuroTS/NeuroTS/.tox/min_versions/tmp/popen-gw0/test_with_rng0')

    def test_with_rng(self, tmpdir):
>       _test_full(
            "path_distances",
            "bio_distribution.json",
            "bio_gradient_path_params.json",
            "gradient_path_grower.h5",
            "gradient_path_persistence_diagram.json",
            rng_or_seed=build_random_generator(0),
            output_dir=tmpdir,
        )

tests/test_neuron_functional.py:539: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

feature = 'path_distances'
distributions = {'apical_dendrite': {'filtration_metric': 'path_distances', 'min_bar_length': 1.0, 'num_trees': {'data': {'bins': [1],...665, 0.02188742478139427], [265.46654445080054, 0, nan, nan, nan, nan]]], ...}, 'diameter': {'method': 'uniform'}, ...}
parameters = 'bio_gradient_path_params.json'
ref_cell = 'gradient_path_grower.h5'
ref_persistence_diagram = 'gradient_path_persistence_diagram.json'
rng_or_seed = RandomState(MT19937) at 0x7F3B113F2740, skip_preprocessing = False
output_dir = local('/home/runner/work/NeuroTS/NeuroTS/.tox/min_versions/tmp/popen-gw0/test_with_rng0')

    def _test_full(
        feature,
        distributions,
        parameters,
        ref_cell,
        ref_persistence_diagram,
        rng_or_seed=None,
        skip_preprocessing=False,
        output_dir=None,
    ):
        distributions, params = _load_inputs(join(_path, distributions), join(_path, parameters))
        if rng_or_seed is None:
            np.random.seed(0)
            n = NeuronGrower(
                input_distributions=distributions,
                input_parameters=params,
                skip_preprocessing=skip_preprocessing,
            ).grow()
        else:
            n = NeuronGrower(
                input_distributions=distributions,
                input_parameters=params,
                rng_or_seed=rng_or_seed,
                skip_preprocessing=skip_preprocessing,
            ).grow()
    
        with TemporaryDirectory("test_grower") as folder:
            out_neuron = join(folder, "test_output_neuron_.h5")
            n.write(out_neuron)
    
            # For checking purposes, we can output the cells as swc
            if output_dir is not None:
                if not os.path.exists(output_dir):
                    os.mkdir(output_dir)
                n.write(join(output_dir, basename(ref_cell)))
    
            if ref_persistence_diagram is not None:
                # Load with TMD and extract radial persistence
                n0 = tmd.io.load_neuron(out_neuron)
    
                actual_persistence_diagram = tmd.methods.get_persistence_diagram(
                    n0.apical_dendrite[0], feature=feature
                )
                if output_dir is not None:
                    with open(
                        join(output_dir, basename(ref_persistence_diagram)), "w", encoding="utf-8"
                    ) as f:
                        json.dump(actual_persistence_diagram, f, sort_keys=True, indent=2)
    
                with open(join(_path, ref_persistence_diagram), encoding="utf-8") as f:
                    expected_persistence_diagram = json.load(f)
                assert_close_persistent_diagram(
                    actual_persistence_diagram, expected_persistence_diagram
                )
>           assert not diff(out_neuron, join(_path, ref_cell))
E           AssertionError: assert not <morph_tool.morphio_diff.DiffResult object at 0x7f3b1c0820d0>
E            +  where <morph_tool.morphio_diff.DiffResult object at 0x7f3b1c0820d0> = diff('/tmp/tmpld83km9wtest_grower/test_output_neuron_.h5', '/home/runner/work/NeuroTS/NeuroTS/tests/data/gradient_path_grower.h5')
E            +    where '/home/runner/work/NeuroTS/NeuroTS/tests/data/gradient_path_grower.h5' = join('/home/runner/work/NeuroTS/NeuroTS/tests/data', 'gradient_path_grower.h5')

tests/test_neuron_functional.py:132: AssertionError

self = <tests.test_neuron_functional.TestBioRatL5Tpc4 object at 0x7effbb1e6790>
tmpdir = local('/home/runner/work/NeuroTS/NeuroTS/.tox/min_versions/tmp/popen-gw3/test_with_rng1')

    def test_with_rng(self, tmpdir):
>       _test_full(
            "path_distances",
            "bio_rat_L5_TPC_B_distribution.json",
            "params4.json",
            "expected_bio_rat_L5_TPC_B_with_params4.h5",
            "expected_bio_rat_L5_TPC_B_with_params4_persistence_diagram.json",
            rng_or_seed=build_random_generator(0),
            output_dir=tmpdir,
        )

tests/test_neuron_functional.py:723: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

feature = 'path_distances'
distributions = {'apical_dendrite': {'filtration_metric': 'path_distances', 'min_bar_length': 1.0, 'num_trees': {'data': {'bins': [1],....4106653615432989, 0.5277795547616266, -0.18579814237229897], ...], ...], ...}, 'diameter': {'method': 'uniform'}, ...}
parameters = 'params4.json'
ref_cell = 'expected_bio_rat_L5_TPC_B_with_params4.h5'
ref_persistence_diagram = 'expected_bio_rat_L5_TPC_B_with_params4_persistence_diagram.json'
rng_or_seed = RandomState(MT19937) at 0x7EFFBB65C640, skip_preprocessing = False
output_dir = local('/home/runner/work/NeuroTS/NeuroTS/.tox/min_versions/tmp/popen-gw3/test_with_rng1')

    def _test_full(
        feature,
        distributions,
        parameters,
        ref_cell,
        ref_persistence_diagram,
        rng_or_seed=None,
        skip_preprocessing=False,
        output_dir=None,
    ):
        distributions, params = _load_inputs(join(_path, distributions), join(_path, parameters))
        if rng_or_seed is None:
            np.random.seed(0)
            n = NeuronGrower(
                input_distributions=distributions,
                input_parameters=params,
                skip_preprocessing=skip_preprocessing,
            ).grow()
        else:
            n = NeuronGrower(
                input_distributions=distributions,
                input_parameters=params,
                rng_or_seed=rng_or_seed,
                skip_preprocessing=skip_preprocessing,
            ).grow()
    
        with TemporaryDirectory("test_grower") as folder:
            out_neuron = join(folder, "test_output_neuron_.h5")
            n.write(out_neuron)
    
            # For checking purposes, we can output the cells as swc
            if output_dir is not None:
                if not os.path.exists(output_dir):
                    os.mkdir(output_dir)
                n.write(join(output_dir, basename(ref_cell)))
    
            if ref_persistence_diagram is not None:
                # Load with TMD and extract radial persistence
                n0 = tmd.io.load_neuron(out_neuron)
    
                actual_persistence_diagram = tmd.methods.get_persistence_diagram(
                    n0.apical_dendrite[0], feature=feature
                )
                if output_dir is not None:
                    with open(
                        join(output_dir, basename(ref_persistence_diagram)), "w", encoding="utf-8"
                    ) as f:
                        json.dump(actual_persistence_diagram, f, sort_keys=True, indent=2)
    
                with open(join(_path, ref_persistence_diagram), encoding="utf-8") as f:
                    expected_persistence_diagram = json.load(f)
                assert_close_persistent_diagram(
                    actual_persistence_diagram, expected_persistence_diagram
                )
>           assert not diff(out_neuron, join(_path, ref_cell))
E           AssertionError: assert not <morph_tool.morphio_diff.DiffResult object at 0x7effbb1f6220>
E            +  where <morph_tool.morphio_diff.DiffResult object at 0x7effbb1f6220> = diff('/tmp/tmpkzgfw1kktest_grower/test_output_neuron_.h5', '/home/runner/work/NeuroTS/NeuroTS/tests/data/expected_bio_rat_L5_TPC_B_with_params4.h5')
E            +    where '/home/runner/work/NeuroTS/NeuroTS/tests/data/expected_bio_rat_L5_TPC_B_with_params4.h5' = join('/home/runner/work/NeuroTS/NeuroTS/tests/data', 'expected_bio_rat_L5_TPC_B_with_params4.h5')

tests/test_neuron_functional.py:132: AssertionError

self = <tests.test_neuron_functional.TestBioRatL5Tpc2 object at 0x7fb3a12afdf0>
tmpdir = local('/home/runner/work/NeuroTS/NeuroTS/.tox/min_versions/tmp/popen-gw1/test_skip_rng_and_preprocessin0')

    def test_skip_rng_and_preprocessing(self, tmpdir):
>       _test_full(
            "path_distances",
            "bio_rat_L5_TPC_B_distribution.json",
            "params2_orientation_manager.json",
            "expected_bio_rat_L5_TPC_B_with_params2.h5",
            "expected_bio_rat_L5_TPC_B_with_params2_persistence_diagram.json",
            skip_preprocessing=True,
            rng_or_seed=build_random_generator(0),
            output_dir=tmpdir,
        )

tests/test_neuron_functional.py:653: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

feature = 'path_distances'
distributions = {'apical_dendrite': {'filtration_metric': 'path_distances', 'min_bar_length': 1.0, 'num_trees': {'data': {'bins': [1],....4106653615432989, 0.5277795547616266, -0.18579814237229897], ...], ...], ...}, 'diameter': {'method': 'uniform'}, ...}
parameters = 'params2_orientation_manager.json'
ref_cell = 'expected_bio_rat_L5_TPC_B_with_params2.h5'
ref_persistence_diagram = 'expected_bio_rat_L5_TPC_B_with_params2_persistence_diagram.json'
rng_or_seed = RandomState(MT19937) at 0x7FB3A145F840, skip_preprocessing = True
output_dir = local('/home/runner/work/NeuroTS/NeuroTS/.tox/min_versions/tmp/popen-gw1/test_skip_rng_and_preprocessin0')

    def _test_full(
        feature,
        distributions,
        parameters,
        ref_cell,
        ref_persistence_diagram,
        rng_or_seed=None,
        skip_preprocessing=False,
        output_dir=None,
    ):
        distributions, params = _load_inputs(join(_path, distributions), join(_path, parameters))
        if rng_or_seed is None:
            np.random.seed(0)
            n = NeuronGrower(
                input_distributions=distributions,
                input_parameters=params,
                skip_preprocessing=skip_preprocessing,
            ).grow()
        else:
            n = NeuronGrower(
                input_distributions=distributions,
                input_parameters=params,
                rng_or_seed=rng_or_seed,
                skip_preprocessing=skip_preprocessing,
            ).grow()
    
        with TemporaryDirectory("test_grower") as folder:
            out_neuron = join(folder, "test_output_neuron_.h5")
            n.write(out_neuron)
    
            # For checking purposes, we can output the cells as swc
            if output_dir is not None:
                if not os.path.exists(output_dir):
                    os.mkdir(output_dir)
                n.write(join(output_dir, basename(ref_cell)))
    
            if ref_persistence_diagram is not None:
                # Load with TMD and extract radial persistence
                n0 = tmd.io.load_neuron(out_neuron)
    
                actual_persistence_diagram = tmd.methods.get_persistence_diagram(
                    n0.apical_dendrite[0], feature=feature
                )
                if output_dir is not None:
                    with open(
                        join(output_dir, basename(ref_persistence_diagram)), "w", encoding="utf-8"
                    ) as f:
                        json.dump(actual_persistence_diagram, f, sort_keys=True, indent=2)
    
                with open(join(_path, ref_persistence_diagram), encoding="utf-8") as f:
                    expected_persistence_diagram = json.load(f)
                assert_close_persistent_diagram(
                    actual_persistence_diagram, expected_persistence_diagram
                )
>           assert not diff(out_neuron, join(_path, ref_cell))
E           AssertionError: assert not <morph_tool.morphio_diff.DiffResult object at 0x7fb3a12afdc0>
E            +  where <morph_tool.morphio_diff.DiffResult object at 0x7fb3a12afdc0> = diff('/tmp/tmplgl3v4v2test_grower/test_output_neuron_.h5', '/home/runner/work/NeuroTS/NeuroTS/tests/data/expected_bio_rat_L5_TPC_B_with_params2.h5')
E            +    where '/home/runner/work/NeuroTS/NeuroTS/tests/data/expected_bio_rat_L5_TPC_B_with_params2.h5' = join('/home/runner/work/NeuroTS/NeuroTS/tests/data', 'expected_bio_rat_L5_TPC_B_with_params2.h5')

tests/test_neuron_functional.py:132: AssertionError

self = <tests.test_neuron_functional.TestGradientPathGrower object at 0x7f3b1c24d3d0>
tmpdir = local('/home/runner/work/NeuroTS/NeuroTS/.tox/min_versions/tmp/popen-gw0/test_skip_preprocessing0')

    def test_skip_preprocessing(self, tmpdir):
>       _test_full(
            "path_distances",
            "bio_distribution.json",
            "bio_gradient_path_params_orientation_manager.json",
            "gradient_path_grower.h5",
            "gradient_path_persistence_diagram.json",
            skip_preprocessing=True,
            output_dir=tmpdir,
        )

tests/test_neuron_functional.py:550: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

feature = 'path_distances'
distributions = {'apical_dendrite': {'filtration_metric': 'path_distances', 'min_bar_length': 1.0, 'num_trees': {'data': {'bins': [1],...665, 0.02188742478139427], [265.46654445080054, 0, nan, nan, nan, nan]]], ...}, 'diameter': {'method': 'uniform'}, ...}
parameters = 'bio_gradient_path_params_orientation_manager.json'
ref_cell = 'gradient_path_grower.h5'
ref_persistence_diagram = 'gradient_path_persistence_diagram.json'
rng_or_seed = None, skip_preprocessing = True
output_dir = local('/home/runner/work/NeuroTS/NeuroTS/.tox/min_versions/tmp/popen-gw0/test_skip_preprocessing0')

    def _test_full(
        feature,
        distributions,
        parameters,
        ref_cell,
        ref_persistence_diagram,
        rng_or_seed=None,
        skip_preprocessing=False,
        output_dir=None,
    ):
        distributions, params = _load_inputs(join(_path, distributions), join(_path, parameters))
        if rng_or_seed is None:
            np.random.seed(0)
            n = NeuronGrower(
                input_distributions=distributions,
                input_parameters=params,
                skip_preprocessing=skip_preprocessing,
            ).grow()
        else:
            n = NeuronGrower(
                input_distributions=distributions,
                input_parameters=params,
                rng_or_seed=rng_or_seed,
                skip_preprocessing=skip_preprocessing,
            ).grow()
    
        with TemporaryDirectory("test_grower") as folder:
            out_neuron = join(folder, "test_output_neuron_.h5")
            n.write(out_neuron)
    
            # For checking purposes, we can output the cells as swc
            if output_dir is not None:
                if not os.path.exists(output_dir):
                    os.mkdir(output_dir)
                n.write(join(output_dir, basename(ref_cell)))
    
            if ref_persistence_diagram is not None:
                # Load with TMD and extract radial persistence
                n0 = tmd.io.load_neuron(out_neuron)
    
                actual_persistence_diagram = tmd.methods.get_persistence_diagram(
                    n0.apical_dendrite[0], feature=feature
                )
                if output_dir is not None:
                    with open(
                        join(output_dir, basename(ref_persistence_diagram)), "w", encoding="utf-8"
                    ) as f:
                        json.dump(actual_persistence_diagram, f, sort_keys=True, indent=2)
    
                with open(join(_path, ref_persistence_diagram), encoding="utf-8") as f:
                    expected_persistence_diagram = json.load(f)
                assert_close_persistent_diagram(
                    actual_persistence_diagram, expected_persistence_diagram
                )
>           assert not diff(out_neuron, join(_path, ref_cell))
E           AssertionError: assert not <morph_tool.morphio_diff.DiffResult object at 0x7f3b1c26c3d0>
E            +  where <morph_tool.morphio_diff.DiffResult object at 0x7f3b1c26c3d0> = diff('/tmp/tmplvlyvhmttest_grower/test_output_neuron_.h5', '/home/runner/work/NeuroTS/NeuroTS/tests/data/gradient_path_grower.h5')
E            +    where '/home/runner/work/NeuroTS/NeuroTS/tests/data/gradient_path_grower.h5' = join('/home/runner/work/NeuroTS/NeuroTS/tests/data', 'gradient_path_grower.h5')

tests/test_neuron_functional.py:132: AssertionError

self = <tests.test_neuron_functional.TestGradientPathGrower object at 0x7f3b1c0a9af0>
tmpdir = local('/home/runner/work/NeuroTS/NeuroTS/.tox/min_versions/tmp/popen-gw0/test_skip_rng_and_preprocessin0')

    def test_skip_rng_and_preprocessing(self, tmpdir):
>       _test_full(
            "path_distances",
            "bio_distribution.json",
            "bio_gradient_path_params_orientation_manager.json",
            "gradient_path_grower.h5",
            "gradient_path_persistence_diagram.json",
            skip_preprocessing=True,
            rng_or_seed=build_random_generator(0),
            output_dir=tmpdir,
        )

tests/test_neuron_functional.py:561: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

feature = 'path_distances'
distributions = {'apical_dendrite': {'filtration_metric': 'path_distances', 'min_bar_length': 1.0, 'num_trees': {'data': {'bins': [1],...665, 0.02188742478139427], [265.46654445080054, 0, nan, nan, nan, nan]]], ...}, 'diameter': {'method': 'uniform'}, ...}
parameters = 'bio_gradient_path_params_orientation_manager.json'
ref_cell = 'gradient_path_grower.h5'
ref_persistence_diagram = 'gradient_path_persistence_diagram.json'
rng_or_seed = RandomState(MT19937) at 0x7F3B1C31A840, skip_preprocessing = True
output_dir = local('/home/runner/work/NeuroTS/NeuroTS/.tox/min_versions/tmp/popen-gw0/test_skip_rng_and_preprocessin0')

    def _test_full(
        feature,
        distributions,
        parameters,
        ref_cell,
        ref_persistence_diagram,
        rng_or_seed=None,
        skip_preprocessing=False,
        output_dir=None,
    ):
        distributions, params = _load_inputs(join(_path, distributions), join(_path, parameters))
        if rng_or_seed is None:
            np.random.seed(0)
            n = NeuronGrower(
                input_distributions=distributions,
                input_parameters=params,
                skip_preprocessing=skip_preprocessing,
            ).grow()
        else:
            n = NeuronGrower(
                input_distributions=distributions,
                input_parameters=params,
                rng_or_seed=rng_or_seed,
                skip_preprocessing=skip_preprocessing,
            ).grow()
    
        with TemporaryDirectory("test_grower") as folder:
            out_neuron = join(folder, "test_output_neuron_.h5")
            n.write(out_neuron)
    
            # For checking purposes, we can output the cells as swc
            if output_dir is not None:
                if not os.path.exists(output_dir):
                    os.mkdir(output_dir)
                n.write(join(output_dir, basename(ref_cell)))
    
            if ref_persistence_diagram is not None:
                # Load with TMD and extract radial persistence
                n0 = tmd.io.load_neuron(out_neuron)
    
                actual_persistence_diagram = tmd.methods.get_persistence_diagram(
                    n0.apical_dendrite[0], feature=feature
                )
                if output_dir is not None:
                    with open(
                        join(output_dir, basename(ref_persistence_diagram)), "w", encoding="utf-8"
                    ) as f:
                        json.dump(actual_persistence_diagram, f, sort_keys=True, indent=2)
    
                with open(join(_path, ref_persistence_diagram), encoding="utf-8") as f:
                    expected_persistence_diagram = json.load(f)
                assert_close_persistent_diagram(
                    actual_persistence_diagram, expected_persistence_diagram
                )
>           assert not diff(out_neuron, join(_path, ref_cell))
E           AssertionError: assert not <morph_tool.morphio_diff.DiffResult object at 0x7f3b1c24d220>
E            +  where <morph_tool.morphio_diff.DiffResult object at 0x7f3b1c24d220> = diff('/tmp/tmpdvko6mistest_grower/test_output_neuron_.h5', '/home/runner/work/NeuroTS/NeuroTS/tests/data/gradient_path_grower.h5')
E            +    where '/home/runner/work/NeuroTS/NeuroTS/tests/data/gradient_path_grower.h5' = join('/home/runner/work/NeuroTS/NeuroTS/tests/data', 'gradient_path_grower.h5')

tests/test_neuron_functional.py:132: AssertionError

self = <tests.test_neuron_functional.TestBioRatL5Tpc4 object at 0x7effbb307730>
tmpdir = local('/home/runner/work/NeuroTS/NeuroTS/.tox/min_versions/tmp/popen-gw3/test_skip_preprocessing1')

    def test_skip_preprocessing(self, tmpdir):
>       _test_full(
            "path_distances",
            "bio_rat_L5_TPC_B_distribution.json",
            "params4_orientation_manager.json",
            "expected_bio_rat_L5_TPC_B_with_params4.h5",
            "expected_bio_rat_L5_TPC_B_with_params4_persistence_diagram.json",
            skip_preprocessing=True,
            output_dir=tmpdir,
        )

tests/test_neuron_functional.py:734: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

feature = 'path_distances'
distributions = {'apical_dendrite': {'filtration_metric': 'path_distances', 'min_bar_length': 1.0, 'num_trees': {'data': {'bins': [1],....4106653615432989, 0.5277795547616266, -0.18579814237229897], ...], ...], ...}, 'diameter': {'method': 'uniform'}, ...}
parameters = 'params4_orientation_manager.json'
ref_cell = 'expected_bio_rat_L5_TPC_B_with_params4.h5'
ref_persistence_diagram = 'expected_bio_rat_L5_TPC_B_with_params4_persistence_diagram.json'
rng_or_seed = None, skip_preprocessing = True
output_dir = local('/home/runner/work/NeuroTS/NeuroTS/.tox/min_versions/tmp/popen-gw3/test_skip_preprocessing1')

    def _test_full(
        feature,
        distributions,
        parameters,
        ref_cell,
        ref_persistence_diagram,
        rng_or_seed=None,
        skip_preprocessing=False,
        output_dir=None,
    ):
        distributions, params = _load_inputs(join(_path, distributions), join(_path, parameters))
        if rng_or_seed is None:
            np.random.seed(0)
            n = NeuronGrower(
                input_distributions=distributions,
                input_parameters=params,
                skip_preprocessing=skip_preprocessing,
            ).grow()
        else:
            n = NeuronGrower(
                input_distributions=distributions,
                input_parameters=params,
                rng_or_seed=rng_or_seed,
                skip_preprocessing=skip_preprocessing,
            ).grow()
    
        with TemporaryDirectory("test_grower") as folder:
            out_neuron = join(folder, "test_output_neuron_.h5")
            n.write(out_neuron)
    
            # For checking purposes, we can output the cells as swc
            if output_dir is not None:
                if not os.path.exists(output_dir):
                    os.mkdir(output_dir)
                n.write(join(output_dir, basename(ref_cell)))
    
            if ref_persistence_diagram is not None:
                # Load with TMD and extract radial persistence
                n0 = tmd.io.load_neuron(out_neuron)
    
                actual_persistence_diagram = tmd.methods.get_persistence_diagram(
                    n0.apical_dendrite[0], feature=feature
                )
                if output_dir is not None:
                    with open(
                        join(output_dir, basename(ref_persistence_diagram)), "w", encoding="utf-8"
                    ) as f:
                        json.dump(actual_persistence_diagram, f, sort_keys=True, indent=2)
    
                with open(join(_path, ref_persistence_diagram), encoding="utf-8") as f:
                    expected_persistence_diagram = json.load(f)
                assert_close_persistent_diagram(
                    actual_persistence_diagram, expected_persistence_diagram
                )
>           assert not diff(out_neuron, join(_path, ref_cell))
E           AssertionError: assert not <morph_tool.morphio_diff.DiffResult object at 0x7effbb307940>
E            +  where <morph_tool.morphio_diff.DiffResult object at 0x7effbb307940> = diff('/tmp/tmpfsb3z_zstest_grower/test_output_neuron_.h5', '/home/runner/work/NeuroTS/NeuroTS/tests/data/expected_bio_rat_L5_TPC_B_with_params4.h5')
E            +    where '/home/runner/work/NeuroTS/NeuroTS/tests/data/expected_bio_rat_L5_TPC_B_with_params4.h5' = join('/home/runner/work/NeuroTS/NeuroTS/tests/data', 'expected_bio_rat_L5_TPC_B_with_params4.h5')

tests/test_neuron_functional.py:132: AssertionError

def test_fallback_strategy():
        repulsion = np.array([0.0, 1.0, 2.0])
    
        mock_dir1 = np.array([1.0, 0.0, 0.0])
        mock_dir2 = np.array([0.0, 1.0, 0.0])
    
        with patch(
            "neurots.astrocyte.space_colonization.directional",
            return_value=(mock_dir1.copy(), mock_dir2.copy()),
        ):
            section_direction = np.array([0.0, 0.0, 1.0])
    
            dir1, dir2 = tested._fallback_strategy(section_direction, None, repulsion)
    
            expected_dir1 = section_direction - repulsion
            expected_dir1 /= np.linalg.norm(expected_dir1)
    
            npt.assert_allclose(dir1, expected_dir1)
    
            expected_dir2 = mock_dir2 - repulsion
            expected_dir2 /= np.linalg.norm(expected_dir2)
>           npt.assert_allclose(dir2, expected_dir2)
E           AssertionError: 
E           Not equal to tolerance rtol=1e-07, atol=0
E           
E           Mismatched elements: 2 / 3 (66.7%)
E           Max absolute difference: 2.
E           Max relative difference: 2.
E            x: array([0, 1, 1])
E            y: array([ 0.,  0., -1.])

tests/astrocyte/test_space_colonization.py:134: AssertionError

self = <tests.test_neuron_functional.TestBioRatL5Tpc3 object at 0x7fb3a0d3d670>
tmpdir = local('/home/runner/work/NeuroTS/NeuroTS/.tox/min_versions/tmp/popen-gw1/test_default1')

    def test_default(self, tmpdir):
>       _test_full(
            "path_distances",
            "bio_rat_L5_TPC_B_distribution.json",
            "params3.json",
            "expected_bio_rat_L5_TPC_B_with_params3.h5",
            "expected_bio_rat_L5_TPC_B_with_params3_persistence_diagram.json",
            output_dir=tmpdir,
        )

tests/test_neuron_functional.py:667: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

feature = 'path_distances'
distributions = {'apical_dendrite': {'filtration_metric': 'path_distances', 'min_bar_length': 1.0, 'num_trees': {'data': {'bins': [1],....4106653615432989, 0.5277795547616266, -0.18579814237229897], ...], ...], ...}, 'diameter': {'method': 'uniform'}, ...}
parameters = 'params3.json'
ref_cell = 'expected_bio_rat_L5_TPC_B_with_params3.h5'
ref_persistence_diagram = 'expected_bio_rat_L5_TPC_B_with_params3_persistence_diagram.json'
rng_or_seed = None, skip_preprocessing = False
output_dir = local('/home/runner/work/NeuroTS/NeuroTS/.tox/min_versions/tmp/popen-gw1/test_default1')

    def _test_full(
        feature,
        distributions,
        parameters,
        ref_cell,
        ref_persistence_diagram,
        rng_or_seed=None,
        skip_preprocessing=False,
        output_dir=None,
    ):
        distributions, params = _load_inputs(join(_path, distributions), join(_path, parameters))
        if rng_or_seed is None:
            np.random.seed(0)
            n = NeuronGrower(
                input_distributions=distributions,
                input_parameters=params,
                skip_preprocessing=skip_preprocessing,
            ).grow()
        else:
            n = NeuronGrower(
                input_distributions=distributions,
                input_parameters=params,
                rng_or_seed=rng_or_seed,
                skip_preprocessing=skip_preprocessing,
            ).grow()
    
        with TemporaryDirectory("test_grower") as folder:
            out_neuron = join(folder, "test_output_neuron_.h5")
            n.write(out_neuron)
    
            # For checking purposes, we can output the cells as swc
            if output_dir is not None:
                if not os.path.exists(output_dir):
                    os.mkdir(output_dir)
                n.write(join(output_dir, basename(ref_cell)))
    
            if ref_persistence_diagram is not None:
                # Load with TMD and extract radial persistence
                n0 = tmd.io.load_neuron(out_neuron)
    
                actual_persistence_diagram = tmd.methods.get_persistence_diagram(
                    n0.apical_dendrite[0], feature=feature
                )
                if output_dir is not None:
                    with open(
                        join(output_dir, basename(ref_persistence_diagram)), "w", encoding="utf-8"
                    ) as f:
                        json.dump(actual_persistence_diagram, f, sort_keys=True, indent=2)
    
                with open(join(_path, ref_persistence_diagram), encoding="utf-8") as f:
                    expected_persistence_diagram = json.load(f)
                assert_close_persistent_diagram(
                    actual_persistence_diagram, expected_persistence_diagram
                )
>           assert not diff(out_neuron, join(_path, ref_cell))
E           AssertionError: assert not <morph_tool.morphio_diff.DiffResult object at 0x7fb3a1320970>
E            +  where <morph_tool.morphio_diff.DiffResult object at 0x7fb3a1320970> = diff('/tmp/tmpo1i7l21ptest_grower/test_output_neuron_.h5', '/home/runner/work/NeuroTS/NeuroTS/tests/data/expected_bio_rat_L5_TPC_B_with_params3.h5')
E            +    where '/home/runner/work/NeuroTS/NeuroTS/tests/data/expected_bio_rat_L5_TPC_B_with_params3.h5' = join('/home/runner/work/NeuroTS/NeuroTS/tests/data', 'expected_bio_rat_L5_TPC_B_with_params3.h5')

tests/test_neuron_functional.py:132: AssertionError

self = <tests.test_neuron_functional.TestBioRatL5Tpc1 object at 0x7f3b1c09fa00>
tmpdir = local('/home/runner/work/NeuroTS/NeuroTS/.tox/min_versions/tmp/popen-gw0/test_default1')

    def test_default(self, tmpdir):
>       _test_full(
            "path_distances",
            "bio_rat_L5_TPC_B_distribution.json",
            "params1.json",
            "expected_bio_rat_L5_TPC_B_with_params1.h5",
            "expected_bio_rat_L5_TPC_B_with_params1_persistence_diagram.json",
            output_dir=tmpdir,
        )

tests/test_neuron_functional.py:575: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

feature = 'path_distances'
distributions = {'apical_dendrite': {'filtration_metric': 'path_distances', 'min_bar_length': 1.0, 'num_trees': {'data': {'bins': [1],....4106653615432989, 0.5277795547616266, -0.18579814237229897], ...], ...], ...}, 'diameter': {'method': 'uniform'}, ...}
parameters = 'params1.json'
ref_cell = 'expected_bio_rat_L5_TPC_B_with_params1.h5'
ref_persistence_diagram = 'expected_bio_rat_L5_TPC_B_with_params1_persistence_diagram.json'
rng_or_seed = None, skip_preprocessing = False
output_dir = local('/home/runner/work/NeuroTS/NeuroTS/.tox/min_versions/tmp/popen-gw0/test_default1')

    def _test_full(
        feature,
        distributions,
        parameters,
        ref_cell,
        ref_persistence_diagram,
        rng_or_seed=None,
        skip_preprocessing=False,
        output_dir=None,
    ):
        distributions, params = _load_inputs(join(_path, distributions), join(_path, parameters))
        if rng_or_seed is None:
            np.random.seed(0)
            n = NeuronGrower(
                input_distributions=distributions,
                input_parameters=params,
                skip_preprocessing=skip_preprocessing,
            ).grow()
        else:
            n = NeuronGrower(
                input_distributions=distributions,
                input_parameters=params,
                rng_or_seed=rng_or_seed,
                skip_preprocessing=skip_preprocessing,
            ).grow()
    
        with TemporaryDirectory("test_grower") as folder:
            out_neuron = join(folder, "test_output_neuron_.h5")
            n.write(out_neuron)
    
            # For checking purposes, we can output the cells as swc
            if output_dir is not None:
                if not os.path.exists(output_dir):
                    os.mkdir(output_dir)
                n.write(join(output_dir, basename(ref_cell)))
    
            if ref_persistence_diagram is not None:
                # Load with TMD and extract radial persistence
                n0 = tmd.io.load_neuron(out_neuron)
    
                actual_persistence_diagram = tmd.methods.get_persistence_diagram(
                    n0.apical_dendrite[0], feature=feature
                )
                if output_dir is not None:
                    with open(
                        join(output_dir, basename(ref_persistence_diagram)), "w", encoding="utf-8"
                    ) as f:
                        json.dump(actual_persistence_diagram, f, sort_keys=True, indent=2)
    
                with open(join(_path, ref_persistence_diagram), encoding="utf-8") as f:
                    expected_persistence_diagram = json.load(f)
                assert_close_persistent_diagram(
                    actual_persistence_diagram, expected_persistence_diagram
                )
>           assert not diff(out_neuron, join(_path, ref_cell))
E           AssertionError: assert not <morph_tool.morphio_diff.DiffResult object at 0x7f3b1c09f970>
E            +  where <morph_tool.morphio_diff.DiffResult object at 0x7f3b1c09f970> = diff('/tmp/tmpnn4ex89ytest_grower/test_output_neuron_.h5', '/home/runner/work/NeuroTS/NeuroTS/tests/data/expected_bio_rat_L5_TPC_B_with_params1.h5')
E            +    where '/home/runner/work/NeuroTS/NeuroTS/tests/data/expected_bio_rat_L5_TPC_B_with_params1.h5' = join('/home/runner/work/NeuroTS/NeuroTS/tests/data', 'expected_bio_rat_L5_TPC_B_with_params1.h5')

tests/test_neuron_functional.py:132: AssertionError