Beispiel #1
0
 def parseGoal(self, txt):
     if not txt.endswith(")"):
         print "Error reading goal. Goal must be given in the form: predicate(arg1, arg2,...,argi-1,argi), where each argument is the name of an object in the world"
         return None
     try:
         if txt.startswith('!'):
             negate = True
             txt = txt[1:]
         else:
             negate = False
         predicateName = txt[:txt.index("(")]
         args = [
             arg.strip() for arg in txt[txt.index("(") + 1:-1].split(",")
         ]
         #use on-table predicate
         if predicateName == 'on' and len(args) == 2 and 'table' == args[1]:
             predicateName = 'on-table'
             args = args[:1]
         if negate:
             goal = goals.Goal(*args, predicate=predicateName, negate=True)
         else:
             goal = goals.Goal(*args, predicate=predicateName)
         return goal
     except Exception:
         print "Error reading goal. Goal must be given in the form: predicate(arg1, arg2,...,argi-1,argi), where each argument is the name of an object in the world"
         return None
Beispiel #2
0
    def run(self, cycle, verbose=2):
        if self.deliveringGoalsExist():
            if verbose >= 2:
                print "MIDCA already has a delivering goal. Skipping delivering goal generation"
            return

        if self.alreadygenerated():
            if verbose >= 2:
                print "MIDCA already generated the goals for this problem"
            return
        #if obj-at(p,l) is in the state, it means it needs to be delivered!
        world = self.mem.get(self.mem.STATES)[-1]

        orders = deliverstate.get_order_list(world)
        #\         goal = self.tree.givegoal(blocks)
        for order in orders:
            goal = goals.Goal(order.id,
                              order.destination,
                              order.location,
                              predicate="obj-at")
            added = self.mem.get(self.mem.GOAL_GRAPH).insert(goal)
            if goal:
                if verbose >= 2:
                    print "goal generated:", goal
                ##call monitors
                m = Monitor(self.mem, "m" + order.id, order.id, goal)
                #                 Thread(target=m.goalmonitor, args=[order.id, order.location, "obj-at"]).start()
                self.mem.get(self.mem.GOAL_GRAPH).insert(goal)
Beispiel #3
0
 def run(self, cycle, verbose = 2):
     try:
         text = self.readS.recv(self.readSize)
         if text != "None\n":
            p = Parser()
            frames = p.makeframegraph(text)
            noem = {}   # Node Operator Effect Mapping
            noem['CRIMINAL-VOLITIONAL-AGENT.4697'] = [['apprehend', OPERATOR_EFFECT_NEGATION]]
            t = Traverser(frames, noem)
            (frame, operator, effect) = t.traverse()
            if operator == "apprehend":
                apprehendGoal = goals.Goal("Gui Montag", predicate = "free",
                                           negate = True)
                inserted = self.mem.get(self.mem.GOAL_GRAPH).insert(goal)
                if verbose >= 2:
                    print "Meta-AQUA goal generated:", goal,
                    if inserted:
                        print
                    else:
                        print ". This goal was already in the graph."
            else:
                if verbose >= 2:
                    print "Meta-AQUA output unrecognized. No goal generated. Output:\n",
                    text
     except socket.timeout:
         if verbose >= 1:
             print "Error: no data received from Meta-AQUA before timeout."
     except:
         if verbose >= 1:
             print "Error reading from Meta-AQUA.",
             try:
                 print " Got:\n" + text
             except NameError:
                 print " Unable to read from socket."
Beispiel #4
0
 def run(self, cycle, verbose = 2):
     arsonist = self.free_arsonist()
     if arsonist and self.is_fire():
         goal = goals.Goal(arsonist, predicate = "free", negate = True)
         inserted = self.mem.get(self.mem.GOAL_GRAPH).insert(goal)
         if verbose >= 2:
             print "Meta-AQUA simulation goal generated:", goal,
             if inserted:
                 print
             else:
                 print ". This goal was already in the graph."
