def resolve(self, kb, parameter):
print("Resolving KB with parameter: " + parameter)
resolved_kb = KnowledgeBase()
super(StructuredResolver, self).copy_all(resolved_kb, kb)
# Load document to ID mappings
# TODO: Need to determine what to do about zips
# Structured JSON data contains the full name for the zip,
# i.e. the "rel_path":
# "World_Bank_Data\API_BEN_DS2_en_csv_v2.zip\API_BEN_DS2_en_csv_v2.csv"
# but the current ID data file only goes to the zip filename
# TODO: is this now outdated based on file ids in json to be processed?
with io.open(os.path.dirname(os.path.realpath(__file__)) +
"/../data_files/structured_data_unique_ids.txt",
mode="r",
encoding="utf-8") as f:
for line in f:
(data_id, f_name) = line.split('|')
data_id = data_id.strip()
f_name = f_name.strip()
f_name = ascii_me(ntpath.basename(f_name))
self.id_manager.structured_document_name_to_id[
f_name] = data_id
resolved_kb.structured_documents = self._resolve_structured_inputs(kb)
resolved_kb.structured_relationships = \
self._resolve_structured_relationships(kb)
return resolved_kb
def test_CPTBuilder(self):
kb = KnowledgeBase('..\\..\\..\\test_data\\doug_example.csv',
'..\\..\\..\\test_data\\doug_example.csv')
data = kb.get_query(['Success', 'Smart', 'Work Hard'])
builder = CPTBuilder(data, kb.get_scale())
print()
def __init__(self):
self.kb = KnowledgeBase()
self.lock = threading.Lock()
self.location = Location(self.kb, self.lock)
self.motion = MotionSubsystem(self.kb, self.lock)
def resolve(self, kb):
print("RedundantEventResolver RESOLVE")
resolved_kb = KnowledgeBase()
super(RedundantEventResolver, self).copy_all(resolved_kb, kb)
resolved_kb.clear_events_relations_and_groups()
# Organize events by sentence
sentence_to_event_mention_list = dict()
event_mention_to_event = dict()
for evid, event in kb.get_events():
for event_mention in event.event_mentions:
event_mention_to_event[event_mention] = event
if event_mention.model == "ACCENT":
continue
sentence = event_mention.sentence
if sentence not in sentence_to_event_mention_list:
sentence_to_event_mention_list[sentence] = []
sentence_to_event_mention_list[sentence].append(event_mention)
event_mentions_to_remove = set()
for sentence, event_mention_list in sentence_to_event_mention_list.items(
):
# Looking at event mentions for a particular sentence
for em1 in event_mention_list:
for em2 in event_mention_list:
if em1 == em2:
continue
if em1.is_similar_and_better_than(em2):
#print "Throwing out: " + em2.id + " because it is worse than " + em1.id
event_mentions_to_remove.add(em2)
bad_event_ids = set()
for evid, event in kb.get_events():
found_good_event_mention = False
for event_mention in event.event_mentions:
if not event_mention in event_mentions_to_remove:
found_good_event_mention = True
break
if found_good_event_mention:
resolved_kb.add_event(event)
else:
bad_event_ids.add(evid)
for relid, relation in kb.get_relations():
if relation.left_argument_id not in bad_event_ids and relation.right_argument_id not in bad_event_ids:
resolved_kb.add_relation(relation)
# add event group to event mapping:
for evgid, event_group in kb.get_event_groups():
ev_group = KBEventGroup(event_group.id)
for event in event_group.members:
if event.id not in bad_event_ids:
ev_group.members.append(event)
if len(ev_group.members) > 0:
resolved_kb.add_event_group(ev_group)
return resolved_kb
def __init__(self):
self.kb = KnowledgeBase()
self.data = NodeBData()
self.packet = Packet('B')
self.radio = RadioAPI()
self.tx_packet_number = 1
self.rx_packet_list = []
def resolve(self, kb):
print("RemovalByTypeResolver RESOLVE")
resolved_kb = KnowledgeBase()
super(RemovalByTypeResolver, self).copy_all(resolved_kb, kb)
resolved_kb.clear_events_relations_and_groups()
bad_event_ids = set()
for evid, event in kb.get_events():
for event_mention in event.event_mentions:
rule_list = self.removal_info.get(event_mention.event_type)
if not rule_list:
break
for rule in rule_list:
if rule.matches_event_mention(event_mention, kb):
bad_event_ids.add(evid)
break
bad_relation_ids = set()
for relid, relation in kb.get_relations():
for relation_mention in relation.relation_mentions:
rule_list = self.removal_info.get(relation.relation_type)
if not rule_list:
break
for rule in rule_list:
if rule.matches_relation_mention(relation_mention, kb):
bad_relation_ids.add(relid)
break
# Add in non-bad events to resolved KB
for evid, event in kb.get_events():
if evid not in bad_event_ids:
resolved_kb.add_event(event)
#else:
# print "Removing: " + evid
# Add in non-bad relations that didn't have an event removed
for relid, relation in kb.get_relations():
if (relid not in bad_relation_ids
and relation.left_argument_id not in bad_event_ids
and relation.right_argument_id not in bad_event_ids):
resolved_kb.add_relation(relation)
#else:
# print "Removing: " + relid
# add event group to event mapping:
for evgid, event_group in kb.get_event_groups():
ev_group = KBEventGroup(event_group.id)
for event in event_group.members:
if event.id not in bad_event_ids:
ev_group.members.append(event)
if len(ev_group.members) > 0:
resolved_kb.add_event_group(ev_group)
return resolved_kb
def __init__(self):
self.kb = KnowledgeBase()
self.radio = RadioAPI()
self.packet = Packet('B')
self.data = []
for i in range(50):
self.data.append(0xff)
self.tx_packet_number = 1
def test_apply_combination_filter(self):
kb = KnowledgeBase('..\\..\\..\\test_data\\doug_example.csv',
'..\\..\\..\\test_data\\doug_example.csv')
data = kb.get_query(['Success', 'Smart', 'Work Hard'])
builder = CPTBuilder(data, kb.get_scale())
print(builder._apply_combination_filter(['T', 'T']))
print(builder._apply_combination_filter(['F', 'T']))
print(builder._apply_combination_filter(
['A', 'B'])) # Combination is not apart of scale
def generate_to_knowledge_base(filename,
sqlite_filename="knowledge_base.sql",
scorer=fuzz.ratio):
templates = generate_templates(filename, scorer)
base = KnowledgeBase(sqlite_filename)
for template in templates:
if not template.generated:
continue
base.insert_exception_template(template)
def load_to_knowledge_base(filename, sqlite_filename="knowledge_base.sql"):
exceptions = load_exceptions(filename)
templates = [
ExceptionTemplate(exception.exception, [], exception.message)
for exception in exceptions
]
base = KnowledgeBase(sqlite_filename)
for template in templates:
if "{*}" in template.template:
base.insert_exception_template(template)
def __init__(self):
self.kb = KnowledgeBase()
self.lock = Lock()
self.data = NodeAData()
self.packet = Packet('A')
self.radio = RadioAPI()
self.tx_packet_number = 1
self.ack_packet_number = 0
self.goodput = 0
def knowledge_base():
"""
Initialises and returns a HuCit KnowledgeBase (new version, standalone package).
"""
try:
config_file = pkg_resources.resource_filename('knowledge_base','config/virtuoso.ini')
kb = KnowledgeBaseNew(config_file)
kb.get_authors()[0]
return kb
except Exception, e:
config_file = pkg_resources.resource_filename('knowledge_base','config/inmemory.ini')
return KnowledgeBaseNew(config_file)
def resolve(self, kb):
print("BadRelationResolver RESOLVE")
resolved_kb = KnowledgeBase()
super(BadRelationResolver, self).copy_all(resolved_kb, kb)
resolved_kb.clear_relations_and_relation_groups()
for relid, relation in kb.get_relations():
# Always let event-event relations through
if relation.argument_pair_type == "event-event":
resolved_kb.add_relation(relation)
continue
# Entity-level arguments are the same, skip
if relation.left_argument_id == relation.right_argument_id:
#print "Skipping relation (1): " + relation.id
continue
# Cross-document entities will end up the same if the
# args have the same cameo_country_code, so skip
left_entity = kb.entid_to_kb_entity[relation.left_argument_id]
right_entity = kb.entid_to_kb_entity[relation.right_argument_id]
if (left_entity.properties.get("cameo_country_code") is not None and
right_entity.properties.get("cameo_country_code") is not None and
left_entity.properties.get("cameo_country_code") == right_entity.properties.get("cameo_country_code")):
#print "Skipping relation (2): " + relation.id
continue
resolved_kb.add_relation(relation)
return resolved_kb
def __init__(self):
self.kb = KnowledgeBase()
self.lock = threading.Lock()
self.location = Location(self.kb, self.lock)
self.motion = SimpleMotion(self.kb, self.lock)
self.rf = RadioSubsystem(self.kb, self.lock, self.radio_data_callback)
self.fsm_state = 'at_beginning'
self.sent_packet = np.array([])
self.ack_packet = np.array([])
self.goodput = np.array([])
def resolve(self, kb):
print("EventRemovalResolver RESOLVE")
resolved_kb = KnowledgeBase()
super(EventRemovalResolver, self).copy_all(resolved_kb, kb)
resolved_kb.clear_events_relations_and_groups()
bad_event_ids = set()
for evid, event in kb.get_events():
found_good_event_mention = False
for event_mention in event.event_mentions:
if event_mention.trigger is None or event_mention.trigger.lower() not in self.bad_trigger_words:
found_good_event_mention = True
break
if found_good_event_mention:
corrected_event = self.correct_event_type(event)
if corrected_event is not None:
resolved_kb.add_event(event)
else:
bad_event_ids.add(evid)
for relid, relation in kb.get_relations():
if relation.left_argument_id not in bad_event_ids and relation.right_argument_id not in bad_event_ids:
resolved_kb.add_relation(relation)
return resolved_kb
def knowledge_base():
"""
Initialises and returns a HuCit KnowledgeBase (new version, standalone package).
"""
try:
config_file = pkg_resources.resource_filename('knowledge_base',
'config/virtuoso.ini')
kb = KnowledgeBaseNew(config_file)
kb.get_authors()[0]
return kb
except Exception, e:
config_file = pkg_resources.resource_filename('knowledge_base',
'config/inmemory.ini')
return KnowledgeBaseNew(config_file)
def __init__(self):
self.lock = Lock()
self.kb = KnowledgeBase()
self.location = Location(self.kb, self.lock)
self.motion = MotionSubsystem(self.kb, self.lock, self.motion_callback)
self.rf = RadioSubsystem(self.kb, self.lock, self.radio_data_callback)
self.fsm_state = 'at_beginning'
self.sent_packet = np.array([])
self.ack_packet = np.array([])
self.goodput = np.array([])
self.color_values = np.array([])
self.arrived = False
def __init__(self):
self.kb = KnowledgeBase()
self.location = BarcodeServer(self.location_callback)
self.flight_path = FlightPath()
self.motion = Motion(self.kb)
self.node_a = NodeAServer()
def test_get_class_data(self):
kb = KnowledgeBase(None, '..\\..\\test_data\\Test_Data_AB.csv')
kb.add_data('..\\..\\test_data\\Test_Data_C.csv')
print(kb.get_data())
print()
print(kb.get_class_data(['A', 'C']))
print()
print(kb.get_class_data(['B']))
print(kb.get_class_data(['Z']))
print(kb.get_class_data(['A', 'B', 'Z']))
def __init__(self):
self.kb = KnowledgeBase()
self.radio = RadioAPI()
self.packet = Packet('B')
self.data = []
for i in range(50):
self.data.append(0xff)
self.tx_packet_number = 1
def main():
'''User-Inputted Recipie Title'''
#url = generateURL()
'''Hard Coded URLs'''
# url = "http://allrecipes.com/recipe/brown-rice-and-quinoa-sushi-rolls/"
# url = "http://allrecipes.com/recipe/Boilermaker-Tailgate-Chili/"
#url = "http://allrecipes.com/recipe/jerk-chicken/"
#link = urllib.urlopen(url)
#page = link.read()
'''Local Cached Webpages'''
# url = "../data/Burger"
# url = "../data/Cake"
url = "../data/Stir-Fry"
f = open(url + ".html")
page = f.read()
if len(sys.argv) < 2:
recipe = parse_recipe(page)
recipe = unabridgeMeasure(recipe)
prettyPrintRecipe(recipe)
save_output(url, recipe)
elif len(sys.argv) == 2:
case_num = int(sys.argv[1])
if case_num < 1 or case_num > 8:
print('You can only pick from [1-8]')
return
recipe = parse_recipe(page)
recipe = unabridgeMeasure(recipe)
kb = KnowledgeBase()
if case_num == 1:
tf_recipe = kb.transform_cuisine("italian", recipe)
elif case_num == 2:
tf_recipe = kb.transform_cuisine("chinese", recipe)
elif case_num == 3:
tf_recipe = kb.transform_diet("vegetarian", recipe)
elif case_num == 4:
tf_recipe = kb.transform_diet("pescatarian", recipe)
elif case_num == 5:
tf_recipe = kb.transform_healthy("low-fat", recipe)
elif case_num == 6:
tf_recipe = kb.transform_healthy("low-sodium", recipe)
elif case_num == 7:
tf_recipe = transformQty(2, recipe)
elif case_num == 8:
tf_recipe = transformQty(3, recipe)
prettyPrintRecipe(tf_recipe)
save_output(url, tf_recipe)
else:
print(
'Too many arguments. You can either either just call main.py to see the recipe or pass in a single integer to select a transformation.'
)
def resolve(self, kb):
resolved_kb = KnowledgeBase()
super(DropNegativePolarityCausalAssertionResolver,
self).copy_all(resolved_kb, kb)
new_relid_to_kb_relation = dict()
for relid, kb_relation in resolved_kb.relid_to_kb_relation.items():
if kb_relation.argument_pair_type != "event-event":
new_relid_to_kb_relation[relid] = kb_relation
elif kb_relation.polarity != "Negative":
new_relid_to_kb_relation[relid] = kb_relation
else:
src_kb_event = resolved_kb.evid_to_kb_event[
kb_relation.left_argument_id]
tar_kb_event = resolved_kb.evid_to_kb_event[
kb_relation.right_argument_id]
logger.debug("NCA Dropping {}".format(
get_marked_up_string_for_event_event_relation(
kb_relation, src_kb_event, tar_kb_event)))
resolved_kb.relid_to_kb_relation = new_relid_to_kb_relation
return resolved_kb
def resolve(self, kb):
print("RelevantKBEntityMentionResolver RESOLVE")
resolved_kb = KnowledgeBase()
super(RelevantKBEntityMentionResolver, self).copy_all(resolved_kb, kb)
self.kb_entity_mention_to_kb_entity = dict()
self.kb_entity_to_kb_entity_group = dict()
self.actor_id_to_kb_entity_group = dict()
self.marked_kb_elements = set()
for entgroupid, kb_entity_group in resolved_kb.entgroupid_to_kb_entity_group.items():
kb_entity_group.is_referred_in_kb = False
for kb_entity in kb_entity_group.members:
kb_entity.is_referred_in_kb = False
self.kb_entity_to_kb_entity_group[kb_entity] = kb_entity_group
for kb_entity_mention in kb_entity.mentions:
kb_entity_mention.is_referred_in_kb = False
self.kb_entity_mention_to_kb_entity[kb_entity_mention] = kb_entity
if kb_entity_group.actor_id is not None:
self.actor_id_to_kb_entity_group[kb_entity_group.actor_id] = kb_entity_group
start_searching_points = set()
for evt_id,kb_event in resolved_kb.evid_to_kb_event.items():
for kb_event_mention in kb_event.event_mentions:
for arg_role,args in kb_event_mention.arguments.items():
for arg,score in args:
if isinstance(arg, KBMention):
self.mark_from_bottom_to_top(arg)
start_searching_points.add(self.kb_entity_mention_to_kb_entity[arg])
OUT_DEGREE = 2
while OUT_DEGREE > 0:
alternative_searching_points = set()
for relid, kb_relation in resolved_kb.relid_to_kb_relation.items():
if kb_relation.argument_pair_type == "entity-entity":
left_entity = resolved_kb.entid_to_kb_entity[kb_relation.left_argument_id]
right_entity = resolved_kb.entid_to_kb_entity[kb_relation.right_argument_id]
if left_entity in start_searching_points:
if right_entity not in start_searching_points and right_entity.is_referred_in_kb is False:
alternative_searching_points.add(right_entity)
self.mark_from_bottom_to_top(right_entity)
if right_entity in start_searching_points:
if left_entity not in start_searching_points and left_entity.is_referred_in_kb is False:
alternative_searching_points.add(left_entity)
self.mark_from_bottom_to_top(left_entity)
OUT_DEGREE -= 1
start_searching_points = alternative_searching_points
return resolved_kb
def resolve(self, kb):
print("EntityAddPropertyResolver RESOLVE")
resolved_kb = KnowledgeBase()
super(EntityAddPropertyResolver, self).copy_all(resolved_kb, kb)
for entid, kb_entity in resolved_kb.entid_to_kb_entity.items():
if kb_entity.canonical_name is None:
self.pick_canonical_name(kb_entity)
return resolved_kb
def resolve(self, kb):
print("AddGenericEventTypeIfOnlyCausalFactorTypeAvailableResolver RESOLVE")
generic_event_uri = "http://ontology.causeex.com/ontology/odps/Event#Event"
resolved_kb = KnowledgeBase()
super(AddGenericEventTypeIfOnlyCausalFactorTypeAvailableResolver, self).copy_all(resolved_kb, kb)
for kb_event_id, kb_event in resolved_kb.evid_to_kb_event.items():
for kb_event_mention in kb_event.event_mentions:
if len(kb_event_mention.external_ontology_sources) < 1 and len(kb_event_mention.causal_factors) > 0:
highest_cf_score = max(cf.relevance for cf in kb_event_mention.causal_factors)
kb_event_mention.external_ontology_sources.append([generic_event_uri,highest_cf_score])
return resolved_kb
def test_build_with_no_parents(self):
kb = KnowledgeBase('..\\..\\..\\test_data\\doug_example.csv',
'..\\..\\..\\test_data\\doug_example.csv')
data = kb.get_query(['Work Hard'])
builder = CPTBuilder(data, kb.get_scale())
print(builder.build_with_no_parents())
kb1 = KnowledgeBase('..\\..\\..\\test_data\\doug_example.csv',
'..\\..\\..\\test_data\\doug_example.csv')
data = kb1.get_query(['Smart'])
builder1 = CPTBuilder(data, kb.get_scale())
print(builder1.build_with_no_parents())
def __init__(self):
self.kb = KnowledgeBase()
self.lock = Lock()
self.data = NodeAData()
self.packet = Packet('A')
self.radio = RadioAPI()
self.tx_packet_number = 1
self.ack_packet_number = 0
self.goodput = 0
def __init__(self, inputfile=None):
# For reading/writing input/output
if inputfile == None:
self.inputFileName = self.getInputFileName()
else:
self.inputFileName = inputfile
self.inputFile = open(self.inputFileName, 'r')
self.outputFileName = "output.txt"
self.outputFile = open(self.outputFileName, 'w')
# Num queries
self.numQueries = 0
# Num statements for the kb
self.numStatements = 0
# List of queries. Stored as predicate objects.
self.queryList = []
# The knowledge base for this set of queries
self.kb = KnowledgeBase()
def resolve(self, kb, awake_db):
print("ExternalURIResolver RESOLVE")
resolved_kb = KnowledgeBase()
super(ExternalURIResolver, self).copy_all(resolved_kb, kb)
if awake_db == "NA":
return resolved_kb
kb_entity_to_entity_group = dict()
for entgroupid, kb_entity_group in resolved_kb.get_entity_groups():
for kb_entity in kb_entity_group.members:
kb_entity_to_entity_group[kb_entity] = kb_entity_group
AwakeDB.initialize_awake_db(awake_db)
for entid, kb_entity in resolved_kb.entid_to_kb_entity.items():
kb_entity_group = kb_entity_to_entity_group[kb_entity]
source_string = AwakeDB.get_source_string(kb_entity_group.actor_id)
if source_string is not None and source_string.find(
"dbpedia.org") != -1:
formatted_string = source_string.strip()
if source_string.startswith("<"):
source_string = source_string[1:]
if source_string.endswith(">"):
source_string = source_string[0:-1]
source_string = source_string.replace("dbpedia.org/resource",
"en.wikipedia.org/wiki",
1)
kb_entity.properties["external_uri"] = source_string
# For countries, add geoname_id to properties
if (kb_entity_group.actor_id is not None
and "external_uri" not in kb_entity.properties
and "geonameid" not in kb_entity.properties):
geonameid = AwakeDB.get_geonameid_from_actorid(
kb_entity_group.actor_id)
if geonameid is not None and len(str(geonameid).strip()) != 0:
kb_entity.properties["geonameid"] = str(geonameid)
return resolved_kb
class Controller(object):
def __init__(self):
self.kb = KnowledgeBase()
self.lock = threading.Lock()
self.location = Location(self.kb, self.lock)
self.motion = MotionSubsystem(self.kb, self.lock)
def run(self):
"""
Start the controller.
"""
self.kb.build_route()
self.motion.start()
self.location.start()
while True:
print "time: ", time.time()
time.sleep(1)
def shutdown(self):
# self.kb.save_kb()
# pprint.pprint(self.kb.get_state())
# print "\n\n\n\n\n"
# self.kb.route_debug()
# print "\n\n\n\n\n"
self.motion.join()
# self.motion.shutdown()
# self.rf.join()
time.sleep(0.1)
self.location.join() # shut this down last
def resolve(self, kb):
print("EventPolarityResolver RESOLVE")
resolved_kb = KnowledgeBase()
super(EventPolarityResolver, self).copy_all(resolved_kb, kb)
for evid, kb_event in resolved_kb.get_events():
for kb_event_mention in kb_event.event_mentions:
event_mention_text = kb_event_mention.trigger
should_reverse_polarity = False
tokens_in_mention = event_mention_text.split(" ")
for token in tokens_in_mention:
if token in negative_word_set and len(
tokens_in_mention) > 1:
should_reverse_polarity = True
if should_reverse_polarity is True:
for event_type, grounding in kb_event_mention.external_ontology_sources:
for negative_type_keyword in negative_type_set:
if negative_type_keyword in event_type:
should_reverse_polarity = False
if should_reverse_polarity is True:
kb_event_mention.properties["polarity"] = "Negative"
return resolved_kb
def __init__(self, agent):
self._agent = agent
self._cooperation = {}
self._knowledge_base = KnowledgeBase()
self._current_goal = self._knowledge_base.goals['find_trash']
# time awareness
self._time_trash_found = self.time
self._agent_trash_count_history = self._agent.trash_count
# queue to maintain last 10 positions
self._agent_position_history = deque([(0, 0)], 10)
# domain awareness
self._time_domain_strategy_applied = self.time
def resolve(self, kb):
print("EntityGroupEntityTypeResolver RESOLVE")
resolved_kb = KnowledgeBase()
super(EntityGroupEntityTypeResolver, self).copy_all(resolved_kb, kb)
# Make sure best entity type across each entity group is consistent
for entgroupid, entity_group in resolved_kb.get_entity_groups():
entity_type_to_count = dict() # entity_type => count
for entity in entity_group.members:
entity_type = entity.get_best_entity_type()
if entity_type not in entity_type_to_count:
entity_type_to_count[entity_type] = 0
entity_type_to_count[entity_type] += 1
# Get best entity type from dict
best_entity_type = None
highest_count = None
for et, count in entity_type_to_count.items():
if best_entity_type is None or count > highest_count:
best_entity_type = et
highest_count = count
continue
if count < highest_count:
continue
# count and highest count is equal
best_entity_type = self.get_better_entity_type(
best_entity_type, et)
# set entity type for group
if len(entity_type_to_count) > 1:
#print "Setting entity type for " + unidecode.unidecode(entity_group.canonical_name) + " " + entity_group.id + " to " + best_entity_type
#print "Based on: " + str(entity_type_to_count)
for entity in entity_group.members:
entity.add_entity_type(best_entity_type, 0.9)
return resolved_kb
def __init__(self):
self.lock = Lock()
self.kb = KnowledgeBase()
self.location = Location(self.kb, self.lock)
self.motion = MotionSubsystem(self.kb, self.lock, self.motion_callback)
self.rf = RadioSubsystem(self.kb, self.lock, self.radio_data_callback)
self.fsm_state = 'at_beginning'
self.sent_packet = np.array([])
self.ack_packet = np.array([])
self.goodput = np.array([])
self.color_values = np.array([])
self.arrived = False
def __init__(self, inputfile = None): # For reading/writing input/output if inputfile == None : self.inputFileName = self.getInputFileName() else : self.inputFileName = inputfile self.inputFile = open(self.inputFileName, 'r') self.outputFileName = "output.txt" self.outputFile = open(self.outputFileName, 'w') # Num queries self.numQueries = 0 # Num statements for the kb self.numStatements = 0 # List of queries. Stored as predicate objects. self.queryList = [] # The knowledge base for this set of queries self.kb = KnowledgeBase()
class Controller(object):
def __init__(self):
self.kb = KnowledgeBase()
self.lock = threading.Lock()
self.location = Location(self.kb, self.lock)
self.motion = SimpleMotion(self.kb, self.lock)
self.rf = RadioSubsystem(self.kb, self.lock, self.radio_data_callback)
self.fsm_state = 'at_beginning'
self.sent_packet = np.array([])
self.ack_packet = np.array([])
self.goodput = np.array([])
def run(self):
"""
Start the controller.
"""
self.kb.build_route()
self.location.start()
self.rf.start()
while True:
self.fsm()
def radio_data_callback(self, sent_packet, ack_packet, goodput):
self.sent_packet = np.append(self.sent_packet, sent_packet)
self.ack_packet = np.append(self.ack_packet, ack_packet)
self.goodput = np.append(self.goodput, goodput)
def reset_radio_data(self):
self.sent_packet = np.array([])
self.ack_packet = np.array([])
self.goodput = np.array([])
def fsm(self):
if self.fsm_state == 'at_beginning':
print "\n\n\n"
print "at_beginning"
start_node = self.kb.get_start_node()
self.motion.move_until_location(start_node, speed = 25)
while not self.kb.get_state()['current_location'] == start_node:
time.sleep(0.2)
next_node = self.kb.get_next_node(start_node)
# self.lock.acquire()
self.kb.set_current_node(start_node)
self.kb.set_next_node(next_node)
self.kb.set_next_edge((start_node, next_node))
# self.lock.release()
self.fsm_state = 'traversing_edge'
return
elif self.fsm_state == 'traversing_edge':
print "\n\n\n"
print "traversing_edge"
kb_state = self.kb.get_state()
current_edge = kb_state['next_edge']
next_edge = None
last_node = kb_state['current_node']
current_node = None
next_node = kb_state['next_node']
# self.lock.acquire()
self.kb.set_current_edge(current_edge)
self.kb.set_next_edge(next_edge)
self.kb.set_last_node(last_node)
self.kb.set_current_node(current_node)
# self.lock.release()
tic = time.time()
# this is not threaded!!!!!
self.motion.move_from_here_to_there(last_node, next_node, speed = 45)
# print "self.kb.get_state()['current_location'] = ", self.kb.get_state()['current_location']
# print "next_node = ", next_node
# print "self.kb.get_state()['current_location'] == next_node : ", self.kb.get_state()['current_location'] == next_node
print "traversing_eddge, current_node = ", current_node
print "traversing_edge, next_node = ", next_node
while not self.kb.get_state()['current_location'] == next_node:
# color = motion.get_color_reading()
print "\n\n\n\n"
print "Blah blah blah"
# print "Detected color: ", color
print "\n\n\n\n"
time.sleep(0.01)
toc = time.time() - tic
weight = toc * np.average(self.goodput)
print "weight value for edge %s = %0.2f" %(str(current_edge), weight)
self.kb.set_edge_weight(current_edge, weight)
# print self.goodput
# print "average goodput for edge %s = %0.2f" %(str(current_edge), np.average(self.goodput))
self.fsm_state = 'at_a_node'
return
elif self.fsm_state == 'at_a_node':
print "\n\n\n"
print "at_a_node"
self.rf.control_radio_operation('pause')
kb_state = self.kb.get_state()
current_node = kb_state['next_node']
next_node = self.kb.get_next_node(current_node)
print "at_a_node, current_node = ", current_node
print "at_a_node, next_node = ", next_node
current_edge = None
last_edge = kb_state['current_edge']
next_edge = (current_node, next_node)
# self.lock.acquire()
self.kb.set_current_node(current_node)
self.kb.set_next_node(next_node)
self.kb.set_current_edge(current_edge)
self.kb.set_last_edge(last_edge)
self.kb.set_next_edge(next_edge)
# self.lock.release()
self.fsm_state = 'traversing_edge'
self.rf.control_radio_operation('continue')
self.reset_radio_data()
return
else:
if DEBUG:
print "controller.fsm() error"
print "state == ", state
else:
pass
def shutdown(self):
self.kb.save_kb()
# pprint.pprint(self.kb.get_state())
# print "\n\n\n\n\n"
# self.kb.route_debug()
# print "\n\n\n\n\n"
self.motion.shutdown()
self.rf.join()
time.sleep(0.1)
self.location.join() # shut this down last
class StandAloneRadioB(object):
def __init__(self):
self.kb = KnowledgeBase()
self.radio = RadioAPI()
self.packet = Packet('B')
self.data = []
for i in range(50):
self.data.append(0xff)
self.tx_packet_number = 1
def _configure_radio(self, power, frequency, data_rate, modulation):
"""
Configure radio for operation.
"""
self.radio.configure_radio(power, frequency, data_rate, modulation)
def _send_packet(self):
"""
Transmit packet.
"""
self.packet.set_flags_node_b()
location = self.kb.get_state()['current_location']
tx_packet = self.packet.make_packet(self.tx_packet_number, location, self.data)
self.radio.transmit(tx_packet)
self.tx_packet_number += 1
def _receive_packet(self):
"""
Receive packet.
"""
rx_packet = self.radio.receive(rx_fifo_threshold=63, timeout=None)
if rx_packet == []: # this occurs when timeout has been exceeded
return
else:
packet_number, time_stamp, location, flags, data = self.packet.parse_packet(rx_packet)
print "packet_number=%d time_stamp=%f location=%d flags=0x%x" %(packet_number, time_stamp,
location, flags)
def _listen(self):
"""
Listen before talk.
"""
status = self.radio.listen(rssi_threshold=100, timeout=1.0)
if status == 'clear':
print "channel clear"
def run(self):
"""
Run the radio subsystem.
"""
self.radio.startup()
default_radio_profile = location = self.kb.get_state()['default_radio_profile']
power = default_radio_profile['power']
frequency = default_radio_profile['frequency']
data_rate = default_radio_profile['data_rate']
modulation = default_radio_profile['modulation']
self._configure_radio(power, frequency, data_rate, modulation)
state = "listen"
while True:
if state == "listen":
self._listen()
state = "receive"
elif state == "receive":
self._receive_packet()
state = "send"
elif state == "send":
self._send_packet()
state = "listen"
else:
print "+++ Melon melon melon +++"
state = "listen"
def shutdown(self):
self.radio.shutdown()
class Controller(object):
def __init__(self):
self.lock = Lock()
self.kb = KnowledgeBase()
self.location = Location(self.kb, self.lock)
self.motion = MotionSubsystem(self.kb, self.lock, self.motion_callback)
self.rf = RadioSubsystem(self.kb, self.lock, self.radio_data_callback)
self.fsm_state = 'at_beginning'
self.sent_packet = np.array([])
self.ack_packet = np.array([])
self.goodput = np.array([])
self.color_values = np.array([])
self.arrived = False
def run(self):
"""
Start the controller.
"""
self.kb.build_route()
self.location.start()
self.motion.start()
self.rf.start()
# time.sleep(0.1)
self.fsm()
def motion_callback(self, has_arrived):
self.arrived = has_arrived
def radio_data_callback(self, sent_packet, ack_packet, goodput):
"""
Radio Subsystem IPC.
"""
self.sent_packet = np.append(self.sent_packet, sent_packet)
self.ack_packet = np.append(self.ack_packet, ack_packet)
self.goodput = np.append(self.goodput, goodput)
def reset_radio_data(self):
"""
Reset local radio data storage.
"""
self.sent_packet = np.array([])
self.ack_packet = np.array([])
self.goodput = np.array([])
def fsm(self):
while True:
if self.fsm_state == 'at_beginning':
before_start = 0
start_node = self.kb.get_start_node()
self.motion.set_source_destination(before_start, start_node)
self.motion.set_speed(25)
self.motion.control_motion_operation('go')
while not self.arrived:
time.sleep(0.1)
next_node = self.kb.get_next_node(start_node)
self.kb.set_current_node(start_node)
self.kb.set_next_node(next_node)
self.kb.set_next_edge((start_node, next_node))
self.fsm_state = 'traversing_edge'
continue
elif self.fsm_state == 'traversing_edge':
if DEBUG:
print "traversing_edge"
kb_state = self.kb.get_state()
print kb_state
current_edge = kb_state['next_edge']
next_edge = None
last_node = kb_state['current_node']
current_node = None
next_node = kb_state['next_node']
self.kb.set_current_edge(current_edge)
self.kb.set_next_edge(next_edge)
self.kb.set_last_node(last_node)
self.kb.set_current_node(current_node)
self.arrived = False
self.motion.set_source_destination(current_edge[0], current_edge[1])
self.motion.set_speed(45)
tic = time.time()
self.motion.control_motion_operation('go')
while not self.arrived:
self.color_values = np.append(self.color_values, self.motion.color_reading())
time.sleep(0.1)
toc = time.time() - tic
# weight = toc * np.average(self.goodput)
# targets = self.count_targets(self.color_values)
# if DEBUG:
# print "values for edge %s: weight = %0.2f, targets = %d" %(str(current_edge),
# weight,
# targets)
# self.kb.set_edge_values(current_edge, weight, targets)
metric_b = toc * np.average(self.goodput)
targets = self.count_targets(self.color_values)
if DEBUG:
print "values for edge %s: targets = %d, metric_b = %f" %(str(current_edge),
targets,
metric_b)
self.kb.set_edge_values(current_edge, targets, metric_b)
self.fsm_state = 'at_a_node'
continue
elif self.fsm_state == 'at_a_node':
self.rf.control_radio_operation('pause')
kb_state = self.kb.get_state()
current_node = kb_state['next_node']
next_node = self.kb.get_next_node(current_node)
current_edge = None
last_edge = kb_state['current_edge']
next_edge = (current_node, next_node)
self.kb.set_current_node(current_node)
self.kb.set_next_node(next_node)
self.kb.set_current_edge(current_edge)
self.kb.set_last_edge(last_edge)
self.kb.set_next_edge(next_edge)
self.fsm_state = 'traversing_edge'
self.reset_radio_data()
self.color_values = np.array([])
self.rf.control_radio_operation('continue')
continue
else:
print "controller.fsm() error"
print "state == ", state
break
def count_targets(self, a):
a[a!=5] = 0
j = 0
for i in range(len(a)-1):
if a[i] == 0 and a[i+1] == 5:
j += 1
return j
def shutdown(self):
self.kb.save_kb()
self.motion.join()
self.rf.join()
time.sleep(0.1)
self.location.join() # shut this down last
#!/usr/bin/env python
import cPickle as pickle
import pprint
import numpy as np
from knowledge_base import KnowledgeBase
from motion.simple_motion import SimpleMotion
kb = KnowledgeBase()
pprint.pprint(kb.get_state())
dump_file = open('dictionary_dump.p', 'wb')
pickle.dump(kb.get_state(), dump_file)
dump_file.close()
# def move_from_here_to_there(here, there):
# coords = kb.get_state()['node_coordinates']
# src = coords[str(here)]
# dst = coords[str(there)]
# print "src: ", src
# print "dst: ", dst
# angle = np.arctan2(dst[0] - src[0], dst[1] - src[1]) * 180/np.pi
# print "angle: ", angle
class Inferences():
def __init__(self, inputfile = None):
# For reading/writing input/output
if inputfile == None :
self.inputFileName = self.getInputFileName()
else :
self.inputFileName = inputfile
self.inputFile = open(self.inputFileName, 'r')
self.outputFileName = "output.txt"
self.outputFile = open(self.outputFileName, 'w')
# Num queries
self.numQueries = 0
# Num statements for the kb
self.numStatements = 0
# List of queries. Stored as predicate objects.
self.queryList = []
# The knowledge base for this set of queries
self.kb = KnowledgeBase()
def getInputFileName(self):
# Set up input and output files
parser = argparse.ArgumentParser()
parser.add_argument('-i', type=str)
args = parser.parse_args()
inputFile = args.i
return inputFile
# Parses input file
def readInput(self):
try :
# Break up by line
lines = self.inputFile.read().split('\n')
for line in lines :
line = line.strip('\r\n')
# Get number of queries to make to the KB
self.numQueries = int(lines[0])
# Read each query and store it as a predicate in self.queryList
for i in range(1, self.numQueries + 1) :
newQuery = Predicate(lines[i])
self.queryList.append(newQuery)
# Read in number of statements for the KB.
self.numStatements = int(lines[self.numQueries + 1])
for j in range(self.numQueries + 2, self.numQueries + 2 + self.numStatements) :
statement = lines[j]
# Check if statement is a rule or a fact
if "=>" in statement :
newRule = Rule(statement)
self.kb.addRule(newRule)
else :
newFact = Predicate(statement)
self.kb.addFact(newFact)
except Exception as e :
print "\nError reading input : ", e
# Call this method to solve all queries in the queryList.
def solveQueries(self):
try :
for q in self.queryList :
try :
if self.kb.bcs(q) :
self.outputFile.write("TRUE\n")
else :
self.outputFile.write("FALSE\n")
except Exception as e :
print "\nError executing specific query : ", e, "...Name = ", q.name
except Exception as e :
self.outputFile.write("FALSE\n")
print "\nError executing queries : ", e
# Closes file input/output streams
def cleanup(self) :
self.inputFile.close()
self.outputFile.close()
class StandAloneRadioA(object):
def __init__(self):
self.kb = KnowledgeBase()
self.lock = Lock()
self.data = NodeAData()
self.packet = Packet('A')
self.radio = RadioAPI()
self.tx_packet_number = 1
self.ack_packet_number = 0
self.goodput = 0
# self.data = []
# for i in range(50):
# self.data.append(0xff)
def _configure_radio(self, power, frequency, data_rate, modulation):
"""
Configure radio for operation.
"""
self.radio.configure_radio(power, frequency, data_rate, modulation)
def _send_packet(self):
"""
Transmit packet.
"""
self.packet.set_flags_node_a()
location = self.kb.get_state()['current_location']
data = self.data.pack_data()
tx_packet = self.packet.make_packet(self.tx_packet_number, location, data)
self.radio.transmit(tx_packet)
def _receive_packet(self):
"""
Receive packet.
"""
rx_packet = self.radio.receive(rx_fifo_threshold=64, timeout=1.0)
if rx_packet == []: # this occurs when timeout has been exceeded
return
else:
packet_number, time_stamp, location, flags, data = self.packet.parse_packet(rx_packet)
self.ack_packet_number, self.goodput = self.data.unpack_data(data)
# print "packet_number=%d time_stamp=%f location=%d flags=0x%x" %(packet_number, time_stamp,
# location, flags)
print "goodput for acknowledged packet #%d = %f bits/second" %(self.ack_packet_number, self.goodput)
def _listen(self):
"""
Listen before talk.
"""
status = self.radio.listen(rssi_threshold=100, timeout=1.0)
if status == 'clear':
print "channel clear"
def _fsm(self):
self._listen()
time.sleep(0.01)
self._send_packet()
time.sleep(0.01)
self._receive_packet()
time.sleep(0.01)
def run(self):
"""
Run the radio subsystem.
"""
self.radio.startup()
default_radio_profile = location = self.kb.get_state()['default_radio_profile']
power = default_radio_profile['power']
frequency = default_radio_profile['frequency']
data_rate = default_radio_profile['data_rate']
modulation = default_radio_profile['modulation']
self._configure_radio(power, frequency, data_rate, modulation)
# state = "listen"
while True:
self._fsm()
self.lock.acquire()
self.kb.sent_packets.append(self.tx_packet_number)
self.kb.ack_packets.append((self.ack_packet_number, self.goodput))
self.lock.release()
self.tx_packet_number += 1
def shutdown(self):
self.kb.save_kb()
self.radio.shutdown()
