Event oriented simulation

import abc
import heapq
import time


class SimEvent:

    def __init__(self, event_time, simulation):
        self.Time = event_time
        self.Simulation = simulation

    @abc.abstractmethod
    def execute(self):
        pass


class SimCore:

    def __init__(self):
        self.CurrentTime = 0
        self.EventsFront = []
        self.Running = True
        self.Pause = False

    def simulate(self, max_time):
        self.before_simulation_run()
        self.simulation_run(max_time)
        self.after_simulation_run()

    @abc.abstractmethod
    def before_simulation_run(self):
        pass

    @abc.abstractmethod
    def after_simulation_run(self):
        pass

    def simulation_run(self, max_time):
        while self.EventsFront.__len__() != 0:
            if self.Running:
                if not self.Pause:
                    (priority, hlpEvent) = heapq.heappop(self.EventsFront)

                    self.CurrentTime = priority

                    if priority < max_time:
                        hlpEvent.execute()
                    else:
                        break
                else:
                    time.sleep(0.2)
            else:
                break

    def insert_event(self, sim_event):
        heapq.heappush(self.EventsFront, (sim_event.Time, sim_event))


class MySimulation(SimCore):

    def after_simulation_run(self):
        print "After simulation run"

    def before_simulation_run(self):
        print "Before simulation run"


class SlowingEvent(SimEvent):

    def execute(self):
        time.sleep(1)
        self.Simulation.insert_event(SlowingEvent(self.Time + 1, self.Simulation))


class MyEvent1(SimEvent):
    def execute(self):
        print "Event 1"
        self.Simulation.insert_event(MyEvent1(self.Time + 1, self.Simulation))


class MyEvent2(SimEvent):
    def execute(self):
        print "Event 2"
        self.Simulation.insert_event(MyEvent2(self.Time + 1, self.Simulation))


sim = MySimulation()
sim.insert_event(MyEvent1(0.5, sim))
sim.insert_event(MyEvent2(0.51, sim))
sim.insert_event(SlowingEvent(0, sim))
sim.simulate(5)