Beispiel #5
0
 def parseGoal(self, txt):
     if not txt.endswith(")"):
         print "Error reading input. Atom must be given in the form: predicate(arg1, arg2,...,argi-1,argi), where each argument is the name of an object in the world"
         return None
     try:
         predicateName = txt[:txt.index("(")]
         args = [
             arg.strip() for arg in txt[txt.index("(") + 1:-1].split(",")
         ]
         goal = goals.Goal(*args, predicate=predicateName)
         return goal
     except Exception:
         print "Error reading input. Atom must be given in the form: predicate(arg1, arg2,...,argi-1,argi), where each argument is the name of an object in the world"
         return None
Beispiel #6
0
    def run(self, cycle, verbose=2):
        trace = self.mem.trace
        if trace:
            trace.add_module(cycle, self.__class__.__name__)
        self.verbose = verbose
        # get discrepancies
        discrep = self.mem.get(self.mem.DISCREPANCY)
        # if discrepancy, get explanation
        if discrep and (len(discrep[0]) > 0 or len(discrep[1]) > 0):
            # first remove old
            # go ahead and remove old plans for any goals the agent has
            # refresh the goals to trigger replanning
            goalgraph = self.mem.get(self.mem.GOAL_GRAPH)
            curr_goals = self.mem.get(self.mem.CURRENT_GOALS)

            if type(curr_goals) is not list:
                curr_goals = [curr_goals]
            for goal in curr_goals:
                # get any plans associated with this goal, and remove them
                plan = goalgraph.getMatchingPlan([goal])
                if plan:
                    goalgraph.removePlan(plan)
                    if self.verbose >= 1:
                        print "Just removed a plan for goal " + str(goal)

            #print "aware of actual discrepancy, retrieving explanation"
            explain_exists = self.mem.get(self.mem.EXPLANATION)
            explanation = self.mem.get(self.mem.EXPLANATION_VAL)
            if explain_exists:

                # now do stuff based on explanation
                if 'stuck' in explanation:
                    # remove current goal from goal graph
                    # insert goal to become free
                    # The priority will automatically be shifted to
                    goalgraph = self.mem.get(self.mem.GOAL_GRAPH)
                    free_goal = goals.Goal('Curiosity', predicate="free")
                    goalgraph.insert(free_goal)
                    if self.verbose >= 1:
                        print "Just inserted goal " + str(free_goal)
                    return
                else:  #if 'wind' in explanation:
                    # do nothing for other explanations, this will just lead to replanning
                    return
            else:
                if self.verbose >= 1:
                    print "No explanation, old plans removed, but no goal management actions"
                return
Beispiel #7
0
    def generate_new_goals(self):
        if self.currGoalIndex < len(self.goalList):
            curr_goal = self.goalList[self.currGoalIndex]
            #if self.verbose >= 1: print "inserting goal "+str(curr_goal)
            self.currGoalIndex += 1
            return [curr_goal]
        if self.currGoalIndex == len(self.goalList):
            print "No more goals..."
            self.currGoalIndex += 1
        return []

        # this is a safety check to make sure experiments are running correctly.
        # if running manual (like running from examples/nbeacons...agentx.py remove this line
        raise Exception(
            "randomly inserting goals, shouldn't be here when running from nbeacons_experiment_1.py"
        )
        world = self.mem.get(self.mem.STATES)[-1]
        goal_b_ids = []
        # get all beacon ids
        unactivated_b_ids = []
        for obj in world.get_possible_objects("", ""):
            # test if a beacon id
            if str(obj).startswith("B"):
                # now test to see if it's activated
                if not world.is_true('activated', [str(obj)]):
                    unactivated_b_ids.append(str(obj))

        if len(unactivated_b_ids) == 0:
            if self.verbose >= 1:
                print(
                    "All beacons are activated. No activation goals will be generated."
                )
            return []

        num_chosen_beacons = 0
        while len(unactivated_b_ids
                  ) > 0 and num_chosen_beacons < self.numbeacons:
            b = random.choice(unactivated_b_ids)
            unactivated_b_ids.remove(b)
            goal_b_ids.append(b)
            num_chosen_beacons += 1

        # turn into goals
        new_goals = map(lambda x: goals.Goal(str(x), predicate="activated"),
                        goal_b_ids)

        return new_goals
