Fixed memory() and RET usage

src/core/sheerka/services/SheerkaMemory.py

@@ -0,0 +1,132 @@
+from dataclasses import dataclass
+
+from cache.ListIfNeededCache import ListIfNeededCache
+from core.builtin_concepts import BuiltinConcepts
+from core.concept import Concept
+from core.sheerka.services.sheerka_service import BaseService, ServiceObj
+
+
+@dataclass
+class MemoryObject(ServiceObj):
+    obj: object
+
+
+class SheerkaMemory(BaseService):
+    NAME = "Memory"
+
+    SHORT_TERM_OBJECTS_ENTRY = "Memory:ShortTermMemoryObjects"
+    OBJECTS_ENTRY = "Memory:Objects"
+
+    def __init__(self, sheerka):
+        super().__init__(sheerka)
+        self.short_term_objects = ListIfNeededCache()
+        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.add_to_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 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
+
+            if context is None:
+                return None
+
+            context = context.get_parent()
+
+    def add_to_short_term_memory(self, context, key, concept):
+        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)
+
+    def remove_context(self, context):
+        self.short_term_objects.evict_by_key(lambda k: k.startswith(str(context.id) + ":"))
+
+    def add_to_memory(self, context, key, concept):
+        """
+        Adds an object to memory
+        :param context:
+        :param key:
+        :param concept:
+        :return:
+        """
+        self.objects.put(key, MemoryObject(context.event.get_digest(), concept))
+
+    def get_from_memory(self, context, key):
+        """"
+        """
+        return self.objects.get(key)
+
+    def register_object(self, context, key, concept):
+        """
+        Before adding objects to memory, they first need to be registered
+        :param context:
+        :param key:
+        :param concept:
+        :return:
+        """
+        self.registration[key] = concept
+
+    def unregister_object(self, context, key):
+        """
+        To indicate that key is no longer to be remembered
+        :param context:
+        :param key:
+        :return:
+        """
+        try:
+            del self.registration[key]
+        except KeyError:
+            pass
+
+    def add_registered_objects(self, context):
+        """
+        Adds all registered objects
+        :param context:
+        :return:
+        """
+        for k, v in self.registration.items():
+            self.add_to_memory(context, k, v)
+        self.registration.clear()
+
+    def memory(self, context, name=None):
+        """
+        Get the list of all objects in memory
+        :param context:
+        :param name:
+        :return:
+        """
+        if name:
+            name_to_use = name.name if isinstance(name, Concept) else name
+            self.unregister_object(context, name_to_use)
+            obj = self.get_from_memory(context, name_to_use)
+            if obj is None:
+                return self.sheerka.new(BuiltinConcepts.NOT_FOUND, body={"#name": name})
+
+            if isinstance(obj, list):
+                obj = obj[-1]
+
+            return obj.obj
+
+        res = {}
+        for k in self.objects:
+            obj = self.objects.get(k)
+            if isinstance(obj, list):
+                obj = obj[-1]
+            res[k] = obj.obj
+
+        return res