solved bug for prior rules remembering every prior rule

todo.txt

@@ -1,3 +1,14 @@
+wafl:
+- create indices
+
+training:
+- retrain phi3
+- add tokens <execute> and <remember> to the training data
+- add some prior conversation to the training data, taken from other examples
+- add more unused rules in the prompt
+
+
+
 * after a rule is deleted, you should also prune the conversation above.
   The system can get confused if the conversation becomes too long
   re-train the system with prior conversations before calling the rule

wafl/answerer/dialogue_answerer.py

@@ -129,8 +129,9 @@ async def _get_relevant_rules(self, conversation: Conversation) -> List[str]:
         rules = await self._rule_creator.create_from_query(conversation)
         for rule in rules:
             if rule not in self._prior_rules:
-                self._prior_rules.append(rule)
-        return self._prior_rules[-self._max_num_past_utterances_for_rules :]
+                self._prior_rules.insert(0, rule)
+        self._prior_rules = self._prior_rules[:self._max_num_past_utterances_for_rules]
+        return self._prior_rules
 
     def _init_python_module(self, module_name):
         self._module = import_module(module_name)

wafl/events/conversation_events.py

@@ -101,12 +101,13 @@ async def process_next(self, activation_word: str = "") -> bool:
 
         return False
 
+    async def reload_knowledge(self):
+        self._knowledge = load_knowledge(self._config, self._logger)
+        await self._knowledge.initialize_retrievers()
+
     def is_computing(self):
         return self._is_computing
 
-    def reload_knowledge(self):
-        self._knowledge = load_knowledge(self._config, self._logger)
-
     def reset_discourse_memory(self):
         self._answerer = create_answerer(
             self._config, self._knowledge, self._interface, self._logger

wafl/interface/base_interface.py

@@ -81,7 +81,10 @@ def _decorate_reply(self, text: str) -> str:
         return self._decorator.extract(text, self._utterances)
 
     def _insert_utterance(self, speaker, text: str):
-        text = re.sub(r"\[.*?\]", "", text)
+        clean_text = re.sub(r"\[.*?]", "", text)
+        if not clean_text.strip():
+            clean_text = text
+
         self._utterances.add_utterance(
-            Utterance(text=text, speaker=speaker, timestamp=time.time())
+            Utterance(text=clean_text, speaker=speaker, timestamp=time.time())
         )

wafl/knowledge/single_file_knowledge.py

@@ -59,7 +59,7 @@ def __init__(self, config, rules_text=None, logger=None):
                 loop = None
 
             if not loop or not loop.is_running():
-                asyncio.run(self._initialize_retrievers())
+                asyncio.run(self.initialize_retrievers())
 
     async def add(self, text):
         fact_index = f"F{len(self._facts_dict)}"
@@ -158,7 +158,7 @@ def get_facts_and_rule_as_text(self):
 
         return text
 
-    async def _initialize_retrievers(self):
+    async def initialize_retrievers(self):
         for index, fact in self._facts_dict.items():
             if text_is_exact_string(fact.text):
                 continue

wafl/scheduler/web_handler.py

@@ -45,7 +45,7 @@ async def reset_conversation(self):
         self._interface.reset_history()
         self._interface.deactivate()
         self._interface.activate()
-        self._conversation_events.reload_knowledge()
+        await self._conversation_events.reload_knowledge()
         self._conversation_events.reset_discourse_memory()
         await self._interface.output("Hello. How may I help you?")
         conversation = await self._messages_creator.get_messages_window()

wafl/testcases.py

@@ -26,7 +26,7 @@ async def test_single_case(self, name):
         is_negated = self._testcase_data[name]["negated"]
         interface = DummyInterface(user_lines)
         conversation_events = ConversationEvents(self._config, interface=interface)
-        await conversation_events._knowledge._initialize_retrievers()
+        await conversation_events._knowledge.initialize_retrievers()
 
         print(self.BLUE_COLOR_START + f"\nRunning test '{name}'." + self.COLOR_END)
         continue_conversations = True