Beispiel #8
0
class SimpleMortarGoalGen(base.BaseModule):
    '''
    MIDCA module that cycles through goals for the agent to achieve.
    '''

    curr_goal_index = 0

    curr_goal_sets = [[
        goals.Goal(*['A_', 'B_'], predicate='stable-on'),
        goals.Goal(*['C_', 'A_'], predicate='stable-on'),
        goals.Goal(*['D_', 'C_'], predicate='stable-on')
    ],
                      [
                          goals.Goal(*['D_', 'B_'], predicate='stable-on'),
                          goals.Goal(*['B_', 'A_'], predicate='stable-on'),
                          goals.Goal(*['A_', 'C_'], predicate='stable-on')
                      ]]

    # starting state: on(D,B), on(B,A), ontable(A) ontable(C)
    # first goal: on(C,B)
    # second goal

    def next_goal(self):
        # get the next goal
        curr_goal_set = self.curr_goal_sets[self.curr_goal_index]
        # update index for next time around
        if self.curr_goal_index == len(self.curr_goal_sets) - 1:
            self.curr_goal_index = 0
        else:
            self.curr_goal_index += 1
        return curr_goal_set

    def run(self, cycle, verbose=2):
        trace = self.mem.trace
        if trace:
            trace.add_module(cycle, self.__class__.__name__)

        # first, check to see if we need a new goal, and only then insert a new one
        if len(self.mem.get(self.mem.GOAL_GRAPH).getAllGoals()) == 0:
            # get the next goal
            goal_set = self.next_goal()
            # insert that goal
            for g in goal_set:
                self.mem.get(self.mem.GOAL_GRAPH).insert(g)
            # update trace
            if trace:
                trace.add_data("NEXT GOAL(s)", goal_set)
                trace.add_data("GOAL GRAPH",
                               copy.deepcopy(self.mem.GOAL_GRAPH))
        else:
            if trace:
                trace.add_data("NEXT GOAL", 'goals not empty; no goal chosen')
                trace.add_data("GOAL GRAPH",
                               copy.deepcopy(self.mem.GOAL_GRAPH))
Beispiel #9
0
 def run(self, cycle, verbose = 2):
     world = self.mem.get(self.mem.STATE)
     i = len(world.utterances)
     while i > 0:
         if self.lastTime - world.utterances[i - 1].time > 0:
             break
         i -= 1
     newUtterances = [utterance.utterance for utterance in world.utterances[i:]]
     #now add goals based on new utterances
     for utterance in newUtterances:
         if verbose >= 2:
             print "received utterance:", utterance
         if utterance == "point to the quad" or utterance == "point at max":
             goal = goals.Goal(objective = "show-loc", subject = "self",
             directObject = "quad", indirectObject = "observer")
             added = self.mem.get(self.mem.GOAL_GRAPH).insert(goal)
             if verbose >= 2:
                 if added:
                     print "adding goal:", str(goal)
                 else:
                     print "generated goal:", str(goal), "but it is already in the \
                     goal graph"
     self.lastTime = midcatime.now()
Beispiel #10
0
from MIDCA.modules import simulator, guide, evaluate, perceive, intend, planning, act, note, assess
from MIDCA.worldsim import domainread, stateread
import inspect, os
import random
# Domain Specific Imports
from MIDCA.domains.nbeacons import nbeacons_util
from MIDCA.domains.nbeacons.plan import methods_nbeacons, operators_nbeacons
'''
Simulation of the NBEACONS domain (adapted from marsworld in [Dannenhauer and Munoz-Avila 2015]).

THIS IS THE START SCRIPT FOR THE VANILLA AGENT (no gda, no meta)
'''
wind_schedule = [[20, 1], [40, 2]]
goal_list = range(10) * 10  # give 100 goals
random.shuffle(goal_list)
goal_list = map(lambda x: goals.Goal('B' + str(x), predicate="activated"),
                goal_list)
print "goal list is "
for g in goal_list:
    print "  " + str(g)

# Setup
thisDir = os.path.dirname(
    os.path.abspath(inspect.getfile(inspect.currentframe())))
MIDCA_ROOT = thisDir + "/../"

### Domain Specific Variables
DOMAIN_ROOT = MIDCA_ROOT + "domains/nbeacons/"
DOMAIN_FILE = DOMAIN_ROOT + "domains/nbeacons.sim"
#STATE_FILE = DOMAIN_ROOT + "states/.sim" # state file is generated dynamically
DISPLAY_FUNC = nbeacons_util.drawNBeaconsScene
Beispiel #11
0
def runexperiment():
    # reset in case we run multiple experiments
    DATADIR = "experiments/nbeacons-experiment-1-data/"
    NOW_STR = datetime.datetime.strftime(datetime.datetime.now(),
                                         '%Y-%m-%d--%H-%M-%S')
    DATA_FILENAME = DATADIR + "NBeaconsExperiment1" + NOW_STR + ".csv"
    DATA_FILE_HEADER_STR = "runID,numCycles,agentType,windDir,windStrength,goalsActionsAchieved\n"
    SCENARIO_FILENAME = DATADIR + "NBeaconsScenario" + NOW_STR + ".txt"

    runs = []

    # generate goals randomly, such that no goal is repeated twice
    num_goals = 1000
    goal_list = []
    i = 0
    possible_goals = range(10)
    last_chosen_goal = -1
    while i < num_goals:
        if last_chosen_goal == -1:
            curr_goal = random.choice(possible_goals)
            goal_list.append(curr_goal)
            last_chosen_goal = curr_goal
        else:
            tmp_possible_goals = set(possible_goals) - set([last_chosen_goal])
            curr_goal = random.sample(tmp_possible_goals, 1)[0]
            goal_list.append(curr_goal)
            last_chosen_goal = curr_goal
        i += 1

    goal_list = map(lambda x: goals.Goal('B' + str(x), predicate="activated"),
                    goal_list)
    #print("goal list is ")
    #for g in goal_list:
    #    print("  "+str(g))
    state1 = nbeacons_util.NBeaconGrid()
    #state1.generate_good_test()
    state1.generate(width=DIMENSION,
                    height=DIMENSION,
                    num_beacons=NUM_BEACONS,
                    num_quicksand_spots=NUM_QUICKSAND)
    state1_str = state1.get_STRIPS_str()

    # args are [runID, agentType, windDir, windStrength, startingState, goalList]
    individual_runs = [
        # no wind, same starting state, same starting goals
        [0, 'v', 'east', 0, state1_str, goal_list],
        [1, 'g', 'east', 0, state1_str, goal_list],
        [2, 'm', 'east', 0, state1_str, goal_list],
    ]

    runs = individual_runs

    # Uses multiprocessing to give each run its own python process
    print("-- Starting experiment using " + str(NUM_PROCESSES) +
          " processes...")
    t0 = time.time()
    # **** NOTE: it is very important chunksize is 1 and maxtasksperchild is 1
    # **** (each MIDCA must use its own python process)
    pool = Pool(processes=NUM_PROCESSES, maxtasksperchild=1)
    results = pool.map(singlerun, runs, chunksize=1)
    t1 = time.time()
    timestr = '%.2f' % (t1 - t0)
    print("-- Experiment finished! Took " + timestr + "s, generated " +
          str(len(results)) + " data points")
    print("-- Writing data to file...")
    f = open(DATA_FILENAME, 'w')
    f.write(DATA_FILE_HEADER_STR)
    for r in results:
        f.write(r)
    print("-- Data written to file " + str(DATA_FILENAME))
    print("-- Experiment complete!")

    # if you have pyttsx installed, a voice will tell you your experiments are finished
    try:
        import pyttsx
        engine = pyttsx.init()
        engine.setProperty('rate', 70)
        engine.say('Your experiments are have finished running')
        engine.runAndWait()
    except:
        pass  # do nothing
