def #INITIAL STATE state1 = pyhop.State('state1') state1.connectionRoad = {'C0':{'C1', 'C2'}, 'C1':{'C0', 'C2'}, 'C2':{'C0', 'C2'}}
def main(): state = pyhop.State('state') state.people = {'me': 1, 'assistant': 2, 'janitor': 5, 'professor': 8} state.side = { 'left': {person for person in state.people.keys()}, 'right': set() } state.chosen = [] state.torch = 'left' state.time = 15 pyhop.declare_operators(all_on_right_within_time, none_on_left, walk_people, is_person_on_side, is_not_chosen, has_time, append_person_to_chosen) pyhop.declare_methods( 'pick_person', *[ fun_factory('chose_{:d}'.format(i), i - 1) for i in range(len(state.people.keys())) ]) pyhop.declare_methods('chose_person', chose_person) pyhop.declare_methods('travel_person', travel_person) pyhop.declare_methods('travel_2_people', travel_2_people) pyhop.declare_methods('assert_escape', assert_escape) pyhop.declare_methods('escape', assert_escape, travel_person, travel_2_people) pyhop.pyhop(state, [('escape', )], verbose=3)
def __init__(self): self.current_world_model = pyhop.State("current_world_model") self.current_world_model.tick = 0 self.current_world_model.max_ticks = 100 self.current_world_model.timestamp = time.time() self.current_world_model.location = { "target_object": "table", "servo_values": [1500, 1500, 1500, 1500, 1500, 1500], "init_servo_values": [1500, 1500, 1500, 1500, 1500, 1500] } self.current_world_model.xyz = { "target_object": [-30, -30, 0], "container": [-0.1, 24.0, 12], "end_effector": [-0.1, 24.0, 12] } self.current_world_model.size = {"object_side_length": 4.0} self.current_world_model.min_bounds = { "xyz": [-25, -25, -25], "object_side_length": 0.5 } self.current_world_model.max_bounds = { "xyz": [25, 25, 25], "object_side_length": 6.0 } self.current_world_model.threshold = {"grabbing_distance": 4.5} # cm self.current_world_model.distance = {"distance_to_gripper": 11.2} # cm self.current_world_model.grabbed = {"target_object": False} self.current_world_model.initialized = {"arm": False} self.current_world_model.url = {"arm": "ESP_02662E"} self.current_world_model.init_delay_seconds = {"arm": 5} self.current_world_model.real_time_clock_period_seconds = {"arm": 0.5} # Control if os.path.isfile('json/control.json'): with open('json/control.json') as f: self.current_world_model.control = json.load(f) # Planner if os.path.isfile('json/planner.json'): with open('json/planner.json') as f: self.current_world_model.planner = json.load(f) # Goals self.current_world_model.goals = [ tuple(self.current_world_model.planner["goals"]) ] # Perception if os.path.isfile('json/perception.json'): with open('json/perception.json') as f: self.current_world_model.perception = json.load(f) self.world_model_history = []
def get_start_state(): state = pyhop.State('init') state.days = {} state.days['green'] = [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]] state.days['blue'] = [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]] state.pills = list(state.days.keys()) return state
def test1(): """!@brief (Helper function) Create a state object for test 1 with a slightly different environment. The kettle is open, full and has cold water. @return state state """ state = pyhop.State('Test1 alt 2') state.TOTAL_NUMBER_OF_TEACUPS = 1 state.NUMBER_OF_DIRTY_TEACUPS = 0 state.loc = {'robot':teaathome.Location.startlocation, 'teacup1':teaathome.Location.countertop, 'coldtap':teaathome.Location.kitchensink, 'kettle':teaathome.Location.kettlebase, 'teabag':teaathome.Location.countertop} teacups = 1 while teacups <= state.TOTAL_NUMBER_OF_TEACUPS: state.loc['teacup'+str(teacups)] = teaathome.Location.countertop teacups = teacups + 1 state.accessible = {'kettle':teaathome.Accessible.yes, 'kettlebase':teaathome.Accessible.yes, 'coldtap':teaathome.Accessible.yes, 'teabag':teaathome.Accessible.yes} teacups = 1 while teacups <= state.TOTAL_NUMBER_OF_TEACUPS: state.accessible['teacup'+str(teacups)] = teaathome.Accessible.yes teacups = teacups + 1 state.itemstate = {'kettle':{'openstate':teaathome.Itemstate.closed, 'fillstate':teaathome.Itemstate.full, 'tempstate':teaathome.Itemstate.cold}, 'coldtap':{'openstate':teaathome.Itemstate.closed}} for x in range(1, state.TOTAL_NUMBER_OF_TEACUPS + 1): state.itemstate['teacup'+str(x)] = {'cleanstate':teaathome.Itemstate.clean, 'fillstate':teaathome.Itemstate.empty, 'tempstate':teaathome.Itemstate.cold} #dirtycups = 1 '''while dirtycups <= state.NUMBER_OF_DIRTY_TEACUPS: cup = 'teacup'+str(random.randint(1,state.TOTAL_NUMBER_OF_TEACUPS)) if(state.itemstate[cup]['cleanstate'] == teaathome.Itemstate.unknown): state.itemstate[cup]['cleanstate'] = teaathome.Itemstate.dirty dirtycups = dirtycups + 1''' '''cleancups = 0 while cleancups <= state.NUMBER_OF_DIRTY_TEACUPS: cup = 'teacup'+str(random.randint(1, state.TOTAL_NUMBER_OF_TEACUPS)) if(state2.itemstate[cup]['cleanstate'] == Itemstate.unknown): state2.itemstate[cup]['cleanstate'] = Itemstate.clean cleancups = cleancups + 1''' state.currentcup = '' return state
def test2(): """!@brief (Helper function) Create a state object for test 2. @return state state """ state = pyhop.State('Test2') state.TOTAL_NUMBER_OF_TEACUPS = 76 state.NUMBER_OF_DIRTY_TEACUPS = 30 state.loc = {'robot':teaathome.Location.startlocation, 'coldtap':teaathome.Location.kitchensink, 'kettle':teaathome.Location.kettlebase, 'teabag':teaathome.Location.countertop} teacups = 1 while teacups <= state.TOTAL_NUMBER_OF_TEACUPS: state.loc['teacup'+str(teacups)] = teaathome.Location((random.randint(6, 13))) teacups = teacups + 1 state.accessible = {'kettle':teaathome.Accessible.yes, 'kettlebase':teaathome.Accessible.yes, 'coldtap':teaathome.Accessible.yes, 'teabag':teaathome.Accessible.yes} teacups = 1 while teacups <= state.TOTAL_NUMBER_OF_TEACUPS: state.accessible['teacup'+str(teacups)] = teaathome.Accessible.yes teacups = teacups + 1 state.itemstate = {'kettle':{'openstate':teaathome.Itemstate.closed, 'fillstate':teaathome.Itemstate.empty, 'tempstate':teaathome.Itemstate.cold}, 'coldtap':{'openstate':teaathome.Itemstate.closed}} for x in range(1, state.TOTAL_NUMBER_OF_TEACUPS + 1): state.itemstate['teacup'+str(x)] = {'cleanstate':teaathome.Itemstate.unknown, 'fillstate':teaathome.Itemstate.empty, 'tempstate':teaathome.Itemstate.cold} dirtycups = 1 while dirtycups < state.NUMBER_OF_DIRTY_TEACUPS: cup = 'teacup'+str(random.randint(1,state.TOTAL_NUMBER_OF_TEACUPS)) if(state.itemstate[cup]['cleanstate'] == teaathome.Itemstate.unknown): state.itemstate[cup]['cleanstate'] = teaathome.Itemstate.dirty dirtycups = dirtycups + 1 """cleancups = 0 while cleancups <= numcupsknownclean: cup = 'teacup'+str(random.randint(1, state.TOTAL_NUMBER_OF_TEACUPS)) if(state2.itemstate[cup]['cleanstate'] == Itemstate.unknown): state2.itemstate[cup]['cleanstate'] = Itemstate.clean cleancups = cleancups + 1""" state.currentcup = "" return state
state.num_victims -= 1; return state; def call_success(state, goal): for a in state.ambulances.items(): print(a[0], ": ", a[1]["t"]); if(state.num_victims <= 0): print("Success!!"); return []; else: return False; #############################PYHOP############################ state1 = pyhop.State("state1"); state1.hospitals = hospitals; state1.ambulances = ambulances; state1.victims = victims; state1.num_victims = len(victims); goal1 = pyhop.Goal("goal1"); goal1.num_victims = 0; pyhop.declare_operators(move_ambulance, enter_ambulance, exit_ambulance); pyhop.declare_methods('save_the_victims', save_victim, call_success); pyhop.pyhop(state1,[('save_the_victims', goal1)], verbose=1);
if disk == 0: return [('move', disk, source, dest)] else: num_states_explored = num_states_explored + 1 return False pyhop.declare_methods('move_tower', move_stack, move_disk) print('') pyhop.print_methods() ## Num Disks num_disks = int(sys.argv[1]) num_states_explored = 0 ## Define state state1 = pyhop.State('state1') state1.loc = {} for i in range(0, num_disks): state1.loc[i] = 0 ## Run SHOP planner t0 = time.time() result = pyhop.pyhop(state1, [('move_tower', num_disks - 1, 0, 2, 1)], verbose=0) t1 = time.time() total = t1 - t0 ## Print state count = 0 for i in result: print count, '- Move disk', i[1] + 1, 'from', i[2], 'to', i[3]
def get_travel_data(state, pos): x = places[pos] y = places[pos + 1] data = {'from': x, 'to': y, 'dist': state.dist[x][y]} return data places = [ 'Cracow', 'Cracow-Airport', 'Cayo Guilermo-Airport', 'Cayo Guilermo', 'Long Island', 'Crooked Island', 'Mayaguana', 'Rum Cay', 'Cat Island', 'Cat Island-Airport', 'Cracow-Airport', 'Cracow' ] state0 = pyhop.State('state0') state0.loc = {'me': 'Cracow'} state0.money = {'me': 150000} state0.souvenirs_bought = {'me': 0} state0.souvenirs_made = {'me': 0} state0.photos_available = {'me': 7} state0.dist = { 'Cracow': { 'Cracow-Airport': 20 }, 'Cracow-Airport': { 'Cayo Guilermo-Airport': 7292.18, 'Cat Island-Airport': 10063.81, 'Cracow': 20 }, 'Cayo Guilermo': {
pyhop.print_methods() def make_reachable_by(state, cubes, agent): if not hasattr(state, "isReachableBy"): state.isReachableBy = {} state.isReachableBy.update({c: agent for c in cubes}) def put_on_stack(state, cubes, is_stacked): if not hasattr(state, "isOnStack"): state.isOnStack = {} state.isOnStack.update({c: is_stacked for c in cubes}) state1_h = pyhop.State("state1_h") state1_h.cubes = ["cube1", "cube2", "cube3", "cube4", "cube5", "cube6"] make_reachable_by(state1_h, state1_h.cubes[:3], ["human"]) make_reachable_by(state1_h, state1_h.cubes[3:], ["robot"]) make_reachable_by(state1_h, state1_h.cubes[0:1], ["human", "robot"]) put_on_stack(state1_h, state1_h.cubes, False) state1_h.isCarrying = {"human": None, "robot": None} state1_h.onStack = [] state1_r = deepcopy(state1_h) goal1_h = pyhop.Goal("goal1_h") goal1_h.isOnStack = {"cube4": True, "cube1": True, "cube6": True} goal1_h.onStack = ["cube4", "cube1", "cube6"] goal1_r = deepcopy(goal1_h)
""" The "travel from home to the park" example from my lectures. Author: Dana Nau <*****@*****.**>, May 31, 2013 This file should work correctly in both Python 2.7 and Python 3.2. """ import pyhop import random import sys from utils_plan import * from util_plot import * # state variables state1 = pyhop.State('state') state1.status = 3 state1.concepts = ["Concept A", "Concept B", "Concept C"] state1.relations = ["Relation A", "Relation B", "Relation C"] state1.concepts_heard_count = [0, 0, 0] state1.relations_heard_count = [0, 0, 0] state1.variables = pyhop.State('variables') state1.variables.affect = pyhop.State('affect') state1.variables.affect.skill = 0 state1.variables.affect.challenge = 0 state1.variables.affect.boredom = 2 state1.variables.affect.frustration = -2 state1.variables.affect.confidence = DictEx(2) # end - state variables # Operators
def order_chinese(state, agent, full): if state.time[agent] >= 18: if state.money[agent] >= 25: if state.fullness[agent] + 0.6 < full: return [('chinese', agent),("eating", agent, full)] else: return [('chinese', agent)] return False pyhop.declare_methods('eating', order_pizza, order_burger, order_chinese, cook) print '\n' pyhop.print_methods() person = pyhop.State('state') person.fullness = {'me_friends': 0.0} person.time = {'me_friends': 200} person.money = {'me_friends': 80} pyhop.pyhop(person, [('eating', 'me_friends', 3.0)], verbose=3) person.fullness = {'me_friends': 0.0} person.time = {'me_friends': 220} person.money = {'me_friends': 100} pyhop.pyhop(person, [('eating', 'me_friends', 3.0)], verbose=3) person.fullness = {'me_friends': 0.0} person.time = {'me_friends': 1000} person.money = {'me_friends': 30}
if actor == "arm": if state.initialized["arm"]: return [('grab', actor, actee, from_), ('put', actor, actee, to_)] pyhop.failure_reason = "{} can't transfer {} from {} to {}".format( actor, actee, from_, to_) return False pyhop.declare_methods('transfer_ball_to_container', initialize_transfer) pyhop.declare_methods('transfer_ball_to_container2', put_grabbed, transfer) print('') pyhop.print_methods() current_world_model = pyhop.State('current_world_model') current_world_model.tick = 0 current_world_model.timestamp = time.time() current_world_model.location = {'ball': 'table'} current_world_model.grabbed = {'ball': True} current_world_model.initialized = {'arm': True} current_world_model.min_bounds = {'xyz': [-25, -25, -25]} current_world_model.max_bounds = {'xyz': [25, 25, 25]} current_world_model.plans = "None" htn_plans = pyhop.pyhop( current_world_model, [('transfer_ball_to_container', 'arm', 'ball', 'table', 'container')], verbose=1, all_plans=True, sort_asc=True)
''' Created on Sep 2, 2018 @author: Shane ''' import pyhop import Queue state1 = pyhop.State('state1') state1.at = {'robot': 'dock', 'birthCertificate': 'Office 1'} state1.holding = None state1.signed = [] state1.shredded = [] prob1 = [('goAndGet', 'birthCertificate'), ('takeAndSign', 'birthCertificate', 'Office 2'), ('deliver', 'birthCertificate', 'Office 1')] prob12 = [('take_deliver', 'birthCertificate', 'Office 2')] prob13 = [('take_sign_deliver', 'birthCertificate', 'Office 3', 'Office 2')] state2 = pyhop.State('state2') state2.at = { 'robot': 'dock', 'Doc1': 'AlbertsOffice', 'Doc2': 'StusOffice', 'Doc3': 'TedsOffice' } state2.holding = None state2.signed = [] state2.shredded = []
def generate_new_state(stateName): return pyhop.State(stateName)
def travel_by_goal_state(state, goal): # Get the problem domain info related file fo = openFile('static_value.txt') exec('content=' + fo.read()) global static_state static_state = pyhop.State("static") for stateItem in content: # Load the problem domain info into the state exec("static_state." + stateItem) a = state.target x = state.loc[a] y = goal.loc[a] t = state.time[a] cashX = state.cash[a] if hasattr(goal, 'cash'): cashY = goal.cash[a] else: cashY = 0 # Get the nearest bus stop bs = state.nearest_bus_stop[state.target] # Get the bus fair bus_fair = bus_rate(distance(bs, y)) if distance(x, y) <= 2 and t >= time_cost_walk(distance(x, y)): # If walking is possible, then travel by foot return travel_by_foot(state, a, x, y) elif cashX >= taxi_rate(distance(x,y)) and cashY<=cashX-taxi_rate(distance(x,y)) \ and t >= time_cost_taxi(distance(x,y)): # If taxi travel is possible, then travel by taxi return travel_by_taxi(state, a, x, y) elif cashX >= bus_fair and cashY <= cashX - bus_fair \ and distance(x,bs) <= 2 and (bs+':'+y in static_state.bus_route) \ and t >= time_cost_bus(distance(x,y)): # If bus travel is possible, then travel by bus return travel_by_bus(state, a, x, y) elif y != 'bank': # If no travel is possible, now we will try to go to the bank to withdraw some money # and continue the journey from there # Intermediate state will be the bank location intermediateState = generate_new_state('intermediateState') intermediateState.loc = {} intermediateState.cash = {} intermediateState.cash = {} intermediateState.time = {} intermediateState.balance_bank = {} intermediateState.nearest_bus_stop = {} intermediateState.target = 'me' intermediateState.loc[state.target] = 'bank' intermediateState.loc['bus'] = state.loc['bus'] intermediateState.cash[state.target] = taxi_rate(distance('bank', y)) intermediateState.balance_bank[state.target] = state.balance_bank[ state.target] intermediateState.nearest_bus_stop[ state.target] = state.nearest_bus_stop[state.target] # Find the plan to the bank from the source state plan1 = pyhop.pyhop(state, [('travel_by_goal', intermediateState)], verbose=0) # Get the cost of this intermediate plan cost1 = costForPlan(plan1) # Reduce the amount by cost1 intermediateState.cash[state.target] = state.cash[state.target] - cost1 if plan1 != False: # Now we have a plan to travel to the bank # Need one more plan to travel to the goal from the bank # Amount needed to reach the goal from the bank amount_needed = cost1+taxi_rate(distance('bank',y))+\ goal.cash[state.target]-state.cash[state.target]+3.0 # Get a plan to withdraw necessary amount from the bank plan2 = withdraw_money_from_bank(intermediateState, a, amount_needed) # If we have that much money in the bank, the plan will pass if plan2 != False: # Append the withdraw money plan at the end of the first plan plan1.extend(plan2) # Reflect the time remaining intermediateState.time[state.target] = state.time[state.target] # Find the next plan of going to the destination from the bank plan3 = pyhop.pyhop(intermediateState, [('travel_by_goal', goal)], verbose=0) if plan3 != False: # All plans are passed, extend the last plan at the end plan1.extend(plan3) return plan1 return False else: return False