actions.py

from rasa_core_sdk import Action
from rasa_core_sdk.events import SlotSet

#
# Birthplace
#
class ActionSearchBirthplace(Action):
    def name(self):
        return 'action_search_birthplace'

    def run(self, dispatcher, tracker, domain):
        #person = tracker.get_slot('physicist')
        #if person == None:
        #    dispatcher.utter_message("No Person found")
        #else:
        #    dispatcher.utter_message("Person found:" + person)
        import csv
        import re
        person = tracker.get_slot('physicist')
        name_regex = re.compile(person, re.IGNORECASE)
        actual_birthplace = None
        with open('data.tsv') as csvfile:
            spamreader = csv.DictReader(csvfile, delimiter='\t')
            for row in spamreader:
                if name_regex.match(row['name']):
                    actual_birthplace = row['birthplace']
        return [SlotSet('birthplace', actual_birthplace
            if actual_birthplace is not None and actual_birthplace is not ""
            else "not known")]
        

class ActionUtterBirthplace(Action):
    def name(self):
        return 'action_utter_birthplace'

    def run(self, dispatcher, tracker, domain):
        person = tracker.get_slot('physicist')
        birthplace = tracker.get_slot('birthplace')
        dispatcher.utter_message("Birthplace of {} is {}.".format(person, birthplace))
        return []

#
# Day of death
#
class ActionSearchDayOfDeath(Action):
    def name(self):
        return 'action_search_day_of_death'

    def run(self, dispatcher, tracker, domain):
        import csv
        import re
        person = tracker.get_slot('physicist')
        name_regex = re.compile(person, re.IGNORECASE)
        actual_day_of_death = None
        with open('data.tsv') as csvfile:
            spamreader = csv.DictReader(csvfile, delimiter='\t')
            for row in spamreader:
                if name_regex.match(row['name']):
                    actual_day_of_death = row['day_of_death']
        return [SlotSet('day_of_death', actual_day_of_death 
            if actual_day_of_death is not None and actual_day_of_death is not ""
            else "not known")]
        
        
class ActionUtterDayOfDeath(Action):
    def name(self):
        return 'action_utter_day_of_death'

    def run(self, dispatcher, tracker, domain):
        person = tracker.get_slot('physicist')
        day_of_death = tracker.get_slot('day_of_death')
        dispatcher.utter_message("The day of death of {} is {}.".format(person, day_of_death))
        return []

#
# Place of death
#
class ActionSearchPlaceOfDeath(Action):
    def name(self):
        return 'action_search_place_of_death'

    def run(self, dispatcher, tracker, domain):
        import csv
        import re
        person = tracker.get_slot('physicist')
        name_regex = re.compile(person, re.IGNORECASE)
        actual_place_of_death = None
        with open('data.tsv') as csvfile:
            spamreader = csv.DictReader(csvfile, delimiter='\t')
            for row in spamreader:
                if name_regex.match(row['name']):
                    actual_place_of_death = row['place_of_death']
        return [SlotSet('place_of_death', actual_place_of_death
            if actual_place_of_death is not None and actual_place_of_death is not ""
            else "not known")]
        
        
class ActionUtterPlaceOfDeath(Action):
    def name(self):
        return 'action_utter_place_of_death'

    def run(self, dispatcher, tracker, domain):
        person = tracker.get_slot('physicist')
        place_of_death = tracker.get_slot('place_of_death')
        dispatcher.utter_message("The place of death of {} is {}.".format(person, place_of_death))
        return []

#
# Is alive
#
class ActionSearchIsAlive(Action):
    def name(self):
        return 'action_search_is_alive'

    def run(self, dispatcher, tracker, domain):
        import csv
        import re
        person = tracker.get_slot('physicist')
        name_regex = re.compile(person, re.IGNORECASE)
        actual_is_alive = None
        with open('data.tsv') as csvfile:
            spamreader = csv.DictReader(csvfile, delimiter='\t')
            for row in spamreader:
                if name_regex.match(row['name']):
                    actual_is_alive = row['is_alive']
        return [SlotSet('is_alive', actual_is_alive 
            if actual_is_alive is not None and actual_is_alive is not ""
            else "not known")]
        
        
class ActionUtterIsAlive(Action):
    def name(self):
        return 'action_utter_is_alive'

    def run(self, dispatcher, tracker, domain):
        person = tracker.get_slot('physicist')
        is_alive = tracker.get_slot('is_alive')
        dispatcher.utter_message("{} is {}.".format(person, is_alive))
        return []

