Remove try/except that can hide programming errors

dream/simulation/CoreObject.py

@@ -101,10 +101,7 @@ class CoreObject(Process):
         activeEntity=activeObjectQueue[0]  
         activeObjectQueue.pop(0)                        #remove the Entity from the queue
         self.timeLastEntityLeft=now()
-        try:
-            self.outputTrace(activeEntity.name, "released "+self.objName) 
-        except TypeError:
-            pass
+        self.outputTrace(activeEntity.name, "released "+self.objName)
         return activeEntity          
         
     # ================================== gets an entity from the ====================================
@@ -133,10 +130,7 @@ class CoreObject(Process):
         activeEntity.schedule.append([activeObject,now()])
         activeEntity.currentStation=self
         self.timeLastEntityEntered=now()
-        try:
-            self.outputTrace(activeEntity.name, "got into "+self.objName)
-        except TypeError:
-            pass
+        self.outputTrace(activeEntity.name, "got into "+self.objName)
         return activeEntity
         
     # ========================== actions to be taken after the simulation ends ======================

dream/simulation/Failure.py

@@ -84,14 +84,11 @@ class Failure(ObjectInterruption):
     def run(self):           
         while 1:
             yield hold,self,self.rngTTF.generateNumber()    # wait until a failure happens                  
-            try:
-                if(len(self.getVictimQueue())>0):           # when a Machine gets failure
-                    self.interrupt(self.victim)             #     while in process it is interrupted
-                self.victim.Up=False
-                self.victim.timeLastFailure=now()           
-                self.outputTrace("is down")
-            except AttributeError:
-                print "AttributeError1"
+            if(len(self.getVictimQueue())>0):               # when a Machine gets failure
+                self.interrupt(self.victim)                 #     while in process it is interrupted
+            self.victim.Up=False
+            self.victim.timeLastFailure=now()           
+            self.outputTrace("is down")
             # update the failure time
             failTime=now()            
             if(self.repairman!="None"):     #if the failure needs a resource to be fixed, the machine waits until the 
@@ -104,16 +101,13 @@ class Failure(ObjectInterruption):
             yield hold,self,self.rngTTR.generateNumber()    # wait until the repairing process is over
             self.victim.totalFailureTime+=now()-failTime    
             
-            try:
-                if(len(self.getVictimQueue())>0):                
-                    reactivate(self.victim)                 # since repairing is over, the Machine is reactivated
-                self.victim.Up=True              
-                self.outputTrace("is up")              
-                if(self.repairman!="None"): #if a resource was used, it is now released
-                    yield release,self,self.repairman.getResource() 
-                    self.repairman.totalWorkingTime+=now()-timeOperationStarted                                
-            except AttributeError:
-                print "AttributeError2"    
+            if(len(self.getVictimQueue())>0):                
+                reactivate(self.victim)                 # since repairing is over, the Machine is reactivated
+            self.victim.Up=True              
+            self.outputTrace("is up")              
+            if(self.repairman!="None"): #if a resource was used, it is now released
+                yield release,self,self.repairman.getResource() 
+                self.repairman.totalWorkingTime+=now()-timeOperationStarted                                
            
     #outputs message to the trace.xls. Format is (Simulation Time | Machine Name | message)            
     def outputTrace(self, message):

dream/simulation/LineGenerationJSON.py

@@ -178,10 +178,8 @@ def createObjects():
             name = element.get('name', 'not found')                 # get the name of the element / default 'not_found'
             capacity = int(element.get('capacity', '1'))            # get the capacity of the el. / defautl '1'
             O = Operator(element_id, name, capacity)                # create an operator object
-            try:
-                O.coreObjectIds=getSuccessorList(id)                # update the list of objects that the operator operates
-            except:                                                 # calling the getSuccessorList() method on the operator
-                pass
+            O.coreObjectIds=getSuccessorList(id)                    # update the list of objects that the operator operates
+                                                                    # calling the getSuccessorList() method on the operator
             G.OperatorsList.append(O)                               # add the repairman to the RepairmanList
         elif resourceClass=='Dream.OperatorPool':
             id = element.get('id', 'not found')                     # get the id of the element   / default 'not_found'
@@ -197,11 +195,8 @@ def createObjects():
             else:
                 OP = OperatorPool(element_id, name, capacity,operatorsList)     # create a operatorPool object
             OP.coreObjectIds=getSuccessorList(id)                   # update the list of objects that the operators of the operatorPool operate
-            try:
-                for operator in operatorsList.values():
-                    operator.coreObjectIds=OP.coreObjectIds        # update the list of objects that the operators operate
-            except:
-                pass
+            for operator in operatorsList.values():
+                operator.coreObjectIds=OP.coreObjectIds             # update the list of objects that the operators operate
             G.OperatorPoolsList.append(OP)                          # add the repairman to the RepairmanList
     # -----------------------------------------------------------------------
     #                    loop through all the elements    
@@ -634,15 +629,9 @@ def initializeObjects():
 # ===========================================================================
 def activateObjects():
     for element in G.ObjList:
-        try:
-            activate(element, element.run())
-        except AttributeError:
-            pass
+        activate(element, element.run())
     for ev in G.EventGeneratorList:
-        try:
-            activate(ev, ev.run())
-        except AttributeError:
-            pass        
+        activate(ev, ev.run())
 
 # ===========================================================================
 #                reads the WIP of the stations
@@ -659,11 +648,7 @@ def createWIP():
         element['id'] = element_id
         wip=element.get('wip', [])
         for entity in wip:
-            entityClass=None
-            try:
-                entityClass=entity.get('_class', None)
-            except IndexError:
-                continue
+            entityClass=entity.get('_class', None)
    
             if entityClass=='Dream.Job':
                 id=entity.get('id', 'not found')
@@ -799,17 +784,11 @@ def main(argv=[], input_data=None):
     
     #output data to JSON for every object in the topology         
     for element in G.ObjList:
-        try:
-            element.outputResultsJSON()
-        except AttributeError:
-            pass
+        element.outputResultsJSON()
         
     #output data to JSON for every resource in the topology         
     for model_resource in G.RepairmanList:
-        try:
-            model_resource.outputResultsJSON()
-        except AttributeError:
-            pass
+        model_resource.outputResultsJSON()
         
     for job in G.JobList:
         job.outputResultsJSON()

dream/simulation/Machine.py

@@ -280,10 +280,7 @@ class Machine(CoreObject):
     # checks if the machine down or it can dispose the object
     # =======================================================================
     def ifCanDisposeOrHaveFailure(self):
-        try:
-            return self.Up==False or self.getReceiverObject().canAccept(self) or len(self.getActiveObjectQueue())==0  
-        except AttributeError:
-            return False
+        return self.Up==False or self.getReceiverObject().canAccept(self) or len(self.getActiveObjectQueue())==0  
   
     # =======================================================================
     # removes an entity from the Machine