Beispiel #12
0
    def run(self, cycle, verbose=2):
        world = self.mem.get(self.mem.STATE)
        i = len(world.utterances)
        while i > 0:
            if self.lastTime - world.utterances[i - 1].time > 0:
                break
            i -= 1
        newUtterances = [
            utterance.utterance for utterance in world.utterances[i:]
        ]
        #now add goals based on new utterances
        for utterance in newUtterances:
            if verbose >= 2:
                print "received utterance:", utterance
            if utterance == "point to the quad" or utterance == "goodbye baxter":
                goal = goals.Goal(objective="show-loc",
                                  subject="self",
                                  directObject="quad",
                                  indirectObject="observer")
                added = self.mem.get(self.mem.GOAL_GRAPH).insert(goal)
                if verbose >= 2:
                    if added:
                        print "adding goal:", str(goal)
                    else:
                        print "generated goal:", str(
                            goal), "but it is already in the \
						goal graph"

            if utterance == "get the red block":
                goal = goals.Goal(objective="holding",
                                  subject="self",
                                  directObject="red block",
                                  indirectObject="observer",
                                  pos='red block:arm')
                added = self.mem.get(self.mem.GOAL_GRAPH).insert(goal)
                if verbose >= 2:
                    if added:
                        print "adding goal:", str(goal)
                    else:
                        print "generated goal:", str(
                            goal), "but it is already in the \
						goal graph"

            if utterance == "get the green block":
                goal = goals.Goal(objective="holding",
                                  subject="self",
                                  directObject="green block",
                                  indirectObject="observer",
                                  pos='green block:arm')
                added = self.mem.get(self.mem.GOAL_GRAPH).insert(goal)
                if verbose >= 2:
                    if added:
                        print "adding goal:", str(goal)
                    else:
                        print "generated goal:", str(
                            goal), "but it is already in the \
						goal graph"

            if utterance == "get the blue block":
                goal = goals.Goal(objective="holding",
                                  subject="self",
                                  directObject="blue block",
                                  indirectObject="observer",
                                  pos='blue block:arm')
                added = self.mem.get(self.mem.GOAL_GRAPH).insert(goal)
                if verbose >= 2:
                    if added:
                        print "adding goal:", str(goal)
                    else:
                        print "generated goal:", str(
                            goal), "but it is already in the \
						goal graph"

            if utterance == "put the green block on table":
                goal = goals.Goal(objective="moving",
                                  subject="self",
                                  directObject="green block",
                                  indirectObject="observer",
                                  pos='green block:table')
                added = self.mem.get(self.mem.GOAL_GRAPH).insert(goal)
                if verbose >= 2:
                    if added:
                        print "adding goal:", str(goal)
                    else:
                        print "generated goal:", str(
                            goal), "but it is already in the \
						goal graph"

            if utterance == "put the blue block on table":
                goal = goals.Goal(objective="moving",
                                  subject="self",
                                  directObject="blue block",
                                  indirectObject="observer",
                                  pos='blue block:table')
                added = self.mem.get(self.mem.GOAL_GRAPH).insert(goal)
                if verbose >= 2:
                    if added:
                        print "adding goal:", str(goal)
                    else:
                        print "generated goal:", str(
                            goal), "but it is already in the \
						goal graph"

            if utterance == "put the red block on table":
                goal = goals.Goal(objective="moving",
                                  subject="self",
                                  directObject="red block",
                                  indirectObject="observer",
                                  pos='red block:table')
                added = self.mem.get(self.mem.GOAL_GRAPH).insert(goal)
                if verbose >= 2:
                    if added:
                        print "adding goal:", str(goal)
                    else:
                        print "generated goal:", str(
                            goal), "but it is already in the \
						goal graph"

            if utterance == "stack the green block on the red block":
                goal = goals.Goal(objective="stacking",
                                  subject="self",
                                  directObject="red block",
                                  indirectObject="observer",
                                  pos='green block:red block')
                added = self.mem.get(self.mem.GOAL_GRAPH).insert(goal)
                if verbose >= 2:
                    if added:
                        print "adding goal:", str(goal)
                    else:
                        print "generated goal:", str(
                            goal), "but it is already in the \
						goal graph"

            if utterance == "stack the blue block on the red block":
                goal = goals.Goal(objective="stacking",
                                  subject="self",
                                  directObject="red block",
                                  indirectObject="observer",
                                  pos='blue block:red block')
                added = self.mem.get(self.mem.GOAL_GRAPH).insert(goal)
                if verbose >= 2:
                    if added:
                        print "adding goal:", str(goal)
                    else:
                        print "generated goal:", str(
                            goal), "but it is already in the \
						goal graph"

            if utterance == "stack the blue block on the green block":
                goal = goals.Goal(objective="stacking",
                                  subject="self",
                                  directObject="green block",
                                  indirectObject="observer",
                                  pos='blue block:green block')
                added = self.mem.get(self.mem.GOAL_GRAPH).insert(goal)
                if verbose >= 2:
                    if added:
                        print "adding goal:", str(goal)
                    else:
                        print "generated goal:", str(
                            goal), "but it is already in the \
						goal graph"

            if utterance == "stack the red block on the blue block":
                goal = goals.Goal(objective="stacking",
                                  subject="self",
                                  directObject="blue block",
                                  indirectObject="observer",
                                  pos='red block:blue block')
                added = self.mem.get(self.mem.GOAL_GRAPH).insert(goal)
                if verbose >= 2:
                    if added:
                        print "adding goal:", str(goal)
                    else:
                        print "generated goal:", str(
                            goal), "but it is already in the \
						goal graph"

            if utterance == "stack the green block on the blue block":
                goal = goals.Goal(objective="stacking",
                                  subject="self",
                                  directObject="blue block",
                                  indirectObject="observer",
                                  pos='green block:blue block')
                added = self.mem.get(self.mem.GOAL_GRAPH).insert(goal)
                if verbose >= 2:
                    if added:
                        print "adding goal:", str(goal)
                    else:
                        print "generated goal:", str(
                            goal), "but it is already in the \ goal graph"

            if utterance == "stack the red block on the green block":
                goal = goals.Goal(objective="stacking",
                                  subject="self",
                                  directObject="green block",
                                  indirectObject="observer",
                                  pos='red block:green block')
                added = self.mem.get(self.mem.GOAL_GRAPH).insert(goal)
                if verbose >= 2:
                    if added:
                        print "adding goal:", str(goal)
                    else:
                        print "generated goal:", str(
                            goal), "but it is already in the \
						goal graph"

            if utterance == "stack":
                goal = goals.Goal(objective="stacking",
                                  subject="self",
                                  directObject="green block",
                                  indirectObject="observer",
                                  pos='red block:green block')
                added = self.mem.get(self.mem.GOAL_GRAPH).insert(goal)
                if verbose >= 2:
                    if added:
                        print "adding goal:", str(goal)
                    else:
                        print "generated goal:", str(
                            goal), "but it is already in the \
						goal graph"

