class HangingSimulationError(Exception):

    pass

def nest_run(sim_time):

    import nest, time

    t = time.time()

    nest.Run(sim_time)

    return time.time() - t

def simulate_in_steps(simulation_time):

    """Simulate in steps and catch hanging simulations."""

    import nest

    step = 10 # (virtual time)

    ministep = nest.GetKernelStatus('resolution')

    N_break = 3

    split_t = 2 # (real time) (s) Run next chunk in mini steps if previous took longer

    break_t = 1 # (real time) (s) break if `N_break` consecutive mini-steps takes longer

    total_sim_time = 0

    kernel_time = nest.GetKernelStatus('time')

    with nest.RunManager():

        while total_sim_time < simulation_time:

            next_step_t = min(step, simulation_time - total_sim_time)

            step_real_t = nest_run(next_step_t)

            total_sim_time += next_step_t

            if step_real_t > split_t:

                # Run next {step}ms in ministeps

                # Break if 3 consecutive ministeps last too long

                count = 0

                print(f"Running next {step}ms in ministeps")

                for _ in range(int(step/ministep)):

                    if simulation_time == total_sim_time:

                        break

                    next_ministep_t = min(ministep, simulation_time - total_sim_time)

                    t = nest_run(next_ministep_t)

                    total_sim_time += next_ministep_t

                    if t > break_t:

                        count += 1

                    else:

                        count = 0

                    if count >= N_break:

                        raise HangingSimulationError(

                            f"Simulation froze at {nest.GetKernelStatus('time')}ms"

                        )

    assert nest.GetKernelStatus('time') - kernel_time == simulation_time