Added first version of DebugManager. Implemented draft of the rule engine

src/core/sheerka/services/SheerkaMemory.py

@@ -1,8 +1,10 @@
 from dataclasses import dataclass
 
+from cache.FastCache import FastCache
 from cache.ListIfNeededCache import ListIfNeededCache
 from core.builtin_concepts import BuiltinConcepts
 from core.concept import Concept
+from core.global_symbols import CONTEXT_DISPOSED
 from core.sheerka.services.sheerka_service import BaseService, ServiceObj
 
 
@@ -13,48 +15,72 @@ class MemoryObject(ServiceObj):
 
 class SheerkaMemory(BaseService):
     NAME = "Memory"
+    GLOBAL = "global"
 
     SHORT_TERM_OBJECTS_ENTRY = "Memory:ShortTermMemoryObjects"
     OBJECTS_ENTRY = "Memory:Objects"
 
     def __init__(self, sheerka):
         super().__init__(sheerka)
-        self.short_term_objects = ListIfNeededCache()
+        self.short_term_objects = FastCache()
         self.objects = ListIfNeededCache(default=lambda k: self.sheerka.sdp.get(self.OBJECTS_ENTRY, k))
         self.registration = {}
 
     def initialize(self):
         self.sheerka.bind_service_method(self.get_from_short_term_memory, False, visible=False)
         self.sheerka.bind_service_method(self.add_to_short_term_memory, True, visible=False)
+        self.sheerka.bind_service_method(self.remove_context, True, as_name="clear_short_term_memory", visible=False)
         self.sheerka.bind_service_method(self.add_to_memory, True, visible=False)
+        self.sheerka.bind_service_method(self.add_many_to_short_term_memory, True, visible=False)
         self.sheerka.bind_service_method(self.get_from_memory, False)
         self.sheerka.bind_service_method(self.register_object, True, visible=False)
         self.sheerka.bind_service_method(self.unregister_object, True, visible=False)
         self.sheerka.bind_service_method(self.add_registered_objects, True, visible=False)
         self.sheerka.bind_service_method(self.memory, False)
 
-        self.sheerka.cache_manager.register_cache(self.SHORT_TERM_OBJECTS_ENTRY, self.short_term_objects, persist=False)
         self.sheerka.cache_manager.register_cache(self.OBJECTS_ENTRY, self.objects, persist=True, use_ref=True)
 
+    def reset(self):
+        self.short_term_objects.clear()
+
+    def initialize_deferred(self, context, is_first_time):
+        self.sheerka.subscribe(CONTEXT_DISPOSED, self.remove_context)
+
     def get_from_short_term_memory(self, context, key):
         while True:
-            key_to_use = (str(context.id) if context else "") + ":" + key
-            if (obj := self.sheerka.cache_manager.get(self.SHORT_TERM_OBJECTS_ENTRY, key_to_use)) is not None:
-                return obj
+            try:
+                id_to_use = context.id if context else self.GLOBAL
+                return self.short_term_objects.cache[id_to_use][key]
+            except KeyError:
+                if context is None:
+                    return None
 
-            if context is None:
-                return None
+                context = context.get_parent()
 
-            context = context.get_parent()
+    def get_all_short_term_memory(self, context):
+        return self.short_term_objects.get(context.id)
 
-    def add_to_short_term_memory(self, context, key, concept):
+    def add_to_short_term_memory(self, context, key, value):
         if context:
             context.stm = True
-        key_to_use = (str(context.id) if context else "") + ":" + key
-        return self.sheerka.cache_manager.put(self.SHORT_TERM_OBJECTS_ENTRY, key_to_use, concept)
+            id_to_use = context.id
+        else:
+            id_to_use = SheerkaMemory.GLOBAL
+
+        if id_to_use in self.short_term_objects.cache:
+            self.short_term_objects.cache[id_to_use][key] = value
+        else:
+            self.short_term_objects.put(id_to_use, {key: value})
+
+    def add_many_to_short_term_memory(self, context, bag):
+        context.stm = True
+        self.short_term_objects.put(context.id if context else self.GLOBAL, bag)
 
     def remove_context(self, context):
-        self.short_term_objects.evict_by_key(lambda k: k.startswith(str(context.id) + ":"))
+        try:
+            del self.short_term_objects.cache[context.id]
+        except KeyError:
+            pass
 
     def add_to_memory(self, context, key, concept):
         """
@@ -74,6 +100,11 @@ class SheerkaMemory(BaseService):
     def register_object(self, context, key, concept):
         """
         Before adding objects to memory, they first need to be registered
+        More:
+        We don't want to add all evaluated concept into memory
+        (because some of them may be ref to concept already in memory)
+        So we first register them, and add the end of sheerka.evaluate_user_input()
+        all remaining registered concepts will be added to memory
         :param context:
         :param key:
         :param concept: