def fc_test():
engine.reset()
try:
engine.activate('fc_findall')
except:
krb_traceback.print_exc()
sys.exit(1)
def bc_test(person1='bruce'):
engine.reset() # Allows us to run tests multiple times.
start_time = time.time()
engine.activate('bc_example')
fc_end_time = time.time()
fc_time = fc_end_time - start_time
print("doing proof")
try:
with engine.prove_goal(
'bc_example.how_related($person1, $person2, $relationship)',
person1=person1) \
as gen:
for vars, plan in gen:
print("%s, %s are %s" % \
(person1, vars['person2'], vars['relationship']))
except Exception:
# This converts stack frames of generated python functions back to the
# .krb file.
krb_traceback.print_exc()
sys.exit(1)
prove_time = time.time() - fc_end_time
print()
print("done")
engine.print_stats()
print("bc time %.2f, %.0f goals/sec" % \
(prove_time, engine.get_kb('bc_example').num_prove_calls / prove_time))
def fc_test(coil_kind, external_diameter, width, status1=1, Flag='0'):
fc_goal = goal.compile('coil_area.move_area($coil_kind,$area,$status)')
try:
with fc_goal.prove(engine, coil_kind=coil_kind, status=status1) as gen:
for vars, plan in gen:
# 读取数据库中库区的信息
# 当前库区的最大长度
Max_Length = select_data('UACS_STOCK_INFO', vars['area'])[0]
# 当前库区的最大宽度
Max_Width = select_data('UACS_STOCK_INFO', vars['area'])[1]
# 当前库区的库容率
Current_Ratio = select_data('UACS_STOCK_INFO', vars['area'])[2]
# 计算该钢卷放入之后的库容率
Cal_Capacity = Current_Ratio + (external_diameter * width) / (
Max_Length * Max_Width)
# print "若该钢卷放入%s区域，库容率为%f"%(vars['area'],Cal_Capacity)
if Cal_Capacity < 1 and Flag == '0':
print "%s should be played in %s" % (coil_kind,
vars['area'])
return vars['area']
if Cal_Capacity >= 1 or Flag == '1':
if Flag == '1':
print "the saddle of %s area is full" % (vars['area'])
else:
print "the %s area is full" % (vars['area'])
status_n = status1 + 1
return fc_test(coil_kind,
external_diameter,
width,
status1=status_n)
return "null"
except:
print "something err"
krb_traceback.print_exc()
sys.exit()
def general(person1=None, person2=None, relationship=None):
engine.reset() # Allows us to run tests multiple times.
start_time = time.time()
engine.activate('bc2_example') # same rule base as bc2_test()
fc_end_time = time.time()
fc_time = fc_end_time - start_time
print("doing proof")
args = {}
if person1: args['person1'] = person1
if person2: args['person2'] = person2
if relationship: args['relationship'] = relationship
try:
with engine.prove_goal(
'bc2_example.how_related($person1, $person2, $relationship)',
**args) as gen:
for vars, plan in gen:
print("%s, %s are %s" %
(vars['person1'], vars['person2'], vars['relationship']))
except Exception:
# This converts stack frames of generated python functions back to the
# .krb file.
krb_traceback.print_exc()
sys.exit(1)
prove_time = time.time() - fc_end_time
print()
print("done")
engine.print_stats()
print("bc time %.2f, %.0f goals/sec" % \
(prove_time,
engine.get_kb('bc2_example').num_prove_calls / prove_time))
def fc_test():
engine.reset()
try:
engine.activate('fc_findall')
except:
krb_traceback.print_exc()
sys.exit(1)
def test(person1='bruce'):
engine.reset() # Allows us to run tests multiple times.
# Also runs all applicable forward-chaining rules.
start_time = time.time()
engine.activate('example')
fc_end_time = time.time()
fc_time = fc_end_time - start_time
print("doing proof")
try:
# In this case, the relationship is returned when you run the plan.
with engine.prove_goal(
'example.how_related($person1, $person2)',
person1=person1) \
as gen:
for vars, plan in gen:
print("%s, %s are %s" % (person1, vars['person2'], plan()))
except Exception:
# This converts stack frames of generated python functions back to the
# .krb file.
krb_traceback.print_exc()
sys.exit(1)
prove_time = time.time() - fc_end_time
print()
print("done")
engine.print_stats()
print("fc time %.2f, %.0f asserts/sec" % \
(fc_time, engine.get_kb('family').get_stats()[2] / fc_time))
print("bc time %.2f, %.0f goals/sec" % \
(prove_time, engine.get_kb('example').num_prove_calls / prove_time))
print("total time %.2f" % (fc_time + prove_time))
def general(person1=None, person2=None, relationship=None):
engine.reset() # Allows us to run tests multiple times.
start_time = time.time()
engine.activate("bc2_example") # same rule base as bc2_test()
fc_end_time = time.time()
fc_time = fc_end_time - start_time
print "doing proof"
args = {}
if person1:
args["person1"] = person1
if person2:
args["person2"] = person2
if relationship:
args["relationship"] = relationship
try:
with engine.prove_goal("bc2_example.how_related($person1, $person2, $relationship)", **args) as gen:
for vars, plan in gen:
print "%s, %s are %s" % (vars["person1"], vars["person2"], vars["relationship"])
except StandardError:
# This converts stack frames of generated python functions back to the
# .krb file.
krb_traceback.print_exc()
sys.exit(1)
prove_time = time.time() - fc_end_time
print
print "done"
engine.print_stats()
print "bc time %.2f, %.0f goals/sec" % (prove_time, engine.get_kb("bc2_example").num_prove_calls / prove_time)
def test(person1="bruce"):
engine.reset() # Allows us to run tests multiple times.
# Also runs all applicable forward-chaining rules.
start_time = time.time()
engine.activate("example")
fc_end_time = time.time()
fc_time = fc_end_time - start_time
print "doing proof"
try:
# In this case, the relationship is returned when you run the plan.
with engine.prove_goal("example.how_related($person1, $person2)", person1=person1) as gen:
for vars, plan in gen:
print "%s, %s are %s" % (person1, vars["person2"], plan())
except StandardError:
# This converts stack frames of generated python functions back to the
# .krb file.
krb_traceback.print_exc()
sys.exit(1)
prove_time = time.time() - fc_end_time
print
print "done"
engine.print_stats()
print "fc time %.2f, %.0f asserts/sec" % (fc_time, engine.get_kb("family").get_stats()[2] / fc_time)
print "bc time %.2f, %.0f goals/sec" % (prove_time, engine.get_kb("example").num_prove_calls / prove_time)
print "total time %.2f" % (fc_time + prove_time)
def bc_test(rb_names, goal, num_return, args = (), rb_name = None,
plan_args = None, plan_kws = None):
Engine.reset()
try:
if isinstance(rb_names, types.StringTypes): rb_names = (rb_names,)
for rb_name in rb_names:
Engine.activate(rb_name)
if rb_name is None: rb_name = rb_names[0]
with Engine.prove_n(rb_name, goal, args, num_return) as gen:
for ret_args, plan in gen:
first = True
for ret_arg in ret_args:
if first: first = False
else: print ",",
print ret_arg,
print
if plan_args is None and plan_kws is None:
assert plan is None, "unexpected plan"
else:
assert plan is not None, "expected plan"
print "plan:"
if plan_args is None: ans = plan(**plan_kws)
elif plan_kws is None: ans = plan(*plan_args)
else: ans = plan(*plan_args, **plan_vars)
if ans is not None: print ans
except:
krb_traceback.print_exc()
sys.exit(1)
def evaluate(self, kb, rule, subject):
""" Evaluates a rule or fact in the knowledge base
Args:
kb: Knowledge base to be checked
rule: Rule/Fact to be checked
actor: Entity performing the action. Defaults to the player
subject: The target of the action
"""
# To expand the subject arg, refer to:
# http://stackoverflow.com/questions/6913084/how-to-split-list-and-pass-them-as-separate-parameter
# Useful with FrameNet API
# Construct argument string for testing the rule
self.engine.reset()
if kb is not None:
self.arg_string = kb + "." + rule
print("KB: " + kb)
print("arg_string: " + self.arg_string)
print("Subject: " + subject)
print("Current KB: " + str(self.currentKB))
print("New KB: " + (kb))
try:
self.engine.activate(kb)
if self.engine.prove_1_goal(self.arg_string + "("")"):
return True
except StandardError:
krb_traceback.print_exc()
return False
def myTest():
engine = knowledge_engine.engine(__file__)
engine.activate('subway_rules')
kb = engine.get_kb('subway')
kb.dump_universal_facts()
print("Specific facts are:")
engine.get_kb('subway').dump_specific_facts()
# all forward-chaining rules are run
print("doing proof")
try:
stmt = 'subway.at_station(Airport)' # {}
stmt = 'subway_rules.at_station($a)'
# take_line($from, $line, $to)
# stmt = 'subway_rules.take_line(Airport, $a, $b)'
# stmt = 'subway_rules.connected(Airport, $b)'
# stmt = 'subway_rules.half_sibling($af, $bf)'
with engine.prove_goal(stmt) as gen:
for variable, plan in gen:
print(variable)
# print("%s at_station" % (variable['a']))
except Exception:
# This converts stack frames of generated python functions back to the
# .krb file.
krb_traceback.print_exc()
sys.exit(1)
print()
print("done")
engine.print_stats()
def bc_test(person1 = 'bruce'):
engine.reset() # Allows us to run tests multiple times.
start_time = time.time()
engine.activate('bc_example')
fc_end_time = time.time()
fc_time = fc_end_time - start_time
print "doing proof"
try:
with engine.prove_goal(
'bc_example.how_related($person1, $person2, $relationship)',
person1=person1) \
as gen:
for vars, plan in gen:
print "%s, %s are %s" % \
(person1, vars['person2'], vars['relationship'])
except StandardError:
# This converts stack frames of generated python functions back to the
# .krb file.
krb_traceback.print_exc()
sys.exit(1)
prove_time = time.time() - fc_end_time
print
print "done"
engine.print_stats()
print "bc time %.2f, %.0f goals/sec" % \
(prove_time, engine.get_kb('bc_example').num_prove_calls / prove_time)
def create_stackup():
fc_goal = goal.compile('pcb.needs_gnd_layer($net)')
engine.reset() # Allows us to run tests multiple times.
# Also runs all applicable forward-chaining rules.
start_time = time.time()
engine.activate('fc_pcb')
#print "dumping facts..:"
#engine.get_kb('pcb').dump_universal_facts()
fc_end_time = time.time()
fc_time = fc_end_time - start_time
print "Requires neighboring gnd layer:"
try:
# In this case, the relationship is returned when you run the plan.
with fc_goal.prove(
engine\
) \
as gen:
for vars, plan in gen:
print "%s" % (vars['net'])
#print "%s is a suitable material for %s" % (vars['material'], vars['net'])
except StandardError:
# This converts stack frames of generated python functions back to the
# .krb file.
krb_traceback.print_exc()
sys.exit(1)
def run():
engine.reset()
try:
engine.activate('pattern_matching')
engine.prove_1_goal('pattern_matching.knows_pattern_matching()')
except Exception:
krb_traceback.print_exc()
sys.exit(1)
def fc_test():
consulta()
engine.reset()
try:
engine.activate('fc_diagnostico')
except:
krb_traceback.print_exc()
sys.exit(1)
def run():
engine.reset()
try:
engine.activate('anime_suggestion')
engine.prove_1_goal('anime_suggestion.getting_started()')
except Exception:
krb_traceback.print_exc()
sys.exit(1)
def fc_test(*rb_names):
Engine.reset()
try:
for rb_name in rb_names:
Engine.activate(rb_name)
except:
krb_traceback.print_exc()
sys.exit(1)
def run():
engine.reset()
try:
engine.activate('pattern_matching')
engine.prove_1_goal('pattern_matching.knows_pattern_matching()')
except StandardError:
krb_traceback.print_exc()
sys.exit(1)
def step(self, universe):
"""The agent generates his plan and tries to execute it."""
self.ke = universe.ke
if (self.satisfied):
return
# Generate a new plan if needed
if self.running_plan is None:
plan = None
for goal in self.goals:
initial_state = []
# Extract informations from the knowledge.
initial_state.extend(self.knowledge)
if type(goal[0]) != tuple:
final_state = (goal,)
else:
final_state = goal
# reset the knowledge engine
self.ke.reset()
try:
self.ke.activate('universe_rules', 'facts',
'actions_plan', 'planning',
'actions_exec', 'execution')
except:
krb_traceback.print_exc()
try:
# Generate the plan (can fail)
plan = self.gen_plan(initial_state, final_state)
if plan is None:
# Successfully generated a no-op plan
self.goals.remove(goal)
break
except CanNotProve as e:
# Cannot prove the plan, so do nothing.
continue
if plan is not None:
plan = list(plan)
self.running_plan = plan
self.running_goal = goal
# Execute running plan
if self.running_plan is not None:
success = self.execute(universe)
if success:
if (len(self.running_plan) == 0):
self.running_plan = None
self.goals.remove(self.running_goal)
self.running_goal = None
# If the agent has completed all its goals, it is satisfied.
if len(self.goals) == 0:
self.satisfied = True
def step(self, universe):
"""The agent generates his plan and tries to execute it."""
self.ke = universe.ke
if (self.satisfied):
return
# Generate a new plan if needed
if self.running_plan is None:
plan = None
for goal in self.goals:
initial_state = []
# Extract informations from the knowledge.
initial_state.extend(self.knowledge)
if type(goal[0]) != tuple:
final_state = (goal, )
else:
final_state = goal
# reset the knowledge engine
self.ke.reset()
try:
self.ke.activate('universe_rules', 'facts', 'actions_plan',
'planning', 'actions_exec', 'execution')
except:
krb_traceback.print_exc()
try:
# Generate the plan (can fail)
plan = self.gen_plan(initial_state, final_state)
if plan is None:
# Successfully generated a no-op plan
self.goals.remove(goal)
break
except CanNotProve as e:
# Cannot prove the plan, so do nothing.
continue
if plan is not None:
plan = list(plan)
self.running_plan = plan
self.running_goal = goal
# Execute running plan
if self.running_plan is not None:
success = self.execute(universe)
if success:
if (len(self.running_plan) == 0):
self.running_plan = None
self.goals.remove(self.running_goal)
self.running_goal = None
# If the agent has completed all its goals, it is satisfied.
if len(self.goals) == 0:
self.satisfied = True
def run(rule_bases_to_activate,
default_rb=None,
init_fn=None,
fn_to_run_plan=eval_plan,
plan_globals={}):
if not Did_init: init()
if not isinstance(rule_bases_to_activate, (tuple, list)):
rule_bases_to_activate = (rule_bases_to_activate, )
if default_rb is None: default_rb = rule_bases_to_activate[0]
while True:
print()
goal_str = input("goal: ")
if not goal_str: break
goal, args_str = parse(goal_str)
if goal == "trace":
args = args_str.split()
if len(args) == 1:
Engine.trace(default_rb, args[0])
else:
Engine.trace(*args)
continue
if goal == "untrace":
args = args_str.split()
if len(args) == 1:
Engine.untrace(default_rb, args[0])
else:
Engine.untrace(*args)
continue
args_str = args_str.strip()
rb_name = default_rb
if args_str[0] == '.':
rb_name = goal
goal, args_str = parse(args_str[1:])
args = parse(args_str)[0]
print("proving: %s.%s%s" % (rb_name, goal, args))
goal_args = tuple(as_pattern(arg) for arg in args)
Engine.reset()
if init_fn: init_fn(Engine)
context = contexts.simple_context()
try:
Engine.activate(*rule_bases_to_activate)
with Engine.prove(rb_name, goal, context, goal_args) as it:
for prototype_plan in it:
final = {}
print("got: %s%s" % \
(goal, tuple(arg.as_data(context, True, final)
for arg in goal_args)))
if not prototype_plan:
print("no plan returned")
else:
plan = prototype_plan.create_plan(final)
fn_to_run_plan(plan_globals, locals())
except:
krb_traceback.print_exc(100)
def bc_test():
engine.reset()
try:
engine.activate('bc_forall')
with engine.prove_goal('bc_forall.no_step_siblings($child)') as gen:
for vars, plan in gen:
print vars['child']
except:
krb_traceback.print_exc()
sys.exit(1)
def bc_test():
engine.reset()
try:
engine.activate('bc_forall')
with engine.prove_goal('bc_forall.no_step_siblings($child)') as gen:
for vars, plan in gen:
print(vars['child'])
except:
krb_traceback.print_exc()
sys.exit(1)
def run(rule_bases_to_activate,
default_rb = None, init_fn = None, fn_to_run_plan = eval_plan,
plan_globals = {}):
if not Did_init: init()
if not isinstance(rule_bases_to_activate, (tuple, list)):
rule_bases_to_activate = (rule_bases_to_activate,)
if default_rb is None: default_rb = rule_bases_to_activate[0]
while True:
print
goal_str = raw_input("goal: ")
if not goal_str: break
goal, args_str = parse(goal_str)
if goal == "trace":
args = args_str.split()
if len(args) == 1:
Engine.trace(default_rb, args[0])
else:
Engine.trace(*args)
continue
if goal == "untrace":
args = args_str.split()
if len(args) == 1:
Engine.untrace(default_rb, args[0])
else:
Engine.untrace(*args)
continue
args_str = args_str.strip()
rb_name = default_rb
if args_str[0] == '.':
rb_name = goal
goal, args_str = parse(args_str[1:])
args = parse(args_str)[0]
print "proving: %s.%s%s" % (rb_name, goal, args)
goal_args = tuple(as_pattern(arg) for arg in args)
Engine.reset()
if init_fn: init_fn(Engine)
context = contexts.simple_context()
try:
Engine.activate(*rule_bases_to_activate)
with Engine.prove(rb_name, goal, context, goal_args) as it:
for prototype_plan in it:
final = {}
print "got: %s%s" % \
(goal, tuple(arg.as_data(context, True, final)
for arg in goal_args))
if not prototype_plan:
print "no plan returned"
else:
plan = prototype_plan.create_plan(final)
fn_to_run_plan(plan_globals, locals())
except:
krb_traceback.print_exc(100)
def bc_test():
engine.reset()
try:
engine.activate('bc_findall')
with engine.prove_goal('bc_findall.cousins_of($child, $cousins)') \
as gen:
for vars, plan in gen:
print "%s has %s as cousins" % (vars['child'], vars['cousins'])
except:
krb_traceback.print_exc()
sys.exit(1)
def bc_test():
engine.reset()
try:
engine.activate('bc_findall')
with engine.prove_goal('bc_findall.cousins_of($child, $cousins)') \
as gen:
for vars, plan in gen:
print("%s has %s as cousins" % (vars['child'], vars['cousins']))
except:
krb_traceback.print_exc()
sys.exit(1)
def test(num_disks):
engine.reset()
try:
engine.activate('towers_of_hanoi')
with engine.prove_goal('towers_of_hanoi.solve($num_disks, $moves)',
num_disks=num_disks) \
as gen:
for i, (vars, no_plan) in enumerate(gen):
print "got %d:" % (i + 1), vars['moves']
except:
krb_traceback.print_exc()
sys.exit(1)
def test(num_disks):
engine.reset()
try:
engine.activate('towers_of_hanoi')
with engine.prove_goal('towers_of_hanoi.solve($num_disks, $moves)',
num_disks=num_disks) \
as gen:
for i, (vars, no_plan) in enumerate(gen):
print("got %d:" % (i + 1), vars['moves'])
except:
krb_traceback.print_exc()
sys.exit(1)
def test():
engine.reset()
try:
engine.assert_('sports', 'weighs', ('p1', 100))
engine.assert_('sports', 'weighs', ('p2', 200))
engine.activate('bc_sports')
with engine.prove_goal('bc_sports.heavier($h, $l)') as goal:
for vars, plan in goal:
print vars
print engine.prove_1_goal('bc_sports.heavier(p2, p1)')
#print engine.prove_1_goal('bc_sports.heavier(p1, p2)')
except:
krb_traceback.print_exc()
sys.exit(1)
def bc_test(client="client1"):
engine.reset()
try:
engine.activate('bc_functions')
with engine.prove_goal('bc_functions.findB($client)',
client=client) as gen:
for k, v in gen:
print("iter")
print(k)
print(v())
print("----")
except:
krb_traceback.print_exc()
sys.exit(1)
def present_activities(self):
if self.mode == "online":
self.is_running = False
elif self.mode == "offline":
self.answer_list = []
for items in question_list1:
for i in range(len(items.answer)):
if items.answer[i] == True:
self.answer_list.append(
(items.question_num, self.INDEX_ANSWER_DICT[i]))
for items in question_list2:
for i in range(len(items.answer)):
if items.answer[i] == True:
self.answer_list.append(
(items.question_num, self.INDEX_ANSWER_DICT[i]))
engine = knowledge_engine.engine(__file__)
engine.reset()
engine.activate('category_rules')
for answers in self.answer_list:
engine.assert_('answer', 'question', answers)
print("Facts gathered:")
engine.get_kb('answer').dump_specific_facts()
try:
vars, plan = engine.prove_1_goal(
'category_rules.top2($category1, $category2)')
print()
print("Top 2 Activity Categories selected are: %s, %s" %
(self.RBS_CATEGORIES_DICT[vars['category1']],
self.RBS_CATEGORIES_DICT[vars['category2']]))
print()
except knowledge_engine.CanNotProve:
krb_traceback.print_exc()
self.user_preferences = list(
(self.RBS_CATEGORIES_DICT[vars['category1']],
self.RBS_CATEGORIES_DICT[vars['category2']]))
selector_obj = Selector.city_selector()
throwaway, self.cities_and_activities_results_list = selector_obj.find_matching_city(
self.user_preferences)
self.show_offline_result()
def bc_test():
engine.reset()
try:
engine.activate('bc_syll')
with engine.prove_goal('bc_syll.all($S, $P)') as goalAll:
for vars, plan in goalAll:
print 'All that are', vars['S'], 'are', vars['P']
with engine.prove_goal('bc_syll.some($S, $P)') as goalSome:
# looking for "some elderly are mortal"
for vars, plan in goalSome:
print 'Some that are', vars['S'], 'are', vars['P']
except:
krb_traceback.print_exc()
sys.exit(1)
def getoffering(product):
results = []
engine = start()
engine.reset()
try:
getfacts(engine)
engine.activate('fc_components')
with engine.prove_goal('vendors.vendor_offering_supports_forcost($vendor, $offering, '+product+', $cost)') as gen:
for (r, p) in gen:
results.append(r)
except:
krb_traceback.print_exc()
sys.exit(1)
return results
def general(lista):
engine.reset()
start_time = time.time()
engine.activate('bc_regras')
fc_end_time = time.time()
fc_time = fc_end_time - start_time
febre, dia_febre, dia_manchas, dorMuscular, dorArticulacao, intesiDorArtic, edema, conjuntivite, dorCabeca, coceira, hipertrofia, discrasia, acometimento, neonato = lista
#hipertrofia, discrasia, acometimento, neonato = lista
args = {}
if febre: args['febre'] = febre
if dia_febre: args['dia_febre'] = dia_febre
if dia_manchas: args['dia_manchas'] = dia_manchas
if dorMuscular: args['dorMuscular'] = dorMuscular
if dorArticulacao: args['dorArticulacao'] = dorArticulacao
if intesiDorArtic: args['intesiDorArtic'] = intesiDorArtic
if edema: args['edema'] = edema
if conjuntivite: args['conjuntivite'] = conjuntivite
if dorCabeca: args['dorCabeca'] = dorCabeca
if coceira: args['coceira'] = coceira
if hipertrofia: args['hipertrofia'] = hipertrofia
if discrasia: args['discrasia'] = discrasia
if acometimento: args['acometimento'] = acometimento
if neonato: args['neonato'] = neonato
#if doenca: args['doenca'] = doenca
try:
with engine.prove_goal(
'bc_regras.diagnostico_resultado ($febre, $dia_febre, $dia_manchas, $dorMuscular, $dorArticulacao, $intesiDorArtic, $edema, $conjuntivite, $dorCabeca, $coceira, $hipertrofia, $discrasia, $acometimento, $neonato, $doenca)',
#'bc_regras.diagnostico_4 ($hipertrofia, $discrasia, $acometimento, $neonato, $doenca)',
**args) as gen:
for vars, plan in gen:
print("Provavelmente é %s" % vars['doenca'])
except Exception:
krb_traceback.print_exc()
sys.exit(1)
prove_time = time.time() - fc_end_time
print('\n done')
def bc_test():
engine.reset()
try:
engine.activate('bc_notany')
#with engine.prove_goal(
# 'bc_notany.siblings($sibling1, $sibling2, $_, $_)') \
# as gen1:
# for vars, plan in gen1:
# print "siblings:", vars['sibling1'], vars['sibling2']
with engine.prove_goal('bc_notany.child_with_no_aunt($child)') as gen2:
for vars, plan in gen2:
print vars['child'], "has no aunt"
with engine.prove_goal('bc_notany.child_with_no_uncle($child)') as gen3:
for vars, plan in gen3:
print vars['child'], "has no uncle"
except:
krb_traceback.print_exc()
sys.exit(1)
def recommend_controlled_z():
fc_goal = goal.compile('pcb.needs_ctrl_z($net)')
engine.reset() # Allows us to run tests multiple times.
# Runs all applicable forward-chaining rules.
engine.activate('fc_pcb')
print "Requires controlled impedance tracewidth:"
try:
# In this case, the relationship is returned when you run the plan.
with fc_goal.prove(
engine\
) \
as gen:
for vars, plan in gen:
print "%s" % (vars['net'])
#print "%s is a suitable material for %s" % (vars['material'], vars['net'])
except StandardError:
# This converts stack frames of generated python functions back to the
# .krb file.
krb_traceback.print_exc()
sys.exit(1)
def bc_test():
engine.reset()
try:
engine.activate('bc_notany')
#with engine.prove_goal(
# 'bc_notany.siblings($sibling1, $sibling2, $_, $_)') \
# as gen1:
# for vars, plan in gen1:
# print "siblings:", vars['sibling1'], vars['sibling2']
with engine.prove_goal('bc_notany.child_with_no_aunt($child)') as gen2:
for vars, plan in gen2:
print(vars['child'], "has no aunt")
with engine.prove_goal(
'bc_notany.child_with_no_uncle($child)') as gen3:
for vars, plan in gen3:
print(vars['child'], "has no uncle")
except:
krb_traceback.print_exc()
sys.exit(1)
def myTest():
# knowledge_engine.debug = True
engine = knowledge_engine.engine(__file__)
# engine = knowledge_engine.engine()
# engine.add_universal_fact('family', 'son_of', ('david', 'bruce'))
# engine.get_kb('family').dump_universal_facts()
# engine.get_kb('family').dump_specific_facts()
# son_of('david', 'bruce')
# engine.reset()
engine.activate('example')
kb = engine.get_kb('family')
kb.dump_universal_facts()
print("Specific facts are:")
engine.get_kb('family').dump_specific_facts()
# all forward-chaining rules are run
print("doing proof")
try:
with engine.prove_goal('example.real_siblings($a, $b)') as gen:
for variable, plan in gen:
print("%s and %s" % (variable['a'], variable['b']))
except Exception:
# This converts stack frames of generated python functions back to the
# .krb file.
krb_traceback.print_exc()
sys.exit(1)
print("doing second proof")
try:
with engine.prove_goal('example.half_sibling($a, $b)') as gen:
for variable, plan in gen:
print("%s, %s are half_siblings" % (variable['a'], variable['b']))
except Exception:
# This converts stack frames of generated python functions back to the
# .krb file.
krb_traceback.print_exc()
sys.exit(1)
print()
print("done")
engine.print_stats()
def getremedy(fault):
engine.reset()
i = -1
try:
engine.activate('remedyget')
c_check = input("Is cost an issue?:[y/n]")
c_check = c_check[0].lower()
t_check = input("Is time an issue?;[y/n]")
t_check = t_check[0].lower()
with engine.prove_goal('remedyget.get($fault,$remedy)',
fault=fault) as gen:
for i, (vars, no_plan) in enumerate(gen):
remedy = tuple(vars['remedy'])
ob = REMEDY(remedy[0], remedy[1], remedy[2])
remedy_list.append(ob)
if (c_check == "y" and t_check == "y"):
min_heap("prod")
elif (c_check == "y"):
min_heap("cost")
elif (t_check == "y"):
min_heap("time")
else: #No priority to solution...displaying all
print("Remedy:", remedy[0])
if i == -1:
print("No remedy available")
elif (c_check == "y" or t_check == "y"):
print("\nRemedy:", remedy_list[0].name, "Cost:",
remedy_list[0].cost, "Time:", remedy_list[0].time,
"is the best solution")
print("All solutions: ")
#print("The remedy to the fault: ",fault,"; is ", vars['remedy'])
#print (vars)
except:
krb_traceback.print_exc()
sys.exit(1)
def forwardChani():
try:
engine.reset()
engine.activate('rules')
with engine.prove_goal('rules.diagnostico($resultado)') as gen:
for i, (vars, no_plan) in enumerate(gen):
resultado = vars['resultado']
total = resultado[0] + resultado[1] + resultado[2] + resultado[
3]
print("Denge: ", round(100 * resultado[0] / total),
"% de chance ")
print("Zika: ", round(100 * resultado[1] / total),
"% de chance ")
print("Chikungunya: ", round(100 * resultado[2] / total),
"% de chance ")
print("Outro: ", round(100 * resultado[3] / total),
"% de chance ")
except:
krb_traceback.print_exc()
sys.exit(1)
def getremedy():
engine.reset()
i = -1
global remedy_list
try:
#inputs
engine.activate('Remedyrule')
a_time = input(
"Enter application response time is less than or greater than 15[less\greater]"
)
print("Virtual Machine Paramaeters")
storage1 = int(input("Enter Storage percentage:[0-100]"))
memory1 = int(input("Enter Memory percentage:[0-100]"))
network1 = int(input("Enter Network level:[0-100]"))
cpu1 = int(input("Enter CPU level:[0-100]"))
storage11 = scale(storage1)
memory11 = scale(memory1)
network11 = scale(network1)
cpu11 = scale(cpu1)
print("\nPhysical Machine Parameters")
storage2 = int(input("Enter Storage percentage:[0-100]"))
memory2 = int(input("Enter Memory percentage:[0-100]"))
network2 = int(input("Enter Network level:[0-100]"))
cpu2 = int(input("Enter CPU level:[0-100]"))
storage22 = scale(storage2)
memory22 = scale(memory2)
network22 = scale(network2)
cpu22 = scale(cpu2)
fault = (a_time, (storage11, memory11, network11, cpu11),
(storage22, memory22, network22, cpu22))
print(fault)
# print(fault,'hello')
sum1 = int(storage1) + int(cpu1) + int(network1) + int(memory1) + int(
storage2) + int(cpu2) + int(network2) + int(memory2)
##############################################################################################
try:
remedy_list = []
op = search(sum1, fault)
#op=[(('Regular_checkpointing', (20, 10)), ('application_rejuvination', (25, 8)), ('application_migration', (9, 20)))(('Regular_cg', (20, 10)), ('application', (25, 8)), ('applicattion', (9, 20)))]
# print(op[1])
print(op)
temp = op[1]
print('The following are the faults\n')
if (type(temp) == str):
print(temp + '\n')
return
for i in temp:
for k in range(len(i)):
print(i[k])
for k in op[0]:
for j in k:
# print(j)
ob = REMEDY(j[0], j[1][0], j[1][1])
remedy_list.append(ob)
while (True):
print('inside hash')
c_check = input('Do you want to check based on cost\n')
t_check = input('Do you want to check based on time\n')
if (c_check == "y" and t_check == "y"):
ob = min_heap("prod")
elif (c_check == "y"):
ob = min_heap("cost")
elif (t_check == "y"):
ob = min_heap("time")
# print(ob,'dssd')
else:
for i in remedy_list:
print(i)
break
try:
print("Remedy:", ob.cost, ob.name, ob.time)
except:
pass
except:
remedy_list = []
temp = []
with engine.prove_goal(
'Remedyrule.get($fault,$actualfault,$remedy)',
fault=fault) as gen:
for i, (vars, no_plan) in enumerate(gen):
remedy = vars['remedy']
temp.append(vars['actualfault'])
print(temp, 'helo')
insert(sum1,
[fault, [vars['remedy']], [vars['actualfault']]])
for j in remedy:
# print(j)
ob = REMEDY(j[0], j[1][0], j[1][1])
# print(ob)
remedy_list.append(ob)
print("The following faults were diagonised\n")
# print(temp)
for i in temp:
for k in range(len(i)):
print(i[k])
while (True):
c_check = input('Do you want to check based on cost\n')
t_check = input('Do you want to check based on time\n')
if (c_check == "y" and t_check == "y"):
ob = min_heap("prod")
elif (c_check == "y"):
ob = min_heap("cost")
elif (t_check == "y"):
ob = min_heap("time")
else:
try:
print("Remedy:", vars['remedy'])
break
except:
insert(sum1, [
fault, ['No Remedy Availaible'],
['No faults detected']
])
print('No faults detected\n')
break
try:
print("Remedy:", ob.name, "Cost is", ob.cost,
"Time is", ob.time)
except:
pass
if i == -1:
print("No remedy available")
# insert(sum1,[fault,['No Remedy Availaible'],['No faults detected']])
#elif (c_check=="y" or t_check=="y"):
#print ("\nRemedy:",remedy_list[0].name,"Cost:",remedy_list[0].cost,"Time:",remedy_list[0].time,"is the best solution")
#print("All solutions: ")
#for i in remedy_list:
#print(i.name,i.cost,i.time)
#print("The remedy to the fault: ",fault,"; is ", vars['remedy'])
#print (vars)
except:
krb_traceback.print_exc()
sys.exit(1)
def run():
global Robot, Building_center
engine = knowledge_engine.engine(__file__)
Robot = robot_simulator.start()
# Add the following universal facts:
#
# layout.board(width, height)
# layout.building(left, top, right, bottom)
# layout.building_center(x, y)
# layout.car(width, height)
# layout.car_logical_center(x_offset, y_offset)
# layout.range_finder(width, length)
# layout.safety_factor(safety_factor)
# layout.track(left, top, right, bottom)
# layout.direction(cc|ccw)
# layout.waypoint(x, y)
engine.add_universal_fact('layout', 'board',
(robot_simulator.Width, robot_simulator.Height))
corners = left, top, right, bottom = \
robot_simulator.Building.left, \
robot_simulator.Building.top, \
robot_simulator.Building.right, \
robot_simulator.Building.bottom
print "building corners", corners
engine.add_universal_fact('layout', 'building',
corners)
Building_center = robot_simulator.Building.center
engine.add_universal_fact('layout', 'building_center',
Building_center)
engine.add_universal_fact('layout', 'car',
Robot.car.rect[2:])
engine.add_universal_fact('layout', 'car_logical_center',
Robot.car.logical_center)
engine.add_universal_fact('layout', 'range_finder',
Robot.rf.rect[2:])
safety_factor = max(Robot.car.rect.size) + 5
engine.add_universal_fact('layout', 'safety_factor',
(safety_factor,))
track = (left - safety_factor,
top - safety_factor,
right + safety_factor,
bottom + safety_factor)
print "track", track
engine.add_universal_fact('layout', 'track', track)
initial_direction = direction(Robot.heading)
print "initial_direction", initial_direction
engine.add_universal_fact('layout', 'direction', (initial_direction,))
engine.add_universal_fact('layout', 'waypoint', (track[0], track[1]))
engine.add_universal_fact('layout', 'waypoint', (track[0], track[3]))
engine.add_universal_fact('layout', 'waypoint', (track[2], track[1]))
engine.add_universal_fact('layout', 'waypoint', (track[2], track[3]))
engine.add_universal_fact('layout', 'waypoint', Robot.position)
for step in itertools.count():
x, y = Robot.position
print "Robot position %d, %d" % Robot.position
engine.add_universal_fact('history', 'position', (step, x, y))
print "Robot heading %d" % Robot.heading
engine.add_universal_fact('history', 'heading', (step, Robot.heading))
engine.add_universal_fact('history', 'car_radial',
(step,
heading(Building_center, Robot.position)))
engine.reset()
engine.activate('rules')
print "proving step", step
try:
vars, _ = engine.prove_1_goal('rules.get_plan($step, $plan)',
step=step)
except:
krb_traceback.print_exc()
sys.exit(1)
plan = vars['plan']
if plan is None:
print "Success!"
break
ans = plan()
print "plan done, Robot at (%d, %d)" % Robot.position
engine.add_universal_fact('history', 'result', (step, ans))
def setUp(self):
try:
self.activate()
except:
krb_traceback.print_exc()
raise
def getremedy():
engine.reset()
i = -1
try:
engine.activate('Remedyrule')
a_time = input(
"Enter application response time is less than or greater than 15[less\greater]"
)
print("Virtual Machine Paramaeters")
storage1 = int(input("Enter Storage percentage:[0-100]"))
memory1 = int(input("Enter Memory percentage:[0-100]"))
network1 = int(input("Enter Network level:[0-100]"))
cpu1 = int(input("Enter CPU level:[0-100]"))
storage11 = scale(storage1)
memory11 = scale(memory1)
network11 = scale(network1)
cpu11 = scale(cpu1)
print("\nPhysical Machine Parameters")
storage2 = int(input("Enter Storage percentage:[0-100]"))
memory2 = int(input("Enter Memory percentage:[0-100]"))
network2 = int(input("Enter Network level:[0-100]"))
cpu2 = int(input("Enter CPU level:[0-100]"))
storage22 = scale(storage2)
memory22 = scale(memory2)
network22 = scale(network2)
cpu22 = scale(cpu2)
fault = (a_time, (storage11, memory11, network11, cpu11),
(storage22, memory22, network22, cpu22))
# print(fault,'hello')
sum1 = int(storage1) + int(cpu1) + int(network1) + int(memory1) + int(
storage2) + int(cpu2) + int(network2) + int(memory2)
try:
op = search(sum1, fault)
print(op)
except:
with engine.prove_goal('Remedyrule.get($fault,$remedy)',
fault=fault) as gen:
for i, (vars, no_plan) in enumerate(gen):
#remedy=tuple(vars['remedy'])
#ob=REMEDY(remedy[0],remedy[1],remedy[2])
#if (c_check=="y" and t_check=="y"):
#min_heap(ob,"prod")
#elif (c_check=="y"):
#min_heap(ob,"cost")
#elif (t_check=="y"):
#min_heap(ob,"time")
#else: #No priority to solution...displaying all
#print("Remedy:",ob.cost,ob.name,ob.time)
print("Remedy:", vars['remedy'])
insert(sum1, (fault, ('Insert the fault here',
'Insert best possible remedy here')))
if i == -1:
print("No remedy available")
insert(sum1, (fault, 'No Remedy Availaible'))
#elif (c_check=="y" or t_check=="y"):
#print ("\nRemedy:",remedy_list[0].name,"Cost:",remedy_list[0].cost,"Time:",remedy_list[0].time,"is the best solution")
#print("All solutions: ")
#for i in remedy_list:
#print(i.name,i.cost,i.time)
#print("The remedy to the fault: ",fault,"; is ", vars['remedy'])
#print (vars)
except:
krb_traceback.print_exc()
sys.exit(1)
