diff --git a/python_actr/errors/__init__.py b/python_actr/errors/__init__.py
new file mode 100644
index 0000000..0179aa8
--- /dev/null
+++ b/python_actr/errors/__init__.py
@@ -0,0 +1 @@
+from .errors import *
diff --git a/python_actr/errors/errors.py b/python_actr/errors/errors.py
new file mode 100644
index 0000000..90d6535
--- /dev/null
+++ b/python_actr/errors/errors.py
@@ -0,0 +1,10 @@
+class SchedulerException(Exception):
+    pass
+
+
+class ProductionException(Exception):
+    pass
+
+
+class PatternException(Exception):
+    pass
diff --git a/python_actr/model.py b/python_actr/model.py
index f45f80c..8f6109a 100644
--- a/python_actr/model.py
+++ b/python_actr/model.py
@@ -1,266 +1,223 @@
-
-
-from . import scheduler            
+from . import scheduler
 from . import logger
 import random
-import inspect      
+import inspect
 import copy
-#import ccm.config as config
+
 
 class MethodWrapper:
-  def __init__(self,obj,func,name):
-      self.func=func
-      self.obj=obj
-      self.__name__=name
-      self.begins=scheduler.Trigger(name+' begin')
-      self.ends=scheduler.Trigger(name+' end')
-      self.default_trigger=self.ends
-  def __call__(self,*args,**keys):
-      self.obj.sch.trigger(self.begins)
-      val=self.func(self.obj,*args,**keys)
-      self.obj.sch.trigger(self.ends)
-      return val
+
+    def __init__(self, obj, func, name):
+        self.func = func
+        self.obj = obj
+        self.__name__ = name
+        self.begins = scheduler.Trigger(f'{name} begin')
+        self.ends = scheduler.Trigger(f'{name} end')
+        self.default_trigger = self.ends
+
+    def __call__(self, *args, **keys):
+        self.obj.sch.trigger(self.begins)
+        val = self.func(self.obj, *args, **keys)
+        self.obj.sch.trigger(self.ends)
+        return val
+
+
 class MethodGeneratorWrapper(MethodWrapper):
-  def _generator(self,*args,**keys):
-      self.obj.sch.trigger(self.begins)
-      for x in self.func(self.obj,*args,**keys):
-          yield x
-      self.obj.sch.trigger(self.ends)
-  def __call__(self,*args,**keys):
-      return self.obj.sch.add(self._generator,args=args,keys=keys)
-  def __str__(self):
-      return '<MGW %s %s>'%(self.obj,self.__name__)    
-
-def log_everything(model,log=None):
-  if log is None: log=logger.log_proxy
-  if not hasattr(model,'log'): model.run(limit=0)
-  model.log=log
-  for k,v in list(model.__dict__.items()):
-    if k[0]!='_' and k!='parent':
-      
-      if isinstance(v,Model) and v.parent is model:
-        log_everything(v,getattr(log,k))
+
+    def _generator(self, *args, **keys):
+        self.obj.sch.trigger(self.begins)
+        for x in self.func(self.obj, *args, **keys):
+            yield x
+        self.obj.sch.trigger(self.ends)
+
+    def __call__(self, *args, **keys):
+        return self.obj.sch.add(self._generator, args=args, keys=keys)
+
+    def __str__(self):
+        return f'<MGW {self.obj} {self.name}'
+
+
+def log_everything(model, log=None):
+    if log is None:
+        log = logger.log_proxy
+    if not hasattr(model, 'log'):
+        model.run(limit=0)
+    model.log = log
+    for k, v in list(model.__dict__.items()):
+        if k[0] != '_' and k != 'parent':
+            if isinstance(v, Model) and v.parent is model:
+                log_everything(v, getattr(log, k))
 
 
 class Model:
-    __converted=False
-    _convert_methods=True
-    _auto_run_start=True
-    name='top'
-    
-
-
-    def __init__(self,log=None,**keys):
-        #print("this happens")
-        #print(self,"Model A1")#sterling
-        self.__init_log=log
-        for k,v in list(keys.items()):
-          setattr(self,k,v)
-
-    #getitem added by sterling
-    def __getitem__(self,item):
-        return getattr(self,item)
-
-
-
-    def __convert(self,parent=None,name=None):
-        #print("__convert() called", self)
-        #Culprit
-        #if self.__converted: return
-        assert self.__converted==False
-        self.__converted=True    
-        self.changes=scheduler.Trigger()
-        
-        if hasattr(self,'parent'): parent=self.parent
-        
-        methods={}
-        objects={}
-        #print(inspect.getmro(self.__class__),"MRO") #sterling
-        #This MRO includes class object, whereas in 2.7, it does not
-        #add[:-1], because it seems that object is always at the end.
-        '''            obj.__convert(self,name)
-                    print("run after")'''#(from line 132) now works.
-        #BUT a later run crashes.
+
+    __converted = False
+    _convert_methods = True
+    _auto_run_start = True
+    name = 'top'
+
+    def __init__(self, log=None, **keys):
+        self.__init_log = log
+        for k, v in list(keys.items()):
+            setattr(self, k, v)
+
+    def __getitem__(self, item):
+        return getattr(self, item)
+
+    def __convert(self, parent=None, name=None):
+        assert self.__converted is False
+        self.__converted = True
+        self.changes = scheduler.Trigger()
+
+        if hasattr(self, 'parent'):
+            parent = self.parent
+
+        methods = {}
+        objects = {}
+
         for klass in inspect.getmro(self.__class__)[:-1]:
-          
-            #print(klass, "klass")
             if klass is not Model:
-                #print(klass, "klass")
-                for k,v in inspect.getmembers(klass):
-                    #print(k,",",v,"k,v")
-                    
-                    if k[0]!='_':
-                        #print(k,"just k")
-                        #A problem. ismethod(v) is not returning true.
-                        #Did run an exmample, and it worked fine.
-                        #It is working though, because they are unbound methods, and ismethod
-                        #should only return true if they are bound
-                        #isfunction might work in it's place
-                        #if inspect.ismethod(v):
+                for k, v in inspect.getmembers(klass):
+                    if k[0] != '_':
                         if inspect.isfunction(v):
-                            #print(k,v,"k,v+")
-                            if k not in ['run','now','get_children'] and k not in methods and klass is not Model:
-                                #print(k,v,"k,v-post")
-                                methods[k]=v
+                            if (k not in ['run', 'now', 'get_children']
+                                    and k not in methods
+                                    and klass is not Model):
+                                methods[k] = v
                         else:
-                            if inspect.isclass(v) and Model in inspect.getmro(v):
-                                v=v()
+                            if (inspect.isclass(v)
+                                    and Model in inspect.getmro(v)):
+                                v = v()
                             if k not in objects:
-                                objects[k]=v
-        objects=copy.deepcopy(objects)
-        #works up to here
-        
+                                objects[k] = v
+        objects = copy.deepcopy(objects)
+
         if parent:
-            if not parent.__converted: parent.__convert()
-            self.sch=parent.sch
-            self.log=logger.dummy
-            self.random=parent.random
-            self.parent=parent
+            if not parent.__converted:
+                parent.__convert()
+            self.sch = parent.sch
+            self.log = logger.dummy
+            self.random = parent.random
+            self.parent = parent
         else:
-            self.sch=scheduler.Scheduler()
+            self.sch = scheduler.Scheduler()
             if self.__init_log is True:
-                self.log=logger.log()
+                self.log = logger.log()
             elif self.__init_log is None:
-                self.log=logger.dummy   
+                self.log = logger.dummy
             else:
-                self.log=self.__init_log    
-            self.random=random.Random() 
-            #seed=config.getOptions().random
-            #if seed is not None: self.random.seed(seed)
-            
-            self.parent=None   
-        
-        self._convert_info(objects,methods)
-        #works up to here
-        #print(list(objects.items()))
-        for name,obj in list(objects.items()):
-            #print("run before before",name,obj)
-            #self.run(limit=0)#print(name,obj,"name,obj")
-            if isinstance(obj,Model):
-                #print(dir(obj))  
+                self.log = self.__init_log
+            self.random = random.Random()
+            self.parent = None
+
+        self._convert_info(objects, methods)
+        for name, obj in list(objects.items()):
+            if isinstance(obj, Model):
                 if not obj.__converted:
-                    #print(obj,"obj")
-                    #print(self,"self")
-                    #print("run before")
-                    #self.run(limit=0)
-                    
-                    #self.run(limit=0)
-                    obj.__convert(self,name)
-                    #print("run after")
-                    
-                    #self.run(limit=0)
+                    obj.__convert(self, name)
                 else:
-                    obj.name=name    
+                    obj.name = name
                 try:
-                  self._children[name]=obj
+                    self._children[name] = obj
                 except AttributeError:
-                  self._children={name:obj}
-            #print("run before 2",name,obj)
-            #self.run(limit=0)
-            #print(dir(obj))
-            self.__dict__[name]=obj
-            #print("run after 2",name,obj)
-            #print(dir(obj))
-            #self.run(limit=0)
-        #check out _convert_info - see difference between 2.7 running and 3.3 running.
-        #does not between here and last
-        
-        if self._convert_methods:    
-          for name,func in list(methods.items()):
-              #print("here",name,func)
-              #print(dir(func))
-              #if func.__func__.__code__.co_flags&0x20==0x20:
-              if func.__code__.co_flags&0x20==0x20:
-                  w=MethodGeneratorWrapper(self,func,name)
-              else:
-                  w=MethodWrapper(self,func,name)
-              self.__dict__[name]=w    
+                    self._children = {name: obj}
+            self.__dict__[name] = obj
+
+        if self._convert_methods:
+            for name, func in list(methods.items()):
+                # check if function is a generator
+                if func.__code__.co_flags & 0x20 == 0x20:
+                    w = MethodGeneratorWrapper(self, func, name)
+                else:
+                    w = MethodWrapper(self, func, name)
+                self.__dict__[name] = w
 
         if self._auto_run_start:
             self.start()
-        
-        for k,v in list(self.__dict__.items()):
-            if k[0]!='_' and k!='parent' and isinstance(v,Model):
+
+        for k, v in list(self.__dict__.items()):
+            if k[0] != '_' and k != 'parent' and isinstance(v, Model):
                 if not v.__converted:
                     v.__convert(parent=self)
-                
-        
-    def _convert_info(self,objects,methods):
-        pass    
-                
-    def __setattr__(self,key,value):
-      if key=='parent' and value is None and getattr(self,'parent',None) is not None:
-        del self.parent._children[self.name]
-      self.__dict__[key]=value
-      
-
-      if isinstance(value,Model) and key[0]!='_' and key!='parent':
-        self._ensure_converted()
-        p=self
-        ancestor=True
-        while p is not None:
-          if value is p: break
-          p=getattr(p,'parent',None)
-        else:
-          if getattr(value,'parent',None) is not None:
-            pass
-            #if value.name in value.parent._children:
-            #  del value.parent._children[value.name]
-          else:  
-            value.parent=self
-            value.name=key
-            try:
-              self._children[key]=value
-            except AttributeError:
-              self._children={key:value}  
-            if self.__converted and not value.__converted: value.__convert(name=key,parent=self)
-              
-      if self.__converted and key[0]!='_' and key not in ['parent','sch','changes','log','random','name']:
-          m=self
-          done=[]
-          while m is not None:
-            self.sch.trigger(m.changes,priority=-1)
-            done.append(m)
-            m=m.parent
-            if m in done: m=None
-          if self.log: setattr(self.log,key,value)
-      
-      if key=='log' and value is not None:
-        for k,v in list(self.__dict__.items()):
-          if k[0]!='_' and k not in ['parent','sch','changes','log','random','name']:
-            if isinstance(v,(int,str,float,type(None))):
-              setattr(value,k,v)
-          
-    
-    
-    
+
+    def _convert_info(self, objects, methods):
+        pass
+
+    def __setattr__(self, key, value):
+        if (key == 'parent' and value is None
+                and getattr(self, 'parent', None) is not None):
+            del self.parent._children[self.name]
+
+        if isinstance(value, Model) and key[0] != '_' and key != 'parent':
+            self._ensure_converted()
+            p = self
+            ancestor = True
+            while p is not None:
+                if value is p:
+                    break
+                p = getattr(p, 'parent', None)
+            else:
+                if getattr(value, 'parent', None) is not None:
+                    pass
+                else:
+                    value.parent = self
+                    value.name = key
+                    try:
+                        self._children[key] = value
+                    except AttributeError:
+                        self._children = {key: value}
+                    if self.__converted and not value.__converted:
+                        value.__convert(name=key, parent=self)
+
+        skip_keys = ['parent', 'sch', 'changes', 'log', 'random', 'name']
+        if self.__converted and key[0] != '_' and key not in skip_keys:
+            m = self
+            done = []
+            while m is not None:
+                self.sch.trigger(m.changes, priority=-1)
+                done.append(m)
+                m = m.parent
+                if m in done:
+                    m = None
+            if self.log:
+                setattr(self.log, key, value)
+
+        if key == 'log' and value is not None:
+            for k, v in list(self.__dict__.items()):
+                if k[0] != '_' and k not in skip_keys:
+                    if isinstance(v, (int, str, float, type(None))):
+                        setattr(value, k, v)
+
+        self.__dict__[key] = value
+
     def start(self):
         pass
