def rewriteRewritten(cursor): if DEDALUSREWRITER_DEBUG: print " ... running rewritten rewrite ... " # grab all existing next rule ids rewrittenRuleIDs = getRewrittenRuleIDs(cursor) # check for bugs if DEDALUSREWRITER_DUMPS_DEBUG: print "rewrittenRuleIDs = " + str(rewrittenRuleIDs) for r in rewrittenRuleIDs: print "<><><><><><><><><><><><><><><>" print " DUMPING ASYNC RULES " print dumpers.reconstructRule(r, cursor) print "<><><><><><><><><><><><><><><>" # remove time arg from rule goals for rid in rewrittenRuleIDs: cursor.execute("UPDATE Rule SET goalTimeArg='' WHERE rid='" + rid + "'") # 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 ... "
def equivalent_rule_already_exists(orig_parent_rule, ruleMeta): logging.debug( " EQUIVALENT RULE ALREADY EXISTS : checking:\n " + \ dumpers.reconstructRule( orig_parent_rule.rid, orig_parent_rule.cursor ) ) for rule in ruleMeta: logging.debug( " EQUIVALENT RULE ALREADY EXISTS : against:\n " + \ dumpers.reconstructRule( rule.rid, rule.cursor ) ) if rule.relationName == orig_parent_rule.relationName and \ equivalent_subgoals( orig_parent_rule.relationName, \ rule.subgoalListOfDicts, \ orig_parent_rule.subgoalListOfDicts ) : logging.debug(" EQUIVALENT RULE ALREADY EXISTS : returning True.") return True logging.debug(" EQUIVALENT RULE ALREADY EXISTS : not a match.") logging.debug(" EQUIVALENT RULE ALREADY EXISTS : returning False.") return False
def get_final_fmla(ruleSet): logging.debug(" GET FINAL FMLA : running process...") logging.debug(" GET FINAL FMLA : ruleSet :") for r in ruleSet: logging.debug(" " + str(dumpers.reconstructRule(r.rid, r.cursor))) # collect the initial set of literals literal_id_lists = [] for rule_index in range(0, len(ruleSet)): rule = ruleSet[rule_index] this_literal_id_list = [] for sub_index in range(0, len(rule.subgoalListOfDicts)): this_literal = str(rule_index) + "_" + str(sub_index) if rule.subgoalListOfDicts[sub_index]["polarity"] == "notin": this_literal = "~" + this_literal this_literal_id_list.append(this_literal) literal_id_lists.append(this_literal_id_list) logging.debug(" GET FINAL FMLA : literal_id_lists = " + str(literal_id_lists)) # based on https://stackoverflow.com/a/798893 all_clause_combos = list(itertools.product(*literal_id_lists)) # flip literal polarities flipped_literal_id_lists = [] for clause in all_clause_combos: flipped_lits_clause = [] for lit in clause: if "~" in lit: lit = lit.replace("~", "") else: lit = "~" + lit flipped_lits_clause.append(lit) flipped_literal_id_lists.append(flipped_lits_clause) logging.debug( " GET FINAL FMLA : flipped_literal_id_lists = " + \ str( flipped_literal_id_lists ) ) # build final fmla final_fmla = "" for i in range(0, len(flipped_literal_id_lists)): clause = flipped_literal_id_lists[i] this_clause = "" for j in range(0, len(clause)): lit = clause[j] this_clause += lit if j < len(clause) - 1: this_clause += "&" this_clause = "(" + this_clause + ")" if i < len(flipped_literal_id_lists) - 1: this_clause += "|" final_fmla += this_clause return final_fmla
def get_unidom_facts( factMeta, \ parent_rule, \ target_ruleSet, \ ruleMeta, \ argDict, \ rid_to_rule_meta_map ) : logging.debug(" GET UNIDOM FACTS : parent_rule = " + c4_translator.get_c4_line(parent_rule.ruleData, "rule")) logging.debug(" GET UNIDOM FACTS : target_ruleSet :") for r in target_ruleSet: logging.debug(" " + c4_translator.get_c4_line(r.ruleData, "rule")) target_name = target_ruleSet[0].relationName # 0. get table list table_list = [] for rule in ruleMeta: if not rule.relationName in table_list: table_list.append(rule.relationName) for fact in factMeta: if not fact.relationName in table_list: table_list.append(fact.relationName) # 1. get sip bindings for this parent rule # and generate the domcomp for the target set. sip_bindings = get_sip_bindings( parent_rule, \ target_ruleSet, \ table_list, \ factMeta, \ ruleMeta, \ argDict ) target_domcomp = get_domcomp( target_ruleSet, \ table_list, \ factMeta, \ ruleMeta, \ argDict, \ rid_to_rule_meta_map ) logging.debug(" GET UNIDOM FACTS : target_domcomp :") for t in target_domcomp: logging.debug(" " + str(t)) #sys.exit( "blah" ) # 2. test each domcomp fact in a pilot program. # keep only the domcomp facts which make sense. COUNTER = 0 unidom_tups = [] for domcomp_tup in target_domcomp: # sanity check : make sure identical atts have identical bindings flag = False for rule in target_ruleSet: matches = {} for i in range(0, len(rule.ruleData["goalAttList"])): gatt = rule.ruleData["goalAttList"][i] val = domcomp_tup[i] if not gatt in matches: matches[gatt] = val elif gatt in matches and \ val == matches[ gatt ] : pass else: logging.debug( " binding doesn't make sense for rule '" + \ dumpers.reconstructRule( rule.rid, rule.cursor ) + "'" ) flag = True break if flag: continue # try the next domcomp tuple # 2a. build a pilot program using the domcomp tup. # observe target_domcomp also contains all the original program results. logging.debug(" domcomp_tup = " + str(domcomp_tup)) pilot_program, pilot_table_list = get_pilot_program( domcomp_tup, \ target_ruleSet, \ target_domcomp, \ factMeta, \ ruleMeta ) # 2b. run the pilot program to see if the value makes sense # => yields one of the sip bindings. parsedResults = run_program_c4([pilot_program, pilot_table_list], argDict) for tup in sip_bindings: if tup in parsedResults[target_ruleSet[0].relationName]: if not domcomp_tup in unidom_tups: logging.debug(" GET UNIDOM FACTS : COUNTER = " + str(COUNTER)) logging.debug( " GET UNIDOM FACTS : adding to unidom facts '" + str(domcomp_tup) + "'") unidom_tups.append(domcomp_tup) #if COUNTER == 8 and target_name == "link" : if COUNTER == 1081: print "len( target_domcomp ) = " + str(len(target_domcomp)) print "domcomp_tup = " + str(domcomp_tup) print "sip bindings :" for tup in sip_bindings: print tup print "++++++" print "parsed results for " + target_ruleSet[0].relationName + " :" for tup in parsedResults[target_ruleSet[0].relationName]: print tup print "unidom tups collection :" print len(unidom_tups) for t in unidom_tups: print t sys.exit("one of life's grander delusions.") COUNTER += 1 logging.debug(" GET UNIDOM FACTS : unidom_tups :") for t in unidom_tups: logging.debug(" " + str(t)) logging.debug(" GET UNIDOM FACTS : COUNTER == " + str(COUNTER)) #sys.exit( "lmao" ) # generate facts unidom_facts = [] for tup in unidom_tups: ufact = {} ufact["relationName"] = "unidom_not_" + target_name ufact["factTimeArg"] = "" ufact["dataList"] = [] for d in tup: if d.isdigit(): ufact["dataList"].append(d) elif "'" in d or '"' in d: ufact["dataList"].append(d) else: ufact["dataList"].append('"' + d + '"') fid = tools.getIDFromCounters("fid") new_fact = copy.deepcopy(Fact.Fact(fid, ufact, factMeta[0].cursor)) new_fact.cursor = factMeta[0].cursor unidom_facts.append(new_fact) return unidom_facts
def rewrite_to_datalog( argDict, factMeta, ruleMeta, cursor ) : logging.debug( " REWRITE : running process..." ) settings_path = argDict[ "settings" ] EOT = argDict[ "EOT" ] for rule in ruleMeta : rid = rule.rid cursor.execute( "SELECT attID,attName FROM GoalAtt WHERE rid=='" + str( rid ) + "'" ) goal_atts = cursor.fetchall() logging.debug( " DEDT : len( goal_atts ) = " + str( len( goal_atts )) ) goal_atts = tools.toAscii_multiList( goal_atts ) logging.debug( " DEDT : len( goal_atts ) = " + str( len( goal_atts )) ) logging.debug( " DEDT : goal_atts (0) = " + str( goal_atts ) ) logging.debug( " DEDT : r = " + dumpers.reconstructRule( rid, cursor ) ) # ----------------------------------------------------------------------------- # # dedalus rewrite logging.debug( " REWRITE : calling dedalus rewrites..." ) allMeta = dedalusRewriter.rewriteDedalus( argDict, factMeta, ruleMeta, cursor ) factMeta = allMeta[0] ruleMeta = allMeta[1] # be sure to fill in all the type info for the new rule definitions #setTypes.setTypes( cursor, argDict, ruleMeta ) for rule in ruleMeta : rid = rule.rid cursor.execute( "SELECT attID,attName FROM GoalAtt WHERE rid=='" + str( rid ) + "'" ) goal_atts = cursor.fetchall() goal_atts = tools.toAscii_multiList( goal_atts ) #logging.debug( " DEDT : goal_atts (1) = " + str( goal_atts ) ) logging.debug( " DEDT : rule.ruleData = " + str( rule.ruleData ) ) # ----------------------------------------------------------------------------- # # other rewrites # first get parameters for which rewrites to run. # ========== WILDCARD ========== # try : rewriteWildcards = tools.getConfig( settings_path, "DEFAULT", "WILDCARD_REWRITES", bool ) except ConfigParser.NoOptionError : logging.warning( "WARNING : no 'WILDCARD_REWRITES' defined in 'DEFAULT' section of " + settings_path + \ "...running without wildcard rewrites." ) rewriteWildcards = False pass # ========== DM ========== # try : RUN_DM = tools.getConfig( settings_path, "DEFAULT", "DM", bool ) except ConfigParser.NoOptionError : logging.warning( "WARNING : no 'DM' defined in 'DEFAULT' section of " + settings_path + \ "...running without dm rewrites" ) RUN_DM = False pass # ========== NW_DOM_DEF ========== # try : NW_DOM_DEF = tools.getConfig( settings_path, "DEFAULT", "NW_DOM_DEF", str ) except ConfigParser.NoOptionError : raise Exception( "no 'NW_DOM_DEF' defined in 'DEFAULT' section of " + settings_path + \ ". aborting..." ) # ========== COMBO ========== # try: RUN_COMB = tools.getConfig( settings_path, "DEFAULT", "COMB", bool ) except ConfigParser.NoOptionError : logging.info( "WARNING : no 'COMB' defined in 'DEFAULT' section of " + settings_path + \ "...running without combo rewrites" ) RUN_COMB = False pass # ========== IEDB ========== # try : RUN_IEDB_REWRITES = tools.getConfig( settings_path, "DEFAULT", "IEDB_REWRITES", bool ) except ConfigParser.NoOptionError : logging.info( "WARNING : no 'IEDB_REWRITES' defined in 'DEFAULT' section of " + settings_path + \ "...running without iedb rewrites" ) RUN_IEDB_REWRITES = False pass # ----------------------------------------------------------------------------- # # do wildcard rewrites # always do wildcard rewrites in prep for negative writes. if rewriteWildcards or \ ( NW_DOM_DEF == "sip" and \ ( argDict[ "neg_writes" ] == "dm" or \ argDict[ "neg_writes" ] == "combo" ) ) : logging.debug( " REWRITE : calling wildcard rewrites..." ) ruleMeta = rewrite_wildcards.rewrite_wildcards( ruleMeta, cursor ) # for rule in ruleMeta : # #logging.debug( "rule.ruleData = " + str( rule.ruleData ) ) # logging.debug( " REWRITE : (1) r = " + dumpers.reconstructRule( rule.rid, rule.cursor ) ) # #sys.exit( "blah2" ) # for rule in ruleMeta : # logging.debug( " DEDT : rule.ruleData (2) = " + str( rule.ruleData ) ) # be sure to fill in all the type info for the new rule definitions logging.debug( " REWRITE : running setTypes after wildcard rewrites." ) setTypes.setTypes( cursor, argDict, ruleMeta ) update_goal_types( ruleMeta ) else : setTypes.setTypes( cursor, argDict, ruleMeta ) # ----------------------------------------------------------------------------- # # iedb rewrites if RUN_IEDB_REWRITES or \ ( NW_DOM_DEF == "sip" and \ ( argDict[ "neg_writes" ] == "dm" or \ argDict[ "neg_writes" ] == "combo" ) ) : logging.debug( " REWRITE : calling iedb rewrites..." ) factMeta, ruleMeta = iedb_rewrites.iedb_rewrites( factMeta, \ ruleMeta, \ cursor, \ settings_path ) # for rule in ruleMeta : # rid = rule.rid # cursor.execute( "SELECT attID,attName FROM GoalAtt WHERE rid=='" + str( rid ) + "'" ) # goal_atts = cursor.fetchall() # goal_atts = tools.toAscii_multiList( goal_atts ) # logging.debug( " DEDT : goal_atts (3) = " + str( goal_atts ) ) #for rule in ruleMeta : # print c4_translator.get_c4_line( rule.ruleData, "rule" ) #for fact in factMeta : # print c4_translator.get_c4_line( fact.factData, "fact" ) #sys.exit( "asdf" ) # be sure to fill in all the type info for the new rule definitions logging.debug( " REWRITE : running setTypes after iedb rewrites." ) setTypes.setTypes( cursor, argDict, ruleMeta ) # ----------------------------------------------------------------------------- # # do dm rewrites if argDict[ "neg_writes" ] == "dm" : logging.debug( " REWRITE : calling dm rewrites..." ) factMeta, ruleMeta = dm.dm( factMeta, ruleMeta, cursor, argDict ) # returns new ruleMeta logging.debug( " REWRITE : final dm program lines:" ) for rule in ruleMeta : logging.debug( dumpers.reconstructRule( rule.rid, rule.cursor ) ) #sys.exit( "blah" ) # be sure to fill in all the type info for the new rule definitions logging.debug( " REWRITE : running setTypes after dm rewrites." ) setTypes.setTypes( cursor, argDict, ruleMeta ) # ----------------------------------------------------------------------------- # # do combo rewrites if argDict[ "neg_writes" ] == "comb" : # collect the results from the original program original_prog = c4_translator.c4datalog( argDict, cursor ) results_array = c4_evaluator.runC4_wrapper( original_prog, argDict ) parsedResults = tools.getEvalResults_dict_c4( results_array ) # run the neg rewrite for combinatorial approach # returns a new ruleMeta logging.debug( " REWRITE : calling combo rewrites..." ) ruleMeta, factMeta = combitorialNegRewriter.neg_rewrite( cursor, \ argDict, \ settings_path, ruleMeta, \ factMeta, \ parsedResults ) if argDict[ "neg_writes" ] == "combo" : logging.debug( " REWRITE : calling combo rewrites..." ) factMeta, ruleMeta = combo.combo( factMeta, ruleMeta, cursor, argDict ) #for r in ruleMeta : # print dumpers.reconstructRule( r.rid, r.cursor ) #sys.exit( "f**k" ) # for rule in ruleMeta : # rid = rule.rid # cursor.execute( "SELECT attID,attName FROM GoalAtt WHERE rid=='" + str( rid ) + "'" ) # goal_atts = cursor.fetchall() # goal_atts = tools.toAscii_multiList( goal_atts ) # logging.debug( " DEDT : goal_atts (2) = " + str( goal_atts ) ) # ----------------------------------------------------------------------------- # # provenance rewrites #logging.debug( " REWRITE : before prov dump :" ) #for rule in ruleMeta : # print rule # logging.debug( " REWRITE : (0) r = " + printRuleWithTypes( rule.rid, cursor ) ) #sys.exit( "blah2" ) # add the provenance rules to the existing rule set logging.debug( " REWRITE : calling provenance rewrites..." ) ruleMeta.extend( provenanceRewriter.rewriteProvenance( ruleMeta, cursor, argDict ) ) #for rule in ruleMeta : # #logging.debug( "rule.ruleData = " + str( rule.ruleData ) ) # logging.debug( " REWRITE : (1) rid = " + str( rule.rid ) + " : " + dumpers.reconstructRule( rule.rid, rule.cursor ) ) #sys.exit( "blah2" ) # be sure to fill in all the type info for the new rule definitions logging.debug( " REWRITE : running setTypes after provenance rewrites." ) setTypes.setTypes( cursor, argDict, ruleMeta ) # ----------------------------------------------------------------------------- # # for rule in ruleMeta : # logging.debug( "rule.ruleData = " + str( rule.ruleData ) ) # logging.debug( " REWRITE : (2) r = " + dumpers.reconstructRule( rule.rid, rule.cursor ) ) # sys.exit( "blah2" ) logging.debug( " REWRITE : ...done." ) return [ factMeta, ruleMeta ]
def resolveDoubleNegations(ruleMeta): for rule in ruleMeta: # ----------------------------------------- # # get subgoal info subgoalListOfDicts = copy.deepcopy(rule.subgoalListOfDicts) new_subgoalListOfDicts = [] for subgoal in subgoalListOfDicts: logging.debug( " RESOLVE DOUBLE NEGATIONS : subgoalName = " + \ subgoal[ "subgoalName" ] ) logging.debug( " RESOLVE DOUBLE NEGATIONS : polarity = " + \ subgoal[ "polarity" ] ) logging.debug( " RESOLVE DOUBLE NEGATIONS : subgoalAttList = " + \ str( subgoal[ "subgoalAttList" ] ) ) logging.debug( " RESOLVE DOUBLE NEGATIONS : subgoalTimeArg = " + \ subgoal[ "subgoalTimeArg" ] ) # ----------------------------------------- # # resolve double negatives if subgoal["subgoalName"].startswith( "not_") and subgoal["polarity"] == "notin": logging.debug( " RESOLVE DOUBLE NEGATIONS : hit a double neg for rule:") logging.debug(" " + dumpers.reconstructRule(rule.rid, rule.cursor)) logging.debug( " RESOLVE DOUBLE NEGATIONS : original subgoal = " + str(subgoal)) # based on https://stackoverflow.com/a/14496084 double_neg_sub_name = subgoal["subgoalName"] double_neg_sub_name = double_neg_sub_name[ 4:] # remove the first not last_f = double_neg_sub_name.rfind("_f") orig_sub_name = double_neg_sub_name[:last_f] logging.debug( " RESOLVE DOUBLE NEGATIONS : double_neg_sub_name = " + str(double_neg_sub_name)) logging.debug( " RESOLVE DOUBLE NEGATIONS : orig_sub_name = " + str(orig_sub_name)) new_sub_dict = {} new_sub_dict["subgoalName"] = orig_sub_name new_sub_dict["subgoalAttList"] = subgoal["subgoalAttList"] new_sub_dict["polarity"] = "" new_sub_dict["subgoalTimeArg"] = subgoal["subgoalTimeArg"] logging.debug( " RESOLVE DOUBLE NEGATIONS : new_sub_dict = " + \ str( new_sub_dict ) ) logging.debug( " RESOLVE DOUBLE NEGATIONS : adding to new_subgoalListOfDicts : " + \ str( new_sub_dict ) + "->1") new_subgoalListOfDicts.append(copy.deepcopy(new_sub_dict)) else: logging.debug( " RESOLVE DOUBLE NEGATIONS : adding to new_subgoalListOfDicts : " + \ str( subgoal ) + " -> 3" ) new_subgoalListOfDicts.append(copy.deepcopy(subgoal)) # ----------------------------------------- # # save new subgoal list logging.debug( " RESOLVE DOUBLE NEGATIONS : new_subgoalListOfDicts = " + \ str( new_subgoalListOfDicts ) ) rule.subgoalListOfDicts = copy.deepcopy(new_subgoalListOfDicts) rule.ruleData["subgoalListOfDicts"] = copy.deepcopy( new_subgoalListOfDicts) rule.saveSubgoals() logging.debug(" RESOLVE DOUBLE NEGATIONS : new rule :") logging.debug(" " + dumpers.reconstructRule(rule.rid, rule.cursor)) return ruleMeta
def get_dom_rules( orig_name, \ not_name, \ orig_rid, \ parent_rid, \ rid_to_rule_meta_map, \ ruleMeta, \ cursor, \ argDict ) : newRules = [] # ----------------------------------------- # # get parameters settings_path = argDict["settings"] # ========== POST EOT FILTER ========== # try: POST_EOT_FILTER = tools.getConfig(settings_path, "DEFAULT", "POST_EOT_FILTER", bool) except ConfigParser.NoOptionError: POST_EOT_FILTER = False logging.warning( "WARNING : no 'POST_EOT_FILTER' defined in 'DEFAULT' section of " + \ "settings.ini ...running with POST_EOT_FILTER=False." ) # ----------------------------------------- # # ----------------------------------------- # logging.debug("=====================================================") logging.debug(" GET DOM RULES : orig_name = " + orig_name) logging.debug(" GET DOM RULES : not_name = " + not_name) logging.debug(" GET DOM RULES : orig_rid = " + str(orig_rid)) logging.debug(" GET DOM RULES : parent_rid = " + str(parent_rid)) logging.debug(" GET DOM RULES : parent rule : ") logging.debug(" " + dumpers.reconstructRule(parent_rid, cursor)) # ------------------------------------------ # # gather subgoal atts negated_subgoal_atts = get_negated_subgoal_atts(orig_name, parent_rid, ruleMeta) logging.debug(" GET DOM RULES : negated_subgoal_atts = " + str(negated_subgoal_atts)) # ------------------------------------------ # # map parent goal indexes to atts for # eval data extraction parent_goal_att_to_index_map, parent_goal_att_list = get_goal_att_to_index_map( parent_rid, ruleMeta) logging.debug(" GET DOM RULES : parent_goal_att_to_index_map = " + str(parent_goal_att_to_index_map)) # ------------------------------------------ # # generate sip domain idbs # [ { subgoalName : 'subgoalNameStr', # subgoalAttList : [ data1, ... , dataN ], # polarity : 'notin' OR '', # subgoalTimeArg : <anInteger> }, ... ] # ------------------------------------------ # # build the universal domain rule uni_ruleData = {} # get relation name uni_ruleData["relationName"] = "unidom_" + not_name # check if a rule already exists # to prevent duplicates. if idb_already_exists(uni_ruleData["relationName"], cursor): return newRules #get goal atts uni_ruleData[ "goalAttList" ] = [ "A" + str(i) \ for i in \ range( 0, len( negated_subgoal_atts[0] ) ) ] # just need one for arity # map domain atts to negated subgoal atts # eg. [ [ X, Y ], [ Y, Q ] ] # => dom_thing( A0, A1 ) <- ... # => { A0: [ X, Y ], A1: [ Y, Q ] } # initialize maps to empty lists. uni_dom_atts_to_par_atts_map = { "A" + str( i ) : [] \ for i in range( 0, \ len( uni_ruleData[ "goalAttList" ] ) ) } for neg_sub_atts in negated_subgoal_atts: for i in range(0, len(neg_sub_atts)): sub_att = neg_sub_atts[i] uni_dom_atts_to_par_atts_map["A" + str(i)].append(sub_att) logging.debug(" GET DOM RULES : uni_dom_atts_to_par_atts_map = " + str(uni_dom_atts_to_par_atts_map)) logging.debug(" GET DOM RULES : ----------------------------------------") logging.debug(" GET DOM RULES : relationName = " + uni_ruleData["relationName"]) logging.debug(" GET DOM RULES : goalAttList = " + str(uni_ruleData["goalAttList"])) logging.debug(" GET DOM RULES : negated_subgoal_atts = " + str(negated_subgoal_atts)) # get goal time arg uni_ruleData["goalTimeArg"] = "" # get eqn dict uni_ruleData["eqnDict"] = {} # =================================== # # get subgoal list of dicts # unidom rules encompass the subset of all tuples in the complenent of the # rule targetted for the DM rewrite which help generate data in the parent rule. # accordingly, copy over the contents of the parent rule and project the # attributes for the targeted subgoal(s). # constrain any remaining free goal variables with the actual contents of the # positive definition of the targetted rule. # 1. copy and edit over the list of parent subgoals parent_rule_meta = rid_to_rule_meta_map[parent_rid] uni_subgoalListOfDicts = copy.deepcopy(parent_rule_meta.subgoalListOfDicts) # replace subgoal references to the orig_ versions of the rule. for i in range(0, len(uni_subgoalListOfDicts)): if nw_tools.is_idb( uni_subgoalListOfDicts[ i ][ "subgoalName" ], ruleMeta ) and \ not uni_subgoalListOfDicts[ i ][ "subgoalName" ].startswith( "not_" ) and \ not uni_subgoalListOfDicts[ i ][ "subgoalName" ].startswith( "orig_" ) and \ not uni_subgoalListOfDicts[ i ][ "subgoalName" ].startswith( "unidom_" ) and \ not uni_subgoalListOfDicts[ i ][ "subgoalName" ].startswith( "exidom_" ) : uni_subgoalListOfDicts[ i ][ "subgoalName" ] = "orig_" + \ uni_subgoalListOfDicts[ i ][ "subgoalName" ] # replace atts in the parent subgoals with the goal atts # for the unidom rule. for gatt in uni_dom_atts_to_par_atts_map: these_par_atts = uni_dom_atts_to_par_atts_map[gatt] # iterate over parent subgoals for i in range(0, len(uni_subgoalListOfDicts)): sub = uni_subgoalListOfDicts[i] # iterate over the parent subgoal atts for j in range(0, len(sub["subgoalAttList"])): sub_att = sub["subgoalAttList"][j] # make the replacement if the parent sub att appears # in the atts corresponding to the unidom goal att # under consideration. if sub_att in these_par_atts: uni_subgoalListOfDicts[i]["subgoalAttList"][j] = gatt logging.debug(" GET DOM RULES : subgoalListOfDicts = " + str(uni_subgoalListOfDicts)) # 2. integrate a reference to the original version of the targetted rule to fill # in any missing attributes. all_body_atts = [] for sub in uni_subgoalListOfDicts: if sub["polarity"] == "": for satt in sub["subgoalAttList"]: if not satt in all_body_atts: all_body_atts.append(satt) missing_gatts = [] for gatt in uni_dom_atts_to_par_atts_map: if not gatt in all_body_atts: missing_gatts.append(gatt) # print "uni_dom_atts_to_par_atts_map = " + str( uni_dom_atts_to_par_atts_map ) # print "all_body_atts = " + str( all_body_atts ) # print "missing_gatts = " + str( missing_gatts ) # # if uni_ruleData[ "relationName" ] == "unidom_not_node_f23" : # sys.exit( "blah" ) if len(missing_gatts) > 0: orig_sub = {} orig_sub["subgoalName"] = orig_name orig_sub["subgoalTimeArg"] = "" orig_sub["polarity"] = "" orig_sub["subgoalAttList"] = [] for i in range(0, len(uni_dom_atts_to_par_atts_map)): if "A" + str(i) in missing_gatts: orig_sub["subgoalAttList"].append("A" + str(i)) else: orig_sub["subgoalAttList"].append("_") uni_subgoalListOfDicts.append(orig_sub) uni_ruleData["subgoalListOfDicts"] = uni_subgoalListOfDicts # =================================== # # save rule # replace time arg with constant if the negated subgoal stems from post if POST_EOT_FILTER and parent_name == "post": uni_ruleData["goalAttList"][-1] = argDict["EOT"] uni_rid = tools.getIDFromCounters("rid") uni_rule = copy.deepcopy(Rule.Rule(uni_rid, uni_ruleData, cursor)) uni_rule.cursor = cursor # need to do this for some reason or else cursor disappears? # set the unidom rule types manually uni_goal_types = [] for rule in ruleMeta: if rule.rid == orig_rid: uni_goal_types = rule.goal_att_type_list assert (len(uni_goal_types) > 0) uni_rule.goal_att_type_list = uni_goal_types uni_rule.manually_set_types() # check if a rule already exists # to prevent duplicates. if not nw_tools.identical_rule_already_exists(uni_rule, ruleMeta): newRules.append(uni_rule) logging.debug( " GET DOM RULES : added uni dom rule :\n " + \ dumpers.reconstructRule( uni_rule.rid, uni_rule.cursor ) ) else: logging.debug( " GET DOM RULES : NOT adding uni dom rule :\n " + \ dumpers.reconstructRule( uni_rule.rid, uni_rule.cursor ) ) # if uni_rule.relationName == "unidom_not_node_f40" : # print orig_name # print not_name # print dumpers.reconstructRule( parent_rid, uni_rule.cursor ) # print dumpers.reconstructRule( uni_rule.rid, uni_rule.cursor ) # sys.exit( "blah" ) # ------------------------------------------ # # build the existential domain rule # exidom_ encompasses the set of data from the original version # of the target rule which contributes to generating data in # the original version of the target relation. # accordingly, one exidom_ rule exists per rule in the definition. # get the list of rules defining the target relation target_rules = [] for rule in ruleMeta: if rule.relationName == "orig_" + orig_name: target_rules.append(rule) for target_rule in target_rules: exi_ruleData = {} # get relation name # need the extra _f to maintain arities. exi_ruleData["relationName"] = "exidom_" + not_name + "_f" + str( target_rule.rid) # grab all existential vars from the original definition for the # target relation. all_exi_vars = [] for sub in target_rule.subgoalListOfDicts: for satt in sub["subgoalAttList"]: if not satt in target_rule.goalAttList and \ not satt in all_exi_vars and \ not satt == "_" : all_exi_vars.append(satt) # only write an exidom_ rule if existential vars exist. if len(all_exi_vars) > 0: #get goal atts exi_ruleData["goalAttList"] = copy.deepcopy(all_exi_vars) # get goal time arg exi_ruleData["goalTimeArg"] = "" # get eqn dict exi_ruleData["eqnDict"] = {} # =================================== # # get subgoals exi_subgoalListOfDicts = copy.deepcopy( target_rule.subgoalListOfDicts) for i in range(0, len(exi_subgoalListOfDicts)): sub = exi_subgoalListOfDicts[i] if not sub[ "subgoalName" ].startswith( "orig_" ) and \ not sub[ "subgoalName" ] == "clock" and \ not sub[ "subgoalName" ] == "next_clock" and \ not sub[ "subgoalName" ] == "crash" and \ not sub[ "subgoalName" ].startswith( "not_" ) and \ not sub[ "subgoalName" ].startswith( "unidom_" ) and \ not sub[ "subgoalName" ].startswith( "exidom_" ) and \ nw_tools.is_idb( sub[ "subgoalName" ], ruleMeta ) : exi_subgoalListOfDicts[i][ "subgoalName"] = "orig_" + sub["subgoalName"] exi_ruleData["subgoalListOfDicts"] = exi_subgoalListOfDicts # =================================== # # save rule exi_rid = tools.getIDFromCounters("rid") exi_rule = copy.deepcopy(Rule.Rule(exi_rid, exi_ruleData, cursor)) exi_rule.cursor = cursor # need to do this for some reason or else cursor disappears? # set the unidom rule types manually exi_goal_types = [] for gatt in exi_rule.goalAttList: for sub in exi_subgoalListOfDicts: if gatt in sub["subgoalAttList"]: gatt_index = sub["subgoalAttList"].index(gatt) for rule in ruleMeta: if rule.relationName == sub["subgoalName"]: exi_goal_types.append( rule.goal_att_type_list[gatt_index]) assert (len(uni_goal_types) > 0) exi_rule.goal_att_type_list = exi_goal_types exi_rule.manually_set_types() # check if a rule already exists # to prevent duplicates. if not nw_tools.identical_rule_already_exists(exi_rule, cursor): newRules.append(exi_rule) logging.debug( " GET DOM RULES : added exi dom rule :\n " + \ dumpers.reconstructRule( exi_rule.rid, exi_rule.cursor ) ) else: logging.debug( " GET DOM RULES : NOT adding exi dom rule :\n " + \ dumpers.reconstructRule( exi_rule.rid, exi_rule.cursor ) ) logging.debug(" GET DOM RULES : domain rules:") for rule in newRules: logging.debug(" " + dumpers.reconstructRule(rule.rid, rule.cursor)) #if uni_ruleData[ "relationName" ] == "unidom_not_node_f23" : # for rule in newRules : # print dumpers.reconstructRule( rule.rid, rule.cursor ) # sys.exit( "blah" ) return newRules
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 dm_time_att_replacement(ruleMeta, cursor, argDict): logging.debug(" DM TIME ATT REPLACEMENT : running process...") replacement_time_att = "MRESERVED" target_rule_sets = getRuleMetaSets(ruleMeta, cursor) for ruleSet in target_rule_sets: logging.debug("..........") for rule in ruleSet: logging.debug(rule.relationName + ", " + str(rule.goalAttList) + ", " + str(rule.hitUniformityRewrites)) #sys.exit( "blah" ) # replace the time att for ruleSet in target_rule_sets: for rule in ruleSet: if rule.hitUniformityRewrites == True: target_att = rule.goalAttList[-1] # save new goal attribute list rule.ruleData["goalAttList"] = rule.goalAttList[:-1] + [ replacement_time_att ] rule.goalAttList = rule.goalAttList[:-1] + [ replacement_time_att ] rule.saveToGoalAtt() new_subgoalListOfDicts = [] for sub in rule.ruleData["subgoalListOfDicts"]: subgoalAttList = sub["subgoalAttList"] new_subgoalAttList = [] for satt in subgoalAttList: if satt == target_att: new_subgoalAttList.append(replacement_time_att) else: new_subgoalAttList.append(satt) new_sub_dict = {} new_sub_dict["subgoalName"] = sub["subgoalName"] new_sub_dict["subgoalAttList"] = new_subgoalAttList new_sub_dict["polarity"] = sub["polarity"] new_sub_dict["subgoalTimeArg"] = sub["subgoalTimeArg"] new_subgoalListOfDicts.append(new_sub_dict) # save new subgoals rule.ruleData["subgoalListOfDicts"] = new_subgoalListOfDicts rule.subgoalListOfDicts = new_subgoalListOfDicts rule.saveSubgoals() for rule in ruleMeta: logging.debug(dumpers.reconstructRule(rule.rid, cursor)) #sys.exit( "blah" ) logging.debug(" DM TIME ATT REPLACEMENT : ...done.") return ruleMeta
def do_combo_sip( factMeta, \ ruleMeta, \ targetRuleMetaSets, \ not_templates, \ rid_to_rule_meta_map, \ cursor, \ argDict ) : logging.debug(" DO COMBO SIP : running process...") #for r in targetRuleMetaSets : # print r #for r in ruleMeta : # print c4_translator.get_c4_line( r.ruleData, "rule" ) #sys.exit( "asdf" ) COUNTER = 0 for rule_info in targetRuleMetaSets: logging.debug(" DO COMBO SIP : >COUNTER = " + str(COUNTER)) parent_list = rule_info[0] ruleSet = rule_info[1] # 0. pull the template not_ rules. target_name = ruleSet[0].relationName #target_not_template = copy.deepcopy( not_templates[ target_name ] ) if not previously_pulled(target_name, ruleMeta): target_not_template = copy.deepcopy(not_templates[target_name]) else: target_not_template = [] logging.debug("//////////////////////////////////////////////////") logging.debug(" DO COMBO SIP : parent_list : " + str(parent_list)) logging.debug(" DO COMBO SIP : ruleSet:") for rule in ruleSet: logging.debug(" " + dumpers.reconstructRule(rule.rid, rule.cursor)) logging.debug(" DO COMBO SIP : target_name : " + target_name) logging.debug(" DO COMBO SIP : target_not_template : ") for t in target_not_template: logging.debug(" " + c4_translator.get_c4_line(t, "rule")) logging.debug("//////////////////////////////////////////////////") # Augment the unidom rules for this relation using the parent information. for curr_parent in parent_list: parent_name = curr_parent[0] parent_rid = curr_parent[1] parent_rule = rid_to_rule_meta_map[parent_rid] # don't build unidom references for recursive rules. if parent_name == "not_" + ruleSet[0].relationName: pass elif parent_name == "not_post": pass else: # 2. build and save unidom facts derived using bindings from parent rules. unidom_facts = sip.get_unidom_facts( factMeta, \ parent_rule, \ ruleSet, \ ruleMeta, \ argDict, \ rid_to_rule_meta_map ) factMeta.extend(unidom_facts) #if parent_list == [['post',2]] : # print COUNTER # sys.exit( "here" ) # 3. add the parent-specific unidom subgoal to the template not_ rule. #if COUNTER == 0 : # why this??? if True: for ruleData in target_not_template: uni_sub = {} uni_sub["subgoalName"] = unidom_facts[0].relationName uni_sub["subgoalAttList"] = ruleData["goalAttList"] uni_sub["polarity"] = "" uni_sub["subgoalTimeArg"] = "" ruleData["subgoalListOfDicts"].append(uni_sub) # add rule to ruleMeta rid = tools.getIDFromCounters("rid") newRule = copy.deepcopy( Rule.Rule(rid, ruleData, cursor)) newRule.cursor = cursor newRule.goal_att_type_list = copy.deepcopy( ruleSet[0].goal_att_type_list) newRule.manually_set_types() logging.debug( " DO COMBO SIP : adding rule '" + \ c4_translator.get_c4_line( newRule.ruleData, "rule" ) + "'" ) ruleMeta.append(newRule) # 4. make not_ subgoal replacements in parent rules. flag = False for i in range(0, len(parent_rule.subgoalListOfDicts)): sub = parent_rule.subgoalListOfDicts[i] if sub[ "subgoalName" ] == ruleSet[0].relationName and \ sub[ "polarity" ] == "notin" : parent_rule.subgoalListOfDicts[i][ "subgoalName"] = "not_" + ruleSet[0].relationName parent_rule.subgoalListOfDicts[i]["polarity"] = "" flag = True if flag: parent_rule.saveSubgoals() #if parent_list == [['post', 2]] : # for rule in ruleMeta : # print c4_translator.get_c4_line( rule.ruleData, "rule" ) # for fact in factMeta : # print c4_translator.get_c4_line( fact.factData, "fact" ) # sys.exit( "lmao" ) COUNTER += 1 # ----------------------------------------- # # order recursive rules last ruleMeta = nw_tools.sortDMRules(ruleMeta) # if ruleSet[0].relationName == "link" : # for r in ruleMeta : # print dumpers.reconstructRule( r.rid, r.cursor ) # #print c4_translator.get_c4_line( r.ruleData, "rule" ) # sys.exit( "blah" ) logging.debug(" DO COMBO SIP : ...done.") return ruleMeta
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 doDeMorgans_sip_idb( factMeta, \ ruleMeta, \ targetRuleMetaSets, \ rid_to_rule_meta_map, \ cursor, \ argDict ) : logging.debug(" DO DEMORGANS SIP IDB : running process...") newDMRules = [] COUNTER = 0 for rule_info in targetRuleMetaSets: parent_list = rule_info[0] ruleSet = rule_info[1] for rule in ruleSet: logging.debug("//////////////////////////////////////////////////") logging.debug(" DO DEMORGANS SIP IDB : parent_list: " + str(parent_list)) logging.debug(" DO DEMORGANS SIP ODB : ruleSet:") logging.debug(" " + dumpers.reconstructRule(rule.rid, rule.cursor)) logging.debug("//////////////////////////////////////////////////") # ----------------------------------------- # # get an original rule id to reference types orig_rid = ruleSet[0].rid # ----------------------------------------- # # get new rule name orig_name = ruleSet[0].relationName # ----------------------------------------- # # get new rule goal attribute list # works only if goal att lists are uniform # across all rules per set goalAttList = ruleSet[0].ruleData["goalAttList"] # ----------------------------------------- # # get new rule goal time arg goalTimeArg = "" # ----------------------------------------- # # get current results #parsedResults = get_current_results( argDict, cursor ) #logging.debug( " DO DEMORGANS SIP IDB : done running eval." ) # ----------------------------------------- # final_fmla = nw_tools.get_final_fmla(ruleSet) # ----------------------------------------- # # get the lists of all strings and ints #all_strings = get_all_strings( factMeta ) #all_ints = get_all_ints( factMeta, cursor ) # ----------------------------------------- # # need a new set of dm rules for every instance of a particular # negated subgoal for curr_parent in parent_list: parent_name = curr_parent[0] parent_rid = curr_parent[1] logging.debug(" DO DEMORGANS SIP IDB : parent rule:") logging.debug(" " + dumpers.reconstructRule(parent_rid, cursor)) not_name = "not_" + orig_name + "_f" + str(parent_rid) # ----------------------------------------- # # build the domain subgoal info # returns a subgoal dict #uni_dom_sub = build_uni( not_name, goalAttList ) # returns a subgoal dict #exi_dom_sub = build_exi( orig_name, not_name, goalAttList, ruleMeta ) # ----------------------------------------- # # get the domain rules dom_rules = sip_idb.get_dom_rules( orig_name, \ not_name, \ orig_rid, \ parent_rid, \ rid_to_rule_meta_map, \ ruleMeta, \ cursor, \ argDict ) ruleMeta.extend(dom_rules) # ----------------------------------------- # # each clause in the final dnf fmla # informs the subgoal list of a new # datalog rule newDMRules = dnfToDatalog( orig_name, \ not_name, \ goalAttList, \ goalTimeArg, \ final_fmla, \ ruleSet, \ ruleMeta, \ parent_name, \ parent_rid, \ rid_to_rule_meta_map, \ cursor, \ argDict ) # ----------------------------------------- # # add new dm rules to the rule meta ruleMeta.extend(newDMRules) # ----------------------------------------- # # replace instances of the negated subgoal # with instances of the positive not_ # subgoal ruleMeta = sip_idb.replaceSubgoalNegations( orig_name, \ not_name, \ parent_rid, \ ruleMeta ) # ----------------------------------------- # # resolve double negations ruleMeta = sip_idb.resolveDoubleNegations(ruleMeta) # ----------------------------------------- # # order recursive rules last ruleMeta = nw_tools.sortDMRules(ruleMeta) COUNTER += 1 return ruleMeta
def dnfToDatalog( orig_name, \ not_name, \ goalAttList, \ goalTimeArg, \ final_fmla, \ ruleSet, \ ruleMeta, \ parent_name, \ parent_rid, \ rid_to_rule_meta_map, \ cursor, \ argDict ) : settings_path = argDict["settings"] logging.debug(" DNF TO DATALOG : running process...") logging.debug(" DNF TO DATALOG : not_name = " + not_name) logging.debug(" DNF TO DATALOG : goalAttList = " + str(goalAttList)) logging.debug(" DNF TO DATALOG : goalTimeArg = " + goalTimeArg) logging.debug(" DNF TO DATALOG : final_fmla = " + final_fmla) # get goal types goal_types = ruleSet[ 0].goal_att_type_list # just pick any rule in the set. logging.debug(" DNF TO DATALOG : ruleSet :") for r in ruleSet: logging.debug(" " + str(dumpers.reconstructRule(r.rid, r.cursor))) # ----------------------------------------- # # generate combined equation list # collect eqns from all rules and append to # all dm rules. eqnDict_combined = {} for rule in ruleSet: for eqn in rule.eqnDict: eqnDict_combined[eqn] = rule.eqnDict[eqn] # ----------------------------------------- # # break positive dnf fmla into a set of # conjuncted clauses clauseList = final_fmla.replace("(", "") # valid b/c dnf clauseList = clauseList.replace(")", "") # valid b/c dnf clauseList = clauseList.split("|") logging.debug(" DNF TO DATALOG : clauseList = " + str(clauseList)) # ----------------------------------------- # # iterate over clause list to create # the list of new dm rules # create one new dm rule per clause newDMRules = [] for clause in clauseList: subgoalListOfDicts = [] # ----------------------------------------- # # get list of subgoal literals subgoalLiterals = clause.split("&") logging.debug(" DNF TO DATALOG : subgoalLiterals = " + str(subgoalLiterals)) # ----------------------------------------- # # iterate over the subgoal literals # observe the first integer represents the # index of the parent target rule in the # rule meta list of _targetted_ rule objects # the second integer represents the index # of the associated subgoal in the current # targetted rule for literal in subgoalLiterals: logging.debug(" DNF TO DATALOG : literal = " + literal) # ----------------------------------------- # # get subgoal polarity if "~" in literal: polarity = "notin" literal = literal.replace("~", "") else: polarity = "" # ----------------------------------------- # # grab the rule and subgoal indexes literal = literal.split("_") ruleIndex = int(literal[0]) subgoalIndex = int(literal[1]) # ----------------------------------------- # # grab subgoal dict from appropriate rule rule = ruleSet[ruleIndex] subgoalDict = {} sub = rule.subgoalListOfDicts[subgoalIndex] for key in sub: subgoalDict[key] = sub[key] # ----------------------------------------- # # if not_ rule contains a negated recusrion # instance, replace with the positive head. if subgoalDict["subgoalName"] == orig_name: subgoalDict["subgoalName"] = not_name subgoalDict["polarity"] = "" else: # ----------------------------------------- # # set polarity subgoalDict["polarity"] = polarity # ----------------------------------------- # # save to subgoal list of dicts logging.debug( " DNF TO DATALOG : adding subgoalDict to rule '" + \ not_name + "' : " + str( subgoalDict ) ) subgoalListOfDicts.append(subgoalDict) # ----------------------------------------- # # add domain subgoals, if applicable unidom_rules = [] exidom_rules = [] for r in ruleMeta: if r.relationName.endswith( not_name ) and \ r.relationName.startswith( "unidom_" ) : unidom_rules.append(r) elif sip_idb.is_an_exidom(not_name, r, orig_name, ruleMeta): exidom_rules.append(r) try: assert (len(unidom_rules) == 1) except AssertionError: raise AssertionError( "no unidom_ rule. all DM rules have a unidom_. aborting...") unidom_sub = {} unidom_sub["subgoalName"] = unidom_rules[0].relationName unidom_sub["subgoalTimeArg"] = "" unidom_sub["polarity"] = "" unidom_sub["subgoalAttList"] = goalAttList subgoalListOfDicts.append(unidom_sub) if len(exidom_rules) > 0: for esub in exidom_rules: exidom_sub = {} exidom_sub["subgoalName"] = esub.relationName exidom_sub["subgoalTimeArg"] = "" exidom_sub["polarity"] = "" exidom_sub["subgoalAttList"] = esub.goalAttList subgoalListOfDicts.append(exidom_sub) # ----------------------------------------- # # add existential domain subgoal, # if applicable # prevRules = [] # for currRule in existentialVarsRules : # # if currRule.relationName in prevRules : # pass # # else : # prevRules.append( currRule.relationName ) # # existentialVarSubgoal_dict = {} # existentialVarSubgoal_dict[ "subgoalName" ] = currRule.ruleData[ "relationName" ] # existentialVarSubgoal_dict[ "subgoalAttList" ] = currRule.ruleData[ "goalAttList" ] # existentialVarSubgoal_dict[ "polarity" ] = "" # existentialVarSubgoal_dict[ "subgoalTimeArg" ] = "" # # subgoalListOfDicts.append( existentialVarSubgoal_dict ) # ----------------------------------------- # # build ruleData for new rule and save ruleData = {} ruleData["relationName"] = not_name ruleData["goalAttList"] = goalAttList ruleData["goalTimeArg"] = goalTimeArg ruleData["subgoalListOfDicts"] = subgoalListOfDicts ruleData["eqnDict"] = eqnDict_combined # ----------------------------------------- # # add negation of original version # for good measure. orig_neg = {} orig_neg["subgoalName"] = "orig_" + orig_name orig_neg["subgoalTimeArg"] = "" orig_neg["polarity"] = "notin" orig_neg["subgoalAttList"] = ruleData["goalAttList"] ruleData["subgoalListOfDicts"].append(orig_neg) # ----------------------------------------- # # save rule rid = tools.getIDFromCounters("rid") newRule = copy.deepcopy(Rule.Rule(rid, ruleData, cursor)) newRule.cursor = cursor # need to do this for some reason or else cursor disappears? newRule.goal_att_type_list = goal_types # maintain a list of not_ rules previously derived in the # lineage of this rule. parent_rule = rid_to_rule_meta_map[parent_rid] newRule.lineage_not_names = parent_rule.lineage_not_names if parent_name.startswith("not_"): newRule.lineage_not_names.append(parent_name) newRule.manually_set_types() newDMRules.append(newRule) # if len( newRule.lineage_not_names ) > 0 : # print newRule.lineage_not_names # print dumpers.reconstructRule( parent_rid, cursor ) # print dumpers.reconstructRule( newRule.rid, newRule.cursor ) # sys.exit( "blah" ) logging.debug(" DNF TO DATALOG : newDMRules :") for newRule in newDMRules: logging.debug( " " + str(dumpers.reconstructRule(newRule.rid, newRule.cursor))) return newDMRules
def get_sip_bindings(parent_rule, target_ruleSet, table_list, factMeta, ruleMeta, argDict): logging.debug(" GET SIP BINDINGS : parent_rule :") logging.debug(" " + c4_translator.get_c4_line(parent_rule.ruleData, "rule")) logging.debug(" GET SIP BINDINGS : target_ruleSet :") for t in target_ruleSet: logging.debug(" " + c4_translator.get_c4_line(t.ruleData, "rule")) logging.debug(" GET SIP BINDINGS : ruleMeta :") for r in ruleMeta: logging.debug(" " + c4_translator.get_c4_line(r.ruleData, "rule")) target_name = target_ruleSet[0].relationName # generate sip rule orig_rel_name = target_ruleSet[0].relationName sip_ruleData = {} sip_ruleData["relationName"] = "sip_not_" + orig_rel_name sip_ruleData["goalTimeArg"] = "" sip_ruleData["subgoalListOfDicts"] = copy.deepcopy( parent_rule.subgoalListOfDicts) sip_ruleData["eqnDict"] = copy.deepcopy(parent_rule.eqnDict) lists_of_att_bindings = [] for sub in parent_rule.subgoalListOfDicts: #print "sub = " + str( sub ) if sub[ "subgoalName" ] == orig_rel_name and \ sub[ "polarity" ] == "notin" : lists_of_att_bindings.append(sub["subgoalAttList"]) # cannot support the appearance of the same negated subgoal # more than once in the same rule. try: assert (len(lists_of_att_bindings) == 1) except AssertionError: if len(lists_of_att_bindings) > 1: raise AssertionError( "iapyx does not support rules negating the same subgoal twice. " + \ "see rule :\n " + \ dumpers.reconstructRule( parent_rule.rid, parent_rule.cursor ) ) else: raise AssertionError( "no rule bindings for relation '" + \ orig_rel_name + \ "' in rule :\n " + \ dumpers.reconstructRule( parent_rule.rid, parent_rule.cursor ) ) # replace wildcards with some actual value. # since the value doesn't matter, just pick one. if "_" in lists_of_att_bindings[0]: program = get_program(table_list, factMeta, ruleMeta) parsedResults = run_program_c4(program, argDict) logging.debug("before:") logging.debug(lists_of_att_bindings[0]) for i in range(0, len(lists_of_att_bindings[0])): satt = lists_of_att_bindings[0][i] if satt == "_": pick_something = parsedResults[orig_rel_name][0][i] if pick_something.isdigit(): lists_of_att_bindings[0][i] = pick_something elif "'" in pick_something or '"' in pick_something: lists_of_att_bindings[0][i] = pick_something else: lists_of_att_bindings[0][i] = '"' + pick_something + '"' logging.debug("after:") logging.debug(lists_of_att_bindings[0]) #sys.exit( "fuckingshit" ) sip_ruleData["goalAttList"] = lists_of_att_bindings[0] #sip_type_list = [ t[1] for t in parent_rule.goal_att_type_list ] sip_type_list = [t[1] for t in target_ruleSet[0].goal_att_type_list] if target_name == "link" and \ lists_of_att_bindings[0] == [ "S", "Z3", "Y", "_", "NRESERVED" ] : print c4_translator.get_c4_line(parent_rule.ruleData, "rule") for l in target_ruleSet: print c4_translator.get_c4_line(l.ruleData, "rule") print sip_ruleData print sip_type_list print c4_translator.get_c4_line(sip_ruleData, "rule") sys.exit("asdf") # build and run program program = get_program(table_list, factMeta, ruleMeta, sip_ruleData, sip_type_list) parsedResults = run_program_c4(program, argDict) return parsedResults[sip_ruleData["relationName"]]
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 combo(factMeta, ruleMeta, cursor, argDict): # ----------------------------------------- # logging.debug(" COMBO : running process...") settings_path = argDict["settings"] # ----------------------------------------- # # get parameters # ========== NW DOM DEF ========== # try: NW_DOM_DEF = tools.getConfig(settings_path, "DEFAULT", "NW_DOM_DEF", str) if NW_DOM_DEF == "sip": pass else: raise ValueError( "unrecognized NW_DOM_DEF option '" + NW_DOM_DEF + \ "' for combo NW rewrites. aborting..." ) except ConfigParser.NoOptionError: raise ValueError( "no 'NW_DOM_DEF' defined in 'DEFAULT' section of " + settings_path + \ ". aborting..." ) # ----------------------------------------- # # replace unused variables with wildcards if NW_DOM_DEF == "sip": ruleMeta = nw_tools.replace_unused_vars(ruleMeta, cursor) # ----------------------------------------- # # rewrite rules with fixed data # in the head ruleMeta, factMeta = nw_tools.fixed_data_head_rewrites( ruleMeta, factMeta, argDict) # ----------------------------------------- # # rewrite rules with aggregate functions # in the head ruleMeta = nw_tools.aggRewrites(ruleMeta, argDict) # ----------------------------------------- # # enforce a uniform goal attribute lists ruleMeta = nw_tools.setUniformAttList(ruleMeta, cursor) logging.debug(" COMBO : len( ruleMeta ) after setUniformAttList = " + str(len(ruleMeta))) # ----------------------------------------- # # enforce unique existential attributes # per rule ruleMeta = nw_tools.setUniqueExistentialVars(ruleMeta) # ----------------------------------------- # # replace time att references ruleMeta = dm_time_att_replacement.dm_time_att_replacement( ruleMeta, cursor, argDict) # ----------------------------------------- # # append rids to all rel names and # generate cps of the original rules # (do not reference these in final programs) if NW_DOM_DEF == "sip": # future optimization : do this lazily: ruleMeta.extend(nw_tools.generate_orig_cps(ruleMeta)) # ----------------------------------------- # # append rids to all rel names and # generate cps of the original rules # (do not reference these in final programs) if NW_DOM_DEF == "sip": # future optimization : do this lazily: not_templates, ruleMeta = get_not_templates_combo(factMeta, ruleMeta) #for r in ruleMeta : # print str( r.rid ) + " : " + dumpers.reconstructRule( r.rid, r.cursor ) #sys.exit( "blee" ) # ----------------------------------------- # # generate a map of all rids to corresponding # rule meta object pointers. if NW_DOM_DEF == "sip": rid_to_rule_meta_map = nw_tools.generate_rid_to_rule_meta_map(ruleMeta) # ----------------------------------------- # # build all de morgan's rules COUNTER = 0 while nw_tools.stillContainsNegatedIDBs(ruleMeta, cursor): logging.debug(" COMBO : COUNTER = " + str(COUNTER)) if COUNTER == 3: print "////////////" for r in ruleMeta: print dumpers.reconstructRule(r.rid, r.cursor) sys.exit("wtf?") # ----------------------------------------- # # check if any rules include negated idb # subgoals targetRuleMetaSets = nw_tools.getRuleMetaSetsForRulesCorrespondingToNegatedSubgoals( ruleMeta, \ cursor ) #if COUNTER == 2 : # print targetRuleMetaSets[0][0] # for r in targetRuleMetaSets[0][1] : # print c4_translator.get_c4_line( r.ruleData, "rule" ) # print "////////////" # for r in ruleMeta : # print dumpers.reconstructRule( r.rid, r.cursor ) # sys.exit( "asdf" ) # ----------------------------------------- # # break execution if no rules contain negated IDBs. # should not hit this b/c of loop condition. if len(targetRuleMetaSets) < 1: return [] # ----------------------------------------- # # create the de morgan rewrite rules. # incorporates domcomp and existential # domain subgoals. if NW_DOM_DEF == "sip": ruleMeta = do_combo_sip( factMeta, \ ruleMeta, \ targetRuleMetaSets, \ not_templates, \ rid_to_rule_meta_map, \ cursor, \ argDict ) else: raise ValueError( "unrecognized NW_DOM_DEF option '" + NW_DOM_DEF + \ "'. aborting..." ) #for r in ruleMeta : # print str( r.rid ) + " : " + dumpers.reconstructRule( r.rid, r.cursor ) #sys.exit( "blast" ) # ----------------------------------------- # # update rid to rule meta map rid_to_rule_meta_map = nw_tools.generate_rid_to_rule_meta_map(ruleMeta) #if COUNTER == 2 : # for r in ruleMeta : # print str( r.rid ) + " : " + dumpers.reconstructRule( r.rid, r.cursor ) # sys.exit( "blahasdf" ) # increment loop counter COUNTER += 1 # ----------------------------------------- # # replace unused variables with wildcards if NW_DOM_DEF == "sip": ruleMeta = nw_tools.replace_unused_vars(ruleMeta, cursor) # ----------------------------------------- # # filter out unused not_ rules if NW_DOM_DEF == "sip": ruleMeta = nw_tools.delete_unused_not_rules(ruleMeta, cursor) for r in ruleMeta: print str(r.rid) + " : " + dumpers.reconstructRule(r.rid, r.cursor) sys.exit("blahasdf") logging.debug(" COMBO : ...done.") return factMeta, ruleMeta
def insertDomainFactWithoutPar(cursor, rule, ruleMeta, factMeta, parsedResults): logging.debug(" INSERT DOMAIN FACT WITHOUT PAR : rule = " + str(rule)) # print "not found parent dom" parRules, childRule, childVars = collectDomainRuleInfo( cursor, rule, ruleMeta) childRule = childRule[0] newRules = [] newFacts = [] logging.debug("------------") logging.debug(" INSERT DOMAIN FACT WITHOUT PAR : parRules :") for i in parRules: logging.debug(" " + dumpers.reconstructRule(i.rid, i.cursor)) logging.debug(" INSERT DOMAIN FACT WITHOUT PAR : childRule :") logging.debug(" " + dumpers.reconstructRule(childRule.rid, childRule.cursor)) logging.debug("------------") for parRule in parRules: for subgoal in parRule.subgoalListOfDicts: if subgoal['subgoalName'] == childRule.relationName: # we found the matching subgoal # iterate over the attributes in the subgoal and get the # range of values for the attributes, given the eval results. for attIndex in range(0, len(childRule.goalAttList)): att = subgoal['subgoalAttList'][attIndex] logging.debug(" INSERT DOMAIN FACT WITHOUT PAR : att = " + att) if isConstant(att): # the attribute is constant in the parent goal therefore add a fact for it newFact = createDomFact( cursor, "dom_not_" + rule[0] + "_" + str(attIndex), [att]) newFacts.append(newFact) continue found = False for parAttIndex in range(0, len(parRule.goalAttList)): parAtt = parRule.goalAttList[parAttIndex] if parAtt == att: found = True logging.debug( " INSERT DOMAIN FACT WITHOUT PAR : ...is a goal att. " ) logging.debug( " INSERT DOMAIN FACT WITHOUT PAR : parent results for '" + \ rule[1] + "'" ) for j in parsedResults[rule[1]]: logging.debug(" " + str(j)) # found this attribute in the parent head. # therefore can define based off this value in the parents slot if len(parsedResults[rule[1]]) == 0: # nothing exists in the parents domain. # Going to base off of whole active domain. if rule[0] in parsedResults.keys(): # in this case we can define the domain based off # its previously fired not domain newFacts = newFacts + createFactsBasedOffParsedResults( cursor, \ childVars, \ childRule, \ attIndex, \ parsedResults ) continue dom_name = 'dom_str' if childVars[childRule. goalAttList[attIndex]] == "int": dom_name = 'dom_int' logging.debug( " INSERT DOMAIN FACT WITHOUT PAR : dom_name = " + \ dom_name ) ruleData = createDomRule( rule[0], attIndex, childRule.goalTimeArg, att) goalDict = createSubgoalDict( dom_name, [att], '', childRule.goalTimeArg) ruleData['subgoalListOfDicts'].append(goalDict) domrid = tools.getIDFromCounters("rid") newRule = Rule.Rule(domrid, ruleData, cursor) newRules.append(newRule) else: dom_name = "dom_not_" + rule[0] + "_" + str( attIndex) logging.debug( " INSERT DOMAIN FACT WITHOUT PAR : dom_name = " + \ dom_name ) usedVals = {} logging.debug( " INSERT DOMAIN FACT WITHOUT PAR : usedVals = " + \ str( usedVals ) ) for val in parsedResults[rule[1]]: # add in a rule into the parsed results data = val[parAttIndex] if data in usedVals.keys(): continue usedVals[data] = True newFact = createDomFact( cursor, \ dom_name, \ [data] ) newFacts.append(newFact) break if not found: logging.debug( " INSERT DOMAIN FACT WITHOUT PAR : ...is NOT a goal att." ) if rule[0] in parsedResults.keys(): newFacts = newFacts + createFactsBasedOffParsedResults( cursor, \ childVars, \ childRule, \ attIndex, \ parsedResults ) continue # we have not found it therefore must go off the active domain. att = childRule.goalAttList[attIndex] dom_name = 'dom_int' val = att if childVars[att] == 'string': dom_name = 'dom_str' ruleData = createDomRule(rule[0], attIndex, childRule.goalTimeArg, val) # add in the adom dom_name = "dom_str" if childVars[att].lower() == 'int': dom_name = "dom_int" goalDict = createSubgoalDict(dom_name, [val], '', childRule.goalTimeArg) ruleData['subgoalListOfDicts'].append(goalDict) domrid = tools.getIDFromCounters("rid") newRule = Rule.Rule(domrid, ruleData, cursor) newRules.append(newRule) ruleMeta = ruleMeta + newRules factMeta = factMeta + newFacts return ruleMeta, factMeta
def collectUniversalBoundSubgoals(randomDMRID, parentRID, sidInParent, posName, parentName, univAttData, cursor): print print "^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^" print "BUILDING UNIVERSAL BOUND SUBGOALS" print "randomDMRID rule : " + dumpers.reconstructRule(randomDMRID, cursor) print "parentRID rule : " + dumpers.reconstructRule(parentRID, cursor) print "sidInParent : " + sidInParent print "posName : " + posName print "parentName : " + parentName universalBoundSubgoals = [] # ===================================================================== # # ===================================================================== # # ----------------------------------- # # build parent dom subgoal # # ----------------------------------- # parentSubgoalName = "dom_" + parentName + "_evalres" print "parentSubgoalName : " + parentSubgoalName # ---------------------------------------------- # # get parent rule attribute list # # ---------------------------------------------- # cursor.execute("SELECT attID,attName,attType FROM GoalAtt WHERE rid=='" + parentRID + "'") parentGoalAttList = cursor.fetchall() parentGoalAttList = tools.toAscii_multiList(parentGoalAttList) # ---------------------------------------------- # # get negated subgoal attribute list from parent # # ---------------------------------------------- # cursor.execute( "SELECT attID,attName,attType FROM SubgoalAtt WHERE rid=='" + parentRID + "' AND sid=='" + sidInParent + "'") subAttDataInParent = cursor.fetchall() subAttDataInParent = tools.toAscii_multiList(subAttDataInParent) # --------------------------------------------------------------- # # map parent goal att indexes to subgoal att indexes or wildcards # # --------------------------------------------------------------- # parentSubgoalAttIndexMap = {} for paratt in parentGoalAttList: pattID = paratt[0] pattName = paratt[1] subIndexes = [] for subatt in subAttDataInParent: sattID = subatt[0] sattName = subatt[1] if pattName == sattName: subIndexes.append(sattID) parentSubgoalAttIndexMap[pattID] = subIndexes # ------------------------------------------------------------------------------------------------------ # # map parent subgoal att vars to the corresponding att vars in the uniform attribute set for the DM rule # # ------------------------------------------------------------------------------------------------------ # # get uniform attribute list cursor.execute("SELECT attID,attName,attType FROM GoalAtt WHERE rid=='" + randomDMRID + "'") uniformAttList = cursor.fetchall() uniformAttList = tools.toAscii_multiList(uniformAttList) # populate map subToUniformMap = {} for i in range(0, len(subAttDataInParent)): subatt = subAttDataInParent[i] subAttName = subatt[1] subToUniformMap[subAttName] = uniformAttList[i] # ---------------------------------------------------------------------------------- # # map parent goal att vars to vars from the uniform att list for the negated subgoal # # ---------------------------------------------------------------------------------- # parentSubgoalAttMap = {} for parAttIndex in parentSubgoalAttIndexMap: correspondingSubAttIndexList = parentSubgoalAttIndexMap[parAttIndex] # this attribute in the parent goal does not appear in the negated subgoal att list. # use a wildcard. if correspondingSubAttIndexList == []: parAttType = parentGoalAttList[parAttIndex][2] parentSubgoalAttMap[parAttIndex] = [parAttIndex, "_", parAttType] # this attribute in the parent goal appears in the negated subgoal att list. # replace with the corresponding uniform attribute variable for the subgoal rewrite. else: for subAttIndex in correspondingSubAttIndexList: parentRuleSubAttVar = subAttDataInParent[subAttIndex][1] uniformVar = subToUniformMap[parentRuleSubAttVar] parentSubgoalAttMap[ parAttIndex] = uniformVar # should be identical across subgoal indexes # -------------------- # # build parent subgoal # # -------------------- # # save subgoal contents in a dictionary parentSubgoal = {} parentSubgoal["sid"] = tools.getID() parentSubgoal["subgoalName"] = parentSubgoalName parentSubgoal["subgoalTimeArg"] = "" # default parentSubgoal["subgoalAttDict"] = parentSubgoalAttMap parentSubgoal["argName"] = "" # ============================================================== # # ============================================================== # # ----------------------------------- # # build original dom subgoal # # ----------------------------------- # negatedPositiveSubgoalName = "dom_" + posName + "_evalres" # ----------------------------------------------- # # map parent subgoal att vars to uniform att vars # # ----------------------------------------------- # # correctness depends upon the schemas of the positive and not_ # definitions of the targeted negated subgoal to be identical. # this can only be guaranteed after the uniformity rewrite. negatedPositiveSubgoalAttMap = {} for att in subAttDataInParent: attID = att[0] attName = att[1] if attName == "_": attType = uniformAttList[attID][2] negatedPositiveSubgoalAttMap[attID] = [attID, "_", attType] else: attName = uniformAttList[attID][1] attType = uniformAttList[attID][2] negatedPositiveSubgoalAttMap[attID] = [attID, attName, attType] # ------------------------------ # # build negated positive subgoal # # ------------------------------ # negatedPositiveSubgoal = {} negatedPositiveSubgoal["sid"] = tools.getID() negatedPositiveSubgoal["subgoalName"] = negatedPositiveSubgoalName negatedPositiveSubgoal["subgoalTimeArg"] = "" # default negatedPositiveSubgoal["subgoalAttDict"] = negatedPositiveSubgoalAttMap negatedPositiveSubgoal["argName"] = "notin" # negated positive # ============================================================== # # ============================================================== # # ----------------------------------- # # build original dom subgoal # # ----------------------------------- # positivePositiveSubgoalName = "dom_" + posName + "_evalres" # ----------------------------------------------- # # map parent subgoal att vars to uniform att vars # # ----------------------------------------------- # # correctness depends upon the schemas of the positive and not_ # definitions of the targeted negated subgoal to be identical. # this can only be guaranteed after the uniformity rewrite. # # the attributes in the positive domain subgoal for the targetted negated relation # are exactly the in the negated domain subgoal relation in this rule # minus the attributes incoporated into the parent domain subgoal of this rule. parentEvalRes_atts_only = [ parentSubgoalAttMap[x][1] for x in parentSubgoalAttMap ] positivePositiveSubgoalAttMap = {} for att in univAttData: attID = att[0] attName = att[1] attType = att[2] if attName in parentEvalRes_atts_only: attName = "_" positivePositiveSubgoalAttMap[attID] = [attID, attName, attType] # ------------------------------ # # build negated positive subgoal # # ------------------------------ # positivePositiveSubgoal = {} positivePositiveSubgoal["sid"] = tools.getID() positivePositiveSubgoal["subgoalName"] = positivePositiveSubgoalName positivePositiveSubgoal["subgoalTimeArg"] = "" # default positivePositiveSubgoal["subgoalAttDict"] = positivePositiveSubgoalAttMap positivePositiveSubgoal["argName"] = "" # positive positive # ============================================================== # # ============================================================== # universalBoundSubgoals = [] if not allWildcardAtts(parentSubgoal): universalBoundSubgoals.append(parentSubgoal) if not allWildcardAtts(negatedPositiveSubgoal): universalBoundSubgoals.append(negatedPositiveSubgoal) if not allWildcardAtts(positivePositiveSubgoal): universalBoundSubgoals.append(positivePositiveSubgoal) print "DONE BUILDING UNIVERSAL BOUND SUBGOALS" return universalBoundSubgoals