class DeepSearchHandler(PatternMatchingEventHandler): """ Deep file search handler to handle the events gengerated by file changes """ def __init__(self): self.datahandler = DatabaseHandler() self._ignore_directories = False self._ignore_patterns = False self._ignore_patterns = ["*.log","*.logger"] self._case_sensitive = False self._patterns = ["*.rb","*.py","*.java","*.mp4","*.mp3","*.txt"] print "instance created" def on_created(self,event): """Called when a file or directory is created.""" print "file create event"+str(event) self.datahandler.create(event.src_path) def on_modified(self,event): """"Called when a file or directory is modified.""" print "file modify event"+str(event) self.datahandler.update(event.src_path) def on_deleted(self,event): """" Called when a file or directory is deleted. """ print "file delete event"+str(event) self.datahandler.delete(event.src_path) def on_moved(self,event): """"Called when a file or a directory is moved or renamed.""" print "file moved event"+str(event) self.datahandler.moved(event.src_path) def close_db_connection(self): """ call close_connection function of datanadler """ self.datahandler.close_connection()
def parse_requests(table_name, filename='logs/humans.json'):
try:
ips, requests = _extract_http_and_time(
filename) ##requests is a list of tuple
formated_requests = _format_requests(
requests
) #get the requests as a dict in the format the database accepts
if filename == 'logs/humans.json':
formated_requests_clean = remove_bot_req(formated_requests)
else:
formated_requests_clean = formated_requests
with DatabaseHandler(table_name) as db:
db.create_table(table_name)
for req in formated_requests_clean:
db.store(req)
with DatabaseHandler(table_name) as db:
l = db.cursor.execute(
"SELECT * FROM {}".format(table_name)).fetchall()
ips_in_table = []
for val in l:
ips_in_table.append(val[1])
return list(set(ips_in_table))
except Exception as e:
raise e
class DeepSearchHandler(pyinotify.ProcessEvent):
""" Deep file search handler to handle the events gengerated by file changes """
def __init__(self):
self.datahandler = DatabaseHandler()
print "instance created"
def process_IN_CREATE(self, event):
"""Called when a file or directory is created."""
print "file create event" + str(event)
self.datahandler.create(event.pathname)
def process_IN_MODIFY(self, event):
""""Called when a file or directory is modified."""
print "file modify event" + str(event)
self.datahandler.update(event.pathname)
def process_IN_DELETE(self, event):
"""" Called when a file or directory is deleted. """
print "file delete event" + str(event)
self.datahandler.delete(event.pathname)
def process_IN_ACCESS(self, event):
"""" Called when a file or directory is accessed. """
print "file access event" + str(event.pathname)
self.datahandler.access(event.pathname)
def close_db_connection(self):
""" call close_connection function of datanadler """
self.datahandler.close_connection()
def __init__(self):
rospy.sleep(
2
) # Delay startup so navigation is finished setting up database file
self.current_location = None
self.SCHEDULER_RATE = rospy.Rate(0.05) #(Hz)
self.LOW_POWER_THRESHOLD = 20
self.HOMEDIR = os.path.expanduser("~")
self.PATH = self.HOMEDIR + "/navigation.db"
self.MAP_NAME = "glassgarden.map"
self.current_state = "idle"
self.publisher_event = rospy.Publisher(
"/cyborg_controller/register_event", String, queue_size=100)
self.subscriber_current_location = rospy.Subscriber(
"cyborg_navigation/current_location", String,
self.callback_current_location)
self.subscriber_state = rospy.Subscriber(
"/cyborg_controller/state_change",
SystemState,
self.callback_subscriber_state,
queue_size=100)
self.subscriber_battery_status = rospy.Subscriber(
"/rosarnl_node/battery_status",
BatteryStatus,
callback=self.callback_battery_status,
queue_size=10)
self.database_handler = DatabaseHandler(filename=self.PATH)
self.scheduler_thread = threading.Thread(target=self.scheduler)
self.scheduler_thread.daemon = True # Thread terminates when main thread terminates
self.scheduler_thread.start()
def __init__(self, database_file=""):
self.action_name = rospy.get_name()
self.MAP_NAME = "glassgarden.map"
self.PLANNING_TIMEOUT = 10
self.RATE_ACTIONLOOP = rospy.Rate(4) # Hz
self.next_location = ""
self.current_emotional_state = "neutral"
self.current_state = ""
self.database_handler = DatabaseHandler(filename=database_file)
self.publisher_emotional_feedback = rospy.Publisher(
"/cyborg_controller/emotional_feedback",
EmotionalFeedback,
queue_size=100)
self.subscriber_emotional_state = rospy.Subscriber(
"/cyborg_controller/emotional_state",
EmotionalState,
self.emotional_callback,
queue_size=10)
self.publisher_event = rospy.Publisher(
"/cyborg_controller/register_event", String, queue_size=100)
self.publisher_location_command = rospy.Publisher(
"/cyborg_behavior/command_location", String, queue_size=10)
self.client_behavior = actionlib.SimpleActionClient(
"/cyborg_behavior", StateMachineAction)
self.server_primary_states = actionlib.SimpleActionServer(
self.action_name,
StateMachineAction,
execute_cb=self.callback_server_primary_states,
auto_start=False)
self.server_primary_states.start()
rospy.loginfo("PrimaryStatesServer: Initiated")
def __init__(self): self.datahandler = DatabaseHandler() self._ignore_directories = False self._ignore_patterns = False self._ignore_patterns = ["*.log","*.logger"] self._case_sensitive = False self._patterns = ["*.rb","*.py","*.java","*.mp4","*.mp3","*.txt"] print "instance created"
def __init__(self, log_file_handler, live=False):
self.is_live = live
# Logger setup
if self.is_live:
self.logger = logging.getLogger('PCPPHelperBot')
else:
self.logger = logging.getLogger('PCPPHelperBot-DEBUG')
self.logger.addHandler(log_file_handler)
now_str = datetime.now().strftime('%H:%M:%S')
self.logger.info(f'STARTING {now_str}')
# Database setup
if self.is_live:
self.db_handler = DatabaseHandler()
else:
self.db_handler = DatabaseHandler(debug=True)
self.db_handler.connect()
self.db_handler.create_table()
# Retrieve environment vars for secret data
username = os.environ.get('REDDIT_USERNAME')
password = os.environ.get('REDDIT_PASSWORD')
client_id = os.environ.get('CLIENT_ID')
secret = os.environ.get('CLIENT_SECRET')
version = 0.1
user_agent = f"web:pcpp-helper-bot:v{version} (by u/pcpp-helper-bot)"
# Utilize PRAW wrapper
self.reddit = praw.Reddit(user_agent=user_agent,
client_id=client_id, client_secret=secret,
username=username, password=password)
# Only look at submissions with one of these flairs
# TODO: Are these the best submission flairs to use?
self.pertinent_flairs = ['Build Complete', 'Build Upgrade',
'Build Help', 'Build Ready', None]
self.pcpp_parser = PCPPParser(log_file_handler)
self.table_creator = TableCreator()
self.MAX_TABLES = 2
self.subreddit_name = None
# Read in the templates
with open('./templates/replytemplate.md', 'r') as template:
self.REPLY_TEMPLATE = template.read()
with open('./templates/idenlinkfound.md', 'r') as template:
self.IDENTIFIABLE_TEMPLATE = template.read()
with open('./templates/tableissuetemplate.md', 'r') as template:
self.TABLE_TEMPLATE = template.read()
def __init__(self, database_file=""):
self.scheduler_rate = rospy.Rate(1) # (hz)
self.server_rate = rospy.Rate(0.5) # (hz)
self.server_planing = actionlib.SimpleActionServer(
rospy.get_name() + "/planing",
StateMachineAction,
execute_cb=self.server_planing_callback,
auto_start=False)
self.server_moving = actionlib.SimpleActionServer(
rospy.get_name() + "/moving",
StateMachineAction,
execute_cb=self.server_moving_callback,
auto_start=False)
self.server_talking = actionlib.SimpleActionServer(
rospy.get_name() + "/talking",
StateMachineAction,
execute_cb=self.server_talking_callback,
auto_start=False)
self.server_go_to = actionlib.SimpleActionServer(
rospy.get_name() + "/go_to",
NavigationGoToAction,
execute_cb=self.server_go_to_callback,
auto_start=False)
self.server_planing.start()
self.server_moving.start()
self.server_talking.start()
self.server_go_to.start()
self.client_base = actionlib.SimpleActionClient(
"/rosarnl_node/move_base", MoveBaseAction)
self.emotion_publisher = rospy.Publisher(
"/cyborg_controller/emotional_feedback",
EmotionalFeedback,
queue_size=100)
self.event_publisher = rospy.Publisher(
"/cyborg_controller/register_event", String, queue_size=100)
self.speech_publisher = rospy.Publisher(
"/cyborg_text_to_speech/text_to_speech", String, queue_size=100)
self.database_handler = DatabaseHandler(filename=database_file)
self.location_subscriber = rospy.Subscriber("/rosarnl_node/amcl_pose",
PoseWithCovarianceStamped,
self.location_callback)
self.emotion_subscriber = rospy.Subscriber(
"/cyborg_controller/emotional_state",
EmotionalState,
self.emotion_callback,
queue_size=100)
self.text_subscriber = rospy.Subscriber("/text_from_speech",
String,
self.text_callback,
queue_size=100)
self.scheduler_thread = threading.Thread(target=self.scheduler)
self.scheduler_thread.daemon = True # Thread terminates when main thread terminates
self.scheduler_thread.start()
rospy.loginfo("NavigationServer: Activated.")
def get_unique_ips(table_name):
with DatabaseHandler(table_name) as db:
l = db.cursor.execute("SELECT * FROM {}".format(table_name)).fetchall()
ips_in_table = []
for val in l:
ips_in_table.append(val[1])
return list(set(ips_in_table))
def scanSystem(self):
self.DatabaseHandler_instance = DatabaseHandler(os.getcwd())
scanDialog = QtWidgets.QDialog()
scanDialogui = Ui_Dialog_()
scanDialogui.setupUi_(scanDialog)
scanDialog.show()
scanDialog.exec_()
def __init__(self, database_file=""):
self.MAP_NAME = "glassgarden.map"
self.TIMEOUT_GOTO = 300 # (S)
self.TIMEOUT_WANDERING = 600 # (S)
self.EMOTIONAL_FEEDBACK_CYCLE = 15 # (s)
self.SERVER_RATE = rospy.Rate(10) #(Hz)
self.client_base_feedback = StateMachineFeedback()
self.client_base_result = StateMachineResult()
self.current_x = 0.0
self.current_y = 0.0
self.next_location = None
self.current_location = None
self.current_location_name = None
self.base_canceled = False
self.base_succeeded = False
self.location_subscriber = rospy.Subscriber("/rosarnl_node/amcl_pose",
PoseWithCovarianceStamped,
self.location_callback)
self.publisher_current_location = rospy.Publisher(rospy.get_name() +
"/current_location",
String,
queue_size=10)
self.emotion_publisher = rospy.Publisher(
"/cyborg_controller/emotional_feedback",
EmotionalFeedback,
queue_size=100)
self.server_navigation = actionlib.SimpleActionServer(
rospy.get_name() + "/navigation",
NavigationAction,
execute_cb=self.navigationserver_callback,
auto_start=False)
self.server_navigation.start()
self.client_base = actionlib.SimpleActionClient(
"/rosarnl_node/move_base", MoveBaseAction)
self.database_handler = DatabaseHandler(filename=database_file)
self.location_updater_thread = threading.Thread(
target=self.location_updater)
self.location_updater_thread.daemon = True
self.location_updater_thread.start()
rospy.loginfo("NavigationServer: Activated.")
def __init__(self, database_file=""):
self.event_publisher = rospy.Publisher(rospy.get_name() +
"/register_event",
String,
queue_size=100)
self.emotion_publisher = rospy.Publisher(rospy.get_name() +
"/emotional_feedback",
EmotionalFeedback,
queue_size=100)
self.emotion_subscriber = rospy.Subscriber(rospy.get_name() +
"/emotional_state",
EmotionalState,
self.emotion_callback,
queue_size=100)
self.state_subscriber = rospy.Subscriber(rospy.get_name() +
"/state_change",
SystemState,
self.state_callback,
queue_size=100)
self.rate = rospy.Rate(.5) # (hz), looping speed
self.database_handler = DatabaseHandler(filename=database_file)
self.database_handler.reset_event_values()
def main():
rospy.init_node("cyborg_controller")
# Create emotions
emotion_system = EmotionSystem()
emotion_system.add_emotion(name="angry",
pleasure=-0.51,
arousal=0.59,
dominance=0.25)
emotion_system.add_emotion(name="bored",
pleasure=-0.65,
arousal=-0.62,
dominance=-0.33)
emotion_system.add_emotion(name="curious",
pleasure=0.22,
arousal=0.62,
dominance=-0.10)
emotion_system.add_emotion(name="dignified",
pleasure=0.55,
arousal=0.22,
dominance=0.61)
emotion_system.add_emotion(name="elated",
pleasure=0.50,
arousal=0.42,
dominance=0.23) # Happy
emotion_system.add_emotion(name="inhibited",
pleasure=-0.54,
arousal=-0.04,
dominance=-0.41) # Sadness
emotion_system.add_emotion(name="puzzled",
pleasure=-0.41,
arousal=0.48,
dominance=-0.33) # Surprized
emotion_system.add_emotion(name="loved",
pleasure=0.89,
arousal=0.54,
dominance=-0.18)
emotion_system.add_emotion(name="unconcerned",
pleasure=-0.13,
arousal=-0.41,
dominance=0.08)
homedir = os.path.expanduser("~")
path = homedir + "/controller.db"
# Fill database with default values
if (os.path.exists(path) == False):
event_cost = 0.6 #
database_handler = DatabaseHandler(filename=path)
database_handler.create()
database_handler.add_event(state="idle",
event="music_play",
reward_pleasure=0.08,
reward_arousal=0.02,
reward_dominance=-0.03,
event_cost=event_cost * 2)
database_handler.add_event(state="idle",
event="astrolanguage",
reward_pleasure=0.04,
reward_arousal=0.05,
reward_dominance=0.04,
event_cost=event_cost * 1.5)
database_handler.add_event(state="idle",
event="navigation_emotional",
reward_pleasure=0.02,
reward_arousal=0.04,
reward_dominance=-0.02,
event_cost=event_cost)
database_handler.add_event(state="idle",
event="show_off_mea",
reward_pleasure=0.02,
reward_arousal=0.01,
reward_dominance=0.01,
event_cost=event_cost / 2)
database_handler.add_event(state="idle",
event="convey_emotion",
reward_pleasure=0.01,
reward_arousal=-0.01,
reward_dominance=0.02,
event_cost=event_cost / 3)
# Create motivator
motivator = Motivator(database_file=path)
motivator.start()
# Create a SMACH state machine
sm = smach.StateMachine(outcomes=["error"])
sm.userdata.state_machine_events = []
sm.userdata.last_state = "initializing"
sm.userdata.last_event = "start_up"
with sm:
sm_remapping = {
"input_events": "state_machine_events",
"output_events": "state_machine_events",
"previous_state": "last_state",
"current_state": "last_state",
"previous_event": "last_event",
"current_event": "last_event"
}
idle_transitions = {
"navigation_schedular": "navigation",
"navigation_emotional": "navigation",
"convey_emotion": "conveying_emotional_state",
"show_off_mea": "show_off_mea",
"music_play": "music_horror",
"astrolanguage": "astrolanguage",
"aborted": "idle",
"power_low": "exhausted",
"bedtime": "sleepy"
}
idle_resources = {} # Idle does not require any resources
smach.StateMachine.add(
"idle",
Module("idle", "cyborg_primary_states", idle_transitions,
idle_resources), idle_transitions, sm_remapping)
sleepy_transitions = {"aborted": "idle", "succeeded": "sleeping"}
sleepy_resources = {}
show_off_mea_transitions = {"aborted": "idle", "succeeded": "idle"}
smach.StateMachine.add(
"show_off_mea",
Module("show_off_mea", "cyborg_behavior", show_off_mea_transitions,
sleepy_resources), show_off_mea_transitions, sm_remapping)
smach.StateMachine.add(
"sleepy",
Module("sleepy", "cyborg_behavior", sleepy_transitions,
sleepy_resources), sleepy_transitions, sm_remapping)
exhausted_transitions = {"aborted": "idle", "succeeded": "sleeping"}
exhausted_resources = {}
smach.StateMachine.add(
"exhausted",
Module("exhausted", "cyborg_behavior", exhausted_transitions,
exhausted_resources), exhausted_transitions, sm_remapping)
sleeping_transitions = {
"preempted": "idle",
"cyborg_wake_up": "waking_up"
}
sleeping_resources = {}
smach.StateMachine.add(
"sleeping",
Module("sleeping", "cyborg_primary_states", sleeping_transitions,
sleeping_resources), sleeping_transitions, sm_remapping)
waking_up_transitions = {"aborted": "idle", "succeeded": "idle"}
waking_up_resources = {}
smach.StateMachine.add(
"waking_up",
Module("waking_up", "cyborg_behavior", waking_up_transitions,
waking_up_resources), waking_up_transitions, sm_remapping)
conveying_emotion_transitions = {
"aborted": "idle",
"succeeded": "idle"
}
conveying_emotion_resources = {}
smach.StateMachine.add(
"conveying_emotional_state",
Module("conveying_emotional_state", "cyborg_behavior",
conveying_emotion_transitions, conveying_emotion_resources),
conveying_emotion_transitions, sm_remapping)
sm_nav = smach.StateMachine(
outcomes=["succeeded", "aborted", "power_low"])
with sm_nav:
navigation_planning_transitions = {
"navigation_start_moving_schedular":
"navigation_go_to_schedular",
"navigation_start_moving_emotional":
"navigation_go_to_emotional",
"navigation_start_wandering": "wandering_emotional",
"aborted": "aborted"
}
navigation_planning_resources = {}
smach.StateMachine.add(
"navigation_planning",
Module("navigation_planning", "cyborg_primary_states",
navigation_planning_transitions,
navigation_planning_resources),
navigation_planning_transitions, sm_remapping)
navigation_go_to_transitions = {
"succeeded": "succeeded",
"aborted": "aborted",
"preempted": "aborted"
}
smach.StateMachine.add(
"navigation_go_to_emotional",
statemachines.sequence_navigation_go_to_emotional,
transitions=navigation_go_to_transitions,
remapping=sm_remapping)
navigation_go_to_schedular_resources = {}
smach.StateMachine.add(
"navigation_go_to_schedular",
Module("navigation_go_to_schedular", "cyborg_behavior",
navigation_go_to_transitions,
navigation_go_to_schedular_resources),
navigation_go_to_transitions, sm_remapping)
navigation_wandering_emotional_transitions = {
"navigation_wandering_complete": "succeeded",
"aborted": "aborted",
"power_low": "power_low"
}
navigation_wandering_emotional_resources = {}
smach.StateMachine.add(
"wandering_emotional",
Module("wandering_emotional", "cyborg_primary_states",
navigation_wandering_emotional_transitions,
navigation_wandering_emotional_resources),
navigation_wandering_emotional_transitions, sm_remapping)
sm_nav_transitions = {
"aborted": "idle",
"succeeded": "idle",
"power_low": "exhausted"
}
smach.StateMachine.add("navigation", sm_nav, sm_nav_transitions,
sm_remapping)
music_transitions = {"aborted": "idle", "succeeded": "idle"}
music_resources = {}
smach.StateMachine.add(
"music_horror",
Module("music_horror", "cyborg_behavior", music_transitions,
music_resources), music_transitions, sm_remapping)
astrolanguage_transitions = {"aborted": "idle", "succeeded": "idle"}
astrolanguage_resources = {}
smach.StateMachine.add(
"astrolanguage",
Module("astrolanguage", "cyborg_behavior",
astrolanguage_transitions, astrolanguage_resources),
astrolanguage_transitions, sm_remapping)
sm.register_io_keys(
{"state_machine_events", "last_state", "last_event"})
sm_nav.register_io_keys(
{"state_machine_events", "last_state", "last_event"})
rospy.sleep(3)
sis = smach_ros.IntrospectionServer('controller_viewer', sm,
'/controller_viewer')
sis.start()
smach_thread = threading.Thread(target=sm.execute)
smach_thread.daemon = True
smach_thread.start()
# Start ROS main looping
rospy.loginfo("Controller: Activated...")
rospy.spin()
sis.stop()
rospy.loginfo("Controller: Terminated...")
class PrimaryStatesServer():
"""Primary States Server"""
def __init__(self, database_file=""):
self.action_name = rospy.get_name()
self.MAP_NAME = "glassgarden.map"
self.PLANNING_TIMEOUT = 10
self.RATE_ACTIONLOOP = rospy.Rate(4) # Hz
self.next_location = ""
self.current_emotional_state = "neutral"
self.current_state = ""
self.database_handler = DatabaseHandler(filename=database_file)
self.publisher_emotional_feedback = rospy.Publisher(
"/cyborg_controller/emotional_feedback",
EmotionalFeedback,
queue_size=100)
self.subscriber_emotional_state = rospy.Subscriber(
"/cyborg_controller/emotional_state",
EmotionalState,
self.emotional_callback,
queue_size=10)
self.publisher_event = rospy.Publisher(
"/cyborg_controller/register_event", String, queue_size=100)
self.publisher_location_command = rospy.Publisher(
"/cyborg_behavior/command_location", String, queue_size=10)
self.client_behavior = actionlib.SimpleActionClient(
"/cyborg_behavior", StateMachineAction)
self.server_primary_states = actionlib.SimpleActionServer(
self.action_name,
StateMachineAction,
execute_cb=self.callback_server_primary_states,
auto_start=False)
self.server_primary_states.start()
rospy.loginfo("PrimaryStatesServer: Initiated")
def callback_server_primary_states(self, goal):
self.state_goal = goal
if self.state_goal.current_state == "wandering_emotional":
self.wandering_emotional()
elif self.state_goal.current_state == "navigation_planning":
self.navigation_planning_state(self.state_goal)
def emotional_callback(self, message):
self.current_emotional_state = message.to_emotional_state
def create_and_send_behavior_goal(self, behavior, location=None):
# Create and send goal to behaviorserver
goal = StateMachineGoal()
goal.current_state = behavior
if location != None:
goal.order = location
self.client_behavior.send_goal(goal)
# Check execution of action
def actionloop_check(self):
# Check if preempt is requested
if self.server_primary_states.is_preempt_requested():
self.client_behavior.cancel_all_goals()
self.server_primary_states.set_preempted()
rospy.loginfo("PrimaryStatesServer: %s state preempted.",
self.current_state)
return True
else:
# Check behaviorserver state
behaviorserver_state = self.client_behavior.get_state()
# not active
if behaviorserver_state == 3:
# succeeded
rospy.loginfo(
"PrimaryStatesServer: %s state BehaviorServer goal succeeded. ",
self.current_state)
self.server_primary_states.set_succeeded()
return True
elif behaviorserver_state == 2:
# Preempted
rospy.loginfo(
"PrimaryStatesServer: %s state BehaviorServer goal was preempted. ",
self.current_state)
self.server_primary_states.set_preempted()
return True
elif behaviorserver_state == 4:
# aborted
rospy.loginfo(
"PrimaryStatesServer: %s state BehaviorServer goal aborted. ",
self.current_state)
self.server_primary_states.set_aborted()
return True
def wandering_emotional(self):
rospy.loginfo("PrimaryStatesServer: Executing wander emotional state.")
#connect to server and send goal
goal = "wandering_emotional"
self.create_and_send_behavior_goal(goal)
while not rospy.is_shutdown():
if self.actionloop_check() == True:
return
elif self.current_emotional_state not in [
"bored", "curious", "unconcerned"
]: # emotions currently not integrated in server
self.client_behavior.cancel_all_goals()
rospy.sleep(2)
self.server_primary_states.set_succeeded()
rospy.loginfo(
"PrimaryStatesServer: wandering complete, preempted.")
return
self.RATE_ACTIONLOOP.sleep()
# set terminal goal status in case of shutdown
self.server_primary_states.set_aborted()
# Called when the controller (state machine) sets the navigation_planning state as active
def navigation_planning_state(self, goal):
rospy.loginfo(
"PrimaryStatesServer: Executing navigation_planning state.")
time.sleep(1) # let roscore update connections
self.next_location = None
if goal.event == "navigation_schedular":
if self.current_emotional_state == "angry":
self.next_location = self.database_handler.search_for_crowded_locations(
robot_map_name=self.MAP_NAME, crowded=False)
message = String(data=self.next_location.location_name)
self.publisher_location_command.publish(message)
self.send_emotion(pleasure=0, arousal=0, dominance=0.1)
self.change_state(event="navigation_start_moving_schedular")
else:
self.next_location = self.database_handler.search_ongoing_events(
robot_map_name=self.MAP_NAME,
current_date=datetime.datetime.now())
message = String(data=self.next_location.location_name)
self.publisher_location_command.publish(message)
self.send_emotion(pleasure=0, arousal=0, dominance=-0.1)
self.change_state(event="navigation_start_moving_schedular")
elif goal.event == "navigation_emotional":
if self.current_emotional_state in [
"angry", "sad", "fear", "inhibited"
]:
self.next_location = self.database_handler.search_for_crowded_locations(
robot_map_name=self.MAP_NAME, crowded=False)
message = String(data=self.next_location.location_name)
self.publisher_location_command.publish(message)
self.send_emotion(pleasure=0, arousal=0, dominance=0.1)
self.change_state(event="navigation_start_moving_emotional")
elif self.current_emotional_state in [
"happy", "loved", "dignified", "neutral", "elated"
]:
self.next_location = self.database_handler.search_for_crowded_locations(
robot_map_name=self.MAP_NAME, crowded=True)
message = String(data=self.next_location.location_name)
self.publisher_location_command.publish(message)
self.send_emotion(pleasure=0, arousal=0, dominance=0.1)
self.change_state(event="navigation_start_moving_emotional")
elif self.current_emotional_state in [
"bored", "curious", "unconcerned"
]:
self.next_location = "wandering"
self.send_emotion(pleasure=0, arousal=0, dominance=0.1)
self.change_state(event="navigation_start_wandering")
def change_state(self, event=None):
if event == None:
self.server_primary_states.set_aborted()
return
else:
if event == "navigation_start_moving":
if self.next_location != None:
self.publisher_event.publish(event)
else:
self.publisher_event.publish(event)
# wait until state is preempted, or abort if it takes too long
started_waiting = time.time()
while not rospy.is_shutdown():
if self.server_primary_states.is_preempt_requested():
self.server_primary_states.set_preempted()
return
elif (time.time() - started_waiting > self.PLANNING_TIMEOUT):
self.server_primary_states.set_aborted()
return
self.RATE_ACTIONLOOP.sleep()
# set terminal goal status in case of shutdown
self.server_primary_states.set_aborted()
# Sends the emotional change to the controller
def send_emotion(self, pleasure, arousal, dominance):
msg = EmotionalFeedback()
msg.delta_pleasure = pleasure
msg.delta_arousal = arousal
msg.delta_dominance = dominance
self.publisher_emotional_feedback.publish(msg)
class NavigationServer():
"""NavigationServer"""
def __init__(self, database_file=""):
self.MAP_NAME = "glassgarden.map"
self.TIMEOUT_GOTO = 300 # (S)
self.TIMEOUT_WANDERING = 600 # (S)
self.EMOTIONAL_FEEDBACK_CYCLE = 15 # (s)
self.SERVER_RATE = rospy.Rate(10) #(Hz)
self.client_base_feedback = StateMachineFeedback()
self.client_base_result = StateMachineResult()
self.current_x = 0.0
self.current_y = 0.0
self.next_location = None
self.current_location = None
self.current_location_name = None
self.base_canceled = False
self.base_succeeded = False
self.location_subscriber = rospy.Subscriber("/rosarnl_node/amcl_pose",
PoseWithCovarianceStamped,
self.location_callback)
self.publisher_current_location = rospy.Publisher(rospy.get_name() +
"/current_location",
String,
queue_size=10)
self.emotion_publisher = rospy.Publisher(
"/cyborg_controller/emotional_feedback",
EmotionalFeedback,
queue_size=100)
self.server_navigation = actionlib.SimpleActionServer(
rospy.get_name() + "/navigation",
NavigationAction,
execute_cb=self.navigationserver_callback,
auto_start=False)
self.server_navigation.start()
self.client_base = actionlib.SimpleActionClient(
"/rosarnl_node/move_base", MoveBaseAction)
self.database_handler = DatabaseHandler(filename=database_file)
self.location_updater_thread = threading.Thread(
target=self.location_updater)
self.location_updater_thread.daemon = True
self.location_updater_thread.start()
rospy.loginfo("NavigationServer: Activated.")
# Updates the current position when the position subscriber receives data
def location_callback(self, data):
self.current_x = data.pose.pose.position.x
self.current_y = data.pose.pose.position.y
# Updates current location based on position and publishes to other nodes
def location_updater(self): # Threaded
rospy.sleep(1)
while not rospy.is_shutdown():
self.current_location = self.database_handler.find_location(
robot_map_name=self.MAP_NAME,
location_x=self.current_x,
location_y=self.current_y)
self.current_location_name = self.current_location.location_name if self.current_location != None else ""
self.publisher_current_location.publish(
data=self.current_location_name)
rospy.sleep(1)
# Called once when the robot base (ROSARNL) goal completes
def client_base_done_callback(self, state, result):
if self.is_controlling_base:
if (state == 3): # Succeeded aka arrived at location
self.base_succeeded = True
elif (state == 2): # Happens when we cancel goals aka preempted
self.base_canceled = True
elif (state == 1): # Canceled?
self.base_canceled = True
elif (state == 4): # aborted
self.base_canceled = True
self.client_base_state = state
self.client_base_result = result
rospy.logdebug(
"NavigationServer: Base has completed its execution with " +
str(state) + " and result " + str(result) + ".")
# Called once when the robot base (ROSARNL) goal becomes active
def client_base_active_callback(self):
rospy.logdebug("NavigationServer: Base goal has gone active.")
self.is_controlling_base = True
# Called every time feedback is received for the goal for the robot base (ROSARNL)
def client_base_feedback_callback(self, feedback):
rospy.logdebug("NavigationServer: Received feedback from base - " +
str(feedback) + ".")
self.client_base_feedback = feedback
#Callback for navigation, used for initiating wandering, docking, or go to location
def navigationserver_callback(self, goal):
self.base_canceled = False
self.base_succeeded = False
rospy.loginfo("NavigationServer Callback initiating:" +
str(goal.order) + " order, and " +
str(goal.location_name) + " location.")
self.is_controlling_base = False
if goal.order == "navigation_wander":
self.start_wandering()
elif goal.order == "navigation_go_to" and goal.location_name != None:
self.navigation_go_to(goal)
elif goal.order == "navigation_dock":
self.navigation_dock()
else:
self.server_navigation.set_aborted()
rospy.logdebug(
"NavigationServer: Received event that cant be handled - " +
str(goal.order) + ".")
# This can be used by other nodes for moving the cyborg to a known location.
# Preemptable, ends in Succeeded, Aborted or Preempted.
# Increases PAD values while moving
def navigation_go_to(self, goal):
self.goal = goal
rospy.loginfo("NavigationServer: go to server received a goal - " +
str(self.goal.location_name))
self.next_location = self.database_handler.search_for_location(
location_name=self.goal.location_name)
if self.next_location != None:
self.check_and_send_goal(location=self.next_location)
start_time = time.time()
feedback_timer = time.time()
# Wait until state is preempted or succeeded
while not rospy.is_shutdown():
if self.base_succeeded:
self.send_emotion(pleasure=self.next_location.environment,
arousal=0,
dominance=0.0)
self.server_navigation.set_succeeded()
self.next_location = None
return
if self.server_navigation.is_preempt_requested():
self.client_base.cancel_all_goals()
self.server_navigation.set_preempted
return
if self.base_canceled:
self.server_navigation.set_aborted()
return
else:
server_feedback = NavigationFeedback(status="moving")
self.server_navigation.publish_feedback(server_feedback)
if (time.time() - start_time >
self.TIMEOUT_GOTO): #prevent eternal looping of state
self.client_base.cancel_all_goals()
self.server_navigation.set_aborted()
return
#give emotional feedback
if (time.time() - feedback_timer >
self.EMOTIONAL_FEEDBACK_CYCLE):
self.send_emotion(pleasure=0.0,
arousal=0.02,
dominance=-0.01)
feedback_timer = time.time()
#return
self.SERVER_RATE.sleep()
# set terminal goal status in case of shutdown
self.server_navigation.set_aborted()
else:
rospy.logdebug(
"NavigationServer: Go to server received a location with unrecognized name - "
+ str(goal.location_name))
self.server_navigation.set_aborted()
# Sends the location to the ROSARNL node (Pioneer XL robot base)
# Added check path of goal before sending
def check_and_send_goal(self, location):
if (self.client_base.wait_for_server(
rospy.Duration.from_sec(5.0)) == False):
rospy.logwarn(
"NavigationServer: ERROR - Unable to connect to Pioneer XL.")
self.base_canceled = True
return
pose = geometry_msgs.msg.Pose()
pose.position.x = location.x
pose.position.y = location.y
pose.position.z = location.z
q = tf.transformations.quaternion_from_euler(location.p, location.j,
location.r)
pose.orientation = geometry_msgs.msg.Quaternion(*q)
goal = MoveBaseGoal()
goal.target_pose.pose = pose
goal.target_pose.header.frame_id = location.robot_map_name
goal.target_pose.header.stamp = rospy.Time.now()
rospy.wait_for_service("/rosarnl_node/make_plan")
baseCheckPath = rospy.ServiceProxy("/rosarnl_node/make_plan",
MakePlan())
makeplan = MakePlan()
makeplan.position = location
makeplan.orientation = pose.orientation
try:
path = baseCheckPath(makeplan)
if (len(path.path) > 0):
goal.target_pose.header.stamp = rospy.Time.now()
self.client_base.send_goal(goal,
self.client_base_done_callback,
self.client_base_active_callback,
self.client_base_feedback_callback)
rospy.loginfo("NavigationServer: Path OK.")
rospy.logdebug("NavigationServer: Location goal is - " +
str(self.next_location))
else:
rospy.logdebug("NavigationServer: Could not compute path to " +
str(self.next_location) + ".")
self.next_location = None
self.base_canceled = True
except rospy.ServiceException as exc:
rospy.logdebug(
"NavigationServer: Make plan service did not process request: "
+ str(exc))
self.next_location = None
self.base_canceled = True
return
# The robot base starts to wander and keeps wandering until it is preempted
def start_wandering(self):
# Tell base to start wandering
rospy.logdebug("NavigationServer: Waiting for base wandering service.")
rospy.wait_for_service("/rosarnl_node/wander")
rospy.logdebug("NavigationServer: wandering service available.")
try:
baseStartWandering = rospy.ServiceProxy("/rosarnl_node/wander",
Empty)
baseStartWandering()
except rospy.ServiceException, e:
rospy.logdebug("NavigationServer: wandering service error - " +
str(e))
started_waiting = time.time() # Prevent eternal looping
feedback_timer = time.time()
while not rospy.is_shutdown():
if self.server_navigation.is_preempt_requested():
self.client_base.cancel_all_goals()
try:
baseStop = rospy.ServiceProxy("/rosarnl_node/stop", Empty)
baseStop()
except rospy.ServiceException, e:
rospy.logdebug("NavigationServer: stop service error - " +
str(e))
self.server_navigation.set_preempted()
return
# Check wandering timeout to prevent eternal looping
if (time.time() - started_waiting > self.TIMEOUT_WANDERING):
rospy.loginfo("NavigationServer: Timed out, aborting.")
self.client_base.cancel_all_goals()
try:
baseStop = rospy.ServiceProxy("/rosarnl_node/stop", Empty)
baseStop()
except rospy.ServiceException, e:
rospy.logdebug("NavigationServer: stop service error - " +
str(e))
self.server_navigation.set_aborted()
return
def main():
rospy.init_node("cyborg_controller")
# Create emotions
emotion_system = EmotionSystem()
emotion_system.add_emotion(name="angry",
pleasure=-0.51,
arousal=0.59,
dominance=0.25)
emotion_system.add_emotion(name="bored",
pleasure=-0.65,
arousal=-0.62,
dominance=-0.33)
emotion_system.add_emotion(name="curious",
pleasure=0.22,
arousal=0.62,
dominance=-0.10)
emotion_system.add_emotion(name="dignified",
pleasure=0.55,
arousal=0.22,
dominance=0.61)
emotion_system.add_emotion(name="elated",
pleasure=0.50,
arousal=0.42,
dominance=0.23) # Happy
emotion_system.add_emotion(name="inhibited",
pleasure=-0.54,
arousal=-0.04,
dominance=-0.41) # Sadness
emotion_system.add_emotion(name="puzzled",
pleasure=-0.41,
arousal=0.48,
dominance=-0.33) # Suprized
emotion_system.add_emotion(name="loved",
pleasure=0.89,
arousal=0.54,
dominance=-0.18)
emotion_system.add_emotion(name="unconcerned",
pleasure=-0.13,
arousal=-0.41,
dominance=0.08)
homedir = os.path.expanduser("~")
path = homedir + "/controller.db"
# Fill database with default values
if (os.path.exists(path) == False):
event_cost = 0.45
database_handler = DatabaseHandler(filename=path)
database_handler.create()
database_handler.add_event(state="idle",
event="music_play",
reward_pleasure=0.08,
reward_arousal=0.01,
reward_dominance=-0.02,
event_cost=event_cost)
database_handler.add_event(state="idle",
event="navigation_emotional",
reward_pleasure=0.00,
reward_arousal=0.05,
reward_dominance=-0.01,
event_cost=event_cost)
database_handler.add_event(state="conversation",
event="weather_tell",
reward_pleasure=0.05,
reward_arousal=0.00,
reward_dominance=0.00,
event_cost=event_cost)
database_handler.add_event(state="conversation",
event="joke_tell",
reward_pleasure=0.05,
reward_arousal=0.02,
reward_dominance=0.00,
event_cost=event_cost)
database_handler.add_event(state="conversation",
event="selfie_take",
reward_pleasure=0.05,
reward_arousal=-0.02,
reward_dominance=0.01,
event_cost=event_cost * 1.5)
database_handler.add_event(state="conversation",
event="simon_says_play",
reward_pleasure=0.00,
reward_arousal=0.00,
reward_dominance=0.10,
event_cost=event_cost)
database_handler.add_event(state="conversation",
event="follower_follow",
reward_pleasure=0.00,
reward_arousal=0.05,
reward_dominance=-0.05,
event_cost=event_cost)
# Create motivator
motivator = Motivator(database_file=path)
motivator.start()
# Create a SMACH state machine
state_machine = smach.StateMachine(outcomes=["error"])
state_machine.userdata.state_machine_events = []
state_machine.userdata.last_state = "initializing"
state_machine.userdata.last_event = "start_up"
# Open the container
with state_machine:
# Remapp outputs, so userdata can be moved between states
state_machine_remapping = {
"input_events": "state_machine_events",
"output_events": "state_machine_events",
"previous_state": "last_state",
"current_state": "last_state",
"previous_event": "last_event",
"current_event": "last_event"
}
# Add states to the container
idle_transitions = {
"conversation_interest": "conversation",
"navigation_schedualer": "navigation_planing",
"navigation_emotional": "navigation_planing",
"aborted": "idle",
"navigation_command": "navigation_planing",
"music_play": "music"
}
idle_resources = {} # Idle does not require any resources
smach.StateMachine.add(label="idle",
state=Module(state_name="idle",
actionlib_name="cyborg_idle/idle",
transitions=idle_transitions,
resources=idle_resources),
transitions=idle_transitions,
remapping=state_machine_remapping)
conversation_transitions = {
"aborted": "idle",
"succeded": "idle",
"navigation_feedback": "navigation_talking",
"navigation_command": "navigation_talking",
"navigation_information": "navigation_talking",
"simon_says_play": "simon_says",
"selfie_take": "selfie",
"follower_follow": "follower",
"weather_tell": "weather",
"joke_tell": "joke"
}
conversation_resources = {"trollface": "cyborg_conversation"}
smach.StateMachine.add(
label="conversation",
state=Module(state_name="conversation",
actionlib_name="cyborg_conversation/conversation",
transitions=conversation_transitions,
resources=conversation_resources),
transitions=conversation_transitions,
remapping=state_machine_remapping)
navigation_transitions = {
"aborted": "navigation_talking",
"navigation_start_wandering": "navigation_moving",
"navigation_start_moving": "navigation_moving",
"succeded": "navigation_talking"
}
navigation_resources = {"base": "cyborg_navigation"}
smach.StateMachine.add(label="navigation_planing",
state=Module(
state_name="navigation_planing",
actionlib_name="cyborg_navigation/planing",
transitions=navigation_transitions,
resources=navigation_resources),
transitions=navigation_transitions,
remapping=state_machine_remapping)
navigation_transitions = {
"aborted": "navigation_talking",
"succeded": "navigation_talking",
"navigation_wandering_completed": "idle"
}
navigation_resources = {"base": "cyborg_navigation"}
smach.StateMachine.add(label="navigation_moving",
state=Module(
state_name="navigation_moving",
actionlib_name="cyborg_navigation/moving",
transitions=navigation_transitions,
resources=navigation_resources),
transitions=navigation_transitions,
remapping=state_machine_remapping)
navigation_transitions = {
"aborted": "idle",
"succeded": "idle",
"navigation_feedback_completed": "conversation",
"navigation_command": "navigation_planing"
}
navigation_resources = {
"base": "cyborg_navigation",
"trollface": "cyborg_navigation"
}
smach.StateMachine.add(label="navigation_talking",
state=Module(
state_name="navigation_talking",
actionlib_name="cyborg_navigation/talking",
transitions=navigation_transitions,
resources=navigation_resources),
transitions=navigation_transitions,
remapping=state_machine_remapping)
music_transitions = {
"aborted": "idle",
"succeded": "idle",
"conversation_interest": "conversation"
}
music_resources = {}
smach.StateMachine.add(label="music",
state=Module(
state_name="music",
actionlib_name="cyborg_music/music",
transitions=music_transitions,
resources=music_resources),
transitions=music_transitions,
remapping=state_machine_remapping)
smach.StateMachine.add(
label="simon_says",
state=Module(state_name="simon_says",
actionlib_name="cyborg_conversation/simon_says",
transitions={
"aborted": "conversation",
"succeded": "conversation"
},
resources={"trollface": "cyborg_simon_says"}),
transitions={
"aborted": "conversation",
"succeded": "conversation"
},
remapping=state_machine_remapping)
smach.StateMachine.add(label="selfie",
state=Module(
state_name="selfie",
actionlib_name="cyborg_conversation/selfie",
transitions={
"aborted": "conversation",
"succeded": "conversation"
},
resources={"trollface": "cyborg_selfie"}),
transitions={
"aborted": "conversation",
"succeded": "conversation"
},
remapping=state_machine_remapping)
smach.StateMachine.add(
label="follower",
state=Module(state_name="follower",
actionlib_name="cyborg_conversation/follower",
transitions={
"aborted": "conversation",
"succeded": "conversation"
},
resources={"trollface": "cyborg_follower"}),
transitions={
"aborted": "conversation",
"succeded": "conversation"
},
remapping=state_machine_remapping)
smach.StateMachine.add(
label="weather",
state=Module(state_name="weather",
actionlib_name="cyborg_conversation/weather",
transitions={
"aborted": "conversation",
"succeded": "conversation"
},
resources={"trollface": "cyborg_weather"}),
transitions={
"aborted": "conversation",
"succeded": "conversation"
},
remapping=state_machine_remapping)
smach.StateMachine.add(
label="joke", # name on state
state=Module(
state_name="joke", # name on state
actionlib_name="cyborg_conversation/joke", # actionlib name
transitions={
"aborted": "conversation",
"succeded": "conversation"
}, #event name:state - events that leads away from state
resources={"trollface": "cyborg_joke"
}), # for gatekeepers: resource_name:node_name
transitions={
"aborted": "conversation",
"succeded": "conversation"
},
remapping=state_machine_remapping)
################################################### ADD MORE STATES BELOW ###################################################
################################################### STOP ADDING YOUR STATES ###################################################
# Create a state machine monitorer
smm = StateMachineMonitor(state_machine, display_all=True)
rospy.loginfo("Controller: State Machine Monitor Activated...")
import smach_ros
sis = smach_ros.IntrospectionServer('controler_viewer', state_machine,
'/controler_viewer')
sis.start()
# Create a thread to execute the smach
smach_thread = threading.Thread(target=state_machine.execute)
smach_thread.daemon = True
smach_thread.start()
rospy.loginfo("Controller: SMACH activated...")
# Start ROS main looping
rospy.loginfo("Controller: Activated...")
rospy.spin()
sis.stop()
rospy.loginfo("Controller: Terminated...")
class PCPPHelperBot:
"""Posts PC Part Picker markup tables when applicable.
This utilizes the PRAW wrapper for interacting with Reddit. It streams
new submissions in order to look for submissions with a PC Part Picker
list URL. If the post already has a table, no action will be taken. If
not, or it is malformed, a reply containing the table will be posted.
"""
def __init__(self, log_file_handler, live=False):
self.is_live = live
# Logger setup
if self.is_live:
self.logger = logging.getLogger('PCPPHelperBot')
else:
self.logger = logging.getLogger('PCPPHelperBot-DEBUG')
self.logger.addHandler(log_file_handler)
now_str = datetime.now().strftime('%H:%M:%S')
self.logger.info(f'STARTING {now_str}')
# Database setup
if self.is_live:
self.db_handler = DatabaseHandler()
else:
self.db_handler = DatabaseHandler(debug=True)
self.db_handler.connect()
self.db_handler.create_table()
# Retrieve environment vars for secret data
username = os.environ.get('REDDIT_USERNAME')
password = os.environ.get('REDDIT_PASSWORD')
client_id = os.environ.get('CLIENT_ID')
secret = os.environ.get('CLIENT_SECRET')
version = 0.1
user_agent = f"web:pcpp-helper-bot:v{version} (by u/pcpp-helper-bot)"
# Utilize PRAW wrapper
self.reddit = praw.Reddit(user_agent=user_agent,
client_id=client_id, client_secret=secret,
username=username, password=password)
# Only look at submissions with one of these flairs
# TODO: Are these the best submission flairs to use?
self.pertinent_flairs = ['Build Complete', 'Build Upgrade',
'Build Help', 'Build Ready', None]
self.pcpp_parser = PCPPParser(log_file_handler)
self.table_creator = TableCreator()
self.MAX_TABLES = 2
self.subreddit_name = None
# Read in the templates
with open('./templates/replytemplate.md', 'r') as template:
self.REPLY_TEMPLATE = template.read()
with open('./templates/idenlinkfound.md', 'r') as template:
self.IDENTIFIABLE_TEMPLATE = template.read()
with open('./templates/tableissuetemplate.md', 'r') as template:
self.TABLE_TEMPLATE = template.read()
def monitor_subreddit(self, subreddit_name: str):
"""Monitors the subreddit provided (mainly r/buildapc) for new
submissions.
Args:
subreddit_name (str): The name of the subreddit
"""
continue_monitoring = True
self.subreddit_name = subreddit_name
# skip_existing will skip the posts made BEFORE the bot starts observing
# By default, up to 100 historical submissions/comments would be returned
# See PRAW.reddit.SubredditStream #3147
subreddit = self.reddit.subreddit(subreddit_name)
# Stream in new submissions from the subreddit
while continue_monitoring:
try:
for submission in subreddit.stream.submissions(skip_existing=True):
unpaired_urls, iden_anon_urls, table_data = self.read_submission(submission)
# If there are missing/broken tables or identifiable links
if len(unpaired_urls) != 0 or len(iden_anon_urls) != 0:
self.logger.info('FOUND TABLELESS OR IDENTIFIABLE URLS')
self.logger.info(f'SUBMISSION TEXT: {submission.selftext}')
self.reply(submission, unpaired_urls, iden_anon_urls, table_data)
should_stop, reason = self._check_inbox_for_stop()
if should_stop:
self.logger.info(f'STOPPING BY REQUEST. REASON: {reason}')
continue_monitoring = False
break
except Exception as e:
self.logger.critical('Problem connecting to Reddit or in creating reply')
self.logger.critical('Exception data: ', exc_info=True)
# TODO: Catch any exceptions for when Reddit is down or PRAW has issues
self._cleanup_database()
def read_submission(self, submission: praw.reddit.Submission):
"""Reads a submission from Reddit.
Args:
submission ('obj': praw.reddit.Submission): A PRAW Submission object.
Returns:
(urls without tables, (identifiable, anonymous) pair list,
{'total', 'valid', 'invalid', 'bad_markdown'} dict of table
data).
"""
flair = submission.link_flair_text
tableless_urls = []
iden_anon_urls = []
table_data = {'total': 0, 'valid': 0, 'invalid': 0, 'bad_markdown': False}
if self._already_replied(submission.id):
self.logger.info('Already replied to this submission.')
# Only look at text submissions and with the appropriate flairs
elif flair in self.pertinent_flairs and submission.is_self:
self.logger.info(f'CHECKING SUBMISSION: {submission.url}')
# Parse pertinent info from the submission
tableless_urls, iden_anon_urls, table_data \
= parse_submission(submission.selftext_html, submission.selftext, self.pcpp_parser)
return tableless_urls, iden_anon_urls, table_data
def reply(self, submission, unpaired_urls, iden_anon_urls, table_data):
"""Replies to a Reddit submission.
Args:
submission (`obj`: praw.Reddit.Submission): PRAW Submission object.
unpaired_urls (list): urls without an accompanying table.
iden_anon_urls (list): Pairs of identifiable, anonymous list urls.
table_data (dict): Holds information about table data in submission.
Returns:
Reply message string if NOT live, otherwise PRAW.reddit.Comment object.
"""
# Create the reply with this information
reply_message = self._make_reply(unpaired_urls,
iden_anon_urls,
table_data)
# Only if the bot is 'live' on Reddit or not
if self.is_live:
# Post the reply!
reply = submission.reply(reply_message)
self._save_reply_db(reply, submission, table_data, iden_anon_urls, unpaired_urls)
return reply
else:
return reply_message
def _make_reply(self, tableless_urls: list, iden_anon_urls: list, table_data: dict):
"""Creates the full reply message.
Args:
tableless_urls (list): List of urls that don't have an accompanying
table.
iden_anon_urls (list): List of (identifiable, anonymous) urls found.
table_data (dict): Dictionary describing the table data found
in the submission.
Returns:
The entire reply message, ready to be posted.
"""
table_markdown = self._make_table_markdown(tableless_urls, table_data)
iden_markdown = self._make_identifiable_markdown(iden_anon_urls)
if len(table_markdown) == 0 and len(tableless_urls) != 0:
self.logger.error('Failed to make table markdown for urls: {tableless_urls}')
if len(iden_anon_urls) != 0 and len(iden_markdown) == 0:
self.logger.error(f'Failed to make identifiable markdown for urls: {iden_anon_urls}')
reply_message = self._put_message_together(table_markdown,
iden_markdown)
if len(reply_message) == 0:
self.logger.error('Failed to create a message.')
else:
self.logger.info(f'Reply: {reply_message}')
return reply_message
def _put_message_together(self, table_markdown: str, iden_markdown: str):
"""Puts together the variable data into a message.
Args:
table_markdown (str): Contains the markdown for the table data.
iden_markdown (str): Contains the markdown for the identifiable
message and data.
Returns:
A string containing the combined reply message.
"""
reply_message = ''
message_markdown = []
if len(table_markdown) != 0:
message_markdown.append(table_markdown)
if len(iden_markdown) != 0:
message_markdown.append(iden_markdown)
if len(message_markdown) != 0:
message_markdown = '\n\n'.join(message_markdown)
reply_message = self.REPLY_TEMPLATE.replace(':message:', message_markdown)
return reply_message
def _make_table_markdown(self, urls: list, table_data: dict):
"""Put together the table markdown. This could be up to self.MAX_TABLES.
Args:
urls (list): List of PCPP urls to make tables for.
table_data (dict): Dictionary describing the table data found
in the submission.
Returns:
A string containing the markdown for the tables for the PCPP lists.
"""
table_message = ''
issues = []
if urls and 0 < len(urls) <= self.MAX_TABLES:
all_table_markdown = []
# Create the table markup for each list url
for pcpp_url in urls:
list_html = self.pcpp_parser.request_page_data(pcpp_url)
parts_list, total = self.pcpp_parser.parse_page(list_html)
table_markdown = self.table_creator.create_markdown_table(pcpp_url, parts_list, total)
all_table_markdown.append(table_markdown)
# Put the table(s) together
all_table_markdown = '\n\n\n'.join(all_table_markdown)
lists_without_tables = abs(table_data['total'] - len(urls))
# Check which issue(s) occurred (at least one will match)
if table_data['total'] == 0 or lists_without_tables != 0:
issues.append('a missing table')
if table_data['invalid'] != 0:
issues.append('a broken or partial table')
if table_data['bad_markdown']:
issues.append('escaped or broken markdown')
issues_markdown = ', '.join(issues)
# Input the message data into the template
table_message = self.TABLE_TEMPLATE.replace(':issues:', issues_markdown)
table_message = table_message.replace(':table:', all_table_markdown)
return table_message
def _make_identifiable_markdown(self, iden_anon_urls: list):
"""Creates the message for when identifiable list urls are found.
Args:
iden_anon_urls (list): List of (identifiable, anonymous) urls found.
Returns:
A string containing the markdown message for when identifiable
urls are found.
"""
iden_markdown = ''
if iden_anon_urls and len(iden_anon_urls) > 0:
list_items = []
# Create a bullet point showing the anonymous list url for
# each identifiable list url found.
for iden_url, anon_url in iden_anon_urls:
# identifiable -> anonymous
list_items.append(f'* {iden_url} → {anon_url}')
list_markdown = '\n'.join(list_items)
# Put the list into the template
iden_markdown = self.IDENTIFIABLE_TEMPLATE.replace(':urls:', list_markdown)
return iden_markdown
def _save_reply_db(self, reply: praw.reddit.Comment,
submission: praw.reddit.Submission,
table_data: dict,
iden_anon_urls: list,
urls: list):
"""Save the reply data into the database.
Args:
reply (PRAW.Reddit.Comment): The reply left by the bot
submission (PRAW.Reddit.Submission): Submission the bot replied to
table_data (dict): Holds data about the tables
iden_anon_urls (list): List of identifiable links
urls (list): List of the PCPP urls I made tables for
"""
flair = submission.link_flair_text
had_identifiable = len(iden_anon_urls) != 0
missing_table = table_data['total'] == 0
# Reddit id's are in base 36
reply_id = int(reply.id, 36)
submission_id = int(submission.id, 36)
try:
self.db_handler.insert_reply(reply_id, reply.created_utc,
submission_id, flair,
submission.url,
submission.created_utc,
str(urls),
had_identifiable,
table_data['bad_markdown'],
table_data['invalid'],
missing_table,
len(urls)
)
except mysql_errors.IntegrityError as e:
self.logger.error('MySql insertion error: %s', e.msg)
def _cleanup_database(self):
"""Cleanup."""
# Want to cleanup the table if just testing.
if not self.is_live:
self.db_handler.clear_table()
self.db_handler.disconnect()
def _already_replied(self, submission_id: str):
"""Check if the bot has replied already to this submission."""
id_as_int = int(submission_id, 36)
reply = self.db_handler.select_reply(id_as_int)
return reply is not None
def _check_inbox_for_stop(self):
"""Checks if a moderator messaged the bot to stop running.
The subject must be 'stop', and the body of the message
contains an optional reason for stopping the bot.
Returns:
(boolean on if to stop, a string containing the reason).
"""
should_stop = False
reason = ''
for item in self.reddit.inbox.unread():
# Check if it is a message, not a mention or something else
if isinstance(item, Message):
author = item.author
# Check if the messenger is a moderator of r/buildapc
if not author.is_suspended and author.is_mod and self.subreddit_name in author.moderated():
subject = item.subject
# Did they tell me to stop?
if 'stop' in subject.lower():
reason = item.body
should_stop = True
item.mark_read()
return should_stop, reason
def _get_all_rows(ip,table):
with DatabaseHandler(table) as db:
return db.read(ip)
class QueryBuilder(Exception):
def __init__(self):
""" Initialize """
self.databasehandler = DatabaseHandler()
self.helper = Helper()
print("Hello there..! Query about your system files..")
def builder(self, user_query):
""" Build db query parsing user's query """
file_tense = self.find_tense(user_query) # Return +1/-1
timestamp, timestamp_query = self.find_time_query(
user_query) # Return date & [day/month/year]
file_mode = self.find_file_mode(
user_query) # Return [create/modify/delete]=[0,4,9]
result = self.build_query(file_tense, timestamp, timestamp_query,
file_mode)
if result:
for doc in result:
print(doc["name"])
else:
print("Sorry, I don't found any related files")
def build_query(self, file_tense, timestamp, timestamp_query, file_mode):
""" Build mongodb query """
if file_tense < 0:
timestamp -= 1
if file_mode == 0:
# db.meta.aggregate({$project:{name:1,month:{$month:'$create'}}},{$match:{month:11}})
return self.databasehandler.execute_query(timestamp_query,
"$" + timestamp_query,
"$create", timestamp)
elif file_mode == 4:
return self.databasehandler.execute_query(timestamp_query,
"$" + timestamp_query,
"$modify", timestamp)
elif file_mode == 9:
return self.databasehandler.execute_query(timestamp_query,
"$" + timestamp_query,
"$delete", timestamp)
def find_time_query(self, user_query):
""" Return time"""
if "day" in user_query:
return self.helper.get_present_day(), "dayOfMonth"
elif "month" in user_query:
return self.helper.get_present_month(), "month"
elif "year" in user_query:
return self.helper.get_present_year(), "year"
else:
raise Exception("Specify search date operator i.e day,month,year")
def find_tense(self, user_query):
""" Find the tense of user query """
past_tense_literals = ["last", "previous", "ago"]
present_tense_literals = ["this", "present", "today"]
if any(literal in user_query for literal in past_tense_literals):
return -1
elif any(literal in user_query for literal in present_tense_literals):
return 1
else:
raise Exception("Specify tense i.e previous,today etc.")
def find_file_mode(self, user_query):
""" Return file search mode """
if "create" in user_query:
return 0
elif "modif" in user_query:
return 4
elif "delete" in user_query:
return 9
else:
raise Exception("Specify file mode i.e create,modify,delete")
def __init__(self):
""" Initialize """
self.databasehandler = DatabaseHandler()
self.helper = Helper()
print("Hello there..! Query about your system files..")
class EventScheduler():
"""EventScheduler"""
current_location = None
def __init__(self):
rospy.sleep(
2
) # Delay startup so navigation is finished setting up database file
self.current_location = None
self.SCHEDULER_RATE = rospy.Rate(0.05) #(Hz)
self.LOW_POWER_THRESHOLD = 20
self.HOMEDIR = os.path.expanduser("~")
self.PATH = self.HOMEDIR + "/navigation.db"
self.MAP_NAME = "glassgarden.map"
self.current_state = "idle"
self.publisher_event = rospy.Publisher(
"/cyborg_controller/register_event", String, queue_size=100)
self.subscriber_current_location = rospy.Subscriber(
"cyborg_navigation/current_location", String,
self.callback_current_location)
self.subscriber_state = rospy.Subscriber(
"/cyborg_controller/state_change",
SystemState,
self.callback_subscriber_state,
queue_size=100)
self.subscriber_battery_status = rospy.Subscriber(
"/rosarnl_node/battery_status",
BatteryStatus,
callback=self.callback_battery_status,
queue_size=10)
self.database_handler = DatabaseHandler(filename=self.PATH)
self.scheduler_thread = threading.Thread(target=self.scheduler)
self.scheduler_thread.daemon = True # Thread terminates when main thread terminates
self.scheduler_thread.start()
def callback_current_location(self, data):
if self.current_location != data.data and data.data != "":
self.current_location = data.data
# Thread, updating current location name based on current position, checks for ongoing events and current position compared to the event, if ongoing event is an other location it publish a navigation_schedulaer event for the state machine
def scheduler(self): # Threaded
rospy.loginfo("EventScheduler: Activated.")
while not rospy.is_shutdown():
event = self.database_handler.search_ongoing_events(
robot_map_name=self.MAP_NAME,
current_date=datetime.datetime.now())
if event != None:
if event.location_name != self.current_location:
self.publisher_event.publish("navigation_schedular")
self.SCHEDULER_RATE.sleep()
# Updates the current system state when the system state subscriber receives data
def callback_subscriber_state(self, data):
if data.to_system_state != None:
self.current_state = data.to_system_state
# Monitor battery percentage and publish power_low event when triggered
def callback_battery_status(self, BatteryStatus):
# charge_percent [0,100]
# charge_state [-1, 4], charging_unknown, charging_bulk, charging_overcharge, charging_float, charging_balance
if (BatteryStatus.charge_percent < self.LOW_POWER_THRESHOLD) and (
self.current_state not in ["exhausted", "sleepy", "sleeping"]):
self.publisher_event.publish("power_low")
continue
task: bool = False
# determine whether the sample contains a task
if bisect.bisect_left(all_interactions, output_messages[i]) != bisect.bisect_left(all_interactions, output_messages[i] + sample_duration):
matches_task += 1
else:
matches_notask += 1
#print("\nReturning matches_task = {} and matches_notask = {} for sample {}".format(matches_task, matches_notask, sample))
return matches_task, matches_notask
# split systems, from crdt/stats.py
if len(sys.argv) < 2:
print("Usage: ned.py <database>")
sys.exit(255)
dbh: DatabaseHandler = DatabaseHandler(sys.argv[-1])
systems: List[System] = list(dbh.systems())
sys2 = systems[1]
sys21 = System(sys2._dbh, "2.1", "System 2.1")
setattr(sys21, "messages", functools.partial(sys2.messages, to_timestamp=1352588400))
setattr(sys21, "timespan", functools.partial(sys2.timespan, override_to=1352588400))
sys22 = System(sys2._dbh, "2.2", "System 2.2")
setattr(sys22, "messages", functools.partial(sys2.messages, from_timestamp=1352588400))
setattr(sys22, "timespan", functools.partial(sys2.timespan, override_from=1352588400))
systems[1:2] = [sys21, sys22]
# print LaTeX table header
output_file_suffix: str = ""
if len(sys.argv) > 2:
output_file_suffix = "-" + sys.argv[1]
class MyTestCase(unittest.TestCase):
@classmethod
def setUpClass(self):
self.db = DatabaseHandler(debug=True)
self.db.connect()
self.db.create_table()
@classmethod
def tearDownClass(self):
self.db.clear_table()
self.db.disconnect()
def test_database_insert_read(self):
reply_id = 123
posted_time = 1610990729
submission_id = 456
submission_flair = None
submission_url = "http://testing.com/sub/123"
submission_time = 1610990729
list_url = "http://listing.com/list/123"
had_identifiable = True
bad_markdown = False
bad_html = 2
missing_table = True
tables_made = 2
self.db.insert_reply(reply_id, posted_time, submission_id,
submission_flair, submission_url, submission_time,
list_url, had_identifiable, bad_markdown,
bad_html, missing_table, tables_made)
reply = self.db.select_reply(456)
self.assertIsNotNone(reply)
def setUpClass(self):
self.db = DatabaseHandler(debug=True)
self.db.connect()
self.db.create_table()
class Motivator():
"""Motivator for the controller.
Generate events based on reward/cost functions.
Usage:
motivator = Motivator()
motivator.start()
Add more events (possible actions):
Add more events to the sqlitedatabase.
"""
current_pleasure = 0
current_arousal = 0
current_dominance = 0
current_emotion = "neutral"
current_state = "idle"
state_timer = 0 # When arrived in the current system state
max_time = 60 # Used for calculating cost
# Priority functions
priority_pleasure = 0.6
priority_arousal = 0.6
priority_dominance = 0.6
priority_cost = 0.7
#counter_reduced_social_cost = 0
def __init__(self, database_file=""):
self.event_publisher = rospy.Publisher(rospy.get_name() +
"/register_event",
String,
queue_size=100)
self.emotion_publisher = rospy.Publisher(rospy.get_name() +
"/emotional_feedback",
EmotionalFeedback,
queue_size=100)
self.emotion_subscriber = rospy.Subscriber(rospy.get_name() +
"/emotional_state",
EmotionalState,
self.emotion_callback,
queue_size=100)
self.state_subscriber = rospy.Subscriber(rospy.get_name() +
"/state_change",
SystemState,
self.state_callback,
queue_size=100)
self.rate = rospy.Rate(.5) # (hz), looping speed
self.database_handler = DatabaseHandler(filename=database_file)
self.database_handler.reset_event_values()
# Starts the motivator in a seperate daemon thread
def start(self):
motivator_thread = threading.Thread(target=self.run)
motivator_thread.daemon = True
motivator_thread.start()
# The running thread called when Motivator starts
def run(self): # Threaded
rospy.loginfo("Motivator: Activated...")
timer_sc = time.time()
while not rospy.is_shutdown():
event = self.find_event()
if event != None:
self.send_emotion(pleasure=event.reward_pleasure,
arousal=event.reward_arousal,
dominance=event.reward_dominance)
event_value = event.event_value + event.event_cost if event.event_value + event.event_cost >= 0 else 0
event_value = event_value if event_value <= 1 else 1
self.database_handler.update_event_value(
event_id=event.event_id, event_value=event_value)
self.database_handler.update_all_event_values(
delta_event_value=-0.05)
self.event_publisher.publish(event.event)
rospy.logdebug("Motivator: Current state is " +
self.current_state + " and the event " +
event.event + " was generated...")
self.rate.sleep()
if self.current_state == "idle" and time.time(
) - self.state_timer > 3 * 60:
self.database_handler.reset_event_values()
if time.time() - timer_sc > 10:
timer_sc = time.time()
self.database_handler.update_all_event_values(
delta_event_value=-0.01)
# Finds and returns the event to generate (or None if None to generate)
def find_event(self):
events = self.database_handler.get_all_events(state=self.current_state)
reward = 0
solution = None
# A cost or minimum reward. Decreses with time spendt in current state.
time_in_state = time.time() - self.state_timer
k_s = 1 - (time_in_state * 5 / self.max_time)**math.tan(
(self.priority_cost * math.pi) / 2.0)
c_s = k_s * 1
reward = c_s
reward = reward if reward > 0 else 0.003
# Find best reward grater then cost
for event in events:
p_p = 1 - self.current_pleasure**3
r_p = p_p * ((self.current_pleasure + (
(event.reward_pleasure) / 2.0)) - self.current_pleasure)
p_a = 1 - self.current_arousal**3
r_a = p_a * ((self.current_arousal + (
(event.reward_arousal) / 2.0)) - self.current_arousal)
p_d = 1 - self.current_dominance**3
r_d = p_d * ((self.current_dominance + (
(event.reward_dominance) / 2.0)) - self.current_dominance)
p_e = event.event_value**(1.0 / 3.0)
c_e = p_e * ((event.reward_pleasure / 2.0) +
(event.reward_arousal / 2.0) +
(event.reward_dominance / 2.0))
r = r_p + r_a + r_d - c_e
print(event.event, r + c_e, -c_e, r)
solution = event if r > reward else solution
reward = r if r > reward else reward
return solution
# Send the change (delta) in the emotional state to the emotion system
def send_emotion(self, pleasure, arousal, dominance):
msg = EmotionalFeedback()
msg.delta_pleasure = pleasure
msg.delta_arousal = arousal
msg.delta_dominance = dominance
self.emotion_publisher.publish(msg)
# Updates the current emotion when the emotion subscriber recives data
# Normalizes the data.
def emotion_callback(self, data):
self.current_emotion = data.to_emotional_state
self.current_pleasure = (data.current_pleasure + 1) / 2.0
self.current_arousal = (data.current_arousal + 1) / 2.0
self.current_dominance = (data.current_dominance + 1) / 2.0
# Updates the current system state when the system state subscriber recieves data
def state_callback(self, data):
self.current_state = data.to_system_state
self.state_timer = time.time()
def main():
homedir = os.path.expanduser("~")
path = homedir + "/navigation.db"
if (os.path.exists(path) == False):
database_handler = DatabaseHandler(filename=path)
database_handler.create()
database_handler.add_location(location_name="entrance", robot_map_name="ntnu2.map", x=-18.440, y=6.500, z=0, p=0, j=0, r=2, threshold=3, crowded=False,enviorment=-0.10)
database_handler.add_location(location_name="home", robot_map_name="ntnu2.map", x=-29.500, y=8.700, z=0, p=0, j=0, r=2, threshold=3, crowded=False, enviorment=0.20)
database_handler.add_location(location_name="waiting area", robot_map_name="ntnu2.map", x=-33.600, y=10.600, z=0, p=0, j=0, r=2, threshold=3, crowded=False, enviorment=-0.10)
database_handler.add_location(location_name="cafeteria", robot_map_name="ntnu2.map", x=-33.090, y=-55.700, z=0, p=0, j=0, r=2, threshold=3, crowded=True, enviorment=0.20)
database_handler.add_location(location_name="elevator", robot_map_name="ntnu2.map", x=-29.500, y=-50.200, z=0, p=0, j=0, r=2, threshold=3, crowded=True, enviorment=-0.02)
database_handler.add_location(location_name="entrance 2", robot_map_name="ntnu2.map", x=-18.300, y=-66.000, z=0, p=0, j=0, r=33, threshold=3, crowded=True, enviorment=0.05)
database_handler.add_location(location_name="information", robot_map_name="ntnu2.map", x=-33.490, y=1.160, z=0, p=0, j=0, r=2, threshold=3, crowded=True, enviorment=0.05)
database_handler.add_location(location_name="el5", robot_map_name="ntnu2.map", x=-33.720, y=-32.500, z=0, p=0, j=0, r=-2, threshold=3, crowded=True, enviorment=0.00)
database_handler.add_location(location_name="el6", robot_map_name="ntnu2.map", x=-30.300, y=-12.840, z=0, p=0, j=0, r=2, threshold=3, crowded=True, enviorment=0.00)
database_handler.add_location(location_name="bridge", robot_map_name="ntnu2.map", x=-28.090, y=-63.500, z=0, p=0, j=0, r=2, threshold=3, crowded=True, enviorment=0.00)
database_handler.add_event(event_name="welcome_time", location_name="entrance", start_date=datetime.datetime(2017, 1, 18, 11, 0, 0, 1), end_date=datetime.datetime(2017, 1, 18, 11, 4, 0, 1), ignore=False)
database_handler.add_event(event_name="dinner_time", location_name="cafeteria", start_date=datetime.datetime(2017, 1, 18, 15, 0, 7, 1) , end_date=datetime.datetime(2017, 1, 18, 15, 59, 0, 1), ignore=False)
database_handler.add_event(event_name="wait_time", location_name="waiting area", start_date=datetime.datetime(2017, 1, 18, 8, 0, 1, 1) , end_date=datetime.datetime(2017, 1, 18, 8, 46, 0, 1), ignore=False)
database_handler.add_event(event_name="lunch_time", location_name="cafeteria", start_date=datetime.datetime(2017, 1, 18, 7, 0, 1, 1) , end_date=datetime.datetime(2017, 1, 18, 7, 0, 0, 1), ignore=False)
database_handler.add_event(event_name="goodbye_time", location_name="entrance 2", start_date=datetime.datetime(2017, 1, 18, 9, 0, 1, 1), end_date=datetime.datetime(2017, 1, 18, 9, 0, 0, 1), ignore=False)
database_handler.add_response( message="I love LOCATION", response_type="navigation_response", emotion="love")
database_handler.add_response( message="I am happy about LOCATION", response_type="navigation_response", emotion="elated")
database_handler.add_response( message="I like LOCATION", response_type="navigation_response", emotion="elated")
database_handler.add_response( message="I like LOCATION", response_type="navigation_response", emotion="dignified")
database_handler.add_response( message="I am happy about at LOCATION", response_type="navigation_response", emotion="neutral")
database_handler.add_response( message="I like LOCATION", response_type="navigation_response", emotion="neutral")
database_handler.add_response( message="What is this place? A LOCATION you say?", response_type="navigation_response", emotion="curious")
database_handler.add_response( message="What is this place? A LOCATION you say?", response_type="navigation_response", emotion="puzzled")
database_handler.add_response( message="I hate the LOCATION", response_type="navigation_response", emotion="angry")
database_handler.add_response( message="I dont like the LOCATION", response_type="navigation_response", emotion="angry")
database_handler.add_response( message="A the LOCATION, whatever. Been there, done that...", response_type="navigation_response", emotion="unconcerned")
database_handler.add_response( message="A the LOCATION, whatever. Been there, done that...", response_type="navigation_response", emotion="angry")
database_handler.add_response( message="A the LOCATION, whatever. Been there, done that...", response_type="navigation_response", emotion="inhibited")
rospy.init_node("cyborg_navigation")
navigation_server = NavigationServer(database_file=path)
rospy.spin()
class NavigationServer():
"""NavigationServer"""
client_base_feedback = StateMachineFeedback()
client_base_result = StateMachineResult()
next_location = None
command_location = None
current_location = None
reason = ""
map_name = "ntnu2.map"
base_canceled = False
base_succeded = False
current_x = 0.0
current_y = 0.0
current_emotion = "neutral"
planing_timeout = 60 # (s)
moving_timeout = 1000 # (s)
taking_timeout = 60 # (s)
def __init__(self, database_file=""):
self.scheduler_rate = rospy.Rate(1) # (hz)
self.server_rate = rospy.Rate(0.5) # (hz)
self.server_planing = actionlib.SimpleActionServer(
rospy.get_name() + "/planing",
StateMachineAction,
execute_cb=self.server_planing_callback,
auto_start=False)
self.server_moving = actionlib.SimpleActionServer(
rospy.get_name() + "/moving",
StateMachineAction,
execute_cb=self.server_moving_callback,
auto_start=False)
self.server_talking = actionlib.SimpleActionServer(
rospy.get_name() + "/talking",
StateMachineAction,
execute_cb=self.server_talking_callback,
auto_start=False)
self.server_go_to = actionlib.SimpleActionServer(
rospy.get_name() + "/go_to",
NavigationGoToAction,
execute_cb=self.server_go_to_callback,
auto_start=False)
self.server_planing.start()
self.server_moving.start()
self.server_talking.start()
self.server_go_to.start()
self.client_base = actionlib.SimpleActionClient(
"/rosarnl_node/move_base", MoveBaseAction)
self.emotion_publisher = rospy.Publisher(
"/cyborg_controller/emotional_feedback",
EmotionalFeedback,
queue_size=100)
self.event_publisher = rospy.Publisher(
"/cyborg_controller/register_event", String, queue_size=100)
self.speech_publisher = rospy.Publisher(
"/cyborg_text_to_speech/text_to_speech", String, queue_size=100)
self.database_handler = DatabaseHandler(filename=database_file)
self.location_subscriber = rospy.Subscriber("/rosarnl_node/amcl_pose",
PoseWithCovarianceStamped,
self.location_callback)
self.emotion_subscriber = rospy.Subscriber(
"/cyborg_controller/emotional_state",
EmotionalState,
self.emotion_callback,
queue_size=100)
self.text_subscriber = rospy.Subscriber("/text_from_speech",
String,
self.text_callback,
queue_size=100)
self.scheduler_thread = threading.Thread(target=self.scheduler)
self.scheduler_thread.daemon = True # Thread terminates when main thread terminates
self.scheduler_thread.start()
rospy.loginfo("NavigationServer: Activated.")
# Updates the current position when the position subscriber receives data
def location_callback(self, data):
self.current_x = data.pose.pose.position.x
self.current_y = data.pose.pose.position.y
# Updates the current emotion when the emotion subscriber recives data from the controller (emotion system)
def emotion_callback(self, data):
self.current_emotion = data.to_emotional_state
# Thread, updating current location name based on current possition, checks for ongoing events and current position compared to the event, if ongoing event is an other location it publish a navigation_schedulaer event for the state machine
def scheduler(self): # Threaded
while (not rospy.is_shutdown()):
self.current_location = self.database_handler.find_location(
robot_map_name=self.map_name,
location_x=self.current_x,
location_y=self.current_y)
current_location_name = self.current_location.location_name if self.current_location != None else ""
event = self.database_handler.search_ongoing_events(
robot_map_name=self.map_name,
current_date=datetime.datetime.now())
if event != None:
if event.location_name != current_location_name:
self.event_publisher.publish("navigation_schedualer")
self.scheduler_rate.sleep()
# Called once when the robot base (ROSARNL) goal completes
def client_base_done_callback(self, state, result):
if self.is_controlling_base:
if (state == 3): # Succeded aka arived at location
self.base_succeded = True
elif (state == 2): # Happens when we cancel goals aka preemted
self.base_canceled = True
elif (state == 1): # Canceled?
self.base_canceled = True
self.client_base_state = state
self.client_base_result = result
rospy.logdebug(
"NavigationServer: Base has completed its execution with " +
str(state) + " and result " + str(result) + ".")
# Called once when the robot base (ROSARNL) goal becomes active
def client_base_active_callback(self):
rospy.logdebug("NavigationServer: Base goal has gone active.")
self.is_controlling_base = True
# Called every time feedback is received for the goal for the robot base (ROSARNL)
def client_base_feedback_callback(self, feedback):
rospy.logdebug("NavigationServer: Received feedback from base - " +
str(feedback) + ".")
self.client_base_feedback = feedback
# Called when the controller (state machine) sets the navigation_planing state as active
def server_planing_callback(self, goal):
rospy.logdebug("NavigationServer: Executing planing state.")
time.sleep(2) # Let roscore update connections
# Select what to do based on event
self.next_location = None
if goal.event == "navigation_schedualer":
if self.current_emotion == "angry":
self.next_location = self.database_handler.search_for_crowded_locations(
robot_map_name=self.map_name, crowded=False)
self.send_emotion(pleasure=0, arousal=0, dominance=0.1)
self.change_state(event="navigation_start_moving")
else:
self.next_location = self.database_handler.search_ongoing_events(
robot_map_name=self.map_name,
current_date=datetime.datetime.now())
self.send_emotion(pleasure=0, arousal=0, dominance=-0.1)
self.change_state(event="navigation_start_moving")
elif goal.event == "navigation_emotional":
if self.current_emotion in ["angry", "sad", "fear", "inhibited"]:
self.next_location = self.database_handler.search_for_crowded_locations(
robot_map_name=self.map_name, crowded=False)
self.send_emotion(pleasure=0, arousal=0, dominance=0.1)
self.change_state(event="navigation_start_moving")
elif self.current_emotion in [
"happy", "loved", "dignified", "neutral", "elated"
]:
self.next_location = self.database_handler.search_for_crowded_locations(
robot_map_name=self.map_name, crowded=True)
self.send_emotion(pleasure=0, arousal=0, dominance=0.1)
self.change_state(event="navigation_start_moving")
elif self.current_emotion in ["bored", "curious", "unconcerned"]:
self.next_location = "wandering"
self.send_emotion(pleasure=0, arousal=0, dominance=0.1)
self.change_state(event="navigation_start_wandering")
elif goal.event == "navigation_command":
self.next_location = self.command_location
self.send_emotion(pleasure=0, arousal=0, dominance=-0.2)
self.change_state(event="navigation_start_moving")
# Publishes an event and waits for a change of state.
def change_state(self, event=None):
if event != None and self.next_location != None:
self.event_publisher.publish(event)
else:
self.server_planing.set_aborted()
return
# Wait until state is preemted, or abort if it takes to long time
started_waiting = time.time() # Prevent eternal looping
while not rospy.is_shutdown():
if self.server_planing.is_preempt_requested():
self.server_planing.set_preempted()
return
elif (time.time() - started_waiting >
self.planing_timeout): # Prevent eternal looping
self.server_planing.set_aborted()
return
self.server_rate.sleep()
# Called when the controller (state machine) sets the navigation_moving state as active
def server_moving_callback(self, goal):
rospy.logdebug("NavigationServer: Executing moving state." +
" Navigation movinging cmd " + str(self.next_location))
self.goal = goal
self.base_canceled = False
self.base_succeded = False
self.is_controlling_base = False
# Select how to move based on event
if goal.event == "navigation_start_wandering":
self.start_wandering()
elif goal.event == "navigation_start_moving" and self.next_location != None:
self.start_moving()
else:
self.server_moving.set_aborted()
rospy.logdebug(
"NavigationServer: Received event that cant be handled - " +
str(goal.event) + ".")
# The robot base starts to wander and keeps wandering until it is preemted or no longer in the right mood
def start_wandering(self):
# Tell base to start wandering
rospy.logdebug("NavigationServer: Waiting for base wandering service.")
rospy.wait_for_service("/rosarnl_node/wander")
rospy.logdebug("NavigationServer: wandering service available.")
try:
baseStartWandering = rospy.ServiceProxy("/rosarnl_node/wander",
Empty)
baseStartWandering()
except rospy.ServiceException, e:
rospy.logdebug("NavigationServer: wandering service error - " +
str(e))
started_waiting = time.time() # Prevent eternal looping
feedback_cycle = time.time()
while not rospy.is_shutdown():
if self.server_moving.is_preempt_requested():
self.client_base.cancel_all_goals(
) # HERE - goal on wandering?
try:
baseStop = rospy.ServiceProxy("/rosarnl_node/stop", Empty)
baseStop()
except rospy.ServiceException, e:
rospy.logdebug("NavigationServer: stop service error - " +
str(e))
self.server_moving.set_preempted()
return
if self.current_emotion not in ["bored", "curious", "unconcerned"]:
self.client_base.cancel_all_goals(
) # HERE - goal on wandering?
try:
baseStop = rospy.ServiceProxy("/rosarnl_node/stop", Empty)
baseStop()
except rospy.ServiceException, e:
rospy.logdebug("NavigationServer: stop service error - " +
str(e))
self.event_publisher.publish("navigation_wandering_completed")
# Wait until state is preemted
started_waiting = time.time() # Prevent eternal looping
while not rospy.is_shutdown():
if self.server_moving.is_preempt_requested():
self.server_moving.set_preempted()
return
self.server_rate.sleep()
return
def __init__(self):
self.datahandler = DatabaseHandler()
print "instance created"
formated_requests_clean = formated_requests
with DatabaseHandler(table_name) as db:
db.create_table(table_name)
for req in formated_requests_clean:
db.store(req)
with DatabaseHandler(table_name) as db:
l = db.cursor.execute(
"SELECT * FROM {}".format(table_name)).fetchall()
ips_in_table = []
for val in l:
ips_in_table.append(val[1])
return list(set(ips_in_table))
except Exception as e:
raise e
def get_unique_ips(table_name):
with DatabaseHandler(table_name) as db:
l = db.cursor.execute("SELECT * FROM {}".format(table_name)).fetchall()
ips_in_table = []
for val in l:
ips_in_table.append(val[1])
return list(set(ips_in_table))
if __name__ == "__main__":
ips = parse_requests('humans')
db = DatabaseHandler("humans")
db.print_table()
