def connect_to_dataflow(self, udc): """ makes preparations fpor particular UserDomain. Here we may attach special receptors for VIP Users Args: udc: UserDomainController """ self.ic = udc udc.sm.register_slot(self.username_slot) udc.sm.register_slot(self.interests_slot) # Connecting to dataflow self.sfi.connect_to_dataflow(udc) udc.im.register_interaction(self.sfi) # ############### Prepare RECEPTOR ################################################# # ##################### System Connection (must be redone on system restart) ############# from components.receptors.models import Receptor from components.signal_pattern_reflex.signal_pattern import SignalPattern receptor, created = Receptor.get_or_create( class_name='PhrasesMatcher', init_args={'phrases': ["ПОЗНАКОМИМСЯ", "ЗНАКОМСТВО"]}) sp, _ = SignalPattern.get_or_create_strict( signal_type="UserMessageSignal") udc.user_domain.user_message_signal_pattern.connect(receptor.__call__) receptor_trigger_signal_pattern, _ = SignalPattern.get_or_create_strict( signal_type="ReceptorTriggeredSignal", receptor=receptor) receptor_trigger_signal_pattern.connect(self.start)
def __init__(self, *args, **values): super().__init__(*args, **values) # create signal for each exit gate in interaction # Exit Gate Signals and Registry initialization self.EXIT_GATES_SIGNALS = {} self.EXIT_GATES_SIGNAL_PATTERNS = {} if not hasattr(self.interaction, 'EXIT_GATES_NAMES_LIST'): # TODO fix to support inheritance of ExitGates! # then import default Gates : self.EXIT_GATES_NAMES_LIST = self.interaction.base_EXIT_GATES_NAMES_LIST else: self.EXIT_GATES_NAMES_LIST = self.interaction.EXIT_GATES_NAMES_LIST # now init signal objects for each exit gate: # from components.signal_reflex_routes.models.signals import InteractionProcessCompletedSignal from components.signal_pattern_reflex.signal import Signal from components.signal_pattern_reflex.signal_pattern import SignalPattern for each_exit_gate_name in self.EXIT_GATES_NAMES_LIST: # create a signal object for each exit gate self.EXIT_GATES_SIGNAL_PATTERNS[ each_exit_gate_name], _ = SignalPattern.get_or_create_strict( signal_type="InteractionProcessCompletedSignal", user_domain=self.user_domain, interaction=self.interaction, exit_gate=each_exit_gate_name ) self.EXIT_GATES_SIGNALS[each_exit_gate_name] = Signal( signal_type="InteractionProcessCompletedSignal", user_domain=self.user_domain, interaction=self.interaction, exit_gate=each_exit_gate_name)
def _connect_receptor(self, receptor_type, init_args, callback_fn): """Connects receptor to the system""" # ########################################################### from components.receptors.models import Receptor receptor, created = Receptor.get_or_create(class_name=receptor_type, init_args=init_args) # udc.user_domain.user_message_signal.connect_receptor(receptor) from components.signal_pattern_reflex.signal_pattern import SignalPattern sp, _ = SignalPattern.get_or_create_strict( signal_type="UserMessageSignal") sp.connect(receptor.__call__) receptor_trigger_signal_pattern, _ = SignalPattern.get_or_create_strict( signal_type="ReceptorTriggeredSignal", receptor=receptor) receptor_trigger_signal_pattern.connect(callback_fn)
def connect_to_dataflow(self, udc): """ makes preparations fpor particular UserDomain. Here we may attach special receptors for VIP Users Args: udc: UserDomainController """ # ############### Prepare RECEPTOR ################################################# # # this Interaction may be activated by Receptor (actually it is binary intent classifier here) # self.global_trigger_receptor = PhrasesMatcher(phrases=["ПОЗНАКОМИМСЯ", "ЗНАКОМСТВО"], # daemon_if_matched=self.sfi.start) # # TODO Receptor has intrification of connection. Is it BAD? How to restore it? # # ##################### System Connection (must be redone on system restart) ############# # # connect receptor: # udc.receptors_pool.connect(self.global_trigger_receptor) # # self.ic.user_message_signal.connect(self.global_trigger_receptor, weak=False) # self.ic.DialogPlanner.sendText("Добро пожаловать в мир глубокого обучения!") from components.receptors.models import Receptor # from components.signal_reflex_routes.models.signals import ReceptorTriggeredSignal receptor, created = Receptor.get_or_create( class_name='PhrasesMatcher', init_args={ 'phrases': ["Привет", "Здравствуйте", "Hello", "Kek", "Hi", "Приветик"] }) #udc.user_domain.user_message_signal.connect_receptor(receptor) from components.signal_pattern_reflex.signal_pattern import SignalPattern sp, _ = SignalPattern.get_or_create_strict( signal_type="UserMessageSignal") udc.user_domain.user_message_signal_pattern.connect(receptor.__call__) # udc.user_domain.user_message_signal_pattern.connect(receptor.__call__) from components.signal_pattern_reflex.signal import Signal from components.signal_pattern_reflex.signal_pattern import SignalPattern receptor_trigger_signal_pattern, _ = SignalPattern.get_or_create_strict( signal_type="ReceptorTriggeredSignal", receptor=receptor) # import ipdb; ipdb.set_trace() #receptor_trigger_signal.connect_object_method(instance_locator=self, method_name='start') receptor_trigger_signal_pattern.connect(self.start)
def test_signal_pattern_get_or_create(self): # import ipdb; ipdb.set_trace() user_message_pattern1, created = SignalPattern.get_or_create_strict( signal_type="UserMessageSignal", user_domain=self.user_domain) user_message_pattern2, created2 = SignalPattern.get_or_create_strict( signal_type="UserMessageSignal", user_domain=self.user_domain) self.assertTrue(created) self.assertFalse(created2) user_message_pattern3, created3 = SignalPattern.get_or_create_strict( signal_type="UserMessageSignal1", user_domain=self.user_domain) self.assertTrue(created3) user_message_pattern4, created4 = SignalPattern.get_or_create_strict( signal_type="UserMessageSignal", user_domain=self.user_domain, receptor=self.receptor) self.assertTrue(created4)
def initialize(cls, ic, name=None, *args, **kwargs): """ Interaction initialization requres: 1. specify its name (And register it in the Interactions Registry) 2. initilize EXIT GATES of the interaction. EXIT GATES are declared in implementation class, if not then default set of exit gates is assumed (the only: ExitGate_Ok) :param ic: :param name: :param args: :param kwargs: :return: """ if not name: # default name is a name of class name = cls.__name__ # import ipdb; ipdb.set_trace() intrctn = cls() intrctn.ic = ic # ######################################################################################### # # Exit Gate Signals and Registry initialization intrctn.EXIT_GATES_SIGNALS = {} from components.signal_pattern_reflex.signal_pattern import SignalPattern intrctn.EXIT_GATES_SIGNAL_PATTERNS = {} if not hasattr(intrctn, 'EXIT_GATES_NAMES_LIST'): # TODO fix to support inheritance of ExitGates! # then import default Gates : intrctn.EXIT_GATES_NAMES_LIST = cls.base_EXIT_GATES_NAMES_LIST # now init signal objects for each exit gate: for each_exit_gate_name in intrctn.EXIT_GATES_NAMES_LIST: # create a signal object for each exit gate intrctn.EXIT_GATES_SIGNAL_PATTERNS[ each_exit_gate_name], _ = SignalPattern.get_or_create_strict( signal_type="InteractionProcessCompletedSignal", interaction=intrctn, exit_gate=each_exit_gate_name) intrctn.EXIT_GATES_SIGNALS[ each_exit_gate_name] = django.dispatch.dispatcher.Signal( providing_args=["userdialog"]) intrctn._anti_garbage_collector_callbacks_list = [] # END ExitGate Signals Initialization ######################################################################################## intrctn.post_init_hook() return intrctn
def __init__(self): # Create the kernel and learn AIML files self.kernel = aiml.Kernel() # self.kernel._verboseMode = False self._load_scripts() from components.signal_pattern_reflex.signal_pattern import SignalPattern sp, _ = SignalPattern.get_or_create_strict(signal_type="UserMessageSignal") # import ipdb; ipdb.set_trace() # this connect must work in runtime, otherwise if we disable skill in Agent Configs it will # work anyway... # how to solve this problem? - only routes of enabled skills must trigger # sp.connect(self.process_step, weak=True, parent_skill=self.__name__) sp.connect(self.process_step)
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) # get or create NewUserMessage signal # self.slot_filled_signal = django.dispatch.dispatcher.Signal( # providing_args=["user_slot_process", "results"]) # from components.signal_reflex_routes.models.signals import SlotFilledSignal # if not self.target_uri: # print(self) # import ipdb; ipdb.set_trace() from components.signal_pattern_reflex.signal import Signal self.slot_filled_signal = Signal(signal_type="SlotFilledSignal", user_domain=self.user_domain) from components.signal_pattern_reflex.signal_pattern import SignalPattern self.slot_filled_signal_pattern, _ = SignalPattern.get_or_create_strict( signal_type="SlotFilledSignal", user_domain=self.user_domain, slot=self.slot)
def send(self, **signal_data): if self.data: # print(self.data) # merge signal_data and self.data # import ipdb; ipdb.set_trace() signal_data.update(self.data) # find relevant signal patterns that match sps = SignalPattern.filter_from_signal(**signal_data) print(f"Send Signal: {signal_data}") count = len(sps) print(f"Number of matched patterns for the Signal: {count}") srrs = SignalPatternReflexRoute.objects(signal_pattern__in=sps) print(f"Number of ReflexRoutes for the SignalPatterns: {srrs.count()}") # import ipdb; ipdb.set_trace() try: for each_srr in srrs: each_srr.call_reflex(**signal_data) except Exception as e: # potentialy this occurs in 2 cases: # if we have exception in reflex functor or import mongoengine if e.__class__ == mongoengine.errors.DoesNotExist: # when reflex was deleted during the looping # previous reflexes (on /start event) # ok print(each_srr.id) print("Missed reflexRoute. Skipping silently") print(e) return else: print("Exception!") print(e) # import ipdb; ipdb.set_trace() print(e) raise e
def restart_userdomain(self): """ Clean data from user domain to allow scenarios to be restarted Returns: """ # delete user processes: from components.user_processes.user_slot_process import UserSlotProcess UserSlotProcess.objects(user_domain=self).delete() from components.user_processes.user_interaction_process import UserInteractionProcess UserInteractionProcess.objects(user_domain=self).delete() # remove signal patterns and reflexes from components.signal_pattern_reflex.signal_pattern import SignalPattern sps = SignalPattern.objects(user_domain=self) if sps: from components.signal_pattern_reflex.signal_pattern_reflex_route import SignalPatternReflexRoute SignalPatternReflexRoute.objects(signal_pattern__in=sps).delete() sps.delete() from components.signal_pattern_reflex.reflex import Reflex # from components.signal_pattern_reflex.reflex import Reflex, ObjectMethodReflex, ReceptorReflex reflexes = Reflex.objects(user_domain=self) if reflexes: # import ipdb; ipdb.set_trace() SignalPatternReflexRoute.objects(reflex__in=reflexes).delete() reflexes.delete() # import ipdb; ipdb.set_trace() # ObjectMethodReflex.objects(user_domain=self).delete() # ReceptorReflex.objects(user_domain=self).delete() # delete dialog to avoid prehistory recepts: from components.user_processes.user_interaction_process import UserInteractionProcess self.dialog.utterances = [] self.dialog.save() self.memory = {} self.agenda.reset() self.save() return True
def connect_to_dataflow(self, ic): """ Connection to DataFlow triggers the interaction to create Signals according to Interactions Interface Args: ic: Returns: """ self.ic = ic self.EXIT_GATES_SIGNALS = {} from components.signal_pattern_reflex.signal_pattern import SignalPattern from components.signal_pattern_reflex.signal import Signal self.EXIT_GATES_SIGNAL_PATTERNS = {} if not hasattr(self, 'EXIT_GATES_NAMES_LIST'): # TODO fix to support inheritance of ExitGates! # then import default Gates : self.EXIT_GATES_NAMES_LIST = self.base_EXIT_GATES_NAMES_LIST # now init signal objects for each exit gate: for each_exit_gate_name in self.EXIT_GATES_NAMES_LIST: # create a signal object for each exit gate self.EXIT_GATES_SIGNAL_PATTERNS[ each_exit_gate_name], _ = SignalPattern.get_or_create_strict( signal_type="InteractionProcessCompletedSignal", interaction=self, exit_gate=each_exit_gate_name ) self.EXIT_GATES_SIGNALS[each_exit_gate_name] = Signal(signal_type="InteractionProcessCompletedSignal", interaction=self, exit_gate=each_exit_gate_name) self._anti_garbage_collector_callbacks_list = [] # END ExitGate Signals Initialization self.post_init_hook()
slot_obj = {} slot_obj.start = {} slot_obj.on_user_response = {} user_slot_process = {} user_slot_process.on_user_response = {} interaction_obj1 = {} interaction_obj1.start = {} interaction_obj2 = {} interaction_obj2.on_slot_filled = {} interaction_obj2.start = {} # Global Connections Ideal Specification: # Use cases: # UserMessage Signal Patterns SignalPattern(signal_type="UserMessageSignal", user_domain="*").connect(receptor) SignalPattern(signal_type="UserMessageSignal", user_domain=user_domain).connect(receptor) SignalPattern(signal_type="UserMessageSignal", text__contains="песня", user_domain="*").connect(receptor) SignalPattern(signal_type="UserMessageSignal", user_domain=user_domain).connect(slot_obj.on_user_response) SignalPattern(signal_type="UserMessageSignal", user_domain=user_domain).connect( user_slot_process.on_user_response) SignalPattern(signal_type="UserMessageSignal", user_domain="*").connect(bad_words_receptor) # Receptor Triggered patterns: SignalPattern(signal_type="ReceptorTriggeredSignal",
def user_message_signal_pattern(self): from components.signal_pattern_reflex.signal_pattern import SignalPattern sp, _ = SignalPattern.get_or_create_strict(signal_type="UserMessageSignal", user_domain=self) return sp