Scheduler | Python Fiddle

from __future__ import absolute_import
from datetime import datetime, timedelta
import pprint

class Event(object):
  
  def __init__(self, name='', start=datetime.now(), duration=timedelta(hours=1)):
    self.name = name
    self._start = start
    self._duration = duration
    self._end = start + duration
    
  def __repr__(self):
    fmt = 'Name: {name} | Start: {start} | Duration: {duration} | End: {end}'
    return fmt.format(name=self.name, start=self.start, duration=self.duration, end=self.end)
  
  @property
  def start(self):
    return self._start
  
  @start.setter
  def start(self, value):
    self._start = value
    self._end = self._start + self._duration
    
  @property
  def duration(self):
    return self._duration
  
  @duration.setter
  def duration(self, value):
    self._duration = value
    self._end = self._start + self._duration
    
  @property
  def end(self):
    return self._end
  
  @end.setter
  def end(self, value):
    self._end = value
    self._start = self._end - self._duration

def __gt__(self, other):
    return self.start > other.start
  
  def __lt__(self, other):
    return self.start < other.start
  
  def __ge__(self, other):
    return self.start >= other.start
  
  def __le__(self, other):
    return self.start <= other.start
  
  def __eq__(self, other):
    return self.start == other.start
  
  def __ne__(self, other):
    return self.start != other.start

class After(object):
  
  def __init__(self, event1, event2, weight=0.1):
    self.event1 = event1
    self.event2 = event2
    self.weight = weight
    
  def __call__(self, **kwargs):
    return self.event2.end - self.event1.start

class NoOverlap(object):
  
  def __init__(self, event1, event2, weight=0.1):
    self.event1 = event1
    self.event2 = event2
    self.weight = weight
    
  def __call__(self, **kwargs):
    return self.event1.end - self.event2.start
    
    
class Start_At(object):
  
  def __init__(self, event1, start, weight=0.1):
    self.event1 = event1
    self.start = start
    self.weight = weight
    
  def __call__(self, **kwargs):
    return self.start - self.event1.start
  
  
  
def optimize(events, constraints):
  for constraint in constraints:
    result = constraint()
    if isinstance(constraint, After):
      constraint.event1.start += (result / 2) / int(1/constraint.weight)
      constraint.event2.start -= (result / 2) / int(1/constraint.weight)
    elif isinstance(constraint, Start_At):
      constraint.event1.start += result / int(1/constraint.weight)
    elif isinstance(constraint, NoOverlap):
      constraint.event1.start -= (result / 2) / int(1/constraint.weight)
      constraint.event2.start += (result / 2) / int(1/constraint.weight)
  
  events.sort()
      
  
if __name__ == '__main__':
  
  event_1 = Event('Event 1')
  event_2 = Event('Event 2')
  event_3 = Event('Event 3')
  event_4 = Event('Event 4')

events = [
    event_3,
    event_2,
    event_1, 
    event_4,
  ]

constraints = [
    Start_At(event_1, datetime(2015, 11, 30, 13)),
    After(event_2, event_1),
    After(event_3, event_2),
    Start_At(event_4, datetime(2015, 11, 30, 14, 30)),
    NoOverlap(event_2, event_4)
  ]
  
  pprint.pprint(events)

for _ in range(10000):
    optimize(events, constraints)
    print
    pprint.pprint(events)

Python Fiddle

Python Cloud IDE