#
# num spouses
#
class ActionSearchNumSpouses(Action):
    def name(self):
        return 'action_search_num_spouses'

    def run(self, dispatcher, tracker, domain):
        import csv
        import re
        person = tracker.get_slot('physicist')
        name_regex = re.compile(person, re.IGNORECASE)
        actual_num_spouses = None
        with open('data.tsv') as csvfile:
            spamreader = csv.DictReader(csvfile, delimiter='\t')
            for row in spamreader:
                if name_regex.match(row['name']):
                    actual_num_spouses = row['num_spouses']
        return [SlotSet('num_spouses', actual_num_spouses 
            if actual_num_spouses is not None and actual_num_spouses is not "" 
            else "not known")]
        
        
class ActionUtterNumSpouses(Action):
    def name(self):
        return 'action_utter_num_spouses'

    def run(self, dispatcher, tracker, domain):
        person = tracker.get_slot('physicist')
        num_spouses = tracker.get_slot('num_spouses')
        dispatcher.utter_message("The Number of spouses of {} is {}.".format(person, num_spouses))
        return []

#
# Primary Education
#
class ActionSearchPrimaryEducation(Action):
    def name(self):
        return 'action_search_primary_education'

    def run(self, dispatcher, tracker, domain):
        import csv
        import re
        person = tracker.get_slot('physicist')
        name_regex = re.compile(person, re.IGNORECASE)
        actual_primary_education = None
        with open('data.tsv') as csvfile:
            spamreader = csv.DictReader(csvfile, delimiter='\t')
            for row in spamreader:
                if name_regex.match(row['name']):
                    actual_primary_education = row['primary_education']
        return [SlotSet('primary_education', actual_primary_education 
            if actual_primary_education is not None and actual_primary_education is not ""
            else "not known")]
        
        
class ActionUtterPrimaryEducation(Action):
    def name(self):
        return 'action_utter_primary_education'

    def run(self, dispatcher, tracker, domain):
        person = tracker.get_slot('physicist')
        primary_education = tracker.get_slot('primary_education')
        dispatcher.utter_message("The primary education of {} is {}.".format(person, primary_education))
        return []

#
# University
#
class ActionSearchUniversity(Action):
    def name(self):
        return 'action_search_university'

    def run(self, dispatcher, tracker, domain):
        import csv
        import re
        person = tracker.get_slot('physicist')
        name_regex = re.compile(person, re.IGNORECASE)
        actual_university = None
        with open('data.tsv') as csvfile:
            spamreader = csv.DictReader(csvfile, delimiter='\t')
            for row in spamreader:
                if name_regex.match(row['name']):
                    actual_university = row['university']
        return [SlotSet('university', actual_university
            if actual_university is not None and actual_university is not "" 
            else "not known")]
        
        
class ActionUtterUniversity(Action):
    def name(self):
        return 'action_utter_university'

    def run(self, dispatcher, tracker, domain):
        person = tracker.get_slot('physicist')
        university = tracker.get_slot('university')
        dispatcher.utter_message("The University of {} is {}.".format(person, university))
        return []

#
# Workplace
#
class ActionSearchWorkplace(Action):
    def name(self):
        return 'action_search_workplace'

    def run(self, dispatcher, tracker, domain):
        import csv
        import re
        person = tracker.get_slot('physicist')
        name_regex = re.compile(person, re.IGNORECASE)
        actual_workplace = None
        with open('data.tsv') as csvfile:
            spamreader = csv.DictReader(csvfile, delimiter='\t')
            for row in spamreader:
                if name_regex.match(row['name']):
                    actual_workplace = row['workplace']
        return [SlotSet('workplace', actual_workplace 
            if actual_workplace is not None and actual_workplace is not ""
            else "not known")]
        
        
class ActionUtterWorkplace(Action):
    def name(self):
        return 'action_utter_workplace'

    def run(self, dispatcher, tracker, domain):
        person = tracker.get_slot('physicist')
        workplace = tracker.get_slot('workplace')
        dispatcher.utter_message("The Workplace of {} is {}.".format(person, workplace))
        return []

#
# Awards
#
class ActionSearchAwards(Action):
    def name(self):
        return 'action_search_awards'

    def run(self, dispatcher, tracker, domain):
        import csv
        import re
        person = tracker.get_slot('physicist')
        name_regex = re.compile(person, re.IGNORECASE)
        actual_awards = None
        with open('data.tsv') as csvfile:
            spamreader = csv.DictReader(csvfile, delimiter='\t')
            for row in spamreader:
                if name_regex.match(row['name']):
                    actual_awards = row['awards']
        return [SlotSet('awards', actual_awards 
            if actual_awards is not None and actual_awards is not ""
            else "not known")]
        
        
class ActionUtterAwards(Action):
    def name(self):
        return 'action_utter_awards'

    def run(self, dispatcher, tracker, domain):
        person = tracker.get_slot('physicist')
        awards = tracker.get_slot('awards')
        dispatcher.utter_message("The Awards of {} are {}".format(person, awards))
        return []