def mini_calc(branch, info): # Mini calcualtions a_loc, opr, b_loc, dp = branch opr = opr.replace(" ", "") raw_a = dive_for_dot_values(a_loc, info, DEBUG=SUPER_DEBUG, as_val=1) if isinstance(b_loc, float) or isinstance(b_loc, int): raw_b = b_loc else: raw_b = dive_for_dot_values(b_loc, info, DEBUG=SUPER_DEBUG, as_val=1) bv = float(raw_b) av = float(raw_a) if opr == "-": final = av - bv elif opr == "+": final = av + bv else: print("<SECONDARY SLOT GETV> unknown opr {}".format(opr)) final = av final = cbround(final, dp) # Round to specified dp if SUPER_DEBUG: print("<SS MINI CALC>", av, opr, bv, "=", final) return final
def _check_condition(an): csk = cstate["key"] curr_info = cinfo t_slots = an["trigger_slots"] t_states = an["trigger_states"] trigger_states = t_states correct_state = "_ANY" in trigger_states or csk in trigger_states if correct_state: slots_satisfied = False for ts in t_slots: slot_is_AND = (ts.get("eval", "AND") == "AND") # Default is AND sn = ts.get("slotname", "") ex_val = ts["value"] info_vd = cu.dive_for_dot_values(sn, curr_info) if len(info_vd) == 0: if SUPER_DEBUG: print("<ANNOUNCE> Slot", sn, "not found in info") info_val = info_vd.get(sn, "") if info_val == ex_val: slots_satisfied = True elif slot_is_AND: # ALL slot values must be satisfied return False # One fail all fail return slots_satisfied return False
def tree_search(tree, t_info): any_val_key = "_ANY" for slotname, sub_dict in list(tree.items()): curr_d = t_info # If finds something, returns. If not, breaks. while True: dive_dir = dive_for_dot_values(slotname, curr_d) # As dict if dive_dir == {}: # IF not found # if SUPER_DEBUG: print("<SS TREE> ERROR {} not found".format(str(slotname))) slot_val = "" break loc, slot_val = list(dive_dir.items())[0] slot_val = str( slot_val ) # To convert ints to strings. I.e. for hours # if SUPER_DEBUG: print("<SS TREE> Current slot:", loc, "| val:", slot_val) # Check if key is in the subdict if slot_val in sub_dict: ss_branch = sub_dict[slot_val] if isinstance(ss_branch, dict): # Is a subtree # if SUPER_DEBUG: print("<SS TREE> Found a subtree",ss_branch, "in",sub_dict) slotname, sub_dict = list(ss_branch.items())[0] continue else: # Is a leaf out = get_value(ss_branch, t_info) # Cut from info pp = cu.dotpop(loc, curr_d) # if SUPER_DEBUG: print("<SS TREE> pop leaf",pp) return (True, out) else: # Fallback and look for _ANY match a_branch = sub_dict.get(any_val_key, -1) if not a_branch: # Search failed # if SUPER_DEBUG: print("<SS TREE> Val:", slot_val, "not found in:", sub_dict) break if isinstance(a_branch, dict): # Is a _ANY branch slotname, sub_dict = list(a_branch.items())[0] continue else: # Is a _ANY leaf out = get_value(a_branch, t_info) # Cut from info pp = cu.dotpop(loc, curr_d) # if SUPER_DEBUG: print("<SS TREE> pop _ANY leaf",pp) return (True, out) # if SUPER_DEBUG: print("<SECONDARY SLOT> TREE SEARCH FAILED",tree) return (False, "")
def get_variables(f, enh): def add_formula_conditional_vars(f, vd): ret = {} # This assumes all conditions are joined by AND conds = f.get("conditions", []) for cond in conds: k, v, setval = cond vkey, tval, fval = setval if not k in vd: print("<COND VALS> WARNING {} not in info".format(k)) met = False else: if isinstance(v, list): for val in v: met = (vd[k] == val) if met: break else: met = (vd[k] == v) # Simple match ret[vkey] = tval if met else fval vd.update(ret) return # Fetch mandatory values reqvar_key = "req_vars" opvar_key = "optional_vars" req_vars = f.get(reqvar_key, []) vd = cu.dive_for_dot_values(req_vars, enh) # Fetch optional values op_vars = f.get(opvar_key, []) # If not found, value = 0 op_vars_d = cu.dive_for_dot_values(op_vars, enh, failzero=True) vd.update(op_vars_d) # Fetch conditional values add_formula_conditional_vars(f, vd) if self.SUPER_DEBUG: print("<RESOLVE FORMULA> Value Dict", vd) return vd
def get_leaf_value(branch, info): if isinstance(branch, list): final = cu.dive_for_dot_values(branch, info, DEBUG=SUPER_DEBUG, as_val=1) if final == {}: if DEBUG: print("<SECONDARY SLOT GETV> {} not found in info". format(branch)) final = "" return final # If not, is a raw value return branch
def get_value(branch, info): if isinstance(branch, list): minicalc_bool = len(branch) > 1 if minicalc_bool: final = mini_calc(branch, info) else: final = dive_for_dot_values(branch, info, DEBUG=SUPER_DEBUG, as_val=1) if final == {}: if DEBUG: print("<SECONDARY SLOT GETV> {} not found in info". format(branch)) final = "" return final # If not, is a raw value return branch
def tree_search(tree, t_info): for slotname, sub_dict in list(tree.items()): dive_dict = cu.dive_for_dot_values(slotname, t_info) # As dict if dive_dict == {}: # IF not found if SUPER_DEBUG: print("<TREE> ERROR {} not found".format( str(slotname))) slot_val = "" break loc, slot_val = list(dive_dict.items())[0] slot_val = str( slot_val ) # Convert to strings because json keys are strings. I.e. for hours if SUPER_DEBUG: print("<TREE> Current slot:", loc, "| val:", slot_val) # Check if curr_info detail's value is in the subdict if slot_val in sub_dict: matched_branch = sub_dict[slot_val] if isinstance(matched_branch, dict): # Is a subtree sub_tree = matched_branch if SUPER_DEBUG: print("<TREE> Subtree found. Searching:", str(sub_dict)) found, returned = tree_search(sub_tree, t_info) if found: return (found, returned) continue else: # Is a leaf out = get_leaf_value(matched_branch, t_info) pp = cu.dotpop(loc, t_info) # Cut from info if SUPER_DEBUG: print("<TREE> pop leaf", pp) return (True, out) else: # Fallback and look for _ANY match a_branch = sub_dict.get(any_val_key, -1) if not a_branch: # Search failed if SUPER_DEBUG: print("<TREE> Val:", slot_val, "not found in:", sub_dict) break if isinstance(a_branch, dict): # Is a _ANY branch slotname, sub_tree = list(a_branch.items())[0] found, returned = tree_search(sub_tree, t_info) if found: return (found, returned) continue else: # Is a _ANY leaf out = get_leaf_value(a_branch, t_info) # Cut from info pp = cu.dotpop(loc, t_info) if SUPER_DEBUG: print("<TREE> pop _ANY leaf", pp) return (True, out) return (False, "")