Merge pull request #116 from AToMPM/improve-mt-debugging

Improve model transformation debugging

mt/mtworker.py

@@ -184,8 +184,7 @@ class mtworkerThread(threading.Thread) :
 					transfs.reverse()
 					self._ptcal.loadTransforms(transfs)
 					self._postMessage(msg['resp'],{'statusCode':200})
-			except Exception as e :
-				print("Exception: " + str(e))
+			except Exception as e:
 				traceback.print_exc()
 
 				self._postMessage(

mt/ptcal/compiler.py

@@ -452,11 +452,11 @@ class ModelAndRuleCompiler :
                         return self._dcal.eval(code)
                     except Exception as e :
                         if '$err' in ex :
-                            raise RuntimeError(ex['$err'])
+                            err_msg = str(ex['$err']) + " in filename: " + fname
                         else :
-                            raise RuntimeError( \
-                                'unexpected error encountered while evaluating '+
-                                'pattern condition code :: '+str(e))
+                            err_msg = 'unexpected error encountered while evaluating '+ \
+                                'pattern condition code :: '+str(e) + " in filename: " + fname
+                        raise RuntimeError(err_msg)
                 return evalPatternCode
 
             hg[HC.MT_CONSTRAINT] = wrap(hg[HC.MT_CONSTRAINT])

mt/ptcal/motifcontext.py

@@ -9,25 +9,25 @@ Purpose: MoTif integration to AtomPM
 '''
 
 import collections
-from time import *
-from .tconstants import TConstants as TC
-from .utils import Utilities as utils
-from .tcontext import TransformationContext
-from .pytcore.tcore.messages import Pivots
+
 from .pytcore.rules.arule import ARule
-from .pytcore.rules.query import Query
-from .pytcore.rules.query import CQuery2
-from .pytcore.rules.query import CQuery3
-from .pytcore.rules.srule import SRule
-from .pytcore.rules.crule import CRule
-from .pytcore.rules.frule import FRule
 from .pytcore.rules.brule import BRule
 from .pytcore.rules.bsrule import BSRule
-from .pytcore.rules.lrule import LRule
+from .pytcore.rules.crule import CRule
+from .pytcore.rules.frule import FRule
 from .pytcore.rules.lfrule import LFRule
-from .pytcore.rules.lsrule import LSRule
 from .pytcore.rules.lqsrule import LQSRule
+from .pytcore.rules.lrule import LRule
+from .pytcore.rules.lsrule import LSRule
+from .pytcore.rules.query import CQuery2
+from .pytcore.rules.query import CQuery3
+from .pytcore.rules.query import Query
 from .pytcore.rules.sequence import Sequence
+from .pytcore.rules.srule import SRule
+from .pytcore.tcore.messages import Pivots
+from .tconstants import TConstants as TC
+from .tcontext import TransformationContext
+from .utils import Utilities as utils
 
 '''
 	holds the execution context of a 'Transformation' construct 
@@ -49,144 +49,166 @@ class MotifContext(TransformationContext) :
 
 		self.startStateID = None
 
-		for id in self.t['nodes']:
+		for ruleId in self.t['nodes']:
+
+			try:
+				self.loadRule(ruleId)
+			except Exception as ex:
+				ruleName = self.t['nodes'][ruleId]['rule']['value']
+				template = "{0} Exception raised within rule: {1} Message: {2}"
+				message = template.format(type(ex).__name__, ruleName, str(ex))
+				raise type(ex)(message)  # raise Exception of same type
+
+	def loadRule(self, ruleID):
 
-			rule = self.ruleIdentifier(self.t['nodes'], id)
+		rule = self.ruleIdentifier(self.t['nodes'], ruleID)
 
-			if rule == None:
+		if rule is None:
 
-				if self.t['nodes'][id]['$type'] == self.metamodel+"/LRule" or \
-						self.t['nodes'][id]['$type'] == self.metamodel+"/LSRule" or \
-						self.t['nodes'][id]['$type'] == self.metamodel+"/LFRule" or \
-						self.t['nodes'][id]['$type'] == self.metamodel+"/LQSRule":
+			if self.t['nodes'][ruleID]['$type'] == self.metamodel + "/LRule" or \
+					self.t['nodes'][ruleID]['$type'] == self.metamodel + "/LSRule" or \
+					self.t['nodes'][ruleID]['$type'] == self.metamodel + "/LFRule" or \
+					self.t['nodes'][ruleID]['$type'] == self.metamodel + "/LQSRule":
 
-					maxIterations = int(self.t['nodes'][id]['maxIterations']['value'])
-					nested = int(self.t['nodes'][id]['nested']['value'])
-					outerFirst = True if nested==0 else False
+				maxIterations = int(self.t['nodes'][ruleID]['maxIterations']['value'])
+				nested = int(self.t['nodes'][ruleID]['nested']['value'])
+				outerFirst = True if nested == 0 else False
+
+				def f(e):
+					return e['src'] == ruleID
+
+				lruleEdges = list(filter(f, self.t['edges']))
+
+				baseEdgeId = None
+				loopEdgeId = None
+
+				for edge in lruleEdges:
+					if self.t['nodes'][edge['dest']]['$type'] == self.metamodel + "/base":
+						baseEdgeId = edge['dest']
+					elif self.t['nodes'][edge['dest']]['$type'] == self.metamodel + "/loop":
+						loopEdgeId = edge['dest']
+
+				def f(e):
+					return e['src'] == baseEdgeId
+
+				baseRuleIds = list(filter(f, self.t['edges']))
+				baseRuleID = baseRuleIds[0]['dest']
+
+				compiledBaseRule = None
+
+				if self.t['nodes'][ruleID]['$type'] == self.metamodel + "/LRule" or \
+						self.t['nodes'][ruleID]['$type'] == self.metamodel + "/LQSRule":
+					baseRuleName = self.t['nodes'][baseRuleID]['query']['value']
+					compiledBaseRule = self.compiler.compileRule(None, baseRuleName)
+				else:
+					baseRuleName = self.t['nodes'][baseRuleID]['rule']['value']
+					compiledBaseRule = self.compiler.compileRule(None, baseRuleName)
 
-					def f(e) :
-						return e['src'] == id
-					lruleEdges = list(filter(f,self.t['edges']))
+				# baseRule = ARule(compiledBaseRule['lhs'],compiledBaseRule['rhs'],self.sendAndApplyDeltaFunc)
 
-					baseEdgeId=None
-					loopEdgeId=None
+				def f(e):
+					return e['src'] == loopEdgeId
+
+				loopRuleIds = list(filter(f, self.t['edges']))
+				loopRuleID = loopRuleIds[0]['dest']
+
+				loopRuleType = self.t['nodes'][loopRuleID]['$type']
+
+				if loopRuleType != self.metamodel + "/CRule":
+					loopRuleName = self.t['nodes'][loopRuleID]['rule']['value']
+					compiledLoopRule = self.compiler.compileRule(None, loopRuleName)
+
+				loopRule = None
+
+				if loopRuleType == self.metamodel + "/ARule":
+					loopRule = ARule(compiledLoopRule['lhs'], compiledLoopRule['rhs'], self.sendAndApplyDeltaFunc)
+				elif loopRuleType == self.metamodel + "/FRule":
+					loopRule = FRule(compiledLoopRule['lhs'], compiledLoopRule['rhs'], maxIterations,
+									 self.sendAndApplyDeltaFunc)
+				elif loopRuleType == self.metamodel + "/SRule":
+					loopRule = SRule(compiledLoopRule['lhs'], compiledLoopRule['rhs'], maxIterations,
+									 self.sendAndApplyDeltaFunc)
+				elif loopRuleType == self.metamodel + "/CRule":
+					ruleName = self.t['nodes'][loopRuleID]['ref']['value']
+					self.ptcal._transfData[ruleName] = utils.fread('/users/%s/%s' % (self.ptcal.username, ruleName))
+					motifContext = MotifContext(ruleName, self.ptcal)
+					loopRule = CRule(motifContext)
+
+				if self.t['nodes'][ruleID]['$type'] == self.metamodel + "/LRule":
+					rule = LRule(compiledBaseRule['lhs'], loopRule, max_iterations=maxIterations)
+
+				elif self.t['nodes'][ruleID]['$type'] == self.metamodel + "/LQSRule":
+					rule = LQSRule(compiledBaseRule['lhs'], loopRule, max_iterations=maxIterations)
+
+				elif self.t['nodes'][ruleID]['$type'] == self.metamodel + "/LSRule":
+					rule = LSRule(compiledBaseRule['lhs'], compiledBaseRule['rhs'], loopRule, outer_first=outerFirst,
+								  sendAndApplyDeltaFunc=self.sendAndApplyDeltaFunc, max_iterations=maxIterations)
+
+				elif self.t['nodes'][ruleID]['$type'] == self.metamodel + "/LFRule":
+					rule = LFRule(compiledBaseRule['lhs'], compiledBaseRule['rhs'], loopRule, outer_first=outerFirst,
+								  sendAndApplyDeltaFunc=self.sendAndApplyDeltaFunc, max_iterations=maxIterations)
+
+			elif self.t['nodes'][ruleID]['$type'] == self.metamodel + "/BRule" or \
+					self.t['nodes'][ruleID]['$type'] == self.metamodel + "/BSRule":
+
+				def f(e):
+					return e['src'] == ruleID
+
+				bruleEdges = list(filter(f, self.t['edges']))
+
+				branchRuleList = []
+
+				for edge in bruleEdges:
+					if self.t['nodes'][edge['dest']]['$type'] == self.metamodel + "/branch":
+						branchID = edge['dest']
+
+						def f(e):
+							return e['src'] == branchID
+
+						branchRuleID = list(filter(f, self.t['edges']))[0]['dest']
+
+						rule = self.ruleIdentifier(self.t['nodes'], branchRuleID)
+
+						if rule is None and self.t['nodes'][branchRuleID]['$type'] == self.metamodel + "/CRule":
+							ruleName = self.t['nodes'][branchRuleID]['ref']['value']
+							self.ptcal._transfData[ruleName] = utils.fread(
+								'/users/%s/%s' % (self.ptcal.username, ruleName))
+							motifContext = MotifContext(ruleName, self.ptcal)
+							rule = CRule(motifContext)
+
+						branchRuleList.append(rule)
+
+				if self.t['nodes'][ruleID]['$type'] == self.metamodel + "/BRule":
+					rule = BRule(branchRuleList)
+				elif self.t['nodes'][ruleID]['$type'] == self.metamodel + "/BSRule":
+					maxIterations = int(self.t['nodes'][ruleID]['maxIterations']['value'])
+					rule = BSRule(branchRuleList, maxIterations)
+
+			elif self.t['nodes'][ruleID]['$type'] == self.metamodel + "/CRule":
+				rule = self.t['nodes'][ruleID]['ref']['value']
+
+			elif self.t['nodes'][ruleID]['$type'] == self.metamodel + "/Sequence":
+				sequenceRuleList = []
+				rulesFile = self.t['nodes'][ruleID]['ref']['value']
+				self.ptcal._transfData[rulesFile] = utils.fread('/users/%s/%s' % (self.ptcal.username, rulesFile))
+				rulesOrdered = collections.OrderedDict(sorted(self.ptcal._transfData[rulesFile]['nodes'].items()))
+				for ruleId in rulesOrdered:
+					rule = self.ruleIdentifier(rulesOrdered, ruleId)
+					if rule != None:
+						sequenceRuleList.append(rule)
+					else:  # TODO decide for CRule
+						pass
+				rule = Sequence(sequenceRuleList)
+
+			elif self.t['nodes'][ruleID]['$type'] == self.metamodel + "/Start":
+				self.startStateID = ruleID
+				rule = None
 
-					for edge in lruleEdges:
-						if self.t['nodes'][edge['dest']]['$type']==self.metamodel+"/base":
-							baseEdgeId=edge['dest']
-						elif self.t['nodes'][edge['dest']]['$type']==self.metamodel+"/loop":
-							loopEdgeId=edge['dest']
-
-					def f(e) :
-						return e['src'] == baseEdgeId
-					baseRuleIds = list(filter(f,self.t['edges']))
-					baseRuleID=baseRuleIds[0]['dest']
-
-					compiledBaseRule = None
-
-					if self.t['nodes'][id]['$type'] == self.metamodel+"/LRule" or \
-							self.t['nodes'][id]['$type'] == self.metamodel+"/LQSRule":
-						baseRuleName = self.t['nodes'][baseRuleID]['query']['value']
-						compiledBaseRule = self.compiler.compileRule(None,baseRuleName)
-					else:
-						baseRuleName = self.t['nodes'][baseRuleID]['rule']['value']
-						compiledBaseRule = self.compiler.compileRule(None,baseRuleName)
-					#baseRule = ARule(compiledBaseRule['lhs'],compiledBaseRule['rhs'],self.sendAndApplyDeltaFunc)
-
-					def f(e) :
-						return e['src'] == loopEdgeId
-					loopRuleIds = list(filter(f,self.t['edges']))
-					loopRuleID=loopRuleIds[0]['dest']
-
-					loopRuleType = self.t['nodes'][loopRuleID]['$type']
-
-					if loopRuleType != self.metamodel+"/CRule":
-						loopRuleName = self.t['nodes'][loopRuleID]['rule']['value']
-						compiledLoopRule = self.compiler.compileRule(None,loopRuleName)
-
-					loopRule = None
-
-					if loopRuleType == self.metamodel+"/ARule":
-						loopRule = ARule(compiledLoopRule['lhs'],compiledLoopRule['rhs'],self.sendAndApplyDeltaFunc)
-					elif loopRuleType == self.metamodel+"/FRule":
-						loopRule = FRule(compiledLoopRule['lhs'],compiledLoopRule['rhs'],maxIterations,self.sendAndApplyDeltaFunc)
-					elif loopRuleType == self.metamodel+"/SRule":
-						loopRule = SRule(compiledLoopRule['lhs'],compiledLoopRule['rhs'],maxIterations,self.sendAndApplyDeltaFunc)
-					elif loopRuleType == self.metamodel+"/CRule":
-						ruleName = self.t['nodes'][loopRuleID]['ref']['value']
-						self.ptcal._transfData[ruleName] = utils.fread('/users/%s/%s'%(self.ptcal.username,ruleName))
-						motifContext = MotifContext(ruleName,self.ptcal)
-						loopRule = CRule(motifContext)
-
-					if self.t['nodes'][id]['$type'] == self.metamodel+"/LRule":
-						rule = LRule(compiledBaseRule['lhs'],loopRule,max_iterations=maxIterations)
-
-					elif self.t['nodes'][id]['$type'] == self.metamodel+"/LQSRule":
-						rule = LQSRule(compiledBaseRule['lhs'],loopRule,max_iterations=maxIterations)
-
-					elif self.t['nodes'][id]['$type'] == self.metamodel+"/LSRule":
-						rule = LSRule(compiledBaseRule['lhs'],compiledBaseRule['rhs'],loopRule,outer_first=outerFirst,sendAndApplyDeltaFunc=self.sendAndApplyDeltaFunc,max_iterations=maxIterations)
-
-					elif self.t['nodes'][id]['$type'] == self.metamodel+"/LFRule":
-						rule = LFRule(compiledBaseRule['lhs'],compiledBaseRule['rhs'],loopRule,outer_first=outerFirst,sendAndApplyDeltaFunc=self.sendAndApplyDeltaFunc,max_iterations=maxIterations)
-
-				elif self.t['nodes'][id]['$type'] == self.metamodel+"/BRule" or \
-						self.t['nodes'][id]['$type'] == self.metamodel+"/BSRule":
-
-					def f(e) :
-						return e['src'] == id
-					bruleEdges = list(filter(f,self.t['edges']))
-
-					branchRuleList=[]
-
-					for edge in bruleEdges:
-						if self.t['nodes'][edge['dest']]['$type']==self.metamodel+"/branch":
-							branchID=edge['dest']
-							def f(e) :
-								return e['src'] == branchID
-							branchRuleID=list(filter(f,self.t['edges']))[0]['dest']
-
-							rule = self.ruleIdentifier(self.t['nodes'],branchRuleID)
-
-							if rule == None and self.t['nodes'][branchRuleID]['$type']==self.metamodel+"/CRule":
-								ruleName = self.t['nodes'][branchRuleID]['ref']['value']
-								self.ptcal._transfData[ruleName] = utils.fread('/users/%s/%s'%(self.ptcal.username,ruleName))
-								motifContext = MotifContext(ruleName,self.ptcal)
-								rule = CRule(motifContext)
-
-							branchRuleList.append(rule)
-
-					if self.t['nodes'][id]['$type'] == self.metamodel+"/BRule":
-						rule = BRule(branchRuleList)
-					elif self.t['nodes'][id]['$type'] == self.metamodel+"/BSRule":
-						maxIterations = int(self.t['nodes'][id]['maxIterations']['value'])
-						rule = BSRule(branchRuleList,maxIterations)
-
-				elif self.t['nodes'][id]['$type'] == self.metamodel+"/CRule":
-					rule = self.t['nodes'][id]['ref']['value']
-
-				elif self.t['nodes'][id]['$type'] == self.metamodel+"/Sequence":
-					sequenceRuleList=[]
-					rulesFile = self.t['nodes'][id]['ref']['value']
-					self.ptcal._transfData[rulesFile] = utils.fread('/users/%s/%s'%(self.ptcal.username,rulesFile))
-					rulesOrdered = collections.OrderedDict(sorted(self.ptcal._transfData[rulesFile]['nodes'].items()))
-					for ruleId in rulesOrdered:
-						rule = self.ruleIdentifier(rulesOrdered,ruleId)
-						if rule != None:
-							sequenceRuleList.append(rule)
-						else: # TODO decide for CRule
-							pass
-					rule = Sequence(sequenceRuleList)
-
-				elif self.t['nodes'][id]['$type'] == self.metamodel+"/Start":
-					self.startStateID = id
-					rule = None
-
-			if rule != None:
-				self.rules[id] = {'id':id,
-								  'name':self.t['nodes'][id]['name']['value'],
-								  'alias':self.t['nodes'][id]['alias']['value'],
-								  'rule':rule}
+		if rule is not None:
+			self.rules[ruleID] = {'id': ruleID,
+							  'name': self.t['nodes'][ruleID]['name']['value'],
+							  'alias': self.t['nodes'][ruleID]['alias']['value'],
+							  'rule': rule}
 
 	def ruleIdentifier(self,ruleList,ruleId):