def updateFactSchemas(fids, cursor):
for fid in fids:
# get time arg
cursor.execute("SELECT timeArg FROM Fact WHERE fid=='" + fid + "'")
timeArg = cursor.fetchone()
timeArg = tools.toAscii_str(timeArg)
# get max attID
cursor.execute("SELECT max(attID) FROM FactAtt WHERE fid=='" + fid +
"'")
maxID = cursor.fetchone()
maxID = maxID[0]
# update fact schema
attID = maxID + 1
thisType = "int"
#DEBUGGING
cursor.execute("SELECT name FROM Fact WHERE fid=='" + fid + "'")
name = cursor.fetchone()
name = tools.toAscii_str(name)
#if name == "bcast" :
# print "1CHECK THIS BCAST INSERT!!!"
# print "INSERT INTO FactAtt VALUES ('" + fid + "','" + str(attID) + "','" + timeArg + "','" + thisType + "')"
cursor.execute("INSERT INTO FactAtt VALUES ('" + fid + "','" +
str(attID) + "','" + timeArg + "','" + thisType + "')")
def dumpSingleFact_c4(fid, cursor):
fact = ""
cursor.execute("SELECT name FROM Fact WHERE fid == '" + fid +
"'") # get fact name
factName = cursor.fetchone()
factName = tools.toAscii_str(factName)
# get list of attribs in fact
factList = cursor.execute("SELECT data FROM FactData WHERE fid == '" +
fid + "'") # list of fact atts
factList = cursor.fetchall()
factList = tools.toAscii_list(factList)
# get fact time arg
#factTimeArg = ""
#cursor.execute( "SELECT timeArg FROM Fact WHERE fid == '" + fid + "'" )
#factTimeArg = cursor.fetchone()
#factTimeArg = tools.toAscii_str( factTimeArg )
# convert fact info to pretty string
fact += factName + "("
for j in range(0, len(factList)):
if j < (len(factList) - 1):
fact += factList[j] + ","
else:
fact += factList[j]
#if not factTimeArg == "" :
# fact += "," + factTimeArg
fact += ");" + "\n" # end all facts with a semicolon
return fact
def domainRewrites(parentRID, sidInParent, posName, posNameRIDs, newDMRIDList,
COUNTER, cursor):
print "&&& posName : " + posName
# ---------------------------------------------- #
# get parent name #
# ---------------------------------------------- #
cursor.execute("SELECT goalName FROM Rule WHERE rid=='" + parentRID + "'")
parentName = cursor.fetchone()
parentName = tools.toAscii_str(parentName)
# ---------------------------------------------- #
# buid new domain rule name #
# ---------------------------------------------- #
domainRuleName = "dom_not_" + posName + "_from_" + parentName
# ---------------------------------------------- #
# add new rule for the domain subgoal #
# ---------------------------------------------- #
newRuleMeta = addDomainRules(parentRID, sidInParent, parentName, posName,
domainRuleName, posNameRIDs, newDMRIDList,
cursor)
# ---------------------------------------------- #
# add domain idb subgoal to each new DM rule #
# ---------------------------------------------- #
addSubgoalsToRules(domainRuleName, newDMRIDList, cursor)
return newRuleMeta
def prioritizeNegatedLast(rid, subIDs, cursor):
posSubs = []
negSubs = []
# check if subgoal is negated
# branch on result.
for subID in subIDs:
cursor.execute("SELECT subgoalPolarity FROM Subgoals WHERE rid=='" +
rid + "' AND sid=='" + subID + "'")
sign = cursor.fetchone()
# positive subgoals may have no argName data
# all instances of negative subgoals WILL have an argName
if sign:
sign = tools.toAscii_str(sign)
else:
sign = ""
if not sign == "notin":
posSubs.append(subID)
else:
negSubs.append(subID)
return posSubs + negSubs
def addSubgoalsToRules(domainRuleName, newDMRIDList, cursor):
# -------------------------------------------- #
# get goal att list for the dom_not_whatever
# rule previously written in addDomainRules
# -------------------------------------------- #
# get rid for the domain rule
cursor.execute("SELECT rid FROM Rule WHERE goalName=='" + domainRuleName +
"'")
rid = cursor.fetchone()
if not rid or rid == "":
tools.bp(
__name__,
inspect.stack()[0][3],
"FATAL ERROR : writing domain subgoals, but no '" +
domainRuleName + "' rule exists. aborting...")
else:
rid = tools.toAscii_str(rid)
# get the goal attribute list for the domain rule
cursor.execute("SELECT attID,attName,attType FROM GoalAtt WHERE rid=='" +
rid + "'")
goalAttList = cursor.fetchall()
goalAttList = tools.toAscii_multiList(goalAttList)
for rid in newDMRIDList:
# ----------------------------------- #
# generate sid #
# ----------------------------------- #
sid = tools.getID()
# ----------------------------------- #
# fixed subgoal time arg to nothing #
# ----------------------------------- #
subgoalTimeArg = ""
# ----------------------------------- #
# insert subgoal metadata #
# ----------------------------------- #
cursor.execute("INSERT INTO Subgoals VALUES ('" + rid + "','" + sid +
"','" + domainRuleName + "','" + subgoalTimeArg + "')")
# ----------------------------------- #
# insert subgoal att data #
# ----------------------------------- #
attID = 0
for att in goalAttList:
attName = att[1]
attType = att[2]
cursor.execute("INSERT INTO SubgoalAtt VALUES ('" + rid + "','" +
sid + "','" + str(attID) + "','" + attName + "','" +
attType + "')")
attID += 1
def rewriteNegativeSubgoalsWithWildcards(cursor):
newRuleMeta = []
# ------------------------------------------- #
# get all rids
cursor.execute("SELECT rid FROM RUlE")
rids = cursor.fetchall()
rids = tools.toAscii_list(rids)
for rid in rids:
cursor.execute("SELECT sid FROM Subgoals WHERE rid=='" + rid + "'")
sids = cursor.fetchall()
sids = tools.toAscii_list(sids)
# ------------------------------------------- #
# examine all subgoals per rule
for sid in sids:
cursor.execute("SELECT argName FROM SubgoalAddArgs WHERE rid=='" +
rid + "' AND sid=='" + sid + "'")
sign = cursor.fetchone()
if sign:
sign = tools.toAscii_str(sign)
else:
sign = ""
if sign == "notin":
cursor.execute(
"SELECT attID,attName,attType FROM SubgoalAtt WHERE rid=='"
+ rid + "' AND sid=='" + sid + "'")
attData = cursor.fetchall()
attData = tools.toAscii_multiList(attData)
# ------------------------------------------- #
# examine all atts per subgoal per rule
for att in attData:
attID = att[0]
attName = att[1]
attType = att[2]
if attName == "_":
newRule = rewriteRule(rid, sid, attData, cursor)
newRuleMeta.append(newRule)
break
else:
continue
return newRuleMeta
def getAllTriggerRecords(self, pgattMaps):
if self.name == "bcast":
print "pgattMaps : " + str(pgattMaps)
if self.name == "not_missing_log_from_post":
print "<><>pgattMaps = " + str(pgattMaps)
pTrigRecs = []
for attMap in pgattMaps:
prid = attMap[0]
mapping = attMap[1]
# get full relation name
self.cursor.execute("SELECT goalName FROM Rule WHERE rid=='" +
prid + "'")
pname = self.cursor.fetchone(
) # goalName should be unique per provenance rule
pname = tools.toAscii_str(pname)
# get full results table
resultsTable = self.results[pname]
# get list of valid records which agree with the provenance rule
# goal attribute mapping
# correctness relies upon ordered nature of the mappings.
validRecList = []
for rec in resultsTable:
if self.name == "not_missing_log_from_post":
print "rec = " + str(rec)
print "mapping = " + str(mapping)
if self.checkAgreement(mapping, rec):
validRecList.append(rec)
if self.name == "not_missing_log_from_post":
print "pname = " + pname
print "validRecList = " + str(validRecList)
pTrigRecs.append([prid, mapping, validRecList])
return pTrigRecs
def prioritizeDoms(rid, subIDs, cursor):
domSubs = []
nonDomSubs = []
# check if subgoal is a domain subgoal
# branch on result.
for subID in subIDs:
cursor.execute("SELECT subgoalName FROM Subgoals WHERE rid=='" + rid +
"' AND sid=='" + subID + "'")
subgoalName = cursor.fetchone()
subgoalName = tools.toAscii_str(subgoalName)
if "dom_" in subgoalName[0:4]:
domSubs.append(subID)
else:
nonDomSubs.append(subID)
return domSubs + nonDomSubs
def getSubgoalInfo(self, fullProvMap):
# ------------------------------------------------------------- #
# Transform the provAttMap into a dictionary for convenience.
fullProvDict = {}
for arr in fullProvMap:
att = arr[0]
val = arr[1]
# sanity check
if att in fullProvDict.keys() and not val == fullProvDict[att]:
tools.bp(
__name__,
inspect.stack()[0][3],
"FATAL ERROR : multiple data values exist for the same attribute.\nattribute = "
+ att + "\nval = " + val + " and ogattDict[ att ] = " +
fullProvDict[att])
else: # add to dictionary
fullProvDict[att] = val
# ------------------------------------------------------------- #
subgoalInfo = []
# get the list of subgoals
self.cursor.execute(
"SELECT sid,subgoalName FROM Subgoals WHERE rid=='" + self.prid +
"'")
subIDNameList = self.cursor.fetchall()
subIDNameList = tools.toAscii_multiList(subIDNameList)
# for each sid, grab the subgoal attribute list and the isNeg
for idNamePair in subIDNameList:
sid = idNamePair[0]
subname = idNamePair[1]
# get the attribute list for this subgoal
self.cursor.execute(
"SELECT attID,attName FROM SubgoalAtt WHERE rid=='" +
self.prid + "' AND sid=='" + sid + "'")
attList = self.cursor.fetchall()
attList = tools.toAscii_multiList(attList)
attList = [idNamePair[1] for idNamePair in attList]
# get the isNeg information
self.cursor.execute(
"SELECT argName FROM SubgoalAddArgs WHERE rid=='" + self.prid +
"' AND sid=='" + sid + "'")
isNeg = self.cursor.fetchone()
if isNeg:
isNeg = tools.toAscii_str(isNeg)
else:
isNeg = ""
# ///////////////////////////////////////////////////////// #
# Map each attribute to a value based on the mappings from
# the full provAttMap.
thisSubAttMap = []
for att in attList:
#if att == "__WILDCARD__" :
if att == "_":
thisSubAttMap.append([att, None])
elif att in fullProvDict.keys():
thisSubAttMap.append([att, fullProvDict[att]])
else:
thisSubAttMap.append([att, None])
subgoalInfo.append([subname, isNeg, thisSubAttMap])
# ///////////////////////////////////////////////////////// #
return subgoalInfo
def dumpSingleRule_c4(rid, cursor):
rule = ""
# -------------------------------------------------------------- #
# GOAL #
# get goal name
cursor.execute("SELECT goalName FROM Rule WHERE rid == '" + rid +
"'") # get goal name
goalName = cursor.fetchone()
goalName = tools.toAscii_str(goalName)
# get list of attribs in goal
goalList = cursor.execute("SELECT attName FROM GoalAtt WHERE rid == '" +
rid + "'") # list of goal atts
goalList = cursor.fetchall()
goalList = tools.toAscii_list(goalList)
# get goal time arg
goalTimeArg = ""
cursor.execute("SELECT goalTimeArg FROM Rule WHERE rid == '" + rid + "'")
goalTimeArg = cursor.fetchone()
goalTimeArg = tools.toAscii_str(goalTimeArg)
# convert goal info to pretty string
rule += goalName + "("
for j in range(0, len(goalList)):
if j < (len(goalList) - 1):
rule += goalList[j] + ","
else:
rule += goalList[j] + ")"
#KD
if not goalTimeArg == "":
rule += "@" + goalTimeArg + " :- "
#sys.exit( "ERROR: leftover timeArg in goal: " + rule + "@" + goalTimeArg )
else:
rule += " :- "
# --------------------------------------------------------------- #
# SUBGOALS #
# get list of sids for the subgoals of this rule
cursor.execute("SELECT sid FROM Subgoals WHERE rid == '" + str(rid) +
"'") # get list of sids for this rule
subIDs = cursor.fetchall()
subIDs = tools.toAscii_list(subIDs)
# prioritize dom subgoals first.
subIDs = prioritizeDoms(rid, subIDs, cursor)
# prioritize negated subgoals last.
#subIDs = prioritizeNegatedLast( rid, subIDs, cursor )
subIDs, clockSubIDs, negSubIDs = prioritizeNegatedLast_2(
rid, subIDs, cursor)
subTimeArg = None
# iterate over subgoal ids
for k in range(0, len(subIDs)):
newSubgoal = ""
s = subIDs[k]
# get subgoal name
cursor.execute("SELECT subgoalName FROM Subgoals WHERE rid == '" +
str(rid) + "' AND sid == '" + str(s) + "'")
subgoalName = cursor.fetchone()
if not subgoalName == None:
subgoalName = tools.toAscii_str(subgoalName)
logging.debug("subgoalName = " + subgoalName)
# get subgoal attribute list
subAtts = cursor.execute(
"SELECT attName FROM SubgoalAtt WHERE rid == '" + rid +
"' AND sid == '" + s + "'")
subAtts = cursor.fetchall()
subAtts = tools.toAscii_list(subAtts)
# get subgoal time arg
cursor.execute(
"SELECT subgoalTimeArg FROM Subgoals WHERE rid == '" + rid +
"' AND sid == '" + s + "'")
subTimeArg = cursor.fetchone() # assume only one time arg
subTimeArg = tools.toAscii_str(subTimeArg)
# get subgoal polarity
cursor.execute(
"SELECT subgoalPolarity FROM Subgoals WHERE rid == '" + rid +
"' AND sid == '" + s + "'")
subPolarity = cursor.fetchone() # assume only one additional arg
subPolarity = tools.toAscii_str(subPolarity)
if subPolarity == "notin":
subPolarity += " "
newSubgoal += subPolarity
# all subgoals have a name and open paren
newSubgoal += subgoalName + "("
# add in all attributes
for j in range(0, len(subAtts)):
currAtt = subAtts[j]
# replace SndTime in subgoal with subTimeArg, if applicable
if not subTimeArg == "" and "SndTime" in currAtt:
currAtt = str(subTimeArg)
if j < (len(subAtts) - 1):
newSubgoal += currAtt + ","
else:
newSubgoal += currAtt + ")"
# cap with a comma, if applicable
if k < len(subIDs) - 1:
newSubgoal += ","
rule += newSubgoal
# cap with comma
if len(subIDs) > 0:
rule += ","
# --------------------------------------------------------------- #
# EQUATIONS #
# get list of sids for the subgoals of this rule
cursor.execute(
"SELECT eid FROM Equation") # get list of eids for this rule
eqnIDs = cursor.fetchall()
eqnIDs = tools.toAscii_list(eqnIDs)
# if len( subIDs ) > 0 and \
# ( len( eqnIDs ) > 0 or \
# len( clockSubIDs ) > 0 or \
# len( negSubIDs ) > 0 ):
# rule += ","
for e in range(0, len(eqnIDs)):
currEqnID = eqnIDs[e]
# get associated equation
if not currEqnID == None:
cursor.execute("SELECT eqn FROM Equation WHERE rid == '" + rid +
"' AND eid == '" + str(currEqnID) + "'")
eqn = cursor.fetchone()
if not eqn == None:
eqn = tools.toAscii_str(eqn)
# convert eqn info to pretty string
rule += "," + str(eqn)
# if len( eqnIDs ) > 0 and len( clockSubIDs ) > 0 :
# rule += ","
# add SndTime eqn (only works for one subgoal time annotation)
#if not subTimeArg == None and not subTimeArg == "" :
# rule += ",SndTime==" + str( subTimeArg )
# cap with comma
if len(eqnIDs) > 0:
rule += ","
# --------------------------------------------------------------- #
if len(clockSubIDs) > 0:
subTimeArg = None
# iterate over subgoal ids
for k in range(0, len(clockSubIDs)):
newSubgoal = ""
s = clockSubIDs[k]
# get subgoal name
cursor.execute("SELECT subgoalName \
FROM Subgoals \
WHERE rid == '" + str(rid) + "' AND \
sid == '" + str(s) + "'")
subgoalName = cursor.fetchone()
if not subgoalName == None:
subgoalName = tools.toAscii_str(subgoalName)
logging.debug("subgoalName = " + subgoalName)
# get subgoal attribute list
subAtts = cursor.execute("SELECT attName \
FROM SubgoalAtt \
WHERE rid == '" + rid + "' AND \
sid == '" + s + "'")
subAtts = cursor.fetchall()
subAtts = tools.toAscii_list(subAtts)
# get subgoal time arg
cursor.execute("SELECT subgoalTimeArg \
FROM Subgoals \
WHERE rid == '" + rid + "' AND \
sid == '" + s + "'")
subTimeArg = cursor.fetchone() # assume only one time arg
subTimeArg = tools.toAscii_str(subTimeArg)
# get subgoal polarity
cursor.execute("SELECT subgoalPolarity \
FROM Subgoals \
WHERE rid == '" + rid + "' AND \
sid == '" + s + "'")
subPolarity = cursor.fetchone(
) # assume only one additional arg
subPolarity = tools.toAscii_str(subPolarity)
subPolarity += " "
newSubgoal += subPolarity
# all subgoals have a name and open paren
newSubgoal += subgoalName + "("
# add in all attributes
for j in range(0, len(subAtts)):
currAtt = subAtts[j]
# replace SndTime in subgoal with subTimeArg, if applicable
if not subTimeArg == "" and "SndTime" in currAtt:
currAtt = str(subTimeArg)
if j < (len(subAtts) - 1):
newSubgoal += currAtt + ","
else:
newSubgoal += currAtt + ")"
# cap with a comma, if applicable
if k < len(clockSubIDs) - 1:
newSubgoal += ","
rule += newSubgoal
#if len( clockSubIDs ) > 0 and len( negSubIDs ) > 0 :
# rule += ","
# cap with comma
if len(clockSubIDs) > 0:
rule += ","
# --------------------------------------------------------------- #
if len(negSubIDs) > 0:
subTimeArg = None
# iterate over subgoal ids
for k in range(0, len(negSubIDs)):
newSubgoal = ""
s = negSubIDs[k]
# get subgoal name
cursor.execute("SELECT subgoalName \
FROM Subgoals \
WHERE rid == '" + str(rid) + "' AND \
sid == '" + str(s) + "'")
subgoalName = cursor.fetchone()
if not subgoalName == None:
subgoalName = tools.toAscii_str(subgoalName)
logging.debug("subgoalName = " + subgoalName)
# get subgoal attribute list
subAtts = cursor.execute("SELECT attName \
FROM SubgoalAtt \
WHERE rid == '" + rid + "' AND \
sid == '" + s + "'")
subAtts = cursor.fetchall()
subAtts = tools.toAscii_list(subAtts)
# get subgoal time arg
cursor.execute("SELECT subgoalTimeArg \
FROM Subgoals \
WHERE rid == '" + rid + "' AND \
sid == '" + s + "'")
subTimeArg = cursor.fetchone() # assume only one time arg
subTimeArg = tools.toAscii_str(subTimeArg)
# get subgoal polarity
cursor.execute("SELECT subgoalPolarity \
FROM Subgoals \
WHERE rid == '" + rid + "' AND \
sid == '" + s + "'")
subPolarity = cursor.fetchone(
) # assume only one additional arg
subPolarity = tools.toAscii_str(subPolarity)
subPolarity += " "
newSubgoal += subPolarity
# all subgoals have a name and open paren
newSubgoal += subgoalName + "("
# add in all attributes
for j in range(0, len(subAtts)):
currAtt = subAtts[j]
# replace SndTime in subgoal with subTimeArg, if applicable
if not subTimeArg == "" and "SndTime" in currAtt:
currAtt = str(subTimeArg)
if j < (len(subAtts) - 1):
newSubgoal += currAtt + ","
else:
newSubgoal += currAtt + ")"
# cap with a comma, if applicable
if k < len(negSubIDs) - 1:
newSubgoal += ","
rule += newSubgoal
# --------------------------------------------------------------- #
if rule.endswith(","):
rule = rule[:-1]
rule += " ;" + "\n" # end all rules with a semicolon
rule = rule.replace(" ,", "")
rule = rule.replace(",,", ",")
rule = rule.translate(None, string.whitespace)
rule = rule.replace(",;", ";")
rule = rule.replace("notin", "notin ")
logging.debug(" >>> rule = " + rule)
return rule
def c4datalog( cursor ) :
goalName = None
provGoalNameOrig = None
tableListStr = "" # collect all table names delmited by a single comma only.
tableListArray = []
# ----------------------------------------------------------- #
# create goal defines
# get all rids
cursor.execute( "SELECT rid FROM Rule" )
ridList = cursor.fetchall()
ridList = tools.toAscii_list( ridList )
definesNames = []
definesList = []
# ////////////////////////////////////////////////////////// #
# populate defines list for rules
for rid in ridList :
newDefine = ""
# get goal name
cursor.execute( "SELECT goalName FROM Rule WHERE rid = '" + rid + "'" )
goalName = cursor.fetchone()
goalName = tools.toAscii_str( goalName )
# if it's a prov rule, get the original goal name
provGoalNameOrig = None
if "_prov" in goalName :
provGoalNameOrig = goalName.split( "_prov" )
provGoalNameOrig = provGoalNameOrig[0]
# populate table information collection structures
tableListStr += goalName + ","
tableListArray.append( goalName )
# ////////////////////////////////////////////////////////// #
# populate defines list for rule goals
if C4_TRANSLATOR_DEBUG :
print "In c4datalog: definesList = " + str(definesList)
if not existingDefine( goalName, definesNames ) : # prevent duplicates
# get goal attribute list
cursor.execute( "SELECT attID,attType From GoalAtt WHERE rid = '" + rid + "'" )
goalAttList = cursor.fetchall()
goalAttList = tools.toAscii_multiList( goalAttList )
if C4_TRANSLATOR_DEBUG_1 :
print "* goalName = " + goalName + ", goalAttList " + str( goalAttList )
# populate type list for rule
typeList = []
for k in range(0,len(goalAttList)) :
att = goalAttList[ k ]
attID = att[0]
attType = att[1]
typeList.append( attType )
# populate new c4 define statement
newDefine = ""
newDefine += "define("
newDefine += goalName
newDefine += ",{"
for i in range(0,len(typeList)) :
newDefine += typeList[i]
if i < len(typeList) - 1 :
newDefine += ","
else :
newDefine += "});" + "\n"
# save new c4 define statement
if not newDefine in definesList :
definesNames.append( goalName )
definesList.append( newDefine )
# ////////////////////////////////////////////////////////// #
# ----------------------------------------------------------- #
# create fact defines
# get all fact ids
cursor.execute( "SELECT fid FROM Fact" )
fidList = cursor.fetchall()
fidList = tools.toAscii_list( fidList )
for fid in fidList :
# get goal name
cursor.execute( "SELECT name FROM Fact WHERE fid = '" + fid + "'" )
factName = cursor.fetchone()
factName = tools.toAscii_str( factName )
if C4_TRANSLATOR_DEBUG :
print "**> factName = " + factName
if C4_TRANSLATOR_DEBUG :
print "In c4datalog: definesList = " + str(definesList)
if not existingDefine( factName, definesNames ) : # prevent duplicates
# populate table string
tableListStr += factName + ","
tableListArray.append( factName )
# get goal attribute list
cursor.execute( "SELECT attID,attType From FactAtt WHERE fid = '" + fid + "'" )
factAttList = cursor.fetchall()
factAttList = tools.toAscii_multiList( factAttList )
if C4_TRANSLATOR_DEBUG_1 :
print "* factName = " + factName + ", factAttList " + str( factAttList )
# populate type list for fact
typeList = []
for k in range(0,len(factAttList)) :
att = factAttList[ k ]
attID = att[0]
attType = att[1]
typeList.append( attType )
# check for time argument
#cursor.execute( "SELECT timeArg FROM Fact WHERE fid='" + fid + "'" )
#timeArg = cursor.fetchone()
#timeArg = tools.toAscii_str( timeArg )
#if timeArg :
# typeList.append( "int" )
# populate new c4 define statement
newDefine = ""
newDefine += "define("
newDefine += factName
newDefine += ",{"
for i in range(0,len(typeList)) :
newDefine += typeList[i]
if i < len(typeList) - 1 :
newDefine += ","
else :
newDefine += "});" + "\n"
# save new c4 define statement
if not newDefine in definesList :
definesNames.append( factName )
definesList.append( newDefine )
# ////////////////////////////////////////////////////////// #
# ----------------------------------------------------------- #
# add clock define
definesList.append( "define(clock,{string,string,int,int});\n" )
tableListStr += "clock,"
tableListArray.append( "clock" )
# ----------------------------------------------------------- #
# add not_clock define
#definesList.append( "define(not_clock,{string,string,int,int});\n" )
#tableListStr += "not_clock,"
#tableListArray.append( "not_clock" )
# ----------------------------------------------------------- #
# add facts
cursor.execute( "SELECT fid FROM Fact" )
fidList = cursor.fetchall()
fidList = tools.toAscii_list( fidList )
factList = []
for fid in fidList :
newFact = dumpers_c4.dumpSingleFact_c4( fid, cursor )
factList.append( newFact )
# ----------------------------------------------------------- #
# add clock facts
clockFactList = dumpers_c4.dump_clock( cursor )
if C4_TRANSLATOR_DEBUG :
print "c4_translator: clockFactList = " + str( clockFactList )
# ----------------------------------------------------------- #
# add rules
cursor.execute( "SELECT rid FROM Rule" )
ridList = cursor.fetchall()
ridList = tools.toAscii_list( ridList )
ruleList = []
for rid in ridList :
# verify data type compatibility for rules with equations
verificationResults = tools.checkDataTypes( rid, cursor ) # returns array
yesCompatible = verificationResults[0]
offensiveEqn = verificationResults[1]
lhsType = verificationResults[2]
rhsType = verificationResults[3]
if yesCompatible :
newRule = dumpers_c4.dumpSingleRule_c4( rid, cursor )
ruleList.append( newRule )
else : # data types are incompatible
# throw error and abort
tools.bp( __name__, inspect.stack()[0][3], "FATAL ERROR: DATA TYPE INCOMPATABILITY\nAttempting to evaluate an equation in which variables possess incomparable types.\nERROR in line: " + dumpers_c4.dumpSingleRule_c4( rid, cursor )+ "\nERROR in eqn: " + offensiveEqn + "\nlhs is of type " + lhsType + " and rhs is of type " + rhsType )
# ----------------------------------------------------------- #
# save table list
if C4_TRANSLATOR_DEBUG :
print "*******************************************"
print "table list str :"
print tableListStr
print "table list array :"
print tableListArray
# ----------------------------------------------------------- #
# collect program statements
if C4_TRANSLATOR_DEBUG :
print "*******************************************"
print "definesList :"
print definesList
print "*******************************************"
print "factList :"
print factList
print "*******************************************"
print "ruleList :"
print ruleList
listOfStatementLists = [ definesList, factList, ruleList, clockFactList ]
program = tools.combineLines( listOfStatementLists )
# break down into list of individual statements
allProgramLines = []
for group in listOfStatementLists :
for statement in group :
allProgramLines.append( statement.rstrip() )
# remove duplicates
tableListArray = set( tableListArray )
tableListArray = list( tableListArray )
return [ allProgramLines, tableListArray ]
def printRuleWithTypes( rid, cursor ) :
logging.debug( " PRINT RULE WITH TYPES : running process..." )
printLine = ""
# ----------------------------------------- #
# get relation name
cursor.execute( "SELECT goalName FROM Rule WHERE rid=='" + str( rid ) + "'" )
goalName = cursor.fetchone()
goalName = tools.toAscii_str( goalName )
# ----------------------------------------- #
# get goal att names and types
cursor.execute( "SELECT attID,attName,attType FROM GoalAtt WHERE rid=='" + str( rid ) + "'" )
gattData = cursor.fetchall()
gattData = tools.toAscii_multiList( gattData )
# build head for printing
goal = goalName + "("
for gatt in gattData :
gattName = gatt[1]
gattType = gatt[2]
goal += "[" + gattName + "," + gattType + "]"
goal += ")"
printLine += goal + " :- "
# ----------------------------------------- #
# get all subgoal ids
cursor.execute( "SELECT sid FROM Subgoals WHERE rid=='" + str( rid ) + "'" )
sidList = cursor.fetchall()
sidList = tools.toAscii_list( sidList )
# ----------------------------------------- #
# iterate over sids
for sid in sidList :
# ----------------------------------------- #
# get subgoal name
cursor.execute( "SELECT subgoalName FROM Subgoals WHERE rid=='" + str( rid ) + "' AND sid=='" + str( sid ) + "'" )
subgoalName = cursor.fetchone()
subgoalName = tools.toAscii_str( subgoalName )
# ----------------------------------------- #
# get subgoal att names and types
cursor.execute( "SELECT attID,attName,attType FROM SubgoalAtt WHERE rid=='" + str( rid ) + "' AND sid=='" + str( sid ) + "'" )
sattData = cursor.fetchall()
sattData = tools.toAscii_multiList( sattData )
# ----------------------------------------- #
# build subgoal for printing
subgoal = subgoalName + "("
for satt in sattData :
sattName = satt[1]
sattType = satt[2]
subgoal += "[" + sattName + "," + sattType + "]"
subgoal += ")"
printLine += subgoal + ","
return printLine[:-1]
def collectExistentialBoundSubgoals(universalBoundSubgoals, posNameRIDs,
cursor):
print
print "^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^"
print "BUILDING EXISTENTIAL BOUND SUBGOALS"
print "universalBoundSubgoals : "
for sub in universalBoundSubgoals:
print sub
print "posNameRIDs :"
for r in posNameRIDs:
print dumpers.reconstructRule(r, cursor)
existentialBoundSubgoals = []
# -------------------------- #
# extract all universal vars #
# -------------------------- #
univars = []
for subgoalDict in universalBoundSubgoals:
subgoalAttDict = subgoalDict["subgoalAttDict"]
for subindex in subgoalAttDict:
attData = subgoalAttDict[subindex]
attVar = attData[1]
if not attVar in univars and not attVar == "_":
univars.append(attVar)
# ---------------------------------------------------------------------------------------- #
# collect all subgoals from pos rules with all universal variables replaced with wildcards #
# ---------------------------------------------------------------------------------------- #
for posrid in posNameRIDs:
print "<><> posNameRIDs rule : " + dumpers.reconstructRule(
posrid, cursor)
# get all sids
cursor.execute("SELECT sid FROM Subgoals WHERE rid=='" + posrid + "'")
sidList = cursor.fetchall()
sidList = tools.toAscii_list(sidList)
for possid in sidList:
# ---------------- #
# get subgoal name #
# ---------------- #
cursor.execute("SELECT subgoalName FROM Subgoals WHERE rid=='" +
posrid + "' AND sid=='" + possid + "'")
exisSubgoalName = cursor.fetchone()
exisSubgoalName = tools.toAscii_str(exisSubgoalName)
# ------------------------- #
# get subgoal time argument #
# ------------------------- #
cursor.execute("SELECT subgoalTimeArg FROM Subgoals WHERE rid=='" +
posrid + "' AND sid=='" + possid + "'")
exisSubgoalTimeArg = cursor.fetchone()
exisSubgoalTimearg = tools.toAscii_str(exisSubgoalTimeArg)
if type(exisSubgoalTimeArg) is tuple:
exisSubgoalTimeArg = exisSubgoalTimeArg[0]
# ------------------- #
# get subgoal att map #
# ------------------- #
# ====================================== #
# CASE : subgoal is an EDB #
# ====================================== #
if tools.isFact_only(exisSubgoalName, cursor):
if exisSubgoalName == "clock":
# just need to get the data for one clock fact
cursor.execute(
"SELECT src,dest,sndTime,delivTime FROM Clock")
fact = cursor.fetchall()
fact = tools.toAscii_multiList(fact)
fact = fact[0]
factData = {}
attID = 0
for d in fact:
attName = d
if type(d) is int:
attType = "int"
elif d.isdigit():
attType = "int"
else:
attType = "string"
factData[attID] = [attID, attName, attType]
attID += 1
#tools.bp( __name__, inspect.stack()[0][3], "factData : " + str( factData ) )
else:
# get an fid for this edb
cursor.execute("SELECT fid FROM Fact WHERE name=='" +
exisSubgoalName + "'")
thisSubgoalEDBFID = cursor.fetchone()
thisSubgoalEDBFID = tools.toAscii_str(thisSubgoalEDBFID)
# get fact data
cursor.execute(
"SELECT attID,attName,attType FROM FactAtt WHERE fid=='"
+ thisSubgoalEDBFID + "'")
factData = cursor.fetchall()
factData = tools.toAscii_multiList(factData)
# get subgoal attribute data
cursor.execute(
"SELECT attID,attName,attType FROM SubgoalAtt WHERE rid=='"
+ posrid + "' AND sid=='" + possid + "'")
subAttData = cursor.fetchall()
subAttData = tools.toAscii_multiList(subAttData)
# map subgoal attributes to att types from the corresponding fact schema
attData = {}
for i in range(0, len(factData)):
fact = factData[i]
subatt = subAttData[i]
attID = fact[0]
attName = subatt[1]
attType = fact[2]
attData[attID] = [attID, attName, attType]
# ====================================== #
# CASE : suboal is an IDB #
# ====================================== #
else:
# get original name
orig_name = exisSubgoalName.split("_from")
orig_name = orig_name[0] # remove stuff from _from and after
if orig_name.startswith("not_"):
orig_name = orig_name[4:]
print "orig_name = " + str(orig_name)
# get an rid for this idb
#cursor.execute( "SELECT rid FROM Rule WHERE goalName=='" + exisSubgoalName + "'" )
cursor.execute("SELECT rid FROM Rule WHERE goalName=='" +
orig_name + "'")
thisSubgoalIDBRID = cursor.fetchone()
thisSubgoalIDBRID = tools.toAscii_str(thisSubgoalIDBRID)
# get att data from IDB definition
cursor.execute(
"SELECT attID,attName,attType FROM GoalAtt WHERE rid=='" +
thisSubgoalIDBRID + "'")
orig_subgoalAttList = cursor.fetchall()
orig_subgoalAttList = tools.toAscii_multiList(
orig_subgoalAttList)
# get att data from subgoal from positive rule
cursor.execute(
"SELECT attID,attName,attType FROM SubgoalAtt WHERE rid=='"
+ posrid + "' AND sid=='" + possid + "'")
subgoal_subgoalAttList = cursor.fetchall()
subgoal_subgoalAttList = tools.toAscii_multiList(
subgoal_subgoalAttList)
attData = {}
for i in range(0, len(orig_subgoalAttList)):
orig_att = orig_subgoalAttList[i]
sub_att = subgoal_subgoalAttList[i]
attID = orig_att[0]
attName = sub_att[1]
attType = orig_att[2]
attData[attID] = [attID, attName, attType]
print "attData : " + str(attData)
exisSubgoalAttMap = {}
for attID in attData:
att = attData[attID]
attID = att[0]
attName = att[1]
attType = att[2]
if attName in univars and not attName == "_":
attName = "_"
exisSubgoalAttMap[attID] = [attID, attName, attType]
# ------------------- #
# get subgoal add arg #
# ------------------- #
cursor.execute("SELECT argName FROM SubgoalAddArgs WHERE rid=='" +
posrid + "' AND sid=='" + possid + "'")
exisAddArg = cursor.fetchone()
if exisAddArg:
exisAddArg = tools.toAscii_str(exisAddArg)
else:
exisAddArg = ""
# ------------------------------ #
# build negated positive subgoal #
# ------------------------------ #
exisSubgoal = {}
exisSubgoal["sid"] = tools.getID()
exisSubgoal["subgoalName"] = exisSubgoalName
exisSubgoal["subgoalTimeArg"] = exisSubgoalTimeArg
exisSubgoal["subgoalAttDict"] = exisSubgoalAttMap
exisSubgoal["argName"] = exisAddArg
existentialBoundSubgoals.append(exisSubgoal)
print "DONE BUILDING EXISTENTIAL BOUND SUBGOALS"
return existentialBoundSubgoals
def rewriteDeductive(cursor):
if DEDALUSREWRITER_DEBUG:
print " ... running deductive rewrite ..."
# grab all existing non-next and non-async rule ids
deductiveRuleIDs = getDeductiveRuleIDs(cursor)
# add attribute 'SndTime' to head as the new rightmost attribute
for rid in deductiveRuleIDs:
# ......................................... #
cursor.execute("SELECT goalName FROM Rule WHERE rid =='" + rid + "'")
goalName = cursor.fetchone()
goalName = tools.toAscii_str(goalName)
# ......................................... #
#print "*******************************"
#print "old rule : " + str( dumpers.reconstructRule(rid, cursor) )
if not tools.checkIfRewrittenAlready(rid, cursor):
# set rule as rewritten
cursor.execute("UPDATE Rule SET rewritten='" + rewrittenFlag +
"' WHERE rid=='" + rid + "'")
# grab maximum attribute id
cursor.execute("SELECT MAX(attID) FROM GoalAtt WHERE rid == '" +
rid + "'")
rawMaxID = cursor.fetchone()
rawMaxID = rawMaxID[0] # extract from tuple
if rawMaxID or (rawMaxID == 0):
newAttID = int(rawMaxID + 1) # the att id for SndTime
# check if add arg is a specific time
cursor.execute("SELECT goalTimeArg FROM Rule WHERE rid == '" +
rid + "'")
timeArg = cursor.fetchone()
timeArg = tools.toAscii_str(timeArg)
if timeArg.isdigit():
cursor.execute("INSERT INTO GoalAtt VALUES ('" + rid +
"','" + str(newAttID) + "','" + timeArg +
"','int')")
else:
cursor.execute("INSERT INTO GoalAtt VALUES ('" + rid +
"','" + str(newAttID) + "','" +
timeAtt_snd + "','int')")
else:
tools.bp(
__name__,
inspect.stack()[0][3],
"FATAL ERROR : current rule goal has no attributes:\n" +
dumpers.reconstructRule(rid, cursor))
# add attribute 'Time' to all subgoals
sids = getSubgoalIDs(cursor, rid) # get all subgoal ids
sids = tools.toAscii_list(sids)
firstSubgoalAtts = []
# iterate over rule subgoals
for s in sids:
# ......................................... #
cursor.execute(
"SELECT subgoalName FROM Subgoals WHERE rid=='" + rid +
"' AND sid=='" + s + "'")
subgoalName = cursor.fetchone()
subgoalName = tools.toAscii_str(subgoalName)
# ......................................... #
addArg = None
# get time arg for subgoal
cursor.execute(
"SELECT subgoalTimeArg FROM Subgoals WHERE rid = '" + rid +
"' AND sid = '" + s + "'")
timeArg = cursor.fetchone()
timeArg = tools.toAscii_str(timeArg)
# add Time as a subgoal attribute
cursor.execute(
'''SELECT MAX(attID) FROM SubgoalAtt WHERE SubgoalAtt.sid == "'''
+ s + '''"''')
rawMaxID = cursor.fetchone() # int type
newAttID = int(rawMaxID[0] + 1)
cursor.execute("INSERT INTO SubgoalAtt VALUES ('" + rid +
"','" + s + "'," + str(newAttID) + ",'" +
timeAtt_snd + "','int')")
# replace subgoal time attribute with numeric time arg
if timeArg.isdigit():
cursor.execute(
"SELECT attName FROM SubgoalAtt WHERE sid = '" + s +
"'")
satts = cursor.fetchall()
satts = tools.toAscii_list(satts)
# ......................................... #
#if goalName == "pre" :
# if subgoalName == "bcast" :
# print " timeArg = " + str(timeArg)
# print " satts = " + str(satts)
# tools.bp( __name__, inspect.stack()[0][3], "___ASDFASLKDHFWER" )
# ......................................... #
for i in range(0, len(satts)):
if satts[i] == timeAtt_snd:
cursor.execute("UPDATE SubgoalAtt SET attName='" +
timeArg + "' WHERE rid = '" + rid +
"' AND sid = '" + s +
"' AND attID = '" + str(i) + "'")
# collect the additional argument (aka notin for c4)
cursor.execute(
"SELECT argName FROM SubgoalAddArgs WHERE SubgoalAddArgs.rid == '"
+ rid + "' AND SubgoalAddArgs.sid == '" + s + "'")
addArg = cursor.fetchone()
if addArg:
addArg = tools.toAscii_str(addArg)
# while we're here, collect the first attribute of this subgoal
cursor.execute(
"SELECT attName FROM SubgoalAtt WHERE SubgoalAtt.sid == '"
+ s + "' AND SubgoalAtt.attID == '" + str(0) + "'")
firstAtt = cursor.fetchone()
if (not firstAtt == None) and (
not addArg
== "notin"): # need branch on notin for safety
firstAtt = tools.toAscii_str(firstAtt)
firstSubgoalAtts.append(firstAtt)
else:
if DEDALUSREWRITER_DEBUG:
print "firstAtt = " + str(firstAtt)
# sanity checking branch
if len(firstSubgoalAtts) > 0:
pass
# add clock subgoal
#clockTools.addClockSubgoal_deductive( rid, firstSubgoalAtts, timeAtt_snd, timeAtt_deliv, cursor )
else:
print dumpers.reconstructRule(rid, cursor)
tools.bp(
__name__,
inspect.stack()[0][3],
"We've got major probs, mate. The subgoals of this rule have no attributes.\nfirstSubgoalAtts = "
+ str(firstSubgoalAtts) + "\nMake sure the rule is safe.")
#tools.bp( __name__, inspect.stack()[0][3], "new rule : " + str(dumpers.reconstructRule(rid, cursor)) )
# check for bugs
if DEDALUSREWRITER_DEBUG:
print "Rule :"
cursor.execute('''SELECT * FROM Rule''')
for i in cursor.fetchall():
print i
print "GoalAtt"
cursor.execute("SELECT * FROM GoalAtt")
for s in cursor.fetchall():
print s
print "Subgoals"
cursor.execute("SELECT * FROM Subgoals")
for s in cursor.fetchall():
print s
print "SubgoalAtt"
cursor.execute("SELECT * FROM SubgoalAtt")
for s in cursor.fetchall():
print s
def rewriteAsynchronous(cursor):
if DEDALUSREWRITER_DEBUG:
print " ... running asynchronous rewrite ... "
# grab all existing next rule ids
asynchronousRuleIDs = getAsynchronousRuleIDs(cursor)
# check for bugs
if DEDALUSREWRITER_DUMPS_DEBUG:
print "asynchronousRuleIDs = " + str(asynchronousRuleIDs)
for r in asynchronousRuleIDs:
print "<><><><><><><><><><><><><><><>"
print " DUMPING ASYNC RULES "
print dumpers.reconstructRule(r, cursor)
print "<><><><><><><><><><><><><><><>"
# add attribute 'DelivTime' to head
for rid in asynchronousRuleIDs:
#print "*******************************"
#print "old rule : " + str( dumpers.reconstructRule(rid, cursor) )
if not tools.checkIfRewrittenAlready(rid, cursor):
# set rule as rewritten
cursor.execute("UPDATE Rule SET rewritten='" + rewrittenFlag +
"' WHERE rid=='" + rid + "'")
cursor.execute(
'''SELECT MAX(attID) FROM GoalAtt WHERE GoalAtt.rid == "''' +
rid + '''"''')
rawMaxID = cursor.fetchone()
newAttID = int(rawMaxID[0] + 1)
cursor.execute("INSERT INTO GoalAtt VALUES ('" + rid + "','" +
str(newAttID) + "','" + timeAtt_deliv + "','int')")
# add attribute 'SndTime' to all subgoals and add clock subgoal
for rid in asynchronousRuleIDs:
sids = getSubgoalIDs(cursor, rid) # get all subgoal ids
sids = tools.toAscii_list(sids)
firstSubgoalAtts = []
for s in sids:
cursor.execute(
'''SELECT MAX(attID) FROM SubgoalAtt WHERE SubgoalAtt.sid == "'''
+ s + '''"''')
rawMaxID = cursor.fetchone()
newAttID = int(rawMaxID[0] + 1)
cursor.execute("INSERT INTO SubgoalAtt VALUES ('" + rid + "','" +
s + "'," + str(newAttID) + ",'" + timeAtt_snd +
"','int')")
# while we're here, collect the first attribute of this subgoal
cursor.execute(
"SELECT attName FROM SubgoalAtt WHERE SubgoalAtt.sid == '" +
s + "' AND SubgoalAtt.attID == '" + str(0) + "'")
firstAtt = cursor.fetchone()
if firstAtt:
firstAtt = tools.toAscii_str(firstAtt)
firstSubgoalAtts.append(firstAtt)
# add clock subgoal
cursor.execute("SELECT attName FROM GoalAtt WHERE GoalAtt.rid == '" +
rid + "' AND GoalAtt.attID == '" + str(0) + "'")
secondAtt = cursor.fetchone()
secondAtt = tools.toAscii_str(secondAtt)
clockTools.addClockSubgoal_async(rid, firstSubgoalAtts, secondAtt,
timeAtt_snd, timeAtt_deliv, cursor)
# remove time arg from rule goals
for rid in asynchronousRuleIDs:
cursor.execute("UPDATE Rule SET goalTimeArg='' WHERE rid='" + rid +
"'")
#print "new rule : " + str( dumpers.reconstructRule(rid, cursor) )
#print "-------------------------------"
#tools.bp( __name__, inspect.stack()[0][3], "breakhere" )
# check for bugs
if DEDALUSREWRITER_DUMPS_DEBUG:
print "Dump all rules from async : "
dumpers.ruleDump(cursor)
#dumpers.factDump( cursor )
if DEDALUSREWRITER_DEBUG:
print " ... done asynchronous rewrite ... "
return None
def rewriteInductive(cursor):
if DEDALUSREWRITER_DEBUG:
print " ... running inductive rewrite ... "
# grab all existing next rule ids
inductiveRuleIDs = getInductiveRuleIDs(cursor)
# check for bugs
if DEDALUSREWRITER_DUMPS_DEBUG:
print "inductiveRuleIDs = " + str(inductiveRuleIDs)
print "<><><><><><><><><><><><><><><>"
print " DUMPING INDUCTIVE RULES "
for r in inductiveRuleIDs:
print dumpers.reconstructRule(r, cursor)
print "<><><><><><><><><><><><><><><>"
# add attribute 'SndTime+1' to head
for rid in inductiveRuleIDs:
if not tools.checkIfRewrittenAlready(rid, cursor):
# set rule as rewritten
cursor.execute("UPDATE Rule SET rewritten='" + rewrittenFlag +
"' WHERE rid=='" + rid + "'")
# grab maximum attribute id
cursor.execute("SELECT MAX(attID) FROM GoalAtt WHERE rid == '" +
rid + "'")
rawMaxID = cursor.fetchone()
rawMaxID = rawMaxID[0] # extract from tuple
# .................................. #
#cursor.execute( "SELECT goalName FROM Rule WHERE rid=='" + rid + "'" )
#goalName = cursor.fetchone()
#goalName = tools.toAscii_str( goalName )
#print "___ goalName = " + str(goalName)
#if goalName == "clients" :
# print "rawMaxID = " + str( rawMaxID )
# sys.exit()
# .................................. #
if rawMaxID or (rawMaxID == 0):
newAttID = int(rawMaxID + 1) # the att id for SndTime
# check if add arg is a specific time
cursor.execute("SELECT goalTimeArg FROM Rule WHERE rid == '" +
rid + "'")
timeArg = cursor.fetchone()
timeArg = tools.toAscii_str(timeArg)
# add attribute 'SndTime+1' to head
cursor.execute("INSERT INTO GoalAtt VALUES ('" + rid + "','" +
str(newAttID) + "','" + timeAtt_snd + "+1" +
"','int')")
else:
tools.bp(
__name__,
inspect.stack()[0][3],
"FATAL ERROR : current rule goal has no attributes:\n" +
dumpers.reconstructRule(rid, cursor))
if DEDALUSREWRITER_DEBUG:
print "inductive: rawMaxID = " + str(rawMaxID)
print "inductive: rawMaxID[0] = " + str(rawMaxID[0])
# add attribute 'SndTime' to all subgoals
for rid in inductiveRuleIDs:
sids = getSubgoalIDs(cursor, rid) # get all subgoal ids
sids = tools.toAscii_list(sids)
firstSubgoalAtts = []
for s in sids:
cursor.execute(
'''SELECT MAX(attID) FROM SubgoalAtt WHERE SubgoalAtt.sid == "'''
+ s + '''"''')
rawMaxID = cursor.fetchone()
newAttID = int(rawMaxID[0] + 1)
cursor.execute("INSERT INTO SubgoalAtt VALUES ('" + rid + "','" +
s + "'," + str(newAttID) + ",'" + timeAtt_snd +
"','int')")
# while we're here, collect the first attribute of this subgoal
cursor.execute(
"SELECT argName FROM SubgoalAddArgs WHERE SubgoalAddArgs.rid == '"
+ rid + "' AND SubgoalAddArgs.sid == '" + s + "'")
addArg = cursor.fetchone()
if not addArg == None:
addArg = tools.toAscii_str(addArg)
cursor.execute(
"SELECT attName FROM SubgoalAtt WHERE SubgoalAtt.sid == '" +
s + "' AND SubgoalAtt.attID == '" + str(0) + "'")
firstAtt = cursor.fetchone()
if (not firstAtt == None) and (not addArg == "notin"):
firstAtt = tools.toAscii_str(firstAtt)
firstSubgoalAtts.append(firstAtt)
else:
if DEDALUSREWRITER_DEBUG:
print "firstAtt = " + str(firstAtt)
# add clock subgoal
clockTools.addClockSubgoal_inductive(rid, firstSubgoalAtts,
timeAtt_snd, timeAtt_deliv,
cursor)
# remove time arg from rule goals
for rid in inductiveRuleIDs:
cursor.execute("UPDATE Rule SET goalTimeArg='' WHERE rid='" + rid +
"'")
# check for bugs
if DEDALUSREWRITER_DUMPS_DEBUG:
print "Dump all rules from inductive : "
dumpers.ruleDump(cursor)
if DEDALUSREWRITER_DEBUG:
print "... done rewriteInductive ..."
return None
def test_toAscii_str_tools(self):
unitestfile = testPath + "/testfiles/unicodetest.txt"
with open(unitestfile, "r") as f:
line = [f.readlines()[0][6:]]
line = tools.toAscii_str(line)
self.assertFalse(line.decode('utf-8') == None)
def c4datalog(argDict, cursor):
logging.debug(" C4 DATALOG : running process...")
goalName = None
provGoalNameOrig = None
tableListStr = "" # collect all table names delmited by a single comma only.
tableListArray = []
# ----------------------------------------------------------- #
# create goal defines
# get all rids
cursor.execute("SELECT rid FROM Rule")
ridList = cursor.fetchall()
ridList = tools.toAscii_list(ridList)
definesNames = []
definesList = []
# ////////////////////////////////////////////////////////// #
# populate defines list for rules
for rid in ridList:
newDefine = ""
# get goal name
cursor.execute("SELECT goalName FROM Rule WHERE rid = '" + rid + "'")
goalName = cursor.fetchone()
goalName = tools.toAscii_str(goalName)
# if it's a prov rule, get the original goal name
provGoalNameOrig = None
if "_prov" in goalName:
provGoalNameOrig = goalName.split("_prov")
provGoalNameOrig = provGoalNameOrig[0]
# populate table information collection structures
tableListStr += goalName + ","
tableListArray.append(goalName)
# ////////////////////////////////////////////////////////// #
# populate defines list for rule goals
logging.debug("In c4datalog: definesList = " + str(definesList))
if not existingDefine(goalName, definesNames): # prevent duplicates
# get goal attribute list
cursor.execute("SELECT attID,attType From GoalAtt WHERE rid = '" +
rid + "'")
goalAttList = cursor.fetchall()
goalAttList = tools.toAscii_multiList(goalAttList)
logging.debug("* goalName = " + goalName + ", goalAttList " +
str(goalAttList))
# populate type list for rule
typeList = []
for k in range(0, len(goalAttList)):
att = goalAttList[k]
attID = att[0]
attType = att[1]
typeList.append(attType)
# populate new c4 define statement
newDefine = ""
newDefine += "define("
newDefine += goalName
newDefine += ",{"
for i in range(0, len(typeList)):
newDefine += typeList[i]
if i < len(typeList) - 1:
newDefine += ","
else:
newDefine += "});" + "\n"
# save new c4 define statement
if not newDefine in definesList:
definesNames.append(goalName)
definesList.append(newDefine)
# ////////////////////////////////////////////////////////// #
# ----------------------------------------------------------- #
# create fact defines
# get all fact ids
cursor.execute("SELECT fid FROM Fact")
fidList = cursor.fetchall()
fidList = tools.toAscii_list(fidList)
for fid in fidList:
# get goal name
cursor.execute("SELECT name FROM Fact WHERE fid = '" + fid + "'")
factName = cursor.fetchone()
factName = tools.toAscii_str(factName)
logging.debug("**> factName = " + factName)
logging.debug("In c4datalog: definesList = " + str(definesList))
if not existingDefine(factName, definesNames): # prevent duplicates
# populate table string
tableListStr += factName + ","
tableListArray.append(factName)
# get goal attribute list
cursor.execute(
"SELECT dataID,dataType From FactData WHERE fid = '" + fid +
"'")
factAttList = cursor.fetchall()
factAttList = tools.toAscii_multiList(factAttList)
logging.debug("* factName = " + factName + ", factAttList " +
str(factAttList))
# populate type list for fact
typeList = []
for k in range(0, len(factAttList)):
att = factAttList[k]
attID = att[0]
attType = att[1]
typeList.append(attType)
# check for time argument
#cursor.execute( "SELECT timeArg FROM Fact WHERE fid='" + fid + "'" )
#timeArg = cursor.fetchone()
#timeArg = tools.toAscii_str( timeArg )
#if timeArg :
# typeList.append( "int" )
# populate new c4 define statement
newDefine = ""
newDefine += "define("
newDefine += factName
newDefine += ",{"
for i in range(0, len(typeList)):
newDefine += typeList[i]
if i < len(typeList) - 1:
newDefine += ","
else:
newDefine += "});" + "\n"
# save new c4 define statement
if not newDefine in definesList:
definesNames.append(factName)
definesList.append(newDefine)
# ////////////////////////////////////////////////////////// #
# ----------------------------------------------------------- #
# add clock define
definesList.append("define(clock,{string,string,int,int});\n")
tableListStr += "clock,"
tableListArray.append("clock")
# ----------------------------------------------------------- #
# add not_clock define
#definesList.append( "define(not_clock,{string,string,int,int});\n" )
#tableListStr += "not_clock,"
#tableListArray.append( "not_clock" )
# ----------------------------------------------------------- #
# add crash define
definesList.append("define(crash,{string,string,int,int});\n")
tableListStr += "crash,"
tableListArray.append("crash")
# ----------------------------------------------------------- #
# add facts
cursor.execute("SELECT fid FROM Fact")
fidList = cursor.fetchall()
fidList = tools.toAscii_list(fidList)
factList = []
for fid in fidList:
newFact = dumpers_c4.dumpSingleFact_c4(fid, cursor)
factList.append(newFact)
# ----------------------------------------------------------- #
# add clock facts
clockFactList = dumpers_c4.dump_clock(cursor)
logging.debug("c4_translator: clockFactList = " + str(clockFactList))
# ----------------------------------------------------------- #
# add crash facts
crashFactList = dumpers_c4.dump_crash(cursor)
#crashFactList = []
#print crashFactList
#tools.bp( __name__, inspect.stack()[0][3], "blah" )
#logging.debug( "c4_translator: crashFactList = " + str( crashFactList ) )
# ----------------------------------------------------------- #
# add rules
cursor.execute("SELECT rid FROM Rule")
ridList = cursor.fetchall()
ridList = tools.toAscii_list(ridList)
ruleList = []
for rid in ridList:
# verify data type compatibility for rules with equations
#verificationResults = tools.checkDataTypes( rid, cursor ) # returns array
#yesCompatible = verificationResults[0]
#offensiveEqn = verificationResults[1]
#lhsType = verificationResults[2]
#rhsType = verificationResults[3]
#if yesCompatible :
if True:
newRule = dumpers_c4.dumpSingleRule_c4(rid, cursor)
ruleList.append(newRule)
else: # data types are incompatible
# throw error and abort
tools.bp(
__name__,
inspect.stack()[0][3],
"FATAL ERROR: DATA TYPE INCOMPATABILITY\nAttempting to evaluate an equation in which variables possess incomparable types.\nERROR in line: "
+ dumpers_c4.dumpSingleRule_c4(rid, cursor) +
"\nERROR in eqn: " + offensiveEqn + "\nlhs is of type " +
lhsType + " and rhs is of type " + rhsType)
# ------------------------------------------------------ #
# grab the next rule handling method
try:
NEXT_RULE_HANDLING = tools.getConfig( argDict[ "settings" ], \
"DEFAULT", \
"NEXT_RULE_HANDLING", \
str )
except ConfigParser.NoOptionError:
logging.info(
"WARNING : no 'NEXT_RULE_HANLDING' defined in 'DEFAULT' section of settings file."
)
tools.bp( __name__, inspect.stack()[0][3], \
"FATAL ERROR : NEXT_RULE_HANDLING parameter not specified in DEFAULT section of settings file. use 'USE_AGGS', 'SYNC_ASSUMPTION', or 'USE_NEXT_CLOCK' only." )
# sanity check next rule handling value
if NEXT_RULE_HANDLING == "USE_AGGS" or \
NEXT_RULE_HANDLING == "SYNC_ASSUMPTION" or \
NEXT_RULE_HANDLING == "USE_NEXT_CLOCK" :
pass
else:
tools.bp( __name__, inspect.stack()[0][3], \
"FATAL ERROR : unrecognized NEXT_RULE_HANDLING value '" + NEXT_RULE_HANDLING + "'. use 'USE_AGGS', 'SYNC_ASSUMPTION', or 'USE_NEXT_CLOCK' only." )
# ----------------------------------------------------------- #
# add next_clock, if necessary
if NEXT_RULE_HANDLING == "USE_NEXT_CLOCK":
# ------------------------------------------------------ #
# add define
definesList.append("define(next_clock,{string,string,int,int});\n")
tableListStr += "next_clock,"
tableListArray.append("next_clock")
# ------------------------------------------------------ #
# add next_clock facts for all synchronous facts appearing clock
next_clock_factList = []
for cfact in clockFactList:
if isSynchronous(cfact):
next_clock_fact = "next_" + cfact
next_clock_factList.append(next_clock_fact)
# ----------------------------------------------------------- #
# save table list
logging.debug("*******************************************")
logging.debug("table list str :\n" + str(tableListStr))
logging.debug("table list array :\n" + str(tableListArray))
# ----------------------------------------------------------- #
# collect program statements
logging.debug("*******************************************")
logging.debug("definesList :\n" + str(definesList))
logging.debug("*******************************************")
logging.debug("factList :\n" + str(factList))
logging.debug("*******************************************")
logging.debug("ruleList :\n" + str(ruleList))
# NOTE: listOfStatementLists controls the ordering of statements
# in the final c4 program.
if NEXT_RULE_HANDLING == "USE_NEXT_CLOCK":
listOfStatementLists = [ definesList, \
ruleList, \
factList, \
crashFactList, \
next_clock_factList, \
clockFactList ]
else:
#listOfStatementLists = [ definesList, \
# factList, \
# ruleList, \
# clockFactList ]
listOfStatementLists = [ definesList, \
ruleList, \
factList, \
crashFactList, \
clockFactList ]
program = tools.combineLines(listOfStatementLists)
# break down into list of individual statements
allProgramLines = []
for group in listOfStatementLists:
for statement in group:
allProgramLines.append(statement.rstrip())
# remove duplicates
tableListArray = set(tableListArray)
tableListArray = list(tableListArray)
logging.debug(" C4 DATALOG : ...done.")
return [allProgramLines, tableListArray]
def rewriteRule(rid, sid, attData, cursor):
print "#################################################################"
print " ... running REWRITE RULE from rewriteSubgoalsWithWildcards ... #"
print "#################################################################"
print "BEFORE : attData : " + str(attData)
# ------------------------------------------- #
# get name of sid
cursor.execute("SELECT subgoalName FROM Subgoals WHERE rid=='" + rid +
"' AND sid=='" + sid + "'")
subgoalName = cursor.fetchone()
subgoalName = tools.toAscii_str(subgoalName)
# ------------------------------------------- #
# branch on idb subgoals.
# if negated subgoal with wildcard is IDB, then ensure all attTypes are defined
# by pulling attTypes from the IDB goal attribute list.
if not tools.isFact_only(subgoalName, cursor):
# get rule id for the idb
cursor.execute("SELECT rid FROM Rule WHERE goalName=='" + subgoalName +
"'")
idbrid = cursor.fetchone()
idbrid = tools.toAscii_str(idbrid)
# get goal schema
cursor.execute(
"SELECT attID,attName,attType FROM GoalAtt WHERE rid=='" + idbrid +
"'")
idbAttData = cursor.fetchall()
idbAttData = tools.toAscii_multiList(idbAttData)
print "idbAttData : " + str(idbAttData)
# fix original subgoal att list types
tmp = []
for i in range(0, len(idbAttData)):
idb_att = idbAttData[i]
orig_att = attData[i]
attID = orig_att[0]
attName = orig_att[1]
attType = idb_att[2]
tmp.append([attID, attName, attType])
attData = tmp
# ------------------------------------------- #
# generate new subgoal name
newSubgoalName = subgoalName + "_" + tools.getID_4() + "_wildcardrewrite"
# ------------------------------------------- #
# generate new subgoal att list
attNameList = []
newSubgoalAttList = []
attID = 0
for att in attData:
attName = att[1]
attType = att[2]
if not attName == "_" and attName not in attNameList:
newSubgoalAttList.append([attID, attName, attType])
attNameList.append(attName)
attID += 1
if True:
print ">> ORIG RULE <<"
print dumpers.reconstructRule(rid, cursor)
print ">>> <<<"
print "subgoalName = " + subgoalName
print "newSubgoalName = " + newSubgoalName
print "attData = " + str(attData)
print "newSubgoalAttList = " + str(newSubgoalAttList)
# ------------------------------------------- #
# update subgoal name
cursor.execute("UPDATE Subgoals SET subgoalName=='" + newSubgoalName +
"' WHERE rid=='" + rid + "' AND sid=='" + sid + "'")
# ------------------------------------------- #
# delete old subgoal att data
arity = len(attData)
for attID in range(0, arity):
cursor.execute("DELETE FROM SubgoalAtt WHERE rid=='" + rid +
"' AND sid=='" + sid + "' AND attID=='" + str(attID) +
"'")
# ------------------------------------------- #
# input new subgoal att data
for att in newSubgoalAttList:
attID = att[0]
attName = att[1]
attType = att[2]
cursor.execute("INSERT INTO SubgoalAtt VALUES ('" + rid + "','" + sid +
"'," + str(attID) + ",'" + attName + "','" + attType +
"')")
# ------------------------------------------- #
# add new rule
print "-------------------------------------"
print "subgoalName : " + subgoalName
print "newSubgoalName : " + newSubgoalName
print "attData : " + str(attData)
print "newSubgoalAttList : " + str(newSubgoalAttList)
#tools.bp( __name__, inspect.stack()[0][3], "asdf" )
newRule = addNewRule(subgoalName, newSubgoalName, attData,
newSubgoalAttList, cursor)
return newRule
def iedb_rewrites(factMeta, ruleMeta, cursor, settings_path):
logging.debug(" IEDB REWRITES : running process...")
# ----------------------------------------- #
# generate a dictionary mapping
# relation names to lists of fact ids.
cursor.execute("SELECT goalName FROM Rule")
idb_rel_list = cursor.fetchall()
idb_rel_list = tools.toAscii_list(idb_rel_list)
logging.debug(" IEDB REWRITES : idb_rel_list = " + str(idb_rel_list))
# initialize dictionary
rel_name_to_fact_obj_map = {}
for rel_name in idb_rel_list:
rel_name_to_fact_obj_map[rel_name] = []
logging.debug(" IEDB REWRITES : rel_name_to_fact_obj_map = " +
str(rel_name_to_fact_obj_map))
# collect fids
for f in factMeta:
if f.relationName in idb_rel_list:
rel_name_to_fact_obj_map[f.relationName].append(f)
logging.debug(" IEDB REWRITES : rel_name_to_fact_obj_map = " +
str(rel_name_to_fact_obj_map))
# ----------------------------------------- #
# append "_edb" to all fact names
for rel_name in rel_name_to_fact_obj_map:
fact_obj_list = rel_name_to_fact_obj_map[rel_name]
logging.debug(" IEDB REWRITES : rel_name = " + rel_name)
logging.debug(" IEDB REWRITES : fact_obj_list = " +
str(fact_obj_list))
for fact_obj in fact_obj_list:
logging.debug(" IEDB REWRITES : fact_obj.cursor = " +
str(fact_obj.cursor))
logging.debug(" IEDB REWRITES : fact_obj.factData = " +
str(fact_obj.factData))
fact_obj.relationName += "_edb"
fact_obj.saveFactInfo()
fact_obj.factData[
"relationName"] += "_edb" # reflect the change in the factData
logging.debug(" IEDB REWRITES : after:")
logging.debug(" IEDB REWRITES : fact_obj.factData = " +
str(fact_obj.factData))
cursor.execute("SELECT name FROM Fact WHERE fid=='" +
str(fact_obj.fid) + "'")
name = cursor.fetchone()
name = tools.toAscii_str(name)
logging.debug(" IEBD REWRITES : name = " + str(name))
#sys.exit( "foo" )
# ----------------------------------------- #
# add a new rule with the original goal
# predicated on the new _edb goal name
for rel_name in rel_name_to_fact_obj_map:
logging.debug(" IEDB REWRITES : rel_name = " + rel_name)
logging.debug( " IEDB REWRITEs : len( rel_name_to_fact_obj_map[ " + rel_name + " ] ) = " + \
str( len( rel_name_to_fact_obj_map[ rel_name ] ) ) )
if len(rel_name_to_fact_obj_map[rel_name]) > 0:
new_ruleData = {}
new_ruleData["relationName"] = rel_name
new_ruleData["goalTimeArg"] = ""
new_ruleData["eqnDict"] = {}
# build the goal attribute list
new_goalAttList = []
representative_factData = rel_name_to_fact_obj_map[rel_name][
0].factData # just pick one
representative_dataList = representative_factData["dataList"]
logging.debug(" representative_factData = " +
str(representative_factData))
logging.debug(" representative_dataList = " +
str(representative_dataList))
arity = len(representative_dataList)
for i in range(0, arity):
new_goalAttList.append("A" + str(i))
new_ruleData["goalAttList"] = new_goalAttList
# build the subgoal
new_subgoal_dict = {}
new_subgoal_dict["subgoalName"] = rel_name + "_edb"
new_subgoal_dict["subgoalAttList"] = new_goalAttList
new_subgoal_dict["polarity"] = ""
new_subgoal_dict["subgoalTimeArg"] = ""
new_ruleData["subgoalListOfDicts"] = [new_subgoal_dict]
# generate a new rid
rid = tools.getIDFromCounters("rid")
logging.debug(" IEDB REWRITES : new_ruleData = " +
str(new_ruleData))
# save the new rule
new_rule = copy.deepcopy(Rule.Rule(rid, new_ruleData, cursor))
new_rule.cursor = cursor # need to do this again for some reason???
ruleMeta.append(new_rule)
# set the types!
#setTypes.setTypes( cursor, argDict )
logging.debug(" IEDB REWRITES : done on rel_name = " + rel_name)
# ----------------------------------------- #
logging.debug(" IEDB REWRITES : ...done.")
return factMeta, ruleMeta
def doDeMorgans( parentRID, ruleRIDs, cursor ) :
print "==========================================="
print "... running DO DEMORGANS from deMorgans ..."
print "==========================================="
# ----------------------------------------------------------- #
# get data for naming stuff
# ----------------------------------------------------------- #
# parent name
cursor.execute( "SELECT goalName FROM Rule WHERE rid='" + parentRID + "'" )
parentName = cursor.fetchall()
parentName = tools.toAscii_str( parentName[0] )
# this IDB name
cursor.execute( "SELECT goalName FROM Rule WHERE rid='" + ruleRIDs[0] + "'" )
thisIDBName = cursor.fetchall()
thisIDBName = tools.toAscii_str( thisIDBName[0] )
# ----------------------------------------------------------- #
# combine all rules for each rule name into a single
# sympy formula string
# ----------------------------------------------------------- #
# associate each subgoal per rule for this IDB definition with an identifier
# and map to [ rid, [ sign, sid ] ] arrays
predicateToID_map = {}
# map rids,sid pairs to predicate identifiers (essentially the reverse of the above mapping)
ridSidToPredicate_map = {}
# ////////////////////////////////////////// #
# get all rule data
for rid in ruleRIDs :
# get list of all sids for this rid
# filter out sids for domain subgoals
cursor.execute( "SELECT sid FROM Subgoals WHERE rid=='" + rid + "' AND NOT subgoalName LIKE 'dom_%'" )
sidList = cursor.fetchall()
sidList = tools.toAscii_list( sidList )
# map sids to sign for this rule
signMap = {}
for sid in sidList :
cursor.execute( "SELECT argName FROM SubgoalAddArgs WHERE rid='" + rid + "' AND sid='" + sid + "'" )
sign = cursor.fetchone()
if sign :
sign = tools.toAscii_str( sign )
signMap[ sid ] = sign
for sid in sidList :
sign = signMap[ sid ]
# get a random identifier string
predID = tools.getID()
# map predIDs to rids and sids
predicateToID_map[ predID ] = [ rid, [ sign, sid ] ]
# map rids and sids to predIDs
if sign == "notin" :
key = rid + ",_NEG_" + sid
else :
key = rid + "," + sid
ridSidToPredicate_map[ key ] = predID
# ----------------------------------------------------------- #
# simplify DNF
simplified_negFmla = getDNFFmla_v1( ridSidToPredicate_map )
#simplified_negFmla = getDNFFmla_v2( ridSidToPredicate_map )
# ----------------------------------------------------------- #
# save a new rule to IR db per disjunct
newDMRIDList = setNewRules( parentName, thisIDBName, simplified_negFmla, predicateToID_map, cursor )
# ----------------------------------------------------------- #
return newDMRIDList
def dumpSingleRule_c4(rid, cursor):
rule = ""
# -------------------------------------------------------------- #
# GOAL #
# get goal name
cursor.execute("SELECT goalName FROM Rule WHERE rid == '" + rid +
"'") # get goal name
goalName = cursor.fetchone()
goalName = tools.toAscii_str(goalName)
# get list of attribs in goal
goalList = cursor.execute("SELECT attName FROM GoalAtt WHERE rid == '" +
rid + "'") # list of goal atts
goalList = cursor.fetchall()
goalList = tools.toAscii_list(goalList)
# get goal time arg
goalTimeArg = ""
cursor.execute("SELECT goalTimeArg FROM Rule WHERE rid == '" + rid + "'")
goalTimeArg = cursor.fetchone()
goalTimeArg = tools.toAscii_str(goalTimeArg)
# convert goal info to pretty string
rule += goalName + "("
for j in range(0, len(goalList)):
if j < (len(goalList) - 1):
rule += goalList[j] + ","
else:
rule += goalList[j] + ")"
if not goalTimeArg == "":
#rule += "@" + goalTimeArg + " :- "
sys.exit("ERROR: leftover timeArg in goal: " + rule + "@" +
goalTimeArg)
else:
rule += " :- "
# --------------------------------------------------------------- #
# SUBGOALS #
# get list of sids for the subgoals of this rule
cursor.execute("SELECT sid FROM Subgoals WHERE rid == '" + str(rid) +
"'") # get list of sids for this rule
subIDs = cursor.fetchall()
subIDs = tools.toAscii_list(subIDs)
# prioritize dom subgoals first.
subIDs = prioritizeDoms(rid, subIDs, cursor)
# prioritize negated subgoals last.
subIDs = prioritizeNegatedLast(rid, subIDs, cursor)
subTimeArg = None
# iterate over subgoal ids
for k in range(0, len(subIDs)):
newSubgoal = ""
s = subIDs[k]
# get subgoal name
cursor.execute("SELECT subgoalName FROM Subgoals WHERE rid == '" +
str(rid) + "' AND sid == '" + str(s) + "'")
subgoalName = cursor.fetchone()
if not subgoalName == None:
subgoalName = tools.toAscii_str(subgoalName)
if DUMPERS_C4_DEBUG:
print "subgoalName = " + subgoalName
# get subgoal attribute list
subAtts = cursor.execute(
"SELECT attName FROM SubgoalAtt WHERE rid == '" + rid +
"' AND sid == '" + s + "'")
subAtts = cursor.fetchall()
subAtts = tools.toAscii_list(subAtts)
# get subgoal time arg
cursor.execute(
"SELECT subgoalTimeArg FROM Subgoals WHERE rid == '" + rid +
"' AND sid == '" + s + "'")
subTimeArg = cursor.fetchone() # assume only one time arg
subTimeArg = tools.toAscii_str(subTimeArg)
#if goalName == "pre" and subgoalName == "bcast" :
# print "............................................"
# print dumpers.reconstructRule( rid, cursor )
# print "subgoalName = " + subgoalName
# print "subAtts = " + str( subAtts )
# print "subTimeArg = " + str( subTimeArg )
# tools.bp( __name__, inspect.stack()[0][3], "stuff" )
# get subgoal additional args
cursor.execute(
"SELECT argName FROM SubgoalAddArgs WHERE rid == '" + rid +
"' AND sid == '" + s + "'")
subAddArg = cursor.fetchone() # assume only one additional arg
if not subAddArg == None:
subAddArg = tools.toAscii_str(subAddArg)
subAddArg += " "
newSubgoal += subAddArg
# all subgoals have a name and open paren
newSubgoal += subgoalName + "("
# add in all attributes
for j in range(0, len(subAtts)):
currAtt = subAtts[j]
# replace SndTime in subgoal with subTimeArg, if applicable
if not subTimeArg == "" and "SndTime" in currAtt:
currAtt = str(subTimeArg)
if j < (len(subAtts) - 1):
newSubgoal += currAtt + ","
else:
newSubgoal += currAtt + ")"
# cap with a comma, if applicable
if k < len(subIDs) - 1:
newSubgoal += ","
rule += newSubgoal
# --------------------------------------------------------------- #
# EQUATIONS #
# get list of sids for the subgoals of this rule
cursor.execute(
"SELECT eid FROM Equation") # get list of eids for this rule
eqnIDs = cursor.fetchall()
eqnIDs = tools.toAscii_list(eqnIDs)
for e in range(0, len(eqnIDs)):
currEqnID = eqnIDs[e]
# get associated equation
if not currEqnID == None:
cursor.execute("SELECT eqn FROM Equation WHERE rid == '" + rid +
"' AND eid == '" + str(currEqnID) + "'")
eqn = cursor.fetchone()
if not eqn == None:
eqn = tools.toAscii_str(eqn)
# convert eqn info to pretty string
rule += "," + str(eqn)
# add SndTime eqn (only works for one subgoal time annotation)
#if not subTimeArg == None and not subTimeArg == "" :
# rule += ",SndTime==" + str( subTimeArg )
# --------------------------------------------------------------- #
rule += " ;" + "\n" # end all rules with a semicolon
# .................................. #
#if goalName == "pre" :
# tools.bp( __name__, inspect.stack()[0][3], "rule = " + rule )
# .................................. #
return rule