-    def run(self,limit=None,func=None):
+
+    def run(self, limit=None, func=None):
         if not self.__converted:
             self.__convert()
-        #if config.getOptions().logall: log_everything(self)
-        if limit is not None: 
-            self.sch.add(self.sch.stop,limit,priority=-9999999)
+        if limit is not None:
+            self.sch.add(self.sch.stop, limit, priority=-9999999)
         if func is not None:
             self.sch.add(func)
         self.sch.run()
+
     def stop(self):
         if not self.__converted:
             self.__convert()
         self.sch.stop()
+
     def now(self):
         if not self.__converted:
             self.__convert()
         return self.sch.time
-    
+
     def get_children(self):
         try:
-          return list(self._children.values())
+            return list(self._children.values())
         except AttributeError:
-          return []  
-        
-        
+            return []
+
     def _get_scheduler(self):
         self._ensure_converted()
         return self.sch
@@ -271,15 +228,3 @@ def _ensure_converted(self):
 
     def _is_converted(self):
         return self.__converted
-        
-                    
-      
-      
-      
-      
-      
-    
-
-
-
-
diff --git a/python_actr/scheduler.py b/python_actr/scheduler.py
index b10f6b6..cfbd782 100644
--- a/python_actr/scheduler.py
+++ b/python_actr/scheduler.py
@@ -1,174 +1,185 @@
-
-try:
-    import heapq
-except ImportError:
-    import ccm.legacy.heapq as heapq
+import heapq
 import copy
+from python_actr import logger
+from python_actr.errors import SchedulerException
+
+
+def cmp(x, y):  # from: https://portingguide.readthedocs.io/en/latest/comparisons.html
+    """
+    Replacement for built-in function cmp that was removed in Python 3
+
+    Compare the two objects x and y and return an integer according to
+    the outcome. The return value is negative if x < y, zero if x == y
+    and strictly positive if x > y.
+    """
+
+    return (x > y) - (x < y)
 
-from . import logger
 
 class Trigger:
-    def __init__(self,name=''):
-        self.name=name
+
+    def __init__(self, name=''):
+        self.name = name
+
     def __str__(self):
-        return '<Trigger "%s">'%self.name    
+        return f'<Trigger "{self.name}">'
+
 
 class Event:
-  generator=False
-  def __init__(self,func,time,args=[],keys={},priority=0):    
-    self.name=getattr(func,'func_name',None)
-
-    try:
-       code=func.__code__
-    except AttributeError:
-       try:
-          code=func.__call__.__func__.__code__   
-       except:
-          code=None   
-    if code and code.co_flags&0x20==0x20:    # check for generator
-        func=func(*args,**keys).__next__
-        args=[]
-        keys={}
-        self.generator=True
-
-    self.func=func
-    self.args=args
-    self.keys=keys
-    self.time=time
-    self.priority=priority
-    self.group=()
-    self.cancelled=False
-    self.parent=None
-  #def __cmp__(self,other):
-    #return cmp((self.time,-self.priority),(other.time,-other.priority))
-  
-  def __lt__(self,other):
-    #print(self.time,-self.priority,'other',other.time,-other.priority)
-    return (self.time,-self.priority) < (other.time,-other.priority)
-    #return cmp((self.time,-self.priority),(other.time,-other.priority))
-
-  def __le__(self, other):
-    return cmp((self.time,-self.priority),(other.time,-other.priority))
-
-  def __eq__(self,other):
-    return cmp((self.time,-self.priority),(other.time,-other.priority))
-
-  def __ge__(self, other):
-    return cmp((self.time,-self.priority),(other.time,-other.priority))
-  
-  def __gt__(self,other):
-    return cmp((self.time,-self.priority),(other.time,-other.priority))
-
-  def __ne__(self, other):
-    return cmp((self.time,-self.priority),(other.time,-other.priority))  
-
-  def __repr__(self):
-    return '<%s %x %5.3f>'%(self.name,id(self.func),self.time)
-    
-class SchedulerError(Exception):
-    pass
+
+    generator = False
+
+    def __init__(self, func, time, args=[], keys={}, priority=0):
+        self.name = getattr(func, 'func_name', None)
+        try:
+            code = func.__code__
+        except AttributeError:
+            try:
+                code = func.__call__.__func__.__code__
+            except AttributeError:
+                code = None
+        if code and code.co_flags & 0x20 == 0x20:  # check for generator
+            func = func(*args, **keys).__next__
+            args = []
+            keys = {}
+            self.generator = True
+
+        self.func = func
+        self.args = args
+        self.keys = keys
+        self.time = time
+        self.priority = priority
+        self.group = ()
+        self.cancelled = False
+        self.parent = None
+
+    def __lt__(self, other):
+        return (self.time, -self.priority) < (other.time, -other.priority)
+
+    def __le__(self, other):
+        return cmp((self.time, -self.priority), (other.time, -other.priority))
+
+    def __eq__(self, other):
+        return cmp((self.time, -self.priority), (other.time, -other.priority))
+
+    def __ge__(self, other):
+        return cmp((self.time, -self.priority), (other.time, -other.priority))
+
+    def __gt__(self, other):
+        return cmp((self.time, -self.priority), (other.time, -other.priority))
+
+    def __ne__(self, other):
+        return cmp((self.time, -self.priority), (other.time, -other.priority))
+
+    def __repr__(self):
+        return f'<{self.name} {id(self.func)} {self.time:.3f}>'
+
 
 class Scheduler:
+
     def __init__(self):
-        self.queue=[]
-        self.to_be_added=[]
-        self.triggers={}
-        self.time=0.0
-        self.stop_flag=False
-        self.log=logger.log_proxy
-    def extend(self,other):
-        for k,v in list(other.triggers.items()):    
+        self.queue = []
+        self.to_be_added = []
+        self.triggers = {}
+        self.time = 0.0
+        self.stop_flag = False
+        self.log = logger.log_proxy
+
+    def extend(self, other):
+        for k, v in list(other.triggers.items()):
             if k not in self.triggers:
-                self.triggers[k]=v
+                self.triggers[k] = v
             else:
                 self.triggers[k].extend(v)
-        if len(other.queue)>0:
+        if len(other.queue) > 0:
             self.queue.extend(other.queue)
-            heapq.heapify(self.queue)            
-    def trigger(self,key,priority=None):
+            heapq.heapify(self.queue)
+
+    def trigger(self, key, priority=None):
         if 'OpenGL' in key.name:
-          print(key.name)
-          print(key in self.triggers)
+            print(key.name)
+            print(key in self.triggers)
         if key in self.triggers:
             for event in self.triggers[key]:
-                event.time=self.time
+                event.time = self.time
                 if priority is not None:
-                   event.priority=priority
+                    event.priority = priority
                 self.add_event(event)
             del self.triggers[key][:]
-    def add_event(self,event):
-        heapq.heappush(self.queue,event)
-    def add(self,func,delay=0,args=[],keys={},priority=0,thread_safe=False):
+
+    def add_event(self, event):
+        heapq.heappush(self.queue, event)
+
+    def add(self, func, delay=0,
+            args=[], keys={}, priority=0, thread_safe=False):
         if thread_safe:
-          self.to_be_added.append((func,delay,args,keys,priority))
-        else:  
-          ev=Event(func,self.time+delay,args=args,keys=keys,priority=priority)
-          self.add_event(ev)
-          return ev
-        
+            self.to_be_added.append((func, delay, args, keys, priority))
+        else:
+            ev = Event(func, self.time+delay, args=args,
+                       keys=keys, priority=priority)
+            self.add_event(ev)
+            return ev
+
     def run(self):
-        self.stop_flag=False
-        while not self.stop_flag and len(self.queue)>0:
-            next=self.queue[0].time
-            if next>self.time:
-                self.time=next
-                self.log.time=next
-            self.do_event(heapq.heappop(self.queue))    
+        self.stop_flag = False
+
+        while not self.stop_flag and len(self.queue) > 0:
+            next = self.queue[0].time
+            if next > self.time:
+                self.time = next
+                self.log.time = next
+            self.do_event(heapq.heappop(self.queue))
+
             while self.to_be_added:
-              self.add(*self.to_be_added.pop())
-        
-    def handle_result(self,result,event):
-        if isinstance(result,(int,float)):
-            event.time=self.time+result
+                self.add(*self.to_be_added.pop())
+
+    def handle_result(self, result, event):
+        if isinstance(result, (int, float)):
+            event.time = self.time + result
             self.add_event(event)
-        elif isinstance(result,dict):
-            event.time=self.time+result.get('delay',0)
-            event.priority=result.get('priority',event.priority)
+        elif isinstance(result, dict):
+            event.time = self.time + result.get('delay', 0)
+            event.priority = result.get('priority', event.priority)
             self.add_event(event)
-        elif isinstance(result,(str,Trigger)):
-            event.time=None
+        elif isinstance(result, (str, Trigger)):
+            event.time = None
             if result not in self.triggers:
-                self.triggers[result]=[event]
+                self.triggers[result] = [event]
             else:
                 self.triggers[result].append(event)
-        elif isinstance(result,(list,tuple)):
-            events=[copy.copy(event) for r in result]
-            for e in events: e.group=events
-            for i,r in enumerate(result):
-                self.handle_result(r,events[i])
+        elif isinstance(result, (list, tuple)):
+            events = [copy.copy(event) for r in result]
+            for e in events:
+                e.group = events
+            for i, r in enumerate(result):
+                self.handle_result(r, events[i])
         elif result is None:
             if event.parent is not None:
-                event.parent.time=self.time
+                event.parent.time = self.time
                 self.add_event(event.parent)
-        elif isinstance(result,Event):
+        elif isinstance(result, Event):
             if result.generator and event.generator:
-                result.parent=event
-        elif hasattr(result,'default_trigger'):
-          self.handle_result(result.default_trigger,event)        
+                result.parent = event
+        elif hasattr(result, 'default_trigger'):
+            self.handle_result(result.default_trigger, event)
         else:
-            raise SchedulerError("Incorrect 'yield': %s"%(result))
-                
-            
-            
-    def do_event(self,event):
-        assert self.time==event.time
+            raise SchedulerException(f"Incorrect 'yield': {result}")
+
+    def do_event(self, event):
+        assert self.time == event.time
 
-        if event.cancelled: return
-        for e in event.group: e.cancelled=True
-        event.cancelled=False
+        if event.cancelled:
+            return
+        for e in event.group:
+            e.cancelled = True
+        event.cancelled = False
 
         try:
-          result=event.func(*event.args,**event.keys)
+            result = event.func(*event.args, **event.keys)
         except StopIteration:
-          result=None
-          
-        self.handle_result(result,event)
-        
-                               
-            
-            
-          
-        
-    
-    def stop(self):    
-      self.stop_flag=True  
+            result = None
+
+        self.handle_result(result, event)
+
+    def stop(self):
+        self.stop_flag = True
diff --git a/setup.py b/setup.py
index 4fd238a..2c93f18 100644
--- a/setup.py
+++ b/setup.py
@@ -1,10 +1,11 @@
-from setuptools import setup
-
+from setuptools import setup, find_packages
 import python_actr
 
+exclude = ['python_actr.tests']
+
 setup(
     name='python_actr',
-    packages=['python_actr', 'python_actr.display', 'python_actr.actr', 'python_actr.ui'],
+    packages=find_packages(exclude=exclude),
     version=python_actr.version.version,
     author='Carleton Cognitive Modelling Lab',
     description='Python implementation of the ACT-R cognitive architecture',