# 			else:
# 				print "message is unknown"

        self.lastTime = midcatime.now()
Beispiel #13
0
    def act(self, action, verbose=2):
        # TODO: figure out a way to make the init_args more general (so actions can be kept separate)
        if action[0] == "REMOVE-MODULE":
            # find the component
            module_index = -1
            phase = None
            mod_str = ""

            class Found(Exception):
                pass  # is this bad python? should this go at top of my file?

            try:
                for phasei in self.mem.myMidca.get_phases():
                    i = 0
                    for mod in self.mem.myMidca.get_modules(phasei):
                        mod_str = str(mod.__class__.__name__)
                        print("-*-*- act():  mod = " + mod_str +
                              ", action[1] = " + str(action[1]))
                        if mod_str == action[1]:
                            print("-*-*- act(): we got a match!")
                            module_index = i
                            phase = phasei
                            raise Found
                        i += 1
            except Found:

                # remove the component
                #print("-*-*- act():  phase = "+str(phase)+", module_index = "+str(module_index))
                if phase and module_index > -1:
                    mod = self.mem.myMidca.remove_module(phase, module_index)
                    print "mod is " + str(mod)
                    self.prev_init_args = mod.get_init_args(
                    )  # TODO: only works for modules implementing get_init_args
                    print "got init args: " + str(self.prev_init_args)
                    is_success = mod_str not in map(
                        lambda x: x.__class__.__name__,
                        self.mem.myMidca.get_modules(phase))
                    if is_success:
                        print("    Metareasoner removed " + mod_str
                              )  # report any actions metareasoner carried out
                    return is_success
        elif action[0] == "ADD-MODULE":
            if action[2] == "PyHopPlanner":
                #print("current directory: "+str(os.getcwd()))
                #print("str(dir(modules)) = "+str(dir(modules)))
                planningModuleInstance = importlib.import_module(
                    "MIDCA.modules.planning")
                print("loaded planning module, it has following attributes: " +
                      str(dir(planningModuleInstance)))
                # get the args used to init the old module and use them to init this one
                print "init args is " + str(self.prev_init_args)

                # **** BEGIN: MAGIC! Transform the args *****
                # This is where the real magic happens
                # Hardcoded for now
                # Very Important TODO but likely requires serious research effort
                from MIDCA.domains.blocksworld.plan import methods
                working_methods = methods.declare_methods
                corrected_args = self.prev_init_args
                hardcoded_index_of_methods_arg = 2  # TODO: I know, so hacky, ahhh magic numbers
                corrected_args[2] = working_methods
                # **** END: MAGIC! Transform the args *****

                pyHopPlannerInstance = planningModuleInstance.PyHopPlanner(
                    *corrected_args)
                self.mem.myMidca.runtime_append_module(
                    "Plan", pyHopPlannerInstance
                )  # TODO: hardcoded knowledge of Plan phase
                is_success = "PyHopPlanner" in map(
                    lambda x: x.__class__.__name__,
                    self.mem.myMidca.get_modules("Plan"))
                if is_success:
                    print("    Metareasoner added PyHopPlanner"
                          )  # report any actions metareasoner carried out
                return is_success
        elif action[0] == "TRANSFORM-GOAL":
            # really: its going to have this meta plan by changing the things in orange -
            # you don't monitor and look at the trace to see if the goal transformation achieved something
            # at the ground level, so then meta-evaluate can know if the metagoal succeeded. What if I made the
            # wrong transformation?

            # specific to mortar and blocks world, not general
            # get the highest blocks
            goal_atoms = action[1]
            goal_args = map(lambda x: x.get_args(), goal_atoms)

            # figure out how much mortar we have using the world state
            num_available_mortar = 0
            for atom in map(str,
                            self.mem.get("__world states")[-1].get_atoms()):
                if 'available(' in atom:
                    num_available_mortar += 1
                    if verbose >= 3:
                        print("found available mortar: " + str(atom))

            # transform 'stable-on' to 'on' predicates ensuring there is enough mortar for each
            bottom_blks = []
            top_blks = []
            for a_tpl in goal_args:
                bottom_blks.append(a_tpl[1])
                top_blks.append(a_tpl[0])

            bottommost_blk = [b for b in bottom_blks if b not in top_blks][0]

            transformed_goal_atoms = []

            # transform goal atoms
            curr_bottom_blk = bottommost_blk
            while curr_bottom_blk in bottom_blks:
                i = bottom_blks.index(curr_bottom_blk)
                top_blks[i]
                if num_available_mortar > 0:
                    transformed_goal_atoms.append("stable-on," + top_blks[i] +
                                                  "," + curr_bottom_blk)
                    num_available_mortar -= 1
                else:
                    transformed_goal_atoms.append("on," + top_blks[i] + "," +
                                                  curr_bottom_blk)
                curr_bottom_blk = top_blks[i]

            # now make actual MIDCA goal objects
            transformed_goals = []
            for atom_str in transformed_goal_atoms:
                vals = atom_str.split(",")
                transformed_goals.append(
                    goals.Goal(*[vals[1], vals[2]], predicate=vals[0]))

            goalGraph = self.mem.get(self.mem.GOAL_GRAPH)

            # do removal first
            for g in goal_atoms:
                goalGraph.remove(g)
            if verbose >= 2:
                # now display success statement
                print("Removed from the goal graph the previous goal:")
                for g in goal_atoms:
                    print("    " + str(g))

            # now display transformed goal
            if verbose >= 2:
                print("Goal has been transformed to:")
                for g in transformed_goals:
                    print("    " + str(g))

            # now insert the new goal
            for g in transformed_goals:
                goalGraph.insert(g)
            if verbose >= 2:
                print("Transformed goal has been inserted into goal graph.